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/

這里我還準備了一分學習圖和資料，如下：

鏈接：https://pan.baidu.com/s/1v5gm7n0L7TGyejCmQrMh2g 提取碼：x2p5

免費分享，但是X度限制嚴重，如若鏈接失效點擊鏈接或搜索加群群號518475424，

到這，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

效果

基本實作了，就到這吧，

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/67392.html

標籤：Go

上一篇：go-gin-api 路由中間件 - 簽名驗證（七）

下一篇：Java 生成Word檔案