Golang如何优化DevOps中的分布式追踪 结合OpenTelemetry案例

import (
    "context"
    "log"
    "os"
    "time"

    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/exporters/otlp/otlptrace"
    "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
    "go.opentelemetry.io/otel/propagation"
    "go.opentelemetry.io/otel/sdk/resource"
    sdktrace "go.opentelemetry.io/otel/sdk/trace"
    semconv "go.opentelemetry.io/otel/semconv/v1.17.0"
)

var (
    serviceName  = os.Getenv("OTEL_SERVICE_NAME")
    collectorURL = os.Getenv("OTEL_EXPORTER_OTLP_ENDPOINT")
    insecure     = os.Getenv("OTEL_EXPORTER_OTLP_INSECURE")
)

func newExporter(ctx context.Context) (sdktrace.SpanExporter, error) {
    client := otlptracegrpc.NewClient(
        otlptracegrpc.WithInsecure(),
        otlptracegrpc.WithEndpoint(collectorURL),
    )

    exporter, err := otlptrace.New(ctx, client)
    if err != nil {
        return nil, err
    }
    return exporter, nil
}

func newTraceProvider(exp sdktrace.SpanExporter) *sdktrace.TracerProvider {
    // Ensure default attributes and propagation of trace context.
    resource := resource.NewWithAttributes(
        semconv.SchemaURL,
        semconv.ServiceName(serviceName),
    )

    return sdktrace.NewTracerProvider(
        sdktrace.WithBatcher(exp),
        sdktrace.WithResource(resource),
    )
}

func InitTracer() func(context.Context) error {
    ctx := context.Background()

    exporter, err := newExporter(ctx)
    if err != nil {
        log.Fatalf("creating exporter: %v", err)
    }

    tp := newTraceProvider(exporter)
    otel.SetTracerProvider(tp)
    otel.SetTextMapPropagator(propagation.TraceContext{})

    return func(ctx context.Context) error {
        // Do a clean up.
        return tp.Shutdown(ctx)
    }
}

func main() {
    shutdown := InitTracer()
    defer func() {
        if err := shutdown(context.Background()); err != nil {
            log.Fatal("failed to shutdown TracerProvider: %w", err)
        }
    }()

    // Your application logic here
}

// 在发起HTTP请求时，将追踪上下文注入到HTTP Header中
func makeRequest(ctx context.Context, url string) (*http.Response, error) {
    req, err := http.NewRequest("GET", url, nil)
    if err != nil {
        return nil, err
    }

    otel.GetTextMapPropagator().Inject(ctx, propagation.HeaderCarrier(req.Header))

    client := &http.Client{}
    resp, err := client.Do(req)
    return resp, err
}

// 在接收HTTP请求时，从HTTP Header中提取追踪上下文
func handleRequest(w http.ResponseWriter, r *http.Request) {
    ctx := otel.GetTextMapPropagator().Extract(context.Background(), propagation.HeaderCarrier(r.Header))

    // 创建Span
    tracer := otel.Tracer("my-service")
    ctx, span := tracer.Start(ctx, "handleRequest")
    defer span.End()

    // ...
}