AO-16209 otel tracer

.github/workflows/test.yaml

@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        goversion: ['1.12', '1.13', '1.14', '1.15']
+        goversion: ['1.14', '1.15', '1.16']
     name: Go ${{ matrix.goversion }} tests
     env:
       GO15VENDOREXPERIMENT: 1

examples/go.mod

@@ -7,6 +7,10 @@ require (
 	github.com/gin-gonic/gin v1.6.3
 	github.com/opentracing/opentracing-go v1.1.0
 	github.com/stretchr/testify v1.7.0
+	go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin v0.19.0
+	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.19.0
+	go.opentelemetry.io/otel v0.19.0
+	go.opentelemetry.io/otel/trace v0.19.0
 )
 
 replace github.com/appoptics/appoptics-apm-go => ../

examples/otel/distributed_app/.gitignore

@@ -0,0 +1,2 @@
+distributed_app
+bob/bob

examples/otel/distributed_app/alice/Dockerfile

@@ -0,0 +1,11 @@
+FROM golang:1.12
+
+# Based on https://hub.docker.com/_/golang/
+WORKDIR /go/src/app
+COPY . .
+RUN go-wrapper download
+RUN go-wrapper install
+
+# Start app. APPOPTICS_SERVICE_KEY must be set to enable AppOptics.
+CMD /go/bin/app -testClients true -addr :8890
+EXPOSE 8890

examples/otel/distributed_app/alice/main.go

@@ -0,0 +1,123 @@
+// Test web app
+// Wraps a standard HTTP handler with AppOptics instrumentation
+
+package main
+
+import (
+	"fmt"
+	"io/ioutil"
+	"log"
+	"math/rand"
+	"net/http"
+	"sync"
+
+	"context"
+
+	"github.com/appoptics/appoptics-apm-go/v1/ao"
+)
+
+// hard-coded service discovery
+var urls = []string{
+	"http://bob:8081/bob",
+	"http://carol:8082/carol",
+	"http://dave:8083/",
+	"http://otto:8084/otto",
+}
+
+func aliceHandler(w http.ResponseWriter, r *http.Request) {
+	// trace this request, overwriting w with wrapped ResponseWriter
+	t, w, r := ao.TraceFromHTTPRequestResponse("aliceHandler", w, r)
+	ctx := ao.NewContext(context.Background(), t)
+	defer t.End()
+	log.Printf("%s %s", r.Method, r.URL)
+
+	// call an HTTP endpoint and propagate the distributed trace context
+	url := urls[rand.Intn(len(urls))]
+
+	// create HTTP client and set trace metadata header
+	httpClient := &http.Client{}
+	httpReq, _ := http.NewRequest("GET", url, nil)
+	// begin layer for the client side of the HTTP service request
+	l := ao.BeginHTTPClientSpan(ctx, httpReq)
+
+	// make HTTP request to external API
+	resp, err := httpClient.Do(httpReq)
+	l.AddHTTPResponse(resp, err)
+	if err != nil {
+		w.WriteHeader(500)
+		w.Write([]byte(fmt.Sprintf("err: %v", err)))
+		l.End() // end HTTP client timing
+		return
+	}
+
+	// read response body
+	defer resp.Body.Close()
+	buf, err := ioutil.ReadAll(resp.Body)
+	l.End() // end HTTP client timing
+	//w.WriteHeader(200)
+	if err != nil {
+		w.Write([]byte(`{"error":true}`))
+	} else {
+		w.Write(buf) // return API response to caller
+	}
+}
+
+func concurrentAliceHandler(w http.ResponseWriter, r *http.Request) {
+	// trace this request, overwriting w with wrapped ResponseWriter
+	t, w, _ := ao.TraceFromHTTPRequestResponse("aliceHandler", w, r)
+	ctx := ao.NewContext(context.Background(), t)
+	t.SetAsync(true)
+	defer t.End()
+
+	// call an HTTP endpoint and propagate the distributed trace context
+	var wg sync.WaitGroup
+	wg.Add(len(urls))
+	var out []byte
+	outCh := make(chan []byte)
+	doneCh := make(chan struct{})
+	go func() {
+		for buf := range outCh {
+			out = append(out, buf...)
+		}
+		close(doneCh)
+	}()
+	for _, u := range urls {
+		go func(url string) {
+			// create HTTP client and set trace metadata header
+			client := &http.Client{}
+			req, _ := http.NewRequest("GET", url, nil)
+			// begin layer for the client side of the HTTP service request
+			l := ao.BeginHTTPClientSpan(ctx, req)
+
+			// make HTTP request to external API
+			resp, err := client.Do(req)
+			l.AddHTTPResponse(resp, err)
+			if err != nil {
+				l.End() // end HTTP client timing
+				w.WriteHeader(500)
+				return
+			}
+			// read response body
+			defer resp.Body.Close()
+			buf, err := ioutil.ReadAll(resp.Body)
+			l.End() // end HTTP client timing
+			if err != nil {
+				outCh <- []byte(fmt.Sprintf(`{"error":"%v"}`, err))
+			} else {
+				outCh <- buf
+			}
+			wg.Done()
+		}(u)
+	}
+	wg.Wait()
+	close(outCh)
+	<-doneCh
+
+	w.Write(out)
+}
+
+func main() {
+	http.HandleFunc("/alice", aliceHandler)
+	http.HandleFunc("/concurrent", concurrentAliceHandler)
+	http.ListenAndServe(":8890", nil)
+}

