jaeger

本文将讲解jaeger基本概念，基于golang的代码实现以及注入原理

jaeger 概述

组件概念：

  • jaeger-client

  • jaeger-agent 将client发送的span发送到collector

  • jaeger-collector 收集数据并存储或发送到队列

  • jaeger ingester 读取kafka队列写入存储

  • jaeger-query 查询数据展示tracer

逻辑概念：

  • span 具体的某个操作，包含以下属性

    • 操作名称

    • 开始时间

    • 执行时长

    • logs # 捕获指定时间的消息，或调试输出

    • tags # 不被继承,查询过滤理解追踪数据

  • Trace 是一个完整的执行过程，是span的有向无环图

  • SpanContext # 传递给下级span的信息trace_id，span_id，parentId等

  • Baggage 存储在SpanContext的键值集合，在一个链路上全局传输

应用代码实现

单span代码

    // 从环境变量获取配置参数
    cfg,err:=jaegercfg.FromEnv()
    if err!=nil {
        log.Println(err)
    }
    cfg.Sampler=&jaegercfg.SamplerConfig{
        Type:  "const",// 使用const采样器
        Param: 1, // 采样所有追踪
    }
    // 设置服务名
    cfg.ServiceName = "jaeger tracer demo"
    // 根据创建Tracer
    tracer, closer, err := cfg.NewTracer()
    if err != nil {
        log.Println(err)
    }
    defer closer.Close()
    //设置全局tracer
    opentracing.SetGlobalTracer(tracer)
    //创建一个span
    parentSpan:=tracer.StartSpan("root")
    defer parentSpan.Finish()
    parentSpan.LogFields(
        tracelog.String("hello","world"),
    )
    parentSpan.LogKV("foo","bar")
    // 创建一个childspan
    childspan:=tracer.StartSpan("child span",opentracing.ChildOf(parentSpan.Context()))
    defer childspan.Finish()

夸进程传播

使用上下文传递

ctx := opentracing.ContextWithSpan(context.Background(), span)
span, _ := opentracing.StartSpanFromContext(ctx, "req svc2")

跨请求传播

将span注入header

    ext.SpanKindRPCClient.Set(span)
    ext.HTTPUrl.Set(span, url)
    ext.HTTPMethod.Set(span, "GET")
    span.Tracer().Inject(
        span.Context(),
        opentracing.HTTPHeaders,
        opentracing.HTTPHeadersCarrier(req.Header),
    )

从header获取span上下文，并根据上下文创建新span

    spanCtx, _ := tracer.Extract(opentracing.HTTPHeaders, opentracing.HTTPHeadersCarrier(r.Header))
    span := tracer.StartSpan("get haha", ext.RPCServerOption(spanCtx))

跨应用多span示例代码

有两个服务组成，svc1,svc2 有三个span组成，svc1 sayhello --> svc1 req svc2 --> svc2 get bagger

svc1代码

package main

import (
    "context"
    "github.com/opentracing/opentracing-go"
    "github.com/opentracing/opentracing-go/ext"
    "github.com/uber/jaeger-client-go/config"
    "log"
    "net/http"
)

func main() {
    cfg, err := config.FromEnv()
    if err != nil {
        log.Println(err)
    }
    cfg.ServiceName = "svc1"
    cfg.Sampler = &config.SamplerConfig{
        Type:  "const",
        Param: 1,
    }
    tracer, closer, err := cfg.NewTracer()
    if err != nil {
        log.Println(err)
    }
    defer closer.Close()
    opentracing.SetGlobalTracer(tracer)

    span := tracer.StartSpan("say hello")
    span.SetTag("role", "root")
    span.LogKV("hello", "world")
    defer span.Finish()

    ctx := opentracing.ContextWithSpan(context.Background(), span)
    testchildspan(ctx)
}
func testchildspan(ctx context.Context) {
    url := "http://localhost:8000"
    client := &http.Client{}
    req, err := http.NewRequest("GET", url, nil)
    if err != nil {
        log.Println(err)
    }

    span, _ := opentracing.StartSpanFromContext(ctx, "req svc2")
    defer span.Finish()
    span.SetTag("role", "childspan")
    span.SetBaggageItem("haha", "heihei")

    ext.SpanKindRPCClient.Set(span)
    ext.HTTPUrl.Set(span, url)
    ext.HTTPMethod.Set(span, "GET")
    span.Tracer().Inject(
        span.Context(),
        opentracing.HTTPHeaders,
        opentracing.HTTPHeadersCarrier(req.Header),
    )

    resp, err := client.Do(req)
    if err != nil {
        log.Println(err)
    }
    log.Println(resp.Status)
}

svc2代码

package main

import (
    "net/http"
    "log"
    opentracing "github.com/opentracing/opentracing-go"
    "github.com/opentracing/opentracing-go/ext"
    otlog "github.com/opentracing/opentracing-go/log"
    "github.com/uber/jaeger-client-go/config"
)

