We use OpenTelemetry for distributed tracing.

Configuration

There are two methods for configuration WithTracerProvider() and WithPropagator().

WithTracerProvider

  1. func WithTracerProvider(provider trace.TracerProvider) Option {
  2.     return func(opts *options) {
  3.         opts.TracerProvider = provider
  4.     }
  5. }

WithTracerProvider is for setting the provider, it accepts trace.TracerProvider

WithPropagator

  1. func WithPropagator(propagator propagation.TextMapPropagator) Option {
  2.     return func(opts *options) {
  3.         opts.Propagator = propagator
  4.     }
  5. }

WithPropagator is for setting the text map propagator, it accepts propagation.TextMapPropagator

Usage

Tracing for Server

  1. package server
  3. func initTracer() func() {
  4.     // create a jaeger pipeline
  5.     flush, err := jaeger.InstallNewPipeline(
  6.         jaeger.WithCollectorEndpoint("http://localhost:14268/api/traces"),
  7.         jaeger.WithSDKOptions(
  8.             sdktrace.WithSampler(sdktrace.AlwaysSample()),
  9.             sdktrace.WithResource(resource.NewWithAttributes(
  10.                 semconv.ServiceNameKey.String("kratos-trace"),
  11.                 attribute.String("exporter", "jaeger"),
  12.                 attribute.Float64("float", 312.23),
  13.             )),
  14.         ),
  15.     )
  16.     if err != nil {
  17.         log.Fatal(err)
  18.     }
  19.     return flush
  20. }
  21. // NewGRPCServer new a gRPC server.
  22. func NewGRPCServer(c *conf.Server, executor *service.ExecutorService) *grpc.Server {
  23.     flush := initTracer()
  24.     defer flush()
  25.     //tr := otel.Tracer("component-main")
  26.     var opts = []grpc.ServerOption{
  27.         grpc.Middleware(
  28.             middleware.Chain(
  29.                 tracing.Server(tracing.WithTracerProvider(otel.GetTracerProvider())),
  30.             ),
  31.         ),
  32.     }
  33.    // ...
  34. }

Tracing for Client

  1. func initTracer() func() {
  2.     // create a jaeger pipeline
  3.     flush, err := jaeger.InstallNewPipeline(
  4.         jaeger.WithCollectorEndpoint("http://localhost:14268/api/traces"),
  5.         jaeger.WithSDKOptions(
  6.             sdktrace.WithSampler(sdktrace.AlwaysSample()),
  7.             sdktrace.WithResource(resource.NewWithAttributes(
  8.                 semconv.ServiceNameKey.String("kratos-trace"),
  9.                 attribute.String("exporter", "jaeger"),
  10.                 attribute.Float64("float", 312.23),
  11.             )),
  12.         ),
  13.     )
  14.     if err != nil {
  15.         log.Fatal(err)
  16.     }
  17.     return flush
  18. }
  19. func grpcCli() (*grpc.ClientConn, error) {
  20.     return grpc.DialInsecure(
  21.         context.Background(),
  22.         grpc.WithMiddleware(
  23.             tracing.Client(
  24.                 tracing.WithTracerProvider(
  25.                     otel.GetTracerProvider(),
  26.                 ),
  27.             ),
  28.         ),
  29.     )
  30. }

References