Jaeger介绍入门和Go实现-摩杜云开发者社区

Jaeger介绍入门和Go实现_链路

Jaeger 是受到 Dapper 和 OpenZipkin 启发的由 Uber Technologies 作为开源发布的分布式跟踪系统。

Jaeger 用于监视和诊断基于微服务的分布式系统，包括：

分布式上下文传播
分布式传输监控
根本原因分析
服务依赖性分析
性能/延迟优化

注：简单理解的话，可以认为 Jaeger 是兼容 OpenTracing 的一个实现。

Uber 发表了一篇博客文章 Evolving Distributed Tracing at Uber，文中解释了 Jaeger 在架构选择方面的历史和原因。Jaeger 的创建者 Yuri Shkuro 还出版了一本书 Mastering Distributed Tracing，该书深入介绍了 Jaeger 设计和操作的许多方面，以及一般的分布式跟踪。

特性

兼容 OpenTracing
的数据模型和工具库

包括Go，Java，Node，Python， C++ 和 C＃

对每个服务/端点概率使用一致的前期采样
多种存储后端支持：Cassandra，Elasticsearch，内存。
系统拓扑图
自适应采样（即将推出）
收集后数据处理管道（即将推出）

注：更多详细信息，请参见特性页面。

架构

Jaeger 的客户端遵守 OpenTracing 的数据模型。

为了更好地理解 Jaeger 的架构，先回顾以下几个术语。

Span

一个 Span 表示 Jaeger 的逻辑工作单元，Span 具有操作名称，操作的开始时间，和持续时间。Span 可以嵌套并排序以建立因果关系模型。

Jaeger介绍入门和Go实现_链路_02

Span 由以下信息组成：

An operation name：操作名称，必有；
A start timestamp：开始时间戳，必有；
A finish timestamp：结束时间戳，必有；
Span Tags.：Key-Value 形式表示请求的标签，可选；
Span Logs：Key-Value 形式表示，记录简单的、结构化的日志，必须是字符串类型，可选；
SpanContext：跨度上下文，在不同的 span 中传递，建立关系；
Referencest：引用的其它 Span；

span 之间如果是父子关系，则可以使用 SpanContext 绑定这种关系。父子关系有 ChildOf、FollowsFrom 两种表示，ChildOf 表示父 Span 在一定程度上依赖子 Span，而 FollowsFrom 表示父 Span 完全不依赖其子Span 的结果。

{
    "traceID": "790e003e22209ca4",
    "spanID": "4b73f8e8e77fe9dc",
    "flags": 1,
    "operationName": "print-hello",
    "references": [],
    "startTime": 1611318628515966,
    "duration": 259,
    "tags": [
        {
            "key": "internal.span.format",
            "type": "string",
            "value": "proto"
        }
    ],
    "logs": [
        {
            "timestamp": 1611318628516206,
            "fields": [
                {
                    "key": "event",
                    "type": "string",
                    "value": "WriteLine"
                }
            ]
        }
    ]
}

OpenTracing API

在 OpenTracing API 中，有三个主要对象：

Tracer
Span
SpanContext

Tracer可以创建Spans并了解如何跨流程边界对它们的元数据进行Inject（序列化）和Extract（反序列化）。它具有以下功能：

开始一个新的Span
Inject一个SpanContext到一个载体
Extract一个SpanContext从载体

Jaeger介绍入门和Go实现_github_03

由起点进程创建一个 Tracer，然后启动进程发起请求，每个动作产生一个 Span，如果有父子关系，Tracer 可以将它们关联起来。当请求完成后， Tracer 将跟踪信息推送到 Jaeger-Collector中。

详细请查阅文档：https://opentracing.io/docs/overview/tracers/

Trace

一个 Trace 是通过系统的数据/执行路径，Trace 可被认为是由一组 Span 定义的有向无环图(DAG)。

组件

Jaeger 可以使用 all-in-one 二进制（其中所有 Jaeger 后端组件都在单个进程中运行）进行部署，也可以作为可扩展的分布式系统进行部署，如下所述。有两个主要的部署选项：

收集器直接写入存储。
收集器写入 Kafka 作为中间缓冲。

下面介绍 Jaeger 各个组件以及组件间的关系。

客户端库（client libraries）

Jaeger 客户端是 OpenTracing API 的特定于语言的实现。它们可用于手动或与已经与 OpenTracing 集成的各种现有开源框架（例如 Flask，Dropwizard，gRPC 等）一起为分布式跟踪应用程序进行检测。

检测服务在接收新请求时创建 Span，并将上下文信息（trace id，Span id 和 baggage）附加到传出请求。只有 id 和 baggage 随请求一起传播；所有其他概要分析数据（如操作名称，时间，tag 和 log）都不会传播。相反，它在后台异步地传输到 Jaeger 后端。