func main(){
    http.HandleFunc("/",test)
    http.ListenAndServe(":8000",nil)
}

func test(w http.ResponseWriter,r *http.Request){
    log.Println(r.Header,r.URL)

    cfg,err:=config.FromEnv()
    if err!=nil {
        log.Println(err)
    }
    cfg.ServiceName="svc2"
    cfg.Sampler=&config.SamplerConfig{
        Type:  "const",
        Param: 1,
    }
    tracer,closer,err:=cfg.NewTracer()
    if err!=nil {
        log.Println(err)
    }
    defer closer.Close()

    spanCtx, _ := tracer.Extract(opentracing.HTTPHeaders, opentracing.HTTPHeadersCarrier(r.Header))
    span := tracer.StartSpan("get haha", ext.RPCServerOption(spanCtx))
    defer span.Finish()
    log.Println(span.BaggageItem("haha"))

    span.LogFields(
        otlog.String("event", "string-format"),
        otlog.String("value", "hello wrold"),
    )
    w.Write([]byte("hello wrold"))
}

header数据解析

对于上述代码我们发现svc1发送给svc2有如下特殊header Uber-Trace-Id:[518ee099f68f3974:17531754249a513a:518ee099f68f3974:1] Uberctx-Haha:[heihei] 那这些header是如何根据tracer信息添加呢

根据传入的format获取对应的injector

Inject代码实现

func (t *Tracer) Inject(ctx opentracing.SpanContext, format interface{}, carrier interface{}) error {
    c, ok := ctx.(SpanContext)
    if !ok {
        return opentracing.ErrInvalidSpanContext
    }
    if injector, ok := t.injectors[format]; ok {
        return injector.Inject(c, carrier)
    }
    return opentracing.ErrUnsupportedFormat
}

我们看到是根据format拿到Injector,默认支持三种类型

  • binary

  • TextMap

  • HTTPHeaders

其中HTTPHeaders基于TextMap传播

Propagator

两种Propagator实现了Injector接口

  • BinaryPropagator

  • TextMapPropagator

    BinaryPropagator的不再讲述

TextMapPropagator

func (p *TextMapPropagator) Inject(
    sc SpanContext,
    abstractCarrier interface{},
) error {
    textMapWriter, ok := abstractCarrier.(opentracing.TextMapWriter)
    if !ok {
        return opentracing.ErrInvalidCarrier
    }

    // 不要使用trace context对字符串进行编码
    // 设置trace 上下文header
    // 默认值TraceContextHeaderName = "uber-trace-id"
    textMapWriter.Set(p.headerKeys.TraceContextHeaderName, sc.String())
    // 设置baggage
    for k, v := range sc.baggage {
        safeKey := p.addBaggageKeyPrefix(k)
        safeVal := p.encodeValue(v)
        textMapWriter.Set(safeKey, safeVal)
    }
    return nil
}

carrier

Propagator通过carrier注入提取数据 binary直接传入实现io.Writer接口对象即可 TextMapPropagator有两种carrier

  • HTTPHeadersCarrier

  • TextMapCarrier

HTTPHeadersCarrier

type HTTPHeadersCarrier http.Header

// 符合TextMapWriter接口
func (c HTTPHeadersCarrier) Set(key, val string) {
    h := http.Header(c)
    h.Set(key, val)
}

// 符合TextMapReader接口
func (c HTTPHeadersCarrier) ForeachKey(handler func(key, val string) error) error {
    for k, vals := range c {
        for _, v := range vals {
            if err := handler(k, v); err != nil {
                return err
            }
        }
    }
    return nil
}

TextMapCarrier

type TextMapCarrier map[string]string

// ForeachKey conforms to the TextMapReader interface.
func (c TextMapCarrier) ForeachKey(handler func(key, val string) error) error {
    for k, v := range c {
        if err := handler(k, v); err != nil {
            return err
        }
    }
    return nil
}

// Set implements Set() of opentracing.TextMapWriter
func (c TextMapCarrier) Set(key, val string) {
    c[key] = val
}

结果

TraceContextHeaderName 默认值为 "uber-trace-id" 设置该值代码为：

func (c SpanContext) String() string {
    if c.traceID.High == 0 {
        return fmt.Sprintf("%x:%x:%x:%x", c.traceID.Low, uint64(c.spanID), uint64(c.parentID), c.samplingState.stateFlags.Load())
    }
    return fmt.Sprintf("%x%016x:%x:%x:%x", c.traceID.High, c.traceID.Low, uint64(c.spanID), uint64(c.parentID), c.samplingState.stateFlags.Load())
}

由此看出该header包含了traceID,spanID,parentID

扫描关注我的公众号:

PreviouszipkinNext开发实践

Last updated