微服务的链路是必须的，现在有空，写个demo吧
    主要分为三个部分：gateway、service1（http）、service2（grpc）
    项目地址：https://github.com/jwrookie/trace-demo

    gateway

    1. package main
    3. import (
    4.     "github.com/gin-gonic/gin"
    5.     "github.com/opentracing/opentracing-go"
    6.     "github.com/opentracing/opentracing-go/ext"
    7.     "github.com/opentracing/opentracing-go/log"
    8.     "io"
    9.     "io/ioutil"
    10.     "net/http"
    11.     "trace"
    12. )
    14. var (
    15.     tracer opentracing.Tracer
    16.     closer io.Closer
    17. )
    19. func traceMiddle(c *gin.Context)  {
    20.     span := tracer.StartSpan(c.Request.URL.String(),opentracing.Tag{Key: string(ext.Component), Value: "http"})
    21.     c.Set("span",span)
    22.     defer func() {
    23.         ext.SpanKindRPCClient.Set(span)
    24.         span.Finish()
    25.     }()
    26.     c.Next()
    27. }
    29. func main() {
    30.     tracer, closer = tools.InitJaegerClient("trace-demo")
    31.     defer closer.Close()
    32.     router := gin.Default()
    33.     router.GET("/ping",traceMiddle,pong)
    34.     router.Run(":8080")
    35. }
    37. func pong(c *gin.Context){
    38.     span := c.MustGet("span").(opentracing.Span)
    39.     httpClient := &http.Client{}
    40.     httpReq ,_ := http.NewRequest("GET","http://127.0.0.1:8081/ping",nil)
    41.     carrier := opentracing.HTTPHeadersCarrier(httpReq.Header)
    42.     if err := tracer.Inject(span.Context(), opentracing.HTTPHeaders, carrier);err != nil {
    43.         span.LogFields(log.String("err", err.Error()))
    44.         c.JSON(200,gin.H{"err":err.Error()})
    45.         return
    46.     }
    48.     res,err := httpClient.Do(httpReq)
    50.     if err != nil {
    51.         span.LogFields(log.String("err", err.Error()))
    52.         c.JSON(200,gin.H{"err":err.Error()})
    53.         return
    54.     }
    55.     defer res.Body.Close()
    56.     resS , _:= ioutil.ReadAll(res.Body)
    57.     c.JSON(200,gin.H{"data" : string(resS)})
    58. }

    service1

    1. import (
    2.     "context"
    3.     "github.com/gin-gonic/gin"
    4.     "github.com/opentracing/opentracing-go"
    5.     "github.com/opentracing/opentracing-go/ext"
    6.     "github.com/opentracing/opentracing-go/log"
    7.     "google.golang.org/grpc"
    8.     "google.golang.org/grpc/grpclog"
    9.     "google.golang.org/grpc/metadata"
    10.     "io"
    11.     "trace"
    12.     pb "trace/cmd/protos"
    13. )
    15. const (
    16.     PORT = "127.0.0.1:8082"
    17. )
    19. var (
    20.     tracer opentracing.Tracer
    21.     closer io.Closer
    22. )
    24. func traceMiddle(c *gin.Context)  {
    25.     refFunc := opentracing.FollowsFrom
    26.     carrier := opentracing.HTTPHeadersCarrier(c.Request.Header)
    27.     clientContext, err := tracer.Extract(opentracing.HTTPHeaders, carrier)
    28.     if err != nil {
    29.         c.AbortWithStatusJSON(200,gin.H{"data":err.Error()})
    30.         return
    31.     }
    32.     span := tracer.StartSpan(c.Request.URL.String(),refFunc(clientContext),opentracing.Tag{Key: string(ext.Component), Value: "http"})
    33.     defer func() {
    34.         ext.SpanKindRPCServer.Set(span)
    35.         span.Finish()
    36.     }()
    37.     c.Set("span",span)
    38.     c.Next()
    39. }
    41. func main() {
    42.     tracer, closer = tools.InitJaegerClient("trace-demo")
    43.     defer closer.Close()
    44.     router := gin.Default()
    45.     router.GET("/ping",traceMiddle,pong)
    46.     router.Run(":8081")
    47. }
    49. func pong(c *gin.Context){
    50.     span := c.MustGet("span").(opentracing.Span)
    51.     span.LogFields(log.String(c.Request.URL.String() + "---NewRpcServerClient ：","rpcService:Ping"))
    52.     conn, err := grpc.Dial(PORT, grpc.WithInsecure(), grpc.WithUnaryInterceptor(OpenTracingClientInterceptor()))
    53.     if err != nil {
    54.         span.LogFields(log.String("err", err.Error()))
    55.         return
    56.     }
    57.     client := pb.NewRpcServerClient(conn)
    58.     parm1 := pb.PingReq{}
    60.     ctx := opentracing.ContextWithSpan(context.TODO(),span)
    61.     r, err := client.Ping(ctx, &parm1)
    62.     if err != nil {
    63.         span.LogFields(log.String("err", err.Error()))
    64.         return
    65.     }
    66.     c.String(200,"%s",r.Res)
    67. }
    69. //OpenTracingClientInterceptor  rewrite client's interceptor with open tracing
    70. func OpenTracingClientInterceptor() grpc.UnaryClientInterceptor {
    71.     return func(
    72.         ctx context.Context,
    73.         method string,
    74.         req, resp interface{},
    75.         cc *grpc.ClientConn,
    76.         invoker grpc.UnaryInvoker,
    77.         opts ...grpc.CallOption,
    78.     ) error {
    79.         var parentCtx opentracing.SpanContext
    80.         if parent := opentracing.SpanFromContext(ctx); parent != nil {
    81.             parentCtx = parent.Context()
    82.         }
    83.         cliSpan := tracer.StartSpan(
    84.             method,
    85.             opentracing.ChildOf(parentCtx),
    86.             opentracing.Tag{Key: string(ext.Component), Value: "gRPC"},
    87.             ext.SpanKindRPCClient,
    88.         )
    89.         defer cliSpan.Finish()
    90.         md, ok := metadata.FromOutgoingContext(ctx)
    91.         if !ok {
    92.             md = metadata.New(nil)
    93.         } else {
    94.             md = md.Copy()
    95.         }
    96.         mdWriter := tools.MDReaderWriter{md}
    97.         err := tracer.Inject(cliSpan.Context(), opentracing.TextMap, mdWriter)
    98.         if err != nil {
    99.             grpclog.Errorf("inject to metadata err %v", err)
    100.         }
    101.         ctx = metadata.NewOutgoingContext(ctx, mdWriter.MD)
    102.         err = invoker(ctx, method, req, resp, cc, opts...)
    103.         if err != nil {
    104.             cliSpan.LogFields(log.String("err", err.Error()))
    105.         }
    106.         return err
    107.     }
    108. }

    service2

    1. package main
    3. import (
    4.     "context"
    5.     "github.com/opentracing/opentracing-go"
    6.     "github.com/opentracing/opentracing-go/ext"
    7.     olog "github.com/opentracing/opentracing-go/log"
    8.     "google.golang.org/grpc"
    9.     "google.golang.org/grpc/grpclog"
    10.     "google.golang.org/grpc/metadata"
    11.     "io"
    12.     "log"
    13.     "net"
    14.     "trace"
    15.     pb "trace/cmd/protos"
    16. )
    18. const (
    19.     PORT = ":8082"
    20. )
    22. var (
    23.     tracer opentracing.Tracer
    24.     closer io.Closer
    25. )
    27. type Server struct {
    28. }
    30. func (s *Server) Ping(ctx context.Context, all *pb.PingReq) (*pb.PingRes, error){
    31.     var res = new(pb.PingRes)
    32.     span := ctx.Value("span").(opentracing.Span)
    33.     span.LogFields(olog.String("pos","rpcService:Ping"))
    34.     res.Res = "pong"
    35.     return res,nil
    36. }
    38. func main() {
    39.     tracer, closer = tools.InitJaegerClient("trace-demo")
    40.     defer closer.Close()
    42.     lis, err := net.Listen("tcp", PORT)
    43.     if err != nil {
    44.         log.Fatalf("failed to listen: %v", err)
    45.     }
    47.     opts := grpc.UnaryInterceptor(OpentracingServerInterceptor())
    48.     s := grpc.NewServer(opts) //起一个服务
    49.     pb.RegisterRpcServerServer(s, &Server{})
    51.     if err := s.Serve(lis); err != nil {
    52.         log.Fatalf("failed to serve: %v", err)
    53.     }
    55. }
    58. func OpentracingServerInterceptor() grpc.UnaryServerInterceptor {
    59.     return func(
    60.         ctx context.Context,
    61.         req interface{},
    62.         info *grpc.UnaryServerInfo,
    63.         handler grpc.UnaryHandler,
    64.     ) (resp interface{}, err error) {
    65.         md, ok := metadata.FromIncomingContext(ctx)
    66.         if !ok {
    67.             md = metadata.New(nil)
    68.         }
    69.         spanContext, err := tracer.Extract(opentracing.TextMap, tools.MDReaderWriter{md})
    70.         if err != nil && err != opentracing.ErrSpanContextNotFound {
    71.             grpclog.Errorf("extract from metadata err %v", err)
    72.         }
    73.         serverSpan := tracer.StartSpan(
    74.             info.FullMethod,
    75.             ext.RPCServerOption(spanContext),
    76.             opentracing.Tag{Key: string(ext.Component), Value: "gRPC"},
    77.             ext.SpanKindRPCServer,
    78.         )
    79.         defer serverSpan.Finish()
    80.         ctx = context.WithValue(ctx,"span",serverSpan)
    81.         return handler(ctx, req)
    82.     }
    83. }

    tools

    1. package tools
    3. import (
    4.     "fmt"
    5.     "github.com/opentracing/opentracing-go"
    6.     "github.com/uber/jaeger-client-go"
    7.     "github.com/uber/jaeger-client-go/config"
    8.     "google.golang.org/grpc/metadata"
    9.     "io"
    10. )
    12. func InitJaegerClient(service string) (opentracing.Tracer, io.Closer) {
    13.     cfg := &config.Configuration{
    14.         ServiceName: service,
    15.         Sampler: &config.SamplerConfig{
    16.             Type:  "const",
    17.             Param: 1,
    18.         },
    19.         Reporter: &config.ReporterConfig{
    20.             LogSpans:           true,
    21.             LocalAgentHostPort: "172.17.0.6:6831",
    22.         },
    23.     }
    24.     tracer, closer, err := cfg.NewTracer(config.Logger(jaeger.StdLogger))
    25.     if err != nil {
    26.         panic(fmt.Sprintf("ERROR: cannot init Jaeger: %v\n", err))
    27.     }
    28.     return tracer, closer
    29. }
    32. //MDReaderWriter metadata Reader and Writer
    33. type MDReaderWriter struct {
    34.     MD metadata.MD
    35. }
    37. //ForeachKey range all keys to call handler
    38. func (c MDReaderWriter) ForeachKey(handler func(key, val string) error) error {
    39.     for k, vs := range c.MD {
    40.         for _, v := range vs {
    41.             if err := handler(k, v); err != nil {
    42.                 return err
    43.             }
    44.         }
    45.     }
    46.     return nil
    47. }
    49. // Set implements Set() of opentracing.TextMapWriter
    50. func (c MDReaderWriter) Set(key, val string) {
    51.     c.MD.Set(key, val)
    52. }

    proto

    1. syntax = "proto3";
    3. package protos;
    5. message pingReq {
    6. }
    8. message pingRes {
    9.     string res = 1;
    10. }
    12. service rpcServer {
    13.   rpc Ping(pingReq) returns (pingRes) {}
    14. }

    最终效果
    image.png