Go语言jaeger和opentracing

OpenTracing开放式分布式追踪规范，常见实现：jaeger和zipkin

docker启动一个实例：

docker run  -p 5775:5775/udp    -p 16686:16686    -p 6831:6831/udp   -p 6832:6832/udp   -p 5778:5778   -p 14268:14268    jaegertracing/all-in-one:latest

go 

来一个普通的go程序

package main

import (
	"fmt"
	"io"
	"io/ioutil"
	"net/http"
	"os"

	"github.com/uber/jaeger-client-go"
	"github.com/uber/jaeger-lib/metrics"

	"github.com/opentracing/opentracing-go"
	"github.com/opentracing/opentracing-go/ext"
	"github.com/uber/jaeger-client-go/config"
)

var (
	tracerServer opentracing.Tracer
)

func TraceInit(serviceName string, samplerType string, samplerParam float64) (opentracing.Tracer, io.Closer) {
	cfg := &config.Configuration{
		ServiceName: serviceName,
		Sampler: &config.SamplerConfig{
			Type:  samplerType,
			Param: samplerParam,
		},
		Reporter: &config.ReporterConfig{
			LocalAgentHostPort: "192.168.100.21:6831",
			LogSpans:           true,
		},
	}

	tracer, closer, err := cfg.NewTracer(config.Logger(jaeger.StdLogger), config.Metrics(metrics.NullFactory))
	if err != nil {
		panic(fmt.Sprintf("Init failed: %v\n", err))
	}

	return tracer, closer
}

func GetListProc(w http.ResponseWriter, req *http.Request) {
	spanCtx, _ := tracerServer.Extract(opentracing.HTTPHeaders, opentracing.HTTPHeadersCarrier(req.Header))
	span := tracerServer.StartSpan("GetListProc", ext.RPCServerOption(spanCtx))
	defer span.Finish()

	fmt.Println("Get request getList")
	respList := []string{"l1", "l2", "l3", "l4", "l5"}
	respString := ""

	for _, v := range respList {
		respString += v + ","
	}

	fmt.Println(respString)
	io.WriteString(w, respString)
}

func sendRequest(req *http.Request) {
	resp, err := http.DefaultClient.Do(req)

	if err != nil {
		fmt.Printf("Do send requst failed(%s)\n", err)
		return
	}

	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		fmt.Printf("ReadAll error(%s)\n", err)
		return
	}

	if resp.StatusCode != 200 {
		return
	}
	fmt.Printf("Response:%s\n", string(body))

}

func main() {
	// server
	var closerServer io.Closer
	tracerServer, closerServer = TraceInit("Trace-Server", "const", 1)
	defer closerServer.Close()

	http.HandleFunc("/getList", GetListProc)

	go http.ListenAndServe(":8080", nil)

	//client
	tracerClient, closerClient := TraceInit("CS-tracing", "const", 1)
	defer closerClient.Close()

	opentracing.SetGlobalTracer(tracerClient)
	span := tracerClient.StartSpan("getlist trace")
	span.SetTag("trace to", "getlist")
	defer span.Finish()

	reqURL := "http://localhost:8080/getList"
	req, err := http.NewRequest("GET", reqURL, nil)
	if err != nil {
		fmt.Println(err)
		os.Exit(1)
	}

	span.Tracer().Inject(
		span.Context(),
		opentracing.HTTPHeaders,
		opentracing.HTTPHeadersCarrier(req.Header),
	)

	sendRequest(req)
}

运行效果：

访问http://192.168.100.21:16686/ 如下：

GRPC

我这里用以前的项目 https://github.com/dz45693/gogrpcjwt.git， 大家可以参考grpc 拦截器【 go 和 asp.net core的实现】 这里我引用了github.com/grpc-ecosystem/grpc-opentracing/go/otgrpc 这个包

服务端代码修改如下：

客户端：

普通程序日志：

有些时候 我们的方法会有很多调用和日志， 我希望把这一次api请求的日志归纳在一起【elk可以通过某个字段过滤】， 这里我们可以在api 入口创建一个apn 绑定到context， 然后每个方法都传这个context，日志读取context的traceid

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"io"
	"runtime"
	"strings"
	"time"

	"github.com/opentracing/opentracing-go"
	"github.com/uber/jaeger-client-go"
	"github.com/uber/jaeger-client-go/config"
	"github.com/uber/jaeger-lib/metrics"
	"go.uber.org/zap"
	"go.uber.org/zap/zapcore"
)

func init() {
	tracerClient, closerClient := TraceInit("CS-tracing", "const", 1)
	defer closerClient.Close()

	opentracing.SetGlobalTracer(tracerClient)
}

func main() {
	span := opentracing.GlobalTracer().StartSpan("gavintest")
	ctx := opentracing.ContextWithSpan(context.Background(), span)
	log(ctx, "gavin test")
}

func log(ctx context.Context, format string, args ...interface{}) {
	traceId, spanId := GetTraceId(ctx)

	logerData := JsonLogger{
		TraceId:  traceId,
		SpanId:   spanId,
		Content:  fmt.Sprintf(format, args...),
		CallPath: GetCallPath(),
		Level:    zap.InfoLevel,
		LogTime:  time.Now().Format("2006-01-02T15:04:05.000+08:00"),
	}

	jsonData, _ := json.Marshal(logerData)

	fmt.Println("---------------------")
	fmt.Println(string(jsonData))
}

func TraceInit(serviceName string, samplerType string, samplerParam float64) (opentracing.Tracer, io.Closer) {
	cfg := &config.Configuration{
		ServiceName: serviceName,
		Sampler: &config.SamplerConfig{
			Type:  samplerType,
			Param: samplerParam,
		},
		Reporter: &config.ReporterConfig{
			LocalAgentHostPort: "192.168.100.30:6831",
			LogSpans:           true,
		},
	}

	tracer, closer, err := cfg.NewTracer(config.Logger(jaeger.StdLogger), config.Metrics(metrics.NullFactory))
	if err != nil {
		panic(fmt.Sprintf("Init failed: %v\n", err))
	}

	return tracer, closer
}

func GetTraceId(ctx context.Context) (string, uint64) {
	span := opentracing.SpanFromContext(ctx)
	if span == nil {
		return "", 0
	}

	if sc, ok := span.Context().(jaeger.SpanContext); ok {

		return fmt.Sprintf("%v", sc.TraceID()), uint64(sc.SpanID())
	}
	return "", 0
}

func GetCallPath() string {
	_, file, lineno, ok := runtime.Caller(2)
	if ok {
		return strings.Replace(fmt.Sprintf("%s:%d", stringTrim(file, ""), lineno), "%2e", ".", -1)
	}
	return ""
}

func stringTrim(s, cut string) string {
	ss := strings.SplitN(s, cut, 2)
	if len(ss) == 1 {
		return ss[0]
	}
	return ss[1]
}

type JsonLogger struct {
	TraceId  string        `json:"traceId"`
	SpanId   uint64        `json:"spanId"`
	Content  interface{}   `json:"content"`
	CallPath interface{}   `json:"callPath"`
	LogTime  string        `json:"logdate"`
	Level    zapcore.Level `json:"level"`
}

运行效果：