关于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 加了耗时也体现了进去