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 可以嵌套并排序以建立因果关系模型。

Span 由以下信息组成：

• An operation name：操作名称，必有；

• A start timestamp：开始时间戳，必有；

• A finish timestamp：结束时间戳，必有；

• Span Tags.：Key-Value 形式表示请求的标签，可选；

• Span Logs：Key-Value 形式表示，记录简单的、结构化的日志，必须是字符串类型，可选；

• SpanContext ：跨度上下文，在不同的 span 中传递，建立关系；

• References t：引用的其它 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从载体

  由起点进程创建一个 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 后端检索采样策略。有关更多信息，请参阅采样。

代理（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 简介 | MakeOptim

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

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

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