go-gin-api 路由中間件 - Jaeger 鏈路追蹤

概述

首先同步下項目概況：



上篇文章分享了，路由中間件 - Jaeger 鏈路追蹤（理論篇）。

這篇文章咱們分享：路由中間件 - Jaeger 鏈路追蹤（實戰篇）。

說實話，這篇文章確實讓大家久等了，主要是裡面有一些技術點都是剛剛研究的，沒有存貨。

先看下咱們要實現的東西：


API 調用了 5 個服務，其中 4 個 gRPC 服務，1 個 HTTP 服務，服務與服務之間又相互調用：

    Speak 服務，又調用了 Listen 服務 和 Sing 服務。

    Read 服務，又調用了 Listen 服務 和 Sing 服務。

    Write 服務，又調用了 Listen 服務 和 Sing 服務。

咱們要實現的就是查看 API 調用的鏈路。

關於一些理論的東西，大家可以去看看上篇文章或查閱一些資料，這篇文章就是實現怎麼用。

OK，開整。

Jaeger 部署

咱們使用 All in one 的方式，進行本地部署。

下載地址：https://www.jaegertracing.io/download/

我的電腦是 macOS 選擇 -> Binaries -> macOS

下載後並解壓，會發現以下文件：

    example-hotrod

    jaeger-agent

    jaeger-all-in-one

    jaeger-collector

    jaeger-ingester

    jaeger-query

進入到解壓後的目錄執行：

./jaeger-all-in-one

目測啟動後，訪問地址：

http://127.0.0.1:16686/



到這，Jaeger 已經部署成功了。

準備測試服務

準備的五個測試服務如下：
聽（listen）

    埠：9901

    通訊：gRPC

說（speak）

    埠：9902

    通訊：gRPC

讀（read）

    埠：9903

    通訊：gRPC

寫（write）

    埠：9904

    通訊：gRPC

唱（sing）

    埠：9905

    通訊：HTTP

聽、說、讀、寫、唱，想這幾個服務的名稱就花了好久 ~

我預設大家都會寫 grpc 服務，如果不會寫的，可以查看下我原來的文章《Go gRPC Hello World》。

應用示例

實例化 Tracer

    func NewJaegerTracer(serviceName string, jaegerHostPort string) (opentracing.Tracer, io.Closer, error) {    
        cfg := &jaegerConfig.Configuration {    
            Sampler: &jaegerConfig.SamplerConfig{    
                Type  : "const", //固定採樣    
                Param : 1,       //1=全採樣、0=不採樣    
            },    
            Reporter: &jaegerConfig.ReporterConfig{    
                LogSpans           : true,    
                LocalAgentHostPort : jaegerHostPort,    
            },    
            ServiceName: serviceName,    
        }    
        tracer, closer, err := cfg.NewTracer(jaegerConfig.Logger(jaeger.StdLogger))    
        if err != nil {    
            panic(fmt.Sprintf("ERROR: cannot init Jaeger: %v\n", err))    
        }    
        opentracing.SetGlobalTracer(tracer)    
        return tracer, closer, err    
    }


HTTP 註入

    injectErr := jaeger.Tracer.Inject(span.Context(), opentracing.HTTPHeaders, opentracing.HTTPHeadersCarrier(req.Header))    
    if injectErr != nil {    
        log.Fatalf("%s: Couldn't inject headers", err)    
    }


HTTP 攔截

    spCtx, err := opentracing.GlobalTracer().Extract(opentracing.HTTPHeaders, opentracing.HTTPHeadersCarrier(c.Request.Header))    
    if err != nil {    
        ParentSpan = Tracer.StartSpan(c.Request.URL.Path)    
        defer ParentSpan.Finish()    
    } else {    
        ParentSpan = opentracing.StartSpan(    
            c.Request.URL.Path,    
            opentracing.ChildOf(spCtx),    
            opentracing.Tag{Key: string(ext.Component), Value: "HTTP"},    
            ext.SpanKindRPCServer,    
        )    
        defer ParentSpan.Finish()    
    }


gRPC 註入

    func ClientInterceptor(tracer opentracing.Tracer, spanContext opentracing.SpanContext) grpc.UnaryClientInterceptor {    
        return func(ctx context.Context, method string,    
            req, reply interface{}, cc *grpc.ClientConn,    
            invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {    
            span := opentracing.StartSpan(    
                "call gRPC",    
                opentracing.ChildOf(spanContext),    
                opentracing.Tag{Key: string(ext.Component), Value: "gRPC"},    
                ext.SpanKindRPCClient,    
            )    
            defer span.Finish()    
            md, ok := metadata.FromOutgoingContext(ctx)    
            if !ok {    
                md = metadata.New(nil)    
            } else {    
                md = md.Copy()    
            }    
            err := tracer.Inject(span.Context(), opentracing.TextMap, MDReaderWriter{md})    
            if err != nil {    
                span.LogFields(log.String("inject-error", err.Error()))    
            }    
            newCtx := metadata.NewOutgoingContext(ctx, md)    
            err = invoker(newCtx, method, req, reply, cc, opts...)    
            if err != nil {    
                span.LogFields(log.String("call-error", err.Error()))    
            }    
            return err    
        }    
    }


gRPC 攔截

    func serverInterceptor(tracer opentracing.Tracer) grpc.UnaryServerInterceptor {    
        return func(ctx context.Context,    
            req interface{},    
            info *grpc.UnaryServerInfo,    
            handler grpc.UnaryHandler) (resp interface{}, err error) {    
            md, ok := metadata.FromIncomingContext(ctx)    
            if !ok {    
                md = metadata.New(nil)    
            }    
            spanContext, err := tracer.Extract(opentracing.TextMap, MDReaderWriter{md})    
            if err != nil && err != opentracing.ErrSpanContextNotFound {    
                grpclog.Errorf("extract from metadata err: %v", err)    
            } else {    
                span := tracer.StartSpan(    
                    info.FullMethod,    
                    ext.RPCServerOption(spanContext),    
                    opentracing.Tag{Key: string(ext.Component), Value: "gRPC"},    
                    ext.SpanKindRPCServer,    
                )    
                defer span.Finish()    
                ParentContext = opentracing.ContextWithSpan(ctx, span)    
            }    
            return handler(ParentContext, req)    
        }    
    }

上面是一些核心的代碼，涉及到的全部代碼我都會上傳到 github，供下載。

運行
啟動服務

 // 啟動 Listen 服務    
    cd listen && go run main.go    
    // 啟動 Speak 服務    
    cd speak && go run main.go    
    // 啟動 Read 服務    
    cd read && go run main.go    
    // 啟動 Write 服務    
    cd write && go run main.go    
    // 啟動 Sing 服務    
    cd sing && go run main.go    
    // 啟動 go-gin-api 服務    
    cd go-gin-api && go run main.go

訪問路由

http://127.0.0.1:9999/jaeger_test

效果




基本實現了，就到這吧。