Go应用集成Jaeger仅显示单个Span，跨服务链路追踪异常求助

跨服务调用链路变成独立Trace，核心就是没在请求间传递Jaeger的Trace上下文，导致每个服务都生成了新的Trace。下面是具体的实现步骤：

1. 统一初始化Jaeger Tracer #

每个服务都要按标准方式初始化Tracer，并设置为全局实例：

import (
    "io"
    "github.com/opentracing/opentracing-go"
    "github.com/uber/jaeger-client-go"
    "github.com/uber/jaeger-client-go/config"
)

func InitJaegerTracer(serviceName string) (opentracing.Tracer, io.Closer, error) {
    cfg := config.Configuration{
        ServiceName: serviceName,
        Sampler: &config.SamplerConfig{
            Type:  "const",
            Param: 1, // 调试阶段用全量采样，生产可调整
        },
        Reporter: &config.ReporterConfig{
            LogSpans:           true,
            LocalAgentHostPort: "localhost:6831", // 替换成你的Jaeger Agent地址
        },
    }
    return cfg.NewTracer(config.Logger(jaeger.StdLogger))
}

// 在服务启动时执行
tracer, closer, err := InitJaegerTracer("service-a")
if err != nil {
    panic(err)
}
defer closer.Close()
opentracing.SetGlobalTracer(tracer)

2. 客户端调用时注入Trace上下文 #

当服务A调用服务B时，要把当前活跃Span的上下文注入到请求头中，以HTTP请求为例：

// 假设当前请求上下文里包含父Span
parentSpan := opentracing.SpanFromContext(ctx)

req, err := http.NewRequest("GET", "http://service-b/api/test", nil)
if err != nil {
    // 错误处理
    return
}

// 用HTTP头作为载体，注入Trace上下文
carrier := opentracing.HTTPHeadersCarrier(req.Header)
if err := parentSpan.Tracer().Inject(parentSpan.Context(), opentracing.HTTPHeaders, carrier); err != nil {
    // 错误处理
    return
}

// 发送请求
client := &http.Client{}
resp, err := client.Do(req)
// 后续处理...

gRPC场景可以用opentracing.GRPCHeaderCarrier处理metadata，逻辑类似。

3. 服务端接收时提取并关联上下文 #

服务B收到请求后，从请求头提取Trace上下文，以此为父创建新的Span：

func TestHandler(w http.ResponseWriter, r *http.Request) {
    // 从HTTP头提取Trace上下文
    carrier := opentracing.HTTPHeadersCarrier(r.Header)
    spanCtx, err := opentracing.GlobalTracer().Extract(opentracing.HTTPHeaders, carrier)
    if err != nil && err != opentracing.ErrSpanContextNotFound {
        // 错误处理
    }

    // 创建子Span，关联父上下文
    span := opentracing.GlobalTracer().StartSpan("service-b-test-handler", opentracing.ChildOf(spanCtx))
    defer span.Finish()

    // 将Span上下文传递到后续业务逻辑
    ctxWithSpan := opentracing.ContextWithSpan(r.Context(), span)
    // 执行业务操作...
}

4. 优化：用框架中间件简化操作 #

如果用Gin、Echo这类Web框架，可以封装中间件自动处理上下文的提取和注入，避免重复代码。比如Gin的中间件：

func JaegerMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        // 提取客户端传递的Trace上下文
        carrier := opentracing.HTTPHeadersCarrier(c.Request.Header)
        spanCtx, err := opentracing.GlobalTracer().Extract(opentracing.HTTPHeaders, carrier)
        if err != nil && err != opentracing.ErrSpanContextNotFound {
            log.Printf("extract span context failed: %v", err)
        }

        // 创建当前请求的Span
        span := opentracing.GlobalTracer().StartSpan(c.Request.URL.Path, opentracing.ChildOf(spanCtx))
        defer span.Finish()

        // 将Span上下文存入请求上下文
        c.Request = c.Request.WithContext(opentracing.ContextWithSpan(c.Request.Context(), span))
        c.Next()
    }
}

// 注册中间件
router := gin.Default()
router.Use(JaegerMiddleware())

做完这些步骤，服务A→服务B的调用链路就会共享同一个Trace ID，Jaeger就能渲染出完整的串联链路了。

内容的提问来源于stack exchange，提问作者TheBohne