关于go:golang-使用-OpenTelemetry-实现跨服务-gin-echo-全链路追踪

应用 OpenTelemetry 链路追踪阐明

1. 工作中经常会遇到须要查看服务调用关系, 比方用户申请了一个接口
2. 接口会调用其余 grpc,http 接口, 或者外部的办法
3. 这样的调用链路, 如果呈现了问题, 咱们须要疾速的定位问题, 这时候就须要一个工具来帮忙咱们查看调用链路
4. OpenTelemetry 就是这样一个工具
5. 本文大略以:main 函数初始化 OpenTelemetry、启动 http server、配置 httpclient 申请服务 来进行阐明
6. 残缺可执行源码在:https://github.com/webws/go-moda/tree/main/example/tracing/moda_tracing
7. 前面会补充 grpc 的链路追踪

服务链路关系

关系图

graph LR
A[用户] --> B[api1/bar]
B --> C[api2/bar]
C --> D[api3/bar]
D --> E[bar]
E --> F[bar2]
F --> G[bar3]

阐明:

1. 用户 申请 api1(echo server) 服务的 api1/bar
2. api1 调用 api2 (gin server) 服务的 api2/bar
3. api2 调用 api3 (echo server)服务的 api3/bar
4. api3 调用 外部 调用办法 bar->bar2->bar3

装置 jaeger

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

初始化 全局的 OpenTelemetry

这里 openTelemetry 的 exporter 以 jaeger 为例, 其余的 exporter 能够参考官网文档

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
}

阐明

1. 下面办法的参数 jaegerUrl , 如果装置的是 jaeger-all-in-one, 则地址默认为 http://localhost:14268/api/traces
2. serviceName 是服务名称, 这里我应用的是 api1,api2,api3
3. 减少 span 能够应用 tracer.Start(ctx, “spanName”)

http 服务链路追踪

下面初始化了全局的 OpenTelemetry 后, 在以后服务就能够应用 OpenTelemetry 的 tracer 进行链路追踪了
但如果 须要跨服务进行调用, 这是不够的, 比方 http server 之间的调用, 须要:

1. 对于 http client: httpclient 申请 server 的时候, 将 ctx(上下文) 注入到 req header 中
2. 对于 http server: 在获取 http 申请时, 解析 req header 中的 parent trace 这样就能够在服务传输中获取到上下文, 从而进行链路追踪

启动 http 服务开启链路追踪

下面说的服务传输过程中, 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 启动时 通过解析 req header 中的 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
}

阐明

1. 下面代码中, 应用了 otelhttp.NewTransport(http.DefaultTransport) 将上下文注入到 req header 中
2. http client 调用服务时, 须要将上下文传入到 CallAPI 的 ctx 参数中

调用服务, 查看链路关系

实战代码演示

http 跨服务 链路追踪 大略说完 接下来就是实战演示:

1. 下载示例源码, 启动服务, 而后调用服务, 查看链路关系
   源码地址:https://github.com/webws/go-moda/tree/main/example/tracing/moda_tracing
2. 示例文件:moda_tracing 下 有三个目录, 别离是 api1_http,api2_http,api_http, 别离对应三个服务
3. 别离启动三个服务, 进入目录 go run ./ 即可启动服务, 端口别离是 8081,8082,8083
4. 依据下面链路关系, 调用 api1 期待调用实现: curl localhost:8081/api1/bar
5. 关上 jaeger 面板, 查看链路关系图,http://localhost:16686/
6. 后续示例代码启动采纳 docker-compose 启动, 不便演示

查看 jaeger 链路

能够看到对应的链路, 在 bar,bar2,bar3 刻意 sleep 加了耗时也体现了进去