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

Published on
Authors
  • avatar
    Name
    歪脖松
    Twitter

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

使用 OpenTelemetry 链路追踪说明

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

服务链路关系

关系图

说明:

  1. 用户 请求 api1(echo server) 服务的 api1/bar
  2. api1 调用 Grpc 服务
  3. api1 调用 api2 (gin server) 服务的 api2/bar
  4. api2 调用 api3 (echo server )服务的 api3/bar
  5. 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 为例

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 进行链路追踪 比如

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

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

  1. 对于 http client: 请求server的时候,将ctx(上下文) 注入到 请求头中(req header) 中
  2. 对于 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
}

说明

  1. 上面代码中,主要是使用了 otelhttp.NewTransport(http.DefaultTransport) 将上下文注入到 req header 中
  2. 调用服务时,需要将上下文(ctx)传入到 CallAPI 方法

调用服务,查看链路关系

实战代码演示

跨服务 链路追踪 大概说完 下面是运行实战代码,分为普通运行和docker 一键运行 查看源码位置:opentelemetry-go 示例

普通运行

  1. 示例文件:moda_tracing下 有四个目录,分别是 api1_http,api2_http,api3_http,grpc 分别对应三个api服务 一个grpc服务
  2. 分别启动三个服务,进入目录 go run ./ -c ./conf.toml 即可启动服务

docker 运行

  1. 进入moda_tracing目录
  2. 执行 make deploy,会同时启动 jaeger,api1,api2,api3,grpc(mac 和 linux经过试验可行,win如不行可使用第一种)

查看jaeger 链路

  1. 根据上面链路关系,调用api1 等待调用完成: curl localhost:8081/api1/bar
  2. 打开 jaeger 面板,查看链路关系图,http://localhost:16686/

可以看到对应的链路,在bar,bar2,bar3 刻意sleep 加了耗时也体现了出来