分布式链路追踪系列3-jaeger快速入门

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

docker run -d --name jaeger \
  -e COLLECTOR_ZIPKIN_HTTP_PORT=9411 \
  -p 5775:5775/udp \
  -p 6831:6831/udp \
  -p 6832:6832/udp \
  -p 5778:5778 \
  -p 16686:16686 \
  -p 14268:14268 \
  -p 9411:9411 \
  jaegertracing/all-in-one:1.14

1

jaeger-all-in-one --collector.zipkin.http-port=9411

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

{
  "service_strategies": [
    {
      "service": "foo",
      "type": "probabilistic",
      "param": 0.8,
      "operation_strategies": [
        {
          "operation": "op1",
          "type": "probabilistic",
          "param": 0.2
        },
        {
          "operation": "op2",
          "type": "probabilistic",
          "param": 0.4
        }
      ]
    },
    {
      "service": "bar",
      "type": "ratelimiting",
      "param": 5
    }
  ],
  "default_strategy": {
    "type": "probabilistic",
    "param": 0.5,
    "operation_strategies": [
      {
        "operation": "/health",
        "type": "probabilistic",
        "param": 0.0
      },
      {
        "operation": "/metrics",
        "type": "probabilistic",
        "param": 0.0
      }
    ]
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

package main

import (
	"github.com/opentracing/opentracing-go"
	"github.com/uber/jaeger-client-go"
	"github.com/uber/jaeger-client-go/config"
	"io"
	"time"
)

func main() {
	tracer, closer, err := NewTracer("demo-service", "127.0.0.1:6831")
	if err != nil {
		panic(err)
	}
	defer closer.Close()

	// 创建第一个 span A
	ASpan := tracer.StartSpan("A")
	// 可手动调用 Finish()
	defer ASpan.Finish()

	CallBService(tracer, ASpan)
}

// CallBService 调用B方法，可以假设是另外一个服务
func CallBService(tracer opentracing.Tracer, parentSpan opentracing.Span) {
	// 继承上下文关系，创建子 span
	BSpan := tracer.StartSpan("B", opentracing.ChildOf(parentSpan.Context()))
	BSpan.Finish()
}

// NewTracer 新建tracer
func NewTracer(serviceName, addr string) (opentracing.Tracer, io.Closer, error) {
	cgf := config.Configuration{
		// 服务名称
		ServiceName: serviceName,
		// 采样配置
		Sampler: &config.SamplerConfig{
			Type:  jaeger.SamplerTypeConst,
			Param: 1,
		},
		// 上报配置
		Reporter: &config.ReporterConfig{
			BufferFlushInterval: 1 * time.Second,
			LogSpans:            true,
			LocalAgentHostPort:  addr,
			// 直接上报到collector
			// CollectorEndpoint: "http://127.0.0.1:14268/api/traces",
		},
	}
	return cgf.NewTracer()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

package main

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

func main() {
	tracer, closer, err := NewClientTracer("demo-service", "127.0.0.1:6831")
	if err != nil {
		panic(err)
	}
	defer closer.Close()

	// 创建第一个 span A
	ASpan := tracer.StartSpan("A")
	// 可手动调用 Finish()
	defer ASpan.Finish()

	CallUserInfo(tracer, ASpan)
}

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

	url := "http://127.0.0.1:8081/Get?username=jeff"
	req, _ := http.NewRequest("GET", url, nil)
	// 设置 tag
	ext.SpanKindRPCClient.Set(childSpan)
	ext.HTTPUrl.Set(childSpan, url)
	ext.HTTPMethod.Set(childSpan, "GET")
	err := tracer.Inject(childSpan.Context(), opentracing.HTTPHeaders, opentracing.HTTPHeadersCarrier(req.Header))
	if err != nil {
		log.Error(err)
	}

	resp, _ := http.DefaultClient.Do(req)
	log.Event(fmt.Sprintf("%v", resp))
	defer childSpan.Finish()
}

// NewClientTracer 新建tracer
func NewClientTracer(serviceName, addr string) (opentracing.Tracer, io.Closer, error) {
	cgf := config.Configuration{
		// 服务名称
		ServiceName: serviceName,
		// 采样配置
		Sampler: &config.SamplerConfig{
			Type:  jaeger.SamplerTypeConst,
			Param: 1,
		},
		// 上报配置
		Reporter: &config.ReporterConfig{
			BufferFlushInterval: 1 * time.Second,
			LogSpans:            true,
			LocalAgentHostPort:  addr,
			// 直接上报到collector
			// CollectorEndpoint: "http://127.0.0.1:14268/api/traces",
		},
	}
	return cgf.NewTracer()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

package main

import (
	"github.com/gin-gonic/gin"
	"github.com/opentracing/opentracing-go"
	"github.com/opentracing/opentracing-go/ext"
	"github.com/opentracing/opentracing-go/log"
	"github.com/uber/jaeger-client-go"
	"github.com/uber/jaeger-client-go/config"
	"io"
	"net/http"
	"time"
)

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

func GetUserInfo(ctx *gin.Context) {
	userName := ctx.Param("username")
	log.Event("收到请求，用户名称为:" + userName)
	ctx.String(http.StatusOK, "他的博客是 https://luzhifang.github.io/")
}

func UseOpenTracing() gin.HandlerFunc {
	handler := func(c *gin.Context) {
		tracer, closer, _ := NewServerTracer("userInfoWebService", "127.0.0.1:6831")
		spanContext, err := tracer.Extract(opentracing.HTTPHeaders, opentracing.HTTPHeadersCarrier(c.Request.Header))
		if err != nil {
			log.Error(err)
		}
		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
}

// NewServerTracer 新建tracer
func NewServerTracer(serviceName, addr string) (opentracing.Tracer, io.Closer, error) {
	cgf := config.Configuration{
		// 服务名称
		ServiceName: serviceName,
		// 采样配置
		Sampler: &config.SamplerConfig{
			Type:  jaeger.SamplerTypeConst,
			Param: 1,
		},
		// 上报配置
		Reporter: &config.ReporterConfig{
			BufferFlushInterval: 1 * time.Second,
			LogSpans:            true,
			LocalAgentHostPort:  addr,
			// 直接上报到collector
			// CollectorEndpoint: "http://127.0.0.1:14268/api/traces",
		},
	}
	return cgf.NewTracer()
}