为了最大程度地减少开销，Jaeger 客户端采用了各种采样策略。对跟踪进行采样时，将捕获分析范围数据并将其传输到 Jaeger 后端。当不对跟踪进行采样时，根本不会收集任何性能分析数据，并且对 OpenTracing API 的调用会被短路，以产生最小的开销。默认情况下，Jaeger 客户端对 0.1％ 的 traces 进行采样（每 1000 条中的 1 条），并且能够从 Jaeger 后端检索采样策略。有关更多信息，请参阅采样。

Jaeger介绍入门和Go实现_链路_06

代理（Agent）

Jaeger 代理是一个网络守护程序，它侦听通过 UDP 发送的 span，然后将其分批发送给收集器（Collector）。它旨在作为基础组件部署到所有主机。该代理为客户端抽象了收集器的路由和发现。

收集器（Collector）

Jaeger 收集器从 Jaeger 代理接收跟踪，并通过处理管道运行它们。当前，我们的管道会验证跟踪，为其建立索引，执行转换并最终存储它们。

Jaeger 的存储是一个可插拔组件，目前支持 Cassandra，Elasticsearch 和 Kafka。

查询（Query）

查询是一项从存储中检索跟踪并托管 UI 来显示跟踪的服务。

Ingester

Ingester 是一项从 Kafka topic 读取并写入另一个存储后端（Cassandra，Elasticsearch）的服务。

GO实例

client 客户端

package main

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

func ClientCreateTracer(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
}

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

   url := "http:/127.0.0.1:8081/Get?username=timelesszhuang"
   req, _ := http.NewRequest("GET", url, nil)
   // 设置 tag，这个 tag 我们后面讲
   ext.SpanKindRPCClient.Set(childSpan)
   ext.HTTPUrl.Set(childSpan, url)
   ext.HTTPMethod.Set(childSpan, "GET")
   //inject 函数打包上下文到 Header 中，而 extract 函数则将其解析出来。
   tracer.Inject(childSpan.Context(), opentracing.HTTPHeaders, opentracing.HTTPHeadersCarrier(req.Header))
   resp, _ := http.DefaultClient.Do(req)
   _ = resp // 丢掉
   defer childSpan.Finish()
}

func main() {
   tracer, closer, _ := ClientCreateTracer("UserinfoService")
   // 创建第一个 span A
   parentSpan := tracer.StartSpan("A")
   // 调用其它服务
   ClientGetUserInfo(tracer, parentSpan)
   // 结束 A
   parentSpan.Finish()
   // 结束当前 tracer
   closer.Close()
   reader := bufio.NewReader(os.Stdin)
   _, _ = reader.ReadByte()
}

//func x(ctx context.Context) {
// span, ctx := opentracing.StartSpanFromContext(ctx, "mytest")
// ext.SamplingPriority.Set(span, 1)
// defer span.Finish()
//
// span.LogFields(
//    log.String("event", "soft error"),
//    log.String("type", "cache timeout"),
//    log.Int("waited.millis", 1500),
// )
//}

gin server端

package main

import (
   "bkgrpc/endpoint"
   "bkgrpc/healthservice"
   "bkgrpc/proto"
   "bkgrpc/register"
   "bkgrpc/router"
   "bkgrpc/services"
   "google.golang.org/grpc"
   "google.golang.org/grpc/health/grpc_health_v1"
   "log"
   "net"
)

func main() {
   svc := services.ServicesA{}
   endpoints := endpoint.EndpointA{
      ConcatEndpoint: endpoint.MakeConcatEndpoint(svc),
      DiffEndpoint:   endpoint.MakeDiffEndpoint(svc),
      HealthEndpoint: endpoint.MakeHealthEndpoint(svc),
   }
   r := router.NewRouter(endpoints)
   lis, err := net.Listen("tcp", ":8085")
   if err != nil {
      log.Println(err)
      return
   }
   grpcserver := grpc.NewServer()
   gproto.RegisterStringServicesServer(grpcserver, r)
   //register into consul
   client := register.NewRegister("127.0.0.1", 8085)
   //service check
   c := healthservice.Service{}
   grpc_health_v1.RegisterHealthServer(grpcserver, &c)
   client.Register("Service", "testname", "testid")
   grpcserver.Serve(lis)
}

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。

Jaeger介绍入门和Go实现_github_07

参考博客链接：

微服务监控 - Jaeger 简介 | MakeOptim

Jaeger Client Go 链路追踪|入门详解

Jaeger 教程 - Aspire's Loft (pjw.io)

[全链路追踪与 Jaeger 入门](https://jckling.github.io/2021/04/02/Jaeger/全链路追踪与 Jaeger 入门/)

Jaeger Client Go 链路追踪|入门详解 - 痴者工良 -

分布式链路追踪系统：Jaeger在golang中的应用

没有无缘无故的荣耀