Jaeger Client Go入门并实现链路追踪

更新时间：2022年03月31日 09:40:32 作者：痴者工良

这篇文章介绍了Jaeger Client Go入门并实现链路追踪的方法，文中通过示例代码介绍的非常详细。对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下

Jaeger

OpenTracing 是开放式分布式追踪规范，OpenTracing API 是一致，可表达，与供应商无关的API，用于分布式跟踪和上下文传播。

OpenTracing 的客户端库以及规范，可以到 Github 中查看：https://github.com/opentracing/

Jaeger 是 Uber 开源的分布式跟踪系统，详细的介绍可以自行查阅资料。

部署 Jaeger

这里我们需要部署一个 Jaeger 实例，以供微服务以及后面学习需要。

使用 Docker 部署很简单，只需要执行下面一条命令即可：

docker run -d -p 5775:5775/udp -p 16686:16686 -p 14250:14250 -p 14268:14268 jaegertracing/all-in-one:latest

访问 16686 端口，即可看到 UI 界面。

后面我们生成的链路追踪信息会推送到此服务，而且可以通过 Jaeger UI 查询这些追踪信息。

从示例了解 Jaeger Client Go

这里，我们主要了解一些 Jaeger Client 的接口和结构体，了解一些代码的使用。

为了让读者方便了解 Trace、Span 等，可以看一下这个 Json 的大概结构：

        {
            "traceID": "2da97aa33839442e",
            "spans": [
                {
                    "traceID": "2da97aa33839442e",
                    "spanID": "ccb83780e27f016c",
                    "flags": 1,
                    "operationName": "format-string",
                    "references": [...],
                    "tags": [...],
                    "logs": [...],
                    "processID": "p1",
                    "warnings": null
                },
                ... ...
            ],
            "processes": {
                "p1": {
                    "serviceName": "hello-world",
                    "tags": [...]
                },
                "p2": ...,
            "warnings": null
        }

创建一个 client1 的项目，然后引入 Jaeger client 包。

go get -u github.com/uber/jaeger-client-go/

然后引入包

import (
	"github.com/uber/jaeger-client-go"
)

了解 trace、span

链路追踪中的一个进程使用一个 trace 实例标识，每个服务或函数使用一个 span 标识，jaeger 包中有个函数可以创建空的 trace：

tracer := opentracing.GlobalTracer()	// 生产中不要使用

然后就是调用链中，生成父子关系的 Span：

func main() {
	tracer := opentracing.GlobalTracer()
	// 创建第一个 span A
	parentSpan := tracer.StartSpan("A")
    defer parentSpan.Finish()		// 可手动调用 Finish()

}
func B(tracer opentracing.Tracer,parentSpan opentracing.Span){
	// 继承上下文关系，创建子 span
	childSpan := tracer.StartSpan(
		"B",
		opentracing.ChildOf(parentSpan.Context()),
		)
	defer childSpan.Finish()	// 可手动调用 Finish()
}

每个 span 表示调用链中的一个结点，每个结点都需要明确父 span。

现在，我们知道了，如何生成 trace{span1,span2}，且 span1 -> span2 即 span1 调用 span2，或 span1 依赖于 span2。

tracer 配置

由于服务之间的调用是跨进程的，每个进程都有一些特点的标记，为了标识这些进程，我们需要在上下文间、span 携带一些信息。

例如，我们在发起请求的第一个进程中，配置 trace，配置服务名称等。

// 引入 jaegercfg "github.com/uber/jaeger-client-go/config"
	cfg := jaegercfg.Configuration{
		ServiceName: "client test", // 对其发起请求的的调用链，叫什么服务
		Sampler: &jaegercfg.SamplerConfig{
			Type:  jaeger.SamplerTypeConst,
			Param: 1,
		},
		Reporter: &jaegercfg.ReporterConfig{
			LogSpans: true,
		},
	}

Sampler 是客户端采样率配置，可以通过 sampler.type 和 sampler.param 属性选择采样类型，后面详细聊一下。

Reporter 可以配置如何上报，后面独立小节聊一下这个配置。

传递上下文的时候，我们可以打印一些日志：

	jLogger := jaegerlog.StdLogger

配置完毕后就可以创建 tracer 对象了：

	tracer, closer, err := cfg.NewTracer(
		jaegercfg.Logger(jLogger),
	)
	
	defer closer.Close()
	if err != nil {
	}

完整代码如下：

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

func main() {

	cfg := jaegercfg.Configuration{
		ServiceName: "client test", // 对其发起请求的的调用链，叫什么服务
		Sampler: &jaegercfg.SamplerConfig{
			Type:  jaeger.SamplerTypeConst,
			Param: 1,
		},
		Reporter: &jaegercfg.ReporterConfig{
			LogSpans: true,
		},
	}

	jLogger := jaegerlog.StdLogger
	tracer, closer, err := cfg.NewTracer(
		jaegercfg.Logger(jLogger),
	)

	defer closer.Close()
	if err != nil {
	}

	// 创建第一个 span A
	parentSpan := tracer.StartSpan("A")
	defer parentSpan.Finish()

	B(tracer,parentSpan)
}

func B(tracer opentracing.Tracer, parentSpan opentracing.Span) {
	// 继承上下文关系，创建子 span
	childSpan := tracer.StartSpan(
		"B",
		opentracing.ChildOf(parentSpan.Context()),
	)
	defer childSpan.Finish()
}

启动后：

2021/03/30 11:14:38 Initializing logging reporter
2021/03/30 11:14:38 Reporting span 689df7e83255d05d:75668e8ed5ec61da:689df7e83255d05d:1
2021/03/30 11:14:38 Reporting span 689df7e83255d05d:689df7e83255d05d:0000000000000000:1
2021/03/30 11:14:38 DEBUG: closing tracer
2021/03/30 11:14:38 DEBUG: closing reporter

Sampler 配置

sampler 配置代码示例：

		Sampler: &jaegercfg.SamplerConfig{
			Type:  jaeger.SamplerTypeConst,
			Param: 1,
		}

这个 sampler 可以使用 jaegercfg.SamplerConfig，通过 type、param 两个字段来配置采样器。

为什么要配置采样器？因为服务中的请求千千万万，如果每个请求都要记录追踪信息并发送到 Jaeger 后端，那么面对高并发时，记录链路追踪以及推送追踪信息消耗的性能就不可忽视，会对系统带来较大的影响。当我们配置 sampler 后，jaeger 会根据当前配置的采样策略做出采样行为。

详细可以参考：https://www.jaegertracing.io/docs/1.22/sampling/

jaegercfg.SamplerConfig 结构体中的字段 Param 是设置采样率或速率，要根据 Type 而定。

下面对其关系进行说明：

Type	Param	说明
"const"	0或1	采样器始终对所有 tracer 做出相同的决定；要么全部采样，要么全部不采样
"probabilistic"	0.0~1.0	采样器做出随机采样决策，Param 为采样概率
"ratelimiting"	N	采样器一定的恒定速率对tracer进行采样，Param=2.0，则限制每秒采集2条
"remote"	无	采样器请咨询Jaeger代理以获取在当前服务中使用的适当采样策略。

sampler.Type="remote"/sampler.Type=jaeger.SamplerTypeRemote 是采样器的默认值，当我们不做配置时，会从 Jaeger 后端中央配置甚至动态地控制服务中的采样策略。

Reporter 配置

看一下 ReporterConfig 的定义。

type ReporterConfig struct {
    QueueSize                  int `yaml:"queueSize"`
    BufferFlushInterval        time.Duration
    LogSpans                   bool   `yaml:"logSpans"`
    LocalAgentHostPort         string `yaml:"localAgentHostPort"`
    DisableAttemptReconnecting bool   `yaml:"disableAttemptReconnecting"`
    AttemptReconnectInterval   time.Duration
    CollectorEndpoint          string            `yaml:"collectorEndpoint"`
    User                       string            `yaml:"user"`
    Password                   string            `yaml:"password"`
    HTTPHeaders                map[string]string `yaml:"http_headers"`
}

Reporter 配置客户端如何上报追踪信息的，所有字段都是可选的。

这里我们介绍几个常用的配置字段。

QUEUESIZE，设置队列大小，存储采样的 span 信息，队列满了后一次性发送到 jaeger 后端；defaultQueueSize 默认为 100；
BufferFlushInterval 强制清空、推送队列时间，对于流量不高的程序，队列可能长时间不能满，那么设置这个时间，超时可以自动推送一次。对于高并发的情况，一般队列很快就会满的，满了后也会自动推送。默认为1秒。
LogSpans 是否把 Log 也推送，span 中可以携带一些日志信息。
LocalAgentHostPort 要推送到的 Jaeger agent，默认端口 6831，是 Jaeger 接收压缩格式的 thrift 协议的数据端口。
CollectorEndpoint 要推送到的 Jaeger Collector，用 Collector 就不用 agent 了。

例如通过 http 上传 trace：

		Reporter: &jaegercfg.ReporterConfig{
			LogSpans:           true,
			CollectorEndpoint: "http://127.0.0.1:14268/api/traces",
		},

据黑洞大佬的提示，HTTP 走的就是 thrift，而 gRPC 是 .NET 特供，所以 reporter 格式只有一种，而且填写 CollectorEndpoint，我们注意要填写完整的信息。

完整代码测试：

import (
	"bufio"
    "github.com/opentracing/opentracing-go"
	"github.com/uber/jaeger-client-go"
	jaegercfg "github.com/uber/jaeger-client-go/config"
	jaegerlog "github.com/uber/jaeger-client-go/log"
	"os"
)

func main() {

	var cfg = jaegercfg.Configuration{
		ServiceName: "client test", // 对其发起请求的的调用链，叫什么服务
		Sampler: &jaegercfg.SamplerConfig{
			Type:  jaeger.SamplerTypeConst,
			Param: 1,
		},
		Reporter: &jaegercfg.ReporterConfig{
			LogSpans:           true,
			CollectorEndpoint: "http://127.0.0.1:14268/api/traces",
		},
	}

	jLogger := jaegerlog.StdLogger
	tracer, closer, _ := cfg.NewTracer(
		jaegercfg.Logger(jLogger),
	)

	// 创建第一个 span A
	parentSpan := tracer.StartSpan("A")
	// 调用其它服务
	B(tracer, parentSpan)
	// 结束 A
	parentSpan.Finish()
	// 结束当前 tracer
	closer.Close()

	reader := bufio.NewReader(os.Stdin)
	_, _ = reader.ReadByte()
}
func B(tracer opentracing.Tracer, parentSpan opentracing.Span) {
	// 继承上下文关系，创建子 span
	childSpan := tracer.StartSpan(
		"B",
		opentracing.ChildOf(parentSpan.Context()),
	)
	defer childSpan.Finish()
}

运行后输出结果：

2021/03/30 15:04:15 Initializing logging reporter
2021/03/30 15:04:15 Reporting span 715e0af47c7d9acb:7dc9a6b568951e4f:715e0af47c7d9acb:1
2021/03/30 15:04:15 Reporting span 715e0af47c7d9acb:715e0af47c7d9acb:0000000000000000:1
2021/03/30 15:04:15 DEBUG: closing tracer
2021/03/30 15:04:15 DEBUG: closing reporter
2021/03/30 15:04:15 DEBUG: flushed 1 spans
2021/03/30 15:04:15 DEBUG: flushed 1 spans

打开 Jaeger UI，可以看到已经推送完毕(http://127.0.0.1:16686)。

上传的trace

这时，我们可以抽象代码代码示例：

func CreateTracer(servieName string) (opentracing.Tracer, io.Closer, error) {
	var cfg = jaegercfg.Configuration{
		ServiceName: servieName,
		Sampler: &jaegercfg.SamplerConfig{
			Type:  jaeger.SamplerTypeConst,
			Param: 1,
		},
		Reporter: &jaegercfg.ReporterConfig{
			LogSpans:          true,
			// 按实际情况替换你的 ip
			CollectorEndpoint: "http://127.0.0.1:14268/api/traces",
		},
	}

	jLogger := jaegerlog.StdLogger
	tracer, closer, err := cfg.NewTracer(
		jaegercfg.Logger(jLogger),
	)
	return tracer, closer, err
}

这样可以复用代码，调用函数创建一个新的 tracer。这个记下来，后面要用。

分布式系统与span

前面介绍了如何配置 tracer 、推送数据到 Jaeger Collector，接下来我们聊一下 Span。请看图。

下图是一个由用户 X 请求发起的，穿过多个服务的分布式系统，A、B、C、D、E 表示不同的子系统或处理过程。

在这个图中， A 是前端，B、C 是中间层、D、E 是 C 的后端。这些子系统通过 rpc 协议连接，例如 gRPC。

一个简单实用的分布式链路追踪系统的实现，就是对服务器上每一次请求以及响应收集跟踪标识符(message identifiers)和时间戳(timestamped events)。

这里，我们只需要记住，从 A 开始，A 需要依赖多个服务才能完成任务，每个服务可能是一个进程，也可能是一个进程中的另一个函数。这个要看你代码是怎么写的。后面会详细说一下如何定义这种关系，现在大概了解一下即可。

怎么调、怎么传

如果有了解过 Jaeger 或读过分布式链路追踪框架的基本实现原理，那么已经大概了解的 Jaeger 的工作原理。

jaeger 是分布式链路追踪工具，如果不用在跨进程上，那么 Jaeger 就失去了意义。而微服务中跨进程调用，一般有 HTTP 和 gRPC 两种，下面将来讲解如何在 HTTP、gPRC 调用中传递 Jaeger 的上下文。

HTTP，跨进程追踪

A、B 两个进程，A 通过 HTTP 调用 B 时，通过 Http Header 携带 trace 信息(称为上下文)，然后 B 进程接收后，解析出来，在创建 trace 时跟传递而来的上下文关联起来。

一般使用中间件来处理别的进程传递而来的上下文。inject 函数打包上下文到 Header 中，而 extract 函数则将其解析出来。

这里我们分为两步，第一步从 A 进程中传递上下文信息到 B 进程，为了方便演示已经实践，我们使用 client-webserver 的形式，编写代码。

客户端

在 A 进程新建一个方法：

// 请求远程服务，获得用户信息
func GetUserInfo(tracer opentracing.Tracer, parentSpan opentracing.Span) {
	// 继承上下文关系，创建子 span
	childSpan := tracer.StartSpan(
		"B",
		opentracing.ChildOf(parentSpan.Context()),
	)

	url := "http://127.0.0.1:8081/Get?username=痴者工良"
	req,_ := http.NewRequest("GET", url, nil)
	// 设置 tag，这个 tag 我们后面讲
	ext.SpanKindRPCClient.Set(childSpan)
	ext.HTTPUrl.Set(childSpan, url)
	ext.HTTPMethod.Set(childSpan, "GET")
	tracer.Inject(childSpan.Context(), opentracing.HTTPHeaders, opentracing.HTTPHeadersCarrier(req.Header))
	resp, _ := http.DefaultClient.Do(req)
	_ = resp 	// 丢掉
	defer childSpan.Finish()
}

然后复用前面提到的 CreateTracer 函数。

main 函数改成：

func main() {
	tracer, closer, _ := CreateTracer("UserinfoService")
	// 创建第一个 span A
	parentSpan := tracer.StartSpan("A")
	// 调用其它服务
	GetUserInfo(tracer, parentSpan)
	// 结束 A
	parentSpan.Finish()
	// 结束当前 tracer
	closer.Close()

	reader := bufio.NewReader(os.Stdin)
	_, _ = reader.ReadByte()
}

完整代码可参考：https://github.com/whuanle/DistributedTracingGo/issues/1

Web 服务端

服务端我们使用 gin 来搭建。

新建一个 go 项目，在 main.go 目录中，执行 go get -u github.com/gin-gonic/gin。

创建一个函数，该函数可以从创建一个 tracer，并且继承其它进程传递过来的上下文信息。

// 从上下文中解析并创建一个新的 trace，获得传播的 上下文(SpanContext)
func CreateTracer(serviceName string, header http.Header) (opentracing.Tracer,opentracing.SpanContext, io.Closer, error) {
	var cfg = jaegercfg.Configuration{
		ServiceName: serviceName,
		Sampler: &jaegercfg.SamplerConfig{
			Type:  jaeger.SamplerTypeConst,
			Param: 1,
		},
		Reporter: &jaegercfg.ReporterConfig{
			LogSpans: true,
			// 按实际情况替换你的 ip
			CollectorEndpoint: "http://127.0.0.1:14268/api/traces",
		},
	}

	jLogger := jaegerlog.StdLogger
	tracer, closer, err := cfg.NewTracer(
		jaegercfg.Logger(jLogger),
	)
	// 继承别的进程传递过来的上下文
	spanContext, _ := tracer.Extract(opentracing.HTTPHeaders,
		opentracing.HTTPHeadersCarrier(header))
	return tracer, spanContext, closer, err
}

为了解析 HTTP 传递而来的 span 上下文，我们需要通过中间件来解析了处理一些细节。

func UseOpenTracing() gin.HandlerFunc {
	handler := func(c *gin.Context) {
		// 使用 opentracing.GlobalTracer() 获取全局 Tracer
		tracer,spanContext, closer, _ := CreateTracer("userInfoWebService", c.Request.Header)
		defer closer.Close()
		// 生成依赖关系，并新建一个 span、
		// 这里很重要，因为生成了  References []SpanReference 依赖关系
		startSpan:= tracer.StartSpan(c.Request.URL.Path,ext.RPCServerOption(spanContext))
		defer startSpan.Finish()

		// 记录 tag
		// 记录请求 Url
		ext.HTTPUrl.Set(startSpan, c.Request.URL.Path)
		// Http Method
		ext.HTTPMethod.Set(startSpan, c.Request.Method)
		// 记录组件名称
		ext.Component.Set(startSpan, "Gin-Http")

		// 在 header 中加上当前进程的上下文信息
		c.Request=c.Request.WithContext(opentracing.ContextWithSpan(c.Request.Context(),startSpan))
		// 传递给下一个中间件
		c.Next()
		// 继续设置 tag
		ext.HTTPStatusCode.Set(startSpan, uint16(c.Writer.Status()))
	}

	return handler
}

别忘记了 API 服务：

func GetUserInfo(ctx *gin.Context) {
	userName := ctx.Param("username")
	fmt.Println("收到请求，用户名称为:", userName)
	ctx.String(http.StatusOK, "他的博客是 https://whuanle.cn")
}

然后是 main 方法：

func main() {
	r := gin.Default()
	// 插入中间件处理
	r.Use(UseOpenTracing())
	r.GET("/Get",GetUserInfo)
	r.Run("0.0.0.0:8081") // listen and serve on 0.0.0.0:8080 (for windows "localhost:8080")
}

完整代码可参考：https://github.com/whuanle/DistributedTracingGo/issues/2

分别启动 webserver、client，会发现打印日志。并且打开 jaerger ui 界面，会出现相关的追踪信息。

Jaeger追踪记录

Tag 、 Log 和 Ref

Jaeger 的链路追踪中，可以携带 Tag 和 Log，他们都是键值对的形式：

                        {
                            "key": "http.method",
                            "type": "string",
                            "value": "GET"
                        },

Tag 设置方法是 ext.xxxx，例如：

ext.HTTPUrl.Set(startSpan, c.Request.URL.Path)

因为 opentracing 已经规定了所有的 Tag 类型，所以我们只需要调用 ext.xxx.Set() 设置即可。

前面写示例的时候忘记把日志也加一下了。。。日志其实很简单的，通过 span 对象调用函数即可设置。

示例(在中间件里面加一下)：

        startSpan.LogFields(
            log.String("event", "soft error"),
            log.String("type", "cache timeout"),
            log.Int("waited.millis", 1500))

ref 就是多个 span 之间的关系。span 可以是跨进程的，也可以是一个进程内的不同函数中的。

其中 span 的依赖关系表示示例：

                    "references": [
                        {
                            "refType": "CHILD_OF",
                            "traceID": "33ba35e7cc40172c",
                            "spanID": "1c7826fa185d1107"
                        }]

spanID 为其依赖的父 span。

可以看下面这张图。

一个进程中的 tracer 可以包装一些代码和操作，为多个 span 生成一些信息，或创建父子关系。

而远程请求中传递的是 SpanContext，传递后，远程服务也创建新的 tracer，然后从 SpanContext 生成 span 依赖关系。

子 span 中，其 reference 列表中，会带有父 span 的 span id。

span传播

到此这篇关于Jaeger Client Go入门并实现链路追踪的文章就介绍到这了。希望对大家的学习有所帮助，也希望大家多多支持脚本之家。

您可能感兴趣的文章:

Mango Cache缓存管理库TinyLFU源码解析
这篇文章主要为大家介绍了Mango Cache缓存管理库TinyLFU源码解析，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
2022-09-09
$golang替换无法显示的特殊字符(\u0000, \000, ^@)$
golang替换无法显示的特殊字符(\u0000, \000, ^@)
这篇文章主要介绍了golang替换无法显示的特殊字符,包括的字符有\u0000, \000, ^@等，下文详细资料，需要的小伙伴可以参考一下
2022-04-04
Golang实现微信公众号后台接入的示例代码
这篇文章主要介绍了Golang实现微信公众号后台接入的示例代码，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2023-02-02
Go语言实现简单的一个静态WEB服务器
这篇文章主要介绍了Go语言实现简单的一个静态WEB服务器,本文给出了实现代码和运行效果,学习Golang的练手作品,需要的朋友可以参考下
2014-10-10
Go递归修改文件名的实例代码
这篇文章主要介绍了Go递归修改文件名的实例代码,本文给大家介绍的非常详细，对大家的学习或工作具有一定的饿参考借鉴价值，需要的朋友可以参考下
2021-01-01
一文带你了解Go语言中的指针和结构体
前面的两篇文章对 Go 语言的基础语法和基本数据类型以及几个复合数据类型进行介绍，本文将对 Go 里面的指针和结构体进行介绍，也为后续文章做铺垫，感兴趣的可以了解一下
2022-11-11
Go语言实现可选参数的方法小结
这篇文章主要为大家详细介绍了Go语言实现可选参数的一些常见方法,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下
2024-02-02
入门学习Go的基本语法
这篇文章主要介绍了Go语法的基本概念,本文讲解了Golang的基本知识、基础语法、相关术语等,需要的朋友可以参考下，希望能帮助到你
2021-07-07
golang语言实现的文件上传与文件下载功能示例
这篇文章主要介绍了golang语言实现的文件上传与文件下载功能,结合实例形式分析了Go语言实现的文件传输相关操作技巧,需要的朋友可以参考下
2020-02-02
详解 Go 语言中 Map 类型和 Slice 类型的传递
这篇文章主要介绍了详解 Go 语言中 Map 类型和 Slice 类型的传递的相关资料,需要的朋友可以参考下
2017-09-09