Add zipkin tracing middleware (#48)

Co-authored-by: Arun Gopalpuri <[email protected]>

Author: arun0009

README.md

@@ -14,4 +14,5 @@ Name | Description | Author
 session | Session middleware backed by [gorilla/sessions](https://github.com/gorilla/sessions) | [vishr](https://github.com/vishr)
 jaegertracing | Jaeger tracer middleware | [carlosedp](https://github.com/carlosedp)
 prometheus | Prometheus metrics | [carlosedp](https://github.com/carlosedp)
-pprof      | pprof middlware | [arun0009](https://github.com/arun0009)
+pprof      | pprof middlware | [arun0009](https://github.com/arun0009)
+zipkin | [Zipkin](https://github.com/openzipkin/zipkin-go) middleware | [arun0009](https://github.com/arun0009)

go.mod

@@ -10,9 +10,10 @@ require (
 	github.com/labstack/echo/v4 v4.1.6
 	github.com/labstack/gommon v0.2.9
 	github.com/opentracing/opentracing-go v1.1.0
+	github.com/openzipkin/zipkin-go v0.2.5
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/prometheus/client_golang v1.5.1
-	github.com/prometheus/common v0.10.0 // indirect
+	github.com/prometheus/common v0.10.0
 	github.com/prometheus/procfs v0.2.0 // indirect
 	github.com/stretchr/testify v1.4.0
 	github.com/uber-go/atomic v1.4.0 // indirect

go.sum

@@ -0,0 +1,128 @@
+# Tracing Library for Go
+
+This library provides tracing for go using [Zipkin](https://zipkin.io/)
+ 
+## Usage
+
+### Server Tracing Middleware & http client tracing
+
+```go
+package main
+
+import (
+	"github.com/labstack/echo-contrib/zipkintracing"
+	"github.com/labstack/echo/v4"
+	"github.com/openzipkin/zipkin-go"
+	zipkinhttp "github.com/openzipkin/zipkin-go/middleware/http"
+	zipkinHttpReporter "github.com/openzipkin/zipkin-go/reporter/http"
+	"io/ioutil"
+	"net/http"
+)
+
+func main() {
+	e := echo.New()
+	endpoint, err := zipkin.NewEndpoint("echo-service", "")
+	if err != nil {
+		e.Logger.Fatalf("error creating zipkin endpoint: %s", err.Error())
+	}
+	reporter := zipkinHttpReporter.NewReporter("http://localhost:9411/api/v2/spans")
+	traceTags := make(map[string]string)
+	traceTags["availability_zone"] = "us-east-1"
+	tracer, err := zipkin.NewTracer(reporter, zipkin.WithLocalEndpoint(endpoint), zipkin.WithTags(traceTags))
+	client, _ := zipkinhttp.NewClient(tracer, zipkinhttp.ClientTrace(true))
+	if err != nil {
+		e.Logger.Fatalf("tracing init failed: %s", err.Error())
+	}
+	//Wrap & Use trace server middleware, this traces all server calls
+	e.Use(zipkintracing.TraceServer(tracer))
+	//....
+	e.GET("/echo", func(c echo.Context) error {
+		//trace http request calls.
+		req, _ := http.NewRequest("GET", "https://echo.labstack.com/", nil)
+		resp, _ := zipkintracing.DoHTTP(c, req, client)
+		body, _ := ioutil.ReadAll(resp.Body)
+		return c.String(http.StatusOK, string(body))
+	})
+
+	defer reporter.Close() //defer close reporter
+	e.Logger.Fatal(e.Start(":8080"))
+}
+```
+### Reverse Proxy Tracing
+
+```go
+package main
+
+import (
+	"github.com/labstack/echo-contrib/zipkintracing"
+	"github.com/labstack/echo/v4"
+	"github.com/labstack/echo/v4/middleware"
+	"github.com/openzipkin/zipkin-go"
+	zipkinHttpReporter "github.com/openzipkin/zipkin-go/reporter/http"
+	"net/http/httputil"
+	"net/url"
+)
+
+func main() {
+	e := echo.New()
+	//new tracing instance
+	endpoint, err := zipkin.NewEndpoint("echo-service", "")
+	if err != nil {
+		e.Logger.Fatalf("error creating zipkin endpoint: %s", err.Error())
+	}
+	reporter := zipkinHttpReporter.NewReporter("http://localhost:9411/api/v2/spans")
+	traceTags := make(map[string]string)
+	traceTags["availability_zone"] = "us-east-1"
+	tracer, err := zipkin.NewTracer(reporter, zipkin.WithLocalEndpoint(endpoint), zipkin.WithTags(traceTags))
+	if err != nil {
+		e.Logger.Fatalf("tracing init failed: %s", err.Error())
+	}
+	//....
+	e.GET("/echo",  func(c echo.Context) error {
+		proxyURL, _ := url.Parse("https://echo.labstack.com/")
+		httputil.NewSingleHostReverseProxy(proxyURL)
+		return nil
+	}, zipkintracing.TraceProxy(tracer))
+
+	defer reporter.Close() //close reporter
+	e.Logger.Fatal(e.Start(":8080"))
+
+}
+```
+
+### Trace function calls
+
+To trace function calls e.g. to trace `s3Func`
+
+```go
+package main
+
+import (
+	"github.com/labstack/echo-contrib/zipkintracing"
+	"github.com/labstack/echo/v4"
+	"github.com/openzipkin/zipkin-go"
+)
+
+func s3Func(c echo.Context, tracer *zipkin.Tracer) {
+	defer zipkintracing.TraceFunc(c, "s3_read", zipkintracing.DefaultSpanTags, tracer)()
+	//s3Func logic here...
+}
+```
+
+### Create Child Span
+
+```go
+package main
+
+import (
+	"github.com/labstack/echo-contrib/zipkintracing"
+	"github.com/labstack/echo/v4"
+	"github.com/openzipkin/zipkin-go"
+)
+
+func traceWithChildSpan(c echo.Context, tracer *zipkin.Tracer) {
+	span := zipkintracing.StartChildSpan(c, "someMethod", tracer)
+	//func logic.....
+	span.Finish()
+}
+```

zipkintracing/README.md

@@ -0,0 +1,105 @@
+package zipkintracing
+
+import (
+	"bufio"
+	"errors"
+	"net"
+	"net/http"
+)
+
+// ResponseWriter is a wrapper around http.ResponseWriter that provides extra information about
+// the response. It is recommended that middleware handlers use this construct to wrap a response writer
+// if the functionality calls for it.
+type ResponseWriter interface {
+	http.ResponseWriter
+	http.Flusher
+	// Status returns the status code of the response or 0 if the response has
+	// not been written
+	Status() int
+	// Written returns whether or not the ResponseWriter has been written.
+	Written() bool
+	// Size returns the size of the response body.
+	Size() int
+	// Before allows for a function to be called before the ResponseWriter has been written to. This is
+	// useful for setting headers or any other operations that must happen before a response has been written.
+	Before(func(ResponseWriter))
+}
+
+type beforeFunc func(ResponseWriter)
+
+// NewResponseWriter creates a ResponseWriter that wraps an http.ResponseWriter
+func NewResponseWriter(rw http.ResponseWriter) ResponseWriter {
+	nrw := &responseWriter{
+		ResponseWriter: rw,
+	}
+
+	return nrw
+}
+
+type responseWriter struct {
+	http.ResponseWriter
+	status      int
+	size        int
+	beforeFuncs []beforeFunc
+}
+
+func (rw *responseWriter) WriteHeader(s int) {
+	rw.status = s
+	rw.callBefore()
+	rw.ResponseWriter.WriteHeader(s)
+}
+
+func (rw *responseWriter) Write(b []byte) (int, error) {
+	if !rw.Written() {
+		// The status will be StatusOK if WriteHeader has not been called yet
+		rw.WriteHeader(http.StatusOK)
+	}
+	size, err := rw.ResponseWriter.Write(b)
+	rw.size += size
+	return size, err
+}
+
+func (rw *responseWriter) Status() int {
+	return rw.status
+}
+
+func (rw *responseWriter) Size() int {
+	return rw.size
+}
+
+func (rw *responseWriter) Written() bool {
+	return rw.status != 0
+}
+
+func (rw *responseWriter) Before(before func(ResponseWriter)) {
+	rw.beforeFuncs = append(rw.beforeFuncs, before)
+}
+
+func (rw *responseWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
+	hijacker, ok := rw.ResponseWriter.(http.Hijacker)
+	if !ok {
+		return nil, nil, errors.New("the ResponseWriter doesn't support the Hijacker interface")
+	}
+	return hijacker.Hijack()
+}
+
+func (rw *responseWriter) callBefore() {
+	for i := len(rw.beforeFuncs) - 1; i >= 0; i-- {
+		rw.beforeFuncs[i](rw)
+	}
+}
+
+func (rw *responseWriter) Flush() {
+	flusher, ok := rw.ResponseWriter.(http.Flusher)
+	if ok {
+		if !rw.Written() {
+			// The status will be StatusOK if WriteHeader has not been called yet
+			rw.WriteHeader(http.StatusOK)
+		}
+		flusher.Flush()
+	}
+}
+
+func (rw *responseWriter) CloseNotify() <-chan bool {
+	return rw.ResponseWriter.(http.CloseNotifier).CloseNotify()
+}