Jaeger SDK使用教程-go

Jaeger支持两种SDK，

• 一种是jaeger-Client，地址:https://github.com/jaegertracing/jaeger-client-go，
• 一种 是OpenTelemetry SDK，地址：https://github.com/open-telemetry/opentelemetry-go

官方建议迁移到OpenTelemetry SDK，Client除安全修复，已不再更新；

请提前搭建Jaeger环境，没搭建的看这里

一、OpenTelemetry SDK使用：

直接上示例代码，没有什么比看代码更直观的了

package main

import (
	"context"
	"fmt"
	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/attribute"
	"go.opentelemetry.io/otel/exporters/jaeger"
	"go.opentelemetry.io/otel/sdk/resource"
	tracesdk "go.opentelemetry.io/otel/sdk/trace"
	semconv "go.opentelemetry.io/otel/semconv/v1.9.0"
	"log"
	"time"
)

const (
	service     = "jaeger-OTtrace-demo-01"
	environment = "production"
	id          = 1
)

func tracerProvider(url string) (*tracesdk.TracerProvider, error) {
	// Create the Jaeger exporter
	//exp, err := jaeger.New(jaeger.WithCollectorEndpoint(jaeger.WithEndpoint(url)))
	exp, err := jaeger.New(jaeger.WithAgentEndpoint(jaeger.WithAgentHost("10.1.87.69"), jaeger.WithAgentPort("6831")))
	if err != nil {
		return nil, err
	}
	tp := tracesdk.NewTracerProvider(
		// Always be sure to batch in production.
		tracesdk.WithBatcher(exp),
		// Record information about this application in a Resource.
		tracesdk.WithResource(resource.NewWithAttributes(
			semconv.SchemaURL,
			semconv.ServiceNameKey.String(service),
			attribute.String("environment", environment),
			attribute.Int64("ID", id),
		)),
	)
	//tp.RegisterSpanProcessor()
	return tp, nil
}

func main() {
	tp, err := tracerProvider("http://10.2.97.109:14268/api/traces")
	if err != nil {
		log.Fatal(err)
	}

	// Register our TracerProvider as the global so any imported
	// instrumentation in the future will default to using it.
	otel.SetTracerProvider(tp)

	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	// Cleanly shutdown and flush telemetry when the application exits.
	defer func(ctx context.Context) {
		// Do not make the application hang when it is shutdown.
		ctx, cancel = context.WithTimeout(ctx, time.Second*5)
		defer cancel()
		if err := tp.Shutdown(ctx); err != nil {
			log.Fatal(err)
		}
	}(ctx)

	tr := tp.Tracer(service)
	startTime := time.Now().UnixNano() / 1e6
	for i := 0; i < 10000; i++ {
		_, span := tr.Start(ctx, "foo")
		span.SetName("bar")
		span.SetAttributes(attribute.String("foo", "bar"))
		//span.SetAttributes(attribute.Int64("baz", 1))
		//span.SetAttributes(attribute.Float64("qux", 1.0))
		//span.SetAttributes(attribute.Bool("quux", true))
		span.End()
	}

	fmt.Println(time.Now().UnixNano()/1e6 - startTime)
	time.Sleep(time.Second * 15)
}

二、Jaeger-Client使用

1.通过agent发送

package main

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

func _NewJaegerTracer(serviceName string) (opentracing.Tracer, io.Closer) {
	sender, _ := jaeger.NewUDPTransport("10.2.187.169:6831", 0)
	tracer, closer := jaeger.NewTracer(serviceName,
		jaeger.NewConstSampler(true),
		jaeger.NewRemoteReporter(sender))
	return tracer, closer
}

func initJaeger(service string) (opentracing.Tracer, io.Closer) {
	cfg := &config.Configuration{
		Sampler: &config.SamplerConfig{
			Type:  "const",
			Param: 1,
		},
		Reporter: &config.ReporterConfig{
			LogSpans: true,
			//LocalAgentHostPort: "10.1.87.69:6831",
			LocalAgentHostPort: "10.2.187.169:6121",
		},
	}
	//tracer, closer, err := cfg.New(service, config.Logger(jaeger.StdLogger))
	tracer, closer, err := cfg.NewTracer()
	if err != nil {
		panic(fmt.Sprintf("ERROR: cannot init Jaeger: %v\n", err))
	}
	return tracer, closer
}

func foo3(req string, ctx context.Context) (reply string) {
	//1.创建子span
	span, _ := opentracing.StartSpanFromContext(ctx, "span_foo3")
	defer func() {
		//4.接口调用完，在tag中设置request和reply
		span.SetTag("request", req)
		span.SetTag("reply", reply)
		span.Finish()
	}()

	println(req)
	//2.模拟处理耗时
	time.Sleep(time.Second / 2)
	//3.返回reply
	reply = "foo3Reply"
	return
}

//跟foo3一样逻辑
func foo4(req string, ctx context.Context) (reply string) {
	span, _ := opentracing.StartSpanFromContext(ctx, "span_foo4")
	defer func() {
		span.SetTag("request", req)
		span.SetTag("reply", reply)
		span.Finish()
	}()

	println(req)
	time.Sleep(time.Second / 2)
	reply = "foo4Reply"
	return
}

func stressTest(tracer opentracing.Tracer, closer io.Closer) {
	//defer closer.Close()
	span := tracer.StartSpan("span_root")
	//ctx := opentracing.ContextWithSpan(context.Background(), span)
	//r1 := foo3("Hello foo3", ctx)
	//r2 := foo4("Hello foo4", ctx)
	//fmt.Println(r1, r2)
	span.Finish()
	//wg.Done()
}

var wg sync.WaitGroup //定义一个同步等待的组

func __main() {
	tracer, closer := NewJaegerTracer("jaeger-demo-2")
	opentracing.SetGlobalTracer(tracer) //StartspanFromContext创建新span时会用到
	startTime := time.Now().UnixNano() / 1e6
	for i := 0; i < 1000; i++ {
		stressTest(tracer, closer)
	}
	fmt.Println(time.Now().UnixNano()/1e6 - startTime)
	time.Sleep(time.Second * 15)
}

2.发送给Collector

package main

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

func NewJaegerTracer(service string) (opentracing.Tracer, io.Closer) {

	sender := transport.NewHTTPTransport(
		// 设置网关，网关因地域而异。
		"http://10.2.187.169:14268/api/traces",
	)
	tracer, closer := jaeger.NewTracer(service,
		jaeger.NewConstSampler(true),
		jaeger.NewRemoteReporter(sender))
	return tracer, closer
}

func stress(tracer opentracing.Tracer) {
	// 创建Span。
	span := tracer.StartSpan("myspan")
	// 设置Tag。
	span.SetTag("mytag", "123")
	span.Finish()
}

func _main() {
	tracer, _ := NewJaegerTracer("jaeger-collector-01")

	startTime := time.Now().UnixNano() / 1e6
	for i := 0; i < 1000; i++ {
		stress(tracer)
	}
	fmt.Println(time.Now().UnixNano()/1e6 - startTime)
	time.Sleep(time.Second * 15)
}

参考：

1. https://blog.csdn.net/liyunlong41/article/details/87932953
2. https://help.aliyun.com/document_detail/90505.html
3. https://github.com/open-telemetry/opentelemetry-go/blob/main/example/jaeger/main.go