golang 使用 OpenTelemetry 实现跨服务全链路追踪

文章博客地址: https://blog.taoluyuan.com/posts/opentelmetry/

使用 OpenTelemetry 链路追踪说明

工作中常常会遇到需要查看服务调用关系,比如用户请求了一个接口
接口会调用其他grpc,http接口,或者内部的方法
这样的调用链路,如果出现了问题,我们需要快速的定位问题,这时候就需要一个工具来帮助我们查看调用链路
OpenTelemetry就是这样一个工具
本文大概以:main 函数初始化 OpenTelemetry、启动 http server、配置httpclient 请求服务来进行说明
完整可执行源码在:opentelemetry-go 示例
示例代码已增加 grpc的链路追踪

服务链路关系

关系图

golang 使用 OpenTelemetry 实现跨服务全链路追踪

说明:

用户请求 api1(echo server) 服务的 api1/bar
api1 调用 Grpc 服务
api1 调用 api2 (gin server) 服务的 api2/bar
api2 调用 api3 (echo server )服务的 api3/bar
api3 调用内部调用方法 bar->bar2->bar3

安装jaeger

下载jaeger:我使用的是 jaeger-all-in-one
启动 jaeger: ~/tool/jaeger-1.31.0-linux-amd64/jaeger-all-in-one
默认查看面板地址 http://localhost:16686/
tracer Batcher的地址,下面代码会体现: http://localhost:14268/api/traces

初始化全局的 OpenTelemetry

这里openTelemetry 的exporter 以 jaeger 为例

var tracer = otel.Tracer("go-moda")
func InitJaegerProvider(jaegerUrl string, serviceName string) (func(ctx context.Context) error, error) {
    if jaegerUrl == "" {
        logger.Errorw("jaeger url is empty")
        return nil, nil
    }
    tracer = otel.Tracer(serviceName)
    exp, err := jaeger.New(jaeger.WithCollectorEndpoint(jaeger.WithEndpoint(jaegerUrl)))
    if err != nil {
        return nil, err
    }
    tp := tracesdk.NewTracerProvider(
        tracesdk.WithBatcher(exp),
        tracesdk.WithResource(resource.NewSchemaless(
            semconv.ServiceNameKey.String(serviceName),
        )),
    )
    otel.SetTracerProvider(tp)
    // otel.SetTextMapPropagator(propagation.TraceContext{})
    b3Propagator := b3.New(b3.WithInjectEncoding(b3.B3MultipleHeader))
    propagator := propagation.NewCompositeTextMapPropagator(propagation.TraceContext{}, propagation.Baggage{}, b3Propagator)
    otel.SetTextMapPropagator(propagator)
    return tp.Shutdown, nil
}

说明

jaegerUrl ,如果安装的是 jaeger-all-in-one,则地址默认为 http://localhost:14268/api/traces
serviceName 是服务名称,这里我使用的是 api1,api2,api3
增加 span 可以使用 tracer.Start(ctx, "spanName")

http服务链路追踪

初始化了全局的 OpenTelemetry后,在当前服务就可以使用 OpenTelemetry 的 tracer 进行链路追踪比如

ctx, span := tracing.Start(ctx, "service.bar")
defer span.End()

但如果是跨服务进行调用,比如 http server之间的调用,需要:

对于 http client: 请求server的时候,将ctx(上下文) 注入到请求头中(req header) 中
对于 http server: 在获取http请求时,解析出请求头中的 parent trace 信息这样就可以实现跨服务链路追踪

启动 http服务开启链路追踪

http服务,解析请求头中的trace信息:echo 和 gin 都有成熟的的中间件,我们在初始化的时候,将中间件加入到服务中即可,下面是 echo 和 gin启动服务的演示:

echo server 示例

import "go.opentelemetry.io/contrib/instrumentation/github.com/labstack/echo/otelecho"
e := echo.New()
e.Server.Use(otelecho.Middleware("moda"))

gin 举例

import "go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin"
ginEngine := gin.Default()
g.GetServer().Use(otelgin.Middleware("my-server"))

http client 链路追踪

httpserver 启动时通过解析请求头中的 parent trace 来进行链路追踪
那么在调用服务时,就需要将上下文注入到 req header 中下面是我个人封装的 httpclient,可以参考:

package tracing

import (
    "bytes"
    "context"
    "encoding/json"
    "io"
    "io/ioutil"
    "net/http"

    "go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
)

// 新增 options  http.Transport
type ClientOption struct {
    Transport *http.Transport
}

type ClientOptionFunc func(*ClientOption)

func WithClientTransport(transport *http.Transport) ClientOptionFunc {
    return func(option *ClientOption) {
        option.Transport = transport
    }
}

// CallAPI 为 http client 封装,默认使用 otelhttp.NewTransport(http.DefaultTransport)
func CallAPI(ctx context.Context, url string, method string, reqBody interface{}, option ...ClientOptionFunc) ([]byte, error) {
    clientOption := &ClientOption{}
    for _, o := range option {
        o(clientOption)
    }

    client := http.Client{Transport: otelhttp.NewTransport(http.DefaultTransport)}
    if clientOption.Transport != nil {
        client.Transport = otelhttp.NewTransport(clientOption.Transport)
    }
    var requestBody io.Reader
    if reqBody != nil {
        payload, err := json.Marshal(reqBody)
        if err != nil {
            return nil, err
        }
        requestBody = bytes.NewReader(payload)
    }
    req, err := http.NewRequestWithContext(ctx, method, url, requestBody)
    if err != nil {
        return nil, err
    }
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    resBody, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }
    return resBody, nil
}