Golang微服务日志收集与分布式追踪

github.com/opentracing/opentracing-go

github.com/uber/jaeger-client-go

package main

import (
    "fmt"
    "github.com/opentracing/opentracing-go"
    "github.com/uber/jaeger-client-go"
    "github.com/uber/jaeger-client-go/config"
    "log"
    "time"
)

func main() {
    // 配置 Jaeger
    cfg := config.Configuration{
        ServiceName: "my-service",
        Sampler: &config.SamplerConfig{
            Type:  jaeger.SamplerTypeConst,
            Param: 1,
        },
        Reporter: &config.ReporterConfig{
            LogSpans:            true,
            CollectorEndpoint:   "http://localhost:14268/api/traces", // Jaeger collector 地址
            BufferFlushInterval: time.Second,
        },
    }

    tracer, closer, err := cfg.NewTracer(config.Logger(jaeger.StdLogger))
    if err != nil {
        log.Fatalf("Could not initialize tracer: %v", err)
    }
    defer closer.Close()

    opentracing.SetGlobalTracer(tracer)

    // 创建一个 span
    span := opentracing.GlobalTracer().StartSpan("my-operation")
    defer span.Finish()

    // 模拟一些工作
    fmt.Println("Doing some work...")
    time.Sleep(time.Millisecond * 100)

    // 添加一些 tag
    span.SetTag("component", "my-component")

    fmt.Println("Work done!")
}

package main

import (
    "go.uber.org/zap"
    "go.uber.org/zap/zapcore"
    "context"
)

type contextKey string

const traceIDKey contextKey = "traceID"

func main() {
    // 创建一个 logger
    config := zap.NewProductionConfig()
    config.EncoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
    logger, _ := config.Build()
    defer logger.Sync() // flushes buffer, if any

    // 创建一个带有 trace ID 的 context
    ctx := context.WithValue(context.Background(), traceIDKey, "1234567890")

    // 从 context 中获取 trace ID 并添加到日志中
    traceID := ctx.Value(traceIDKey)
    logger.Info("Hello, world!", zap.Any("trace_id", traceID))
}

net/http

package main

import (
    "fmt"
    "net/http"
    "context"
    "github.com/opentracing/opentracing-go"
    "io/ioutil"
)

const traceIDHeader = "X-Trace-ID"

func main() {
    // 启动一个 HTTP 服务器
    http.HandleFunc("/", handleRequest)
    http.ListenAndServe(":8080", nil)
}

func handleRequest(w http.ResponseWriter, r *http.Request) {
    // 从 HTTP header 中获取 trace ID
    traceID := r.Header.Get(traceIDHeader)

    // 如果没有 trace ID，则生成一个新的
    if traceID == "" {
        traceID = "new-trace-id" // 实际应用中需要使用更可靠的生成方法
    }

    // 创建一个带有 trace ID 的 context
    ctx := context.WithValue(r.Context(), contextKey("traceID"), traceID)

    // 调用下游服务
    response, err := callDownstreamService(ctx, "http://localhost:8081")
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    fmt.Fprintf(w, "Response from downstream service: %s", response)
}

func callDownstreamService(ctx context.Context, url string) (string, error) {
    // 从 context 中获取 trace ID
    traceID := ctx.Value(contextKey("traceID")).(string)

    // 创建一个 HTTP 请求
    req, err := http.NewRequest("GET", url, nil)
    if err != nil {
        return "", err
    }

    // 将 trace ID 添加到 HTTP header 中
    req.Header.Set(traceIDHeader, traceID)

    // 发送 HTTP 请求
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()

    // 读取响应内容
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return "", err
    }

    return string(body), nil
}

package main

import (
    "context"
    "fmt"
    "log"
    "net/http"
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/attribute"
    "go.opentelemetry.io/otel/exporters/jaeger"
    "go.opentelemetry.io/otel/sdk/resource"
    tracesdk "go.opentelemetry.io/otel/sdk/trace"
    semconv "go.opentelemetry.io/otel/semconv/v1.17.0"
)

const (
    service     = "my-service"
    environment = "production"
    id          = 1
)

// tracerProvider returns an OpenTelemetry TracerProvider configured to use Jaeger.
func tracerProvider(url string) (*tracesdk.TracerProvider, error) {
    // Create the Jaeger exporter
    exp, err := jaeger.New(jaeger.WithCollectorEndpoint(jaeger.WithEndpoint(url)))
    if err != nil {
        return nil, err
    }
    tp := tracesdk.NewTracerProvider(
        // Always be sure to batch in production.
        tracesdk.WithBatcher(exp),
        // Record information about this application in a Resource.
        tracesdk.WithResource(resource.NewWithAttributes(
            semconv.SchemaURL,
            semconv.ServiceName(service),
            attribute.String("environment", environment),
            attribute.Int64("ID", id),
        )),
    )
    return tp, nil
}

func main() {
    tp, err := tracerProvider("http://localhost:14268/api/traces")
    if err != nil {
        log.Fatal(err)
    }

    // Register our TracerProvider with the global variable.
    otel.SetTracerProvider(tp)

    mux := http.NewServeMux()
    mux.HandleFunc("/hello", func(w http.ResponseWriter, req *http.Request) {
        ctx := req.Context()
        tracer := otel.Tracer("my-service-tracer")
        ctx, span := tracer.Start(ctx, "hello-handler")
        defer span.End()

        fmt.Fprintf(w, "Hello, world!\n")
    })

    log.Fatal(http.ListenAndServe(":8080", mux))
}