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. import (
  4.     "github.com/go-kratos/kratos/v2/middleware/tracing"
  5.     "github.com/go-kratos/kratos/v2/transport/grpc"
  7.     "go.opentelemetry.io/otel"
  8.     "go.opentelemetry.io/otel/attribute"
  9.     "go.opentelemetry.io/otel/exporters/jaeger"
  10.     "go.opentelemetry.io/otel/sdk/resource"
  11.     tracesdk "go.opentelemetry.io/otel/sdk/trace"
  12.     semconv "go.opentelemetry.io/otel/semconv/v1.4.0"
  13. )
  15. // Set global trace provider
  16. func initTracer(url string) error {
  17.     // Create the Jaeger exporter
  18.     exp, err := jaeger.New(jaeger.WithCollectorEndpoint(jaeger.WithEndpoint(url)))
  19.     if err != nil {
  20.         return err
  21.     }
  22.     tp := tracesdk.NewTracerProvider(
  23.         // Set the sampling rate based on the parent span to 100%
  24.         tracesdk.WithSampler(tracesdk.ParentBased(tracesdk.TraceIDRatioBased(1.0))),
  25.         // Always be sure to batch in production.
  26.         tracesdk.WithBatcher(exp),
  27.         // Record information about this application in an Resource.
  28.         tracesdk.WithResource(resource.NewSchemaless(
  29.             semconv.ServiceNameKey.String("kratos-trace"),
  30.             attribute.String("exporter", "jaeger"),
  31.             attribute.Float64("float", 312.23),
  32.         )),
  33.     )
  34.     otel.SetTracerProvider(tp)
  35.     return nil
  36. }
  38. // NewGRPCServer new a gRPC server.
  39. func NewGRPCServer(c *conf.Server, executor *service.ExecutorService) *grpc.Server {
  40.     err := initTracer("http://localhost:14268/api/traces")
  41.     if err != nil {
  42.         panic(err)
  43.     }
  44.     //tr := otel.Tracer("component-main")
  45.     var opts = []grpc.ServerOption{
  46.         grpc.Middleware(
  47.             tracing.Server(),
  48.         ),
  49.     }
  50.     // ...
  51. }

Tracing for Client

  1. package client
  3. import (
  4.     "context"
  6.     "github.com/go-kratos/kratos/v2/middleware/tracing"
  7.     "github.com/go-kratos/kratos/v2/transport/grpc"
  9.     "go.opentelemetry.io/otel"
  10.     "go.opentelemetry.io/otel/attribute"
  11.     "go.opentelemetry.io/otel/exporters/jaeger"
  12.     "go.opentelemetry.io/otel/sdk/resource"
  13.     tracesdk "go.opentelemetry.io/otel/sdk/trace"
  14.     semconv "go.opentelemetry.io/otel/semconv/v1.4.0"
  15.     googlegrpc "google.golang.org/grpc"
  16. )
  18. // Set global trace provider
  19. func initTracer(url string) error {
  20.     // Create the Jaeger exporter
  21.     exp, err := jaeger.New(jaeger.WithCollectorEndpoint(jaeger.WithEndpoint(url)))
  22.     if err != nil {
  23.         return err
  24.     }
  25.     tp := tracesdk.NewTracerProvider(
  26.         // Set the sampling rate based on the parent span to 100%
  27.         tracesdk.WithSampler(tracesdk.ParentBased(tracesdk.TraceIDRatioBased(1.0))),
  28.         // Always be sure to batch in production.
  29.         tracesdk.WithBatcher(exp),
  30.         // Record information about this application in an Resource.
  31.         tracesdk.WithResource(resource.NewSchemaless(
  32.             semconv.ServiceNameKey.String("kratos-trace"),
  33.             attribute.String("exporter", "jaeger"),
  34.             attribute.Float64("float", 312.23),
  35.         )),
  36.     )
  37.     otel.SetTracerProvider(tp)
  38.     return nil
  39. }
  41. func grpcCli() (*googlegrpc.ClientConn, error) {
  42.     // If the project does not initialize initTracer, please initialize.
  43.     return grpc.DialInsecure(
  44.         context.Background(),
  45.         grpc.WithMiddleware(
  46.             tracing.Client(),
  47.         ),
  48.     )
  49. }

References