examples/otel/distributed_app/alice/main_test.go

@@ -0,0 +1,27 @@
+package main_test
+
+import (
+	"io/ioutil"
+	"net/http"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestClient(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Skipping this test case in short mode")
+	}
+	// run distributed_app server
+
+	// test request to distributed_app example
+	httpClient := &http.Client{}
+	resp, err := httpClient.Get("http://127.0.0.1:8890/lookup")
+	require.NoError(t, err)
+	defer resp.Body.Close()
+
+	body, err := ioutil.ReadAll(resp.Body)
+	assert.NoError(t, err)
+	t.Logf("httpClient.Do body: %v, err: %v", string(body), err)
+}

examples/otel/distributed_app/bob/Dockerfile

@@ -0,0 +1,11 @@
+FROM golang:1.12
+
+# Based on https://hub.docker.com/_/golang/
+WORKDIR /go/src/app
+COPY . .
+RUN go-wrapper download
+RUN go-wrapper install
+
+# Start app. APPOPTICS_SERVICE_KEY must be set to enable AppOptics.
+CMD /go/bin/app -addr :8081
+EXPOSE 8081

examples/otel/distributed_app/bob/main.go

@@ -0,0 +1,21 @@
+// Test web app
+// Wraps a standard HTTP handler with AppOptics instrumentation
+
+package main
+
+import (
+	"log"
+	"net/http"
+
+	"github.com/appoptics/appoptics-apm-go/v1/ao"
+)
+
+func bobHandler(w http.ResponseWriter, r *http.Request) {
+	log.Printf("%s %s", r.Method, r.URL)
+	w.Write([]byte(`{"result":"hello from bob"}`))
+}
+
+func main() {
+	http.HandleFunc("/bob", ao.HTTPHandler(bobHandler))
+	http.ListenAndServe(":8081", nil)
+}

examples/otel/distributed_app/caroljs/Dockerfile

@@ -0,0 +1,16 @@
+FROM ubuntu:16.04
+
+# Install Node.js
+RUN apt-get update && apt-get -y install build-essential nodejs npm
+RUN ln -s /usr/bin/nodejs /usr/bin/node
+
+# Install Node app
+RUN mkdir -p /nodejs
+COPY app.js /nodejs
+WORKDIR /nodejs
+RUN npm install --save appoptics
+
+# Script to run before testing to start services such as tracelyzer and app
+ADD start_services.sh /start_services.sh
+EXPOSE 8082
+CMD [ "bash", "/start_services.sh" ]

examples/otel/distributed_app/caroljs/app.js

@@ -0,0 +1,9 @@
+var ao = require('appoptics');
+var http = require('http');
+
+var server = http.createServer(function(req, res) {
+    console.log(new Date().toISOString(), req.method, req.url);
+    res.writeHead(200);
+    res.end('Hello from app.js\n');
+});
+server.listen(8082);

examples/otel/distributed_app/caroljs/start_services.sh

@@ -0,0 +1,2 @@
+APP_PATH=/nodejs/app.js
+node $APP_PATH

examples/otel/distributed_app/carolpy/Dockerfile

@@ -0,0 +1,16 @@
+FROM ubuntu:17.10
+
+RUN apt-get update
+RUN apt-get -y install build-essential python-dev python-pip
+
+# Install Node app
+RUN mkdir -p /carolpy
+COPY app.py /carolpy
+COPY requirements.txt /carolpy
+WORKDIR /carolpy
+RUN pip install -r requirements.txt
+
+# Script to run before testing to start services such as tracelyzer and app
+ADD start_services.sh /start_services.sh
+EXPOSE 8082
+CMD [ "bash", "/start_services.sh" ]

examples/otel/distributed_app/carolpy/app.py

@@ -0,0 +1,13 @@
+from flask import Flask
+from appoptics.middleware import AppOpticsMiddleware
+
+application = Flask(__name__)
+application.wsgi_app = AppOpticsMiddleware(application.wsgi_app)
+
+
+@application.route('/carol')
+def hello():
+    return "Hello from carolpy/app.py"
+
+if __name__ == '__main__':
+    application.run()

examples/otel/distributed_app/carolpy/requirements.txt

@@ -0,0 +1,3 @@
+appoptics
+flask
+uwsgi

examples/otel/distributed_app/carolpy/start_services.sh

@@ -0,0 +1,2 @@
+cd /carolpy
+uwsgi --socket 0.0.0.0:8082 --protocol=http -w app

examples/otel/distributed_app/davepy/Dockerfile

@@ -0,0 +1,16 @@
+FROM ubuntu:16.04
+
+# Install uWSGI and instrumentation
+RUN apt-get update && apt-get -y install python-pip python-dev build-essential
+RUN pip install appoptics
+RUN pip install uwsgi flask
+
+# Script to run before testing to start services such as tracelyzer and apache
+ADD start_services.sh /start_services.sh
+
+# uWSGI stack
+ADD app /home/app/
+
+EXPOSE 8083
+CMD [ "bash", "/start_services.sh" ]
+

examples/otel/distributed_app/davepy/app/helloworld.py

@@ -0,0 +1,10 @@
+# https://docs.appoptics.com/kb/apm_tracing/python/install/#flask-and-generic-wsgi
+from flask import Flask
+from appoptics.middleware import AppOpticsMiddleware
+
+application = Flask(__name__)
+application.wsgi_app = AppOpticsMiddleware(application.wsgi_app)
+
+@application.route("/")
+def hello():
+    return "Hello from Flask!"

examples/otel/distributed_app/davepy/app/wsgi.py

@@ -0,0 +1,5 @@
+from helloworld import application
+
+if __name__ == "__main__":
+    application.run()
+

examples/otel/distributed_app/davepy/start_services.sh

@@ -0,0 +1,2 @@
+cd /home/app/
+uwsgi --socket 0.0.0.0:8083 --protocol=http -w wsgi

examples/otel/distributed_app/docker-compose.yml

@@ -0,0 +1,57 @@
+# Example distributed app using AppOptics
+# http://www.appoptics.com
+version: '2'
+services:
+  redis:
+    image: redis
+
+  # Alice is a Go service
+  alice:
+    build:
+      context: ./alice
+    environment:
+      APPOPTICS_SERVICE_KEY: ${APPOPTICS_API_TOKEN}:example-alice
+    links:
+      - bob
+      - carolpy:carol
+      - davepy:dave
+      - otto:otto
+    ports:
+      - "8890:8890"
+
+  # Bob is a Go service
+  bob:
+    build:
+      context: ./bob
+    environment:
+      APPOPTICS_SERVICE_KEY: ${APPOPTICS_API_TOKEN}:example-bob
+    links:
+      - redis
+      - carolpy:carol
+
+  # Carol runs Python
+  carolpy:
+    build:
+      context: ./carolpy
+    environment:
+      APPOPTICS_SERVICE_KEY: ${APPOPTICS_API_TOKEN}:example-carol
+
+  # Dave is a Flask app running on uWSGI
+  davepy:
+    build:
+      context: ./davepy
+    environment:
+      APPOPTICS_SERVICE_KEY: ${APPOPTICS_API_TOKEN}:example-dave
+
+  # Otto is a Go app using the OpenTracing API
+  otto:
+    build:
+      context: ./otto
+    environment:
+      APPOPTICS_SERVICE_KEY: ${APPOPTICS_API_TOKEN}:example-otto
+    links:
+      - bob
+      - carolpy:carol
+      - davepy:dave
+    ports:
+      - "8084:8084"

examples/otel/distributed_app/otto/Dockerfile

@@ -0,0 +1,11 @@
+FROM golang:1.12
+
+# Based on https://hub.docker.com/_/golang/
+WORKDIR /go/src/app
+COPY . .
+RUN go-wrapper download
+RUN go-wrapper install
+
+# Start app. APPOPTICS_SERVICE_KEY must be set to enable AppOptics.
+CMD /go/bin/app
+EXPOSE 8084