Tracing

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

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

References