如何在Golang微服务中集成链路追踪 配置Jaeger与OpenTelemetry实现

package main

import (
    "context"
    "log"
    "net/http"
    "time"

    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/attribute"
    "go.opentelemetry.io/otel/exporters/jaeger"
    "go.opentelemetry.io/otel/sdk/resource"
    sdktrace "go.opentelemetry.io/otel/sdk/trace"
    semconv "go.opentelemetry.io/otel/semconv/v1.24.0"

    // 导入用于HTTP请求的otel包
    "go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
)

// initTracer 初始化OpenTelemetry TracerProvider
func initTracer(serviceName string) *sdktrace.TracerProvider {
    // 1. 配置Jaeger导出器
    // 这里假设Jaeger Agent运行在默认端口，或者Collector地址
    // 生产环境建议使用Collector，并配置HTTP或GRPC endpoint
    exporter, err := jaeger.New(jaeger.WithCollectorEndpoint(jaeger.WithEndpoint("http://localhost:14268/api/traces")))
    if err != nil {
        log.Fatalf("failed to create jaeger exporter: %v", err)
    }

    // 2. 创建资源，描述服务本身
    // 这是链路追踪数据的重要元信息，便于在Jaeger UI中过滤和查找
    resource := resource.NewWithAttributes(
        semconv.SchemaURL,
        semconv.ServiceName(serviceName),
        semconv.ServiceVersion("1.0.0"),
        attribute.String("environment", "development"),
    )

    // 3. 创建SpanProcessor
    // BatchSpanProcessor会异步批量发送Span，减少性能开销
    // SimpleSpanProcessor会同步发送，适合调试
    bsp := sdktrace.NewBatchSpanProcessor(exporter)

    // 4. 创建TracerProvider
    tp := sdktrace.NewTracerProvider(
        sdktrace.WithSampler(sdktrace.AlwaysSample()), // 采样策略：AlwaysSample, ParentBased, TraceIDRatioBased
        sdktrace.WithResource(resource),
        sdktrace.WithSpanProcessor(bsp),
    )

    // 5. 设置全局TracerProvider
    otel.SetTracerProvider(tp)
    // 推荐设置Propagator，用于在服务间传递Context
    otel.SetTextMapPropagator(otel.NewCompositeTextMapPropagator(
        // propagation.TraceContext{}, // W3C Trace Context
        // propagation.Baggage{},      // W3C Baggage
    ))

    return tp
}

func main() {
    // 服务A的初始化
    serviceAName := "service-a"
    tpA := initTracer(serviceAName)
    defer func() {
        if err := tpA.Shutdown(context.Background()); err != nil {
            log.Printf("Error shutting down tracer provider A: %v", err)
        }
    }()

    // 模拟一个简单的HTTP服务A
    http.Handle("/hello", otelhttp.NewHandler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 在这里，otelhttp.NewHandler 已经自动创建了一个Span并将其放入r.Context()
        // 如果需要创建子Span，可以从r.Context()中获取
        ctx := r.Context()
        _, span := otel.Tracer(serviceAName).Start(ctx, "handle-hello-request")
        defer span.End()

        log.Println("Service A received request")
        time.Sleep(50 * time.Millisecond) // 模拟处理时间

        // 假设Service A需要调用Service B
        client := http.Client{Transport: otelhttp.NewTransport(http.DefaultTransport)}
        req, _ := http.NewRequestWithContext(ctx, "GET", "http://localhost:8081/world", nil)
        resp, err := client.Do(req)
        if err != nil {
            span.RecordError(err) // 记录错误
            span.SetStatus(semconv.ErrorStatus, err.Error())
            http.Error(w, "Failed to call service B", http.StatusInternalServerError)
            return
        }
        defer resp.Body.Close()

        w.Write([]byte("Hello from Service A and B!"))
    }), "/hello"))

    log.Printf("Service A listening on :8080")
    go func() {
        if err := http.ListenAndServe(":8080", nil); err != nil && err != http.ErrServerClosed {
            log.Fatalf("could not listen on :8080: %v", err)
        }
    }()

    // 服务B的初始化
    serviceBName := "service-b"
    tpB := initTracer(serviceBName)
    defer func() {
        if err := tpB.Shutdown(context.Background()); err != nil {
            log.Printf("Error shutting down tracer provider B: %v", err)
        }
    }()

    // 模拟一个简单的HTTP服务B
    http.Handle("/world", otelhttp.NewHandler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        ctx := r.Context()
        _, span := otel.Tracer(serviceBName).Start(ctx, "handle-world-request")
        defer span.End()

        log.Println("Service B received request")
        time.Sleep(30 * time.Millisecond) // 模拟处理时间
        w.Write([]byte("World from Service B!"))
    }), "/world"))

    log.Printf("Service B listening on :8081")
    if err := http.ListenAndServe(":8081", nil); err != nil && err != http.ErrServerClosed {
        log.Fatalf("could not listen on :8081: %v", err)
    }
}

func processOrder(ctx context.Context, orderID string) error {
    // 从现有上下文创建子Span
    ctx, span := otel.Tracer("my-service").Start(ctx, "process-order-logic",
        trace.WithAttributes(attribute.String("order.id", orderID)))
    defer span.End()

    // 添加事件
    span.AddEvent("Order processing started")

    // 模拟一些操作
    time.Sleep(10 * time.Millisecond)

    // 调用数据库操作，可以再创建一个子Span
    ctx, dbSpan := otel.Tracer("my-service").Start(ctx, "db-query-order",
        trace.WithAttributes(attribute.String("db.table", "orders")))
    defer dbSpan.End()
    time.Sleep(5 * time.Millisecond)
    // 模拟数据库错误
    if orderID == "invalid" {
        dbSpan.RecordError(errors.New("invalid order ID"))
        dbSpan.SetStatus(semconv.ErrorStatus, "Order ID validation failed")
        return errors.New("validation error")
    }
    dbSpan.AddEvent("DB query finished")
    dbSpan.SetAttributes(attribute.Int("rows.affected", 1))

    span.AddEvent("Order processing finished")
    return nil
}