Zipkin Library for Go
Zipkin Go is the official Go Tracer implementation for Zipkin, supported by the OpenZipkin community.
zipkin-go is built with interoperability in mind within the OpenZipkin
community and even 3rd parties, the library consists of several packages.
The main tracing implementation can be found in the root folder of this repository. Reusable parts not considered core implementation or deemed beneficiary for usage by others are placed in their own packages within this repository.
This library implements the Zipkin V2 Span Model which is available in the model package. It contains a Go data model compatible with the Zipkin V2 API and can automatically sanitize, parse and (de)serialize to and from the required JSON representation as used by the official Zipkin V2 Collectors.
The propagation package and B3 subpackage hold the logic for propagating SpanContext (span identifiers and sampling flags) between services participating in traces. Currently Zipkin B3 Propagation is supported for HTTP and GRPC.
The middleware subpackages contain officially supported middleware handlers and tracing wrappers.
An easy to use http.Handler middleware for tracing server side requests is provided. This allows one to use this middleware in applications using standard library servers as well as most available higher level frameworks. Some frameworks will have their own instrumentation and middleware that maps better for their ecosystem.
For HTTP client operations
NewTransport can return a
implementation that can either wrap the standard http.Client's Transport or a
custom provided one and add per request tracing. Since HTTP Requests can have
one or multiple redirects it is advisable to always enclose HTTP Client calls
Span either around the
*http.Client call level or parent function
NewClient is provided which returns a HTTP Client which embeds
*http.Client and provides an
application span around the HTTP calls when
Easy to use grpc.StatsHandler middleware are provided for tracing gRPC server and client requests.
For a server, pass
NewServerHandler when calling
import ( "google.golang.org/grpc" zipkingrpc "github.com/openzipkin/zipkin-go/middleware/grpc" ) server = grpc.NewServer(grpc.StatsHandler(zipkingrpc.NewServerHandler(tracer)))
For a client, pass
NewClientHandler when calling
import ( "google.golang.org/grpc" zipkingrpc "github.com/openzipkin/zipkin-go/middleware/grpc" ) conn, err = grpc.Dial(addr, grpc.WithStatsHandler(zipkingrpc.NewClientHandler(tracer)))
The reporter package holds the interface which the various Reporter
implementations use. It is exported into its own package as it can be used by
3rd parties to use these Reporter packages in their own libraries for exporting
to the Zipkin ecosystem. The
zipkin-go tracer also uses the interface to
accept 3rd party Reporter implementations.
Most common Reporter type used by Zipkin users transporting Spans to the Zipkin server using JSON over HTTP. The reporter holds a buffer and reports to the backend asynchronously.
High performance Reporter transporting Spans to the Zipkin server using a Kafka Producer digesting JSON V2 Spans. The reporter uses the Sarama async producer underneath.