微服务-如何解决链路追踪问题

# 拉取镜像
$docker pull jaegertracing/all-in-one:latest

# 运行镜像
$docker run -d --name jaeger \
  -e COLLECTOR_ZIPKIN_HTTP_PORT=9411 \
  -p 5775:5775/udp \
  -p 6831:6831/udp \
  -p 6832:6832/udp \
  -p 5778:5778 \
  -p 14268:14268 \
  -p 9411:9411 \
  -p 16686:16686 \
  jaegertracing/all-in-one:latest

func initJaeger() (tracer opentracing.Tracer, closer io.Closer, err error) {
 // 构造配置信息
 cfg := &config.Configuration{
  // 设置服务名称
  ServiceName: "ServiceAmount",
  // 设置采样参数
  Sampler: &config.SamplerConfig{
   Type:  "const", // 全采样模式
   Param: 1,       // 开启状态
  },
 }
 
 // 生成一条新tracer
 tracer, closer, err = cfg.NewTracer()
 if err == nil {
  // 设置tracer为全局单例对象
  opentracing.SetGlobalTracer(tracer)
 }
 return
}

func CheckBalance(request string, ctx context.Context) {
 // 创建子span
 span, _ := opentracing.StartSpanFromContext(ctx, "CheckBalance")

 // 模拟系统进行一系列的操作，耗时1/3秒
 time.Sleep(time.Second / 3)

 // 示例：将需要追踪的信息放入tag
 span.SetTag("request", request)
 span.SetTag("reply", "CheckBalance reply")

 // 结束当前span
 span.Finish()

 log.Println("CheckBalance is done")
}

func Reduction(request string, ctx context.Context) {
 // 创建子span
 span, _ := opentracing.StartSpanFromContext(ctx, "Reduction")

 // 模拟系统进行一系列的操作，耗时1/2秒
 time.Sleep(time.Second / 2)

 // 示例：将需要追踪的信息放入tag
 span.SetTag("request", request)
 span.SetTag("reply", "Reduction reply")

 // 结束当前span
 span.Finish()

 log.Println("Reduction is done")
}

package main

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

func main() {
 // 初始化jaeger，创建一条新tracer
 tracer, closer, err := initJaeger()
 if err != nil {
  panic(fmt.Sprintf("ERROR: cannot init Jaeger: %v\n", err))
 }
 defer closer.Close()

 // 创建一个新span，作为父span，开始计费过程
 span := tracer.StartSpan("CalculateFee")
 
 // 生成父span的context
 ctx := opentracing.ContextWithSpan(context.Background(), span)

 // 示例：设置一个span标签信息
 span.SetTag("db.instance", "customers")
 // 示例：输出一条span日志信息
 span.LogKV("event", "timed out")

 // 将父span的context作为参数，调用检测用户余额函数
 CheckBalance("CheckBalance request", ctx)

 // 将父span的context作为参数，调用扣款函数
 Reduction("Reduction request", ctx)

 // 结束父span
 span.Finish()
}

package main

import (
 "fmt"
 "github.com/grpc-ecosystem/go-grpc-middleware/tracing/opentracing"
 "github.com/opentracing/opentracing-go"
 "github.com/uber/jaeger-client-go/config"
 "google.golang.org/grpc"
 "google.golang.org/grpc/reflection"
 "grpc-jaeger-server/account"
 "io"
 "log"
 "net"
)

// 初始化jaeger
func initJaeger() (tracer opentracing.Tracer, closer io.Closer, err error) {
 // 构造配置信息
 cfg := &config.Configuration{
  // 设置服务名称
  ServiceName: "ServiceAmount",

  // 设置采样参数
  Sampler: &config.SamplerConfig{
   Type:  "const", // 全采样模式
   Param: 1,       // 开启全采样模式
  },
 }

 // 生成一条新tracer
 tracer, closer, err = cfg.NewTracer()
 if err == nil {
  // 设置tracer为全局单例对象
  opentracing.SetGlobalTracer(tracer)
 }
 return
}

func main() {
 // 初始化jaeger，创建一条新tracer
 tracer, closer, err := initJaeger()
 if err != nil {
  panic(fmt.Sprintf("ERROR: cannot init Jaeger: %v\n", err))
 }
 defer closer.Close()
 log.Println("succeed to init jaeger")

 // 注册gRPC account服务
 server := grpc.NewServer(grpc.UnaryInterceptor(grpc_opentracing.UnaryServerInterceptor(grpc_opentracing.WithTracer(tracer))))
 account.RegisterAccountServer(server, &AccountServer{})
 reflection.Register(server)
 log.Println("succeed to register account service")

 // 监听gRPC account服务端口
 listener, err := net.Listen("tcp", ":8080")
 if err != nil {
  log.Println(err)
  return
 }
 log.Println("starting register account service")

 // 开启gRpc account服务
 if err := server.Serve(listener); err != nil {
  log.Println(err)
  return
 }
}

package main

import (
 "github.com/opentracing/opentracing-go"
 "golang.org/x/net/context"
 "grpc-jaeger-server/account"
 "time"
)

// 计费服务
type AccountServer struct{}

// 检测用户余额微服务，模拟子span任务
func (s *AccountServer) CheckBalance(ctx context.Context, request *account.CheckBalanceRequest) (response *account.CheckBalanceResponse, err error) {
 response = &account.CheckBalanceResponse{
  Reply: "CheckBalance Reply", // 处理结果
 }

 // 创建子span
 span, _ := opentracing.StartSpanFromContext(ctx, "CheckBalance")

 // 模拟系统进行一系列的操作，耗时1/3秒
 time.Sleep(time.Second / 3)

 // 将需要追踪的信息放入tag
 span.SetTag("request", request)
 span.SetTag("reply", response)

 // 结束当前span
 span.Finish()

 return response, err
}

// 从用户账户扣款微服务，模拟子span任务
func (s *AccountServer) Reduction(ctx context.Context, request *account.ReductionRequest) (response *account.ReductionResponse, err error) {
 response = &account.ReductionResponse{
  Reply: "Reduction Reply", // 处理结果
 }

 // 创建子span
 span, _ := opentracing.StartSpanFromContext(ctx, "Reduction")

 // 模拟系统进行一系列的操作，耗时1/3秒
 time.Sleep(time.Second / 3)

 // 将需要追踪的信息放入tag
 span.SetTag("request", request)
 span.SetTag("reply", response)

 // 结束当前span
 span.Finish()
 return response, err
}

package main

import (
 "context"
 "fmt"
 "github.com/grpc-ecosystem/go-grpc-middleware/tracing/opentracing"
 "github.com/opentracing/opentracing-go"
 "github.com/uber/jaeger-client-go/config"
 "google.golang.org/grpc"
 "grpc-jaeger-client/account"
 "io"
 "log"
)

// 初始化jaeger
func initJaeger() (tracer opentracing.Tracer, closer io.Closer, err error) {
 // 构造配置信息
 cfg := &config.Configuration{
  // 设置服务名称
  ServiceName: "ServiceAmount",

  // 设置采样参数
  Sampler: &config.SamplerConfig{
   Type:  "const", // 全采样模式
   Param: 1,       // 开启全采样模式
  },
 }

 // 生成一条新tracer
 tracer, closer, err = cfg.NewTracer()
 if err == nil {
  // 设置tracer为全局单例对象
  opentracing.SetGlobalTracer(tracer)
 }
 return
}

func main() {
 // 初始化jaeger，创建一条新tracer
 tracer, closer, err := initJaeger()
 if err != nil {
  panic(fmt.Sprintf("ERROR: cannot init Jaeger: %v\n", err))
 }
 defer closer.Close()
 log.Println("succeed to init jaeger")

 // 创建一个新span，作为父span
 span := tracer.StartSpan("CalculateFee")

 // 函数返回时关闭span
 defer span.Finish()

 // 生成span的context
 ctx := opentracing.ContextWithSpan(context.Background(), span)

 // 连接gRPC server
 conn, err := grpc.Dial("localhost:8080",
  grpc.WithInsecure(),
  grpc.WithUnaryInterceptor(grpc_opentracing.UnaryClientInterceptor(grpc_opentracing.WithTracer(tracer),
  )))
 if err != nil {
  log.Println(err)
  return
 }

 // 创建gRPC计费服务客户端
 client := account.NewAccountClient(conn)

 // 将父span的context作为参数，调用检测用户余额的gRPC微服务
 checkBalanceResponse, err := client.CheckBalance(ctx,
  &account.CheckBalanceRequest{
   Account: "user account",
  })
 if err != nil {
  log.Println(err)
  return
 }
 log.Println(checkBalanceResponse)

 // 将父span的context作为参数，调用扣款的gRPC微服务
 reductionResponse, err := client.Reduction(ctx,
  &account.ReductionRequest{
   Account: "user account",
   Amount: 1,
  })
 if err != nil {
  log.Println(err)
  return
 }
 log.Println(reductionResponse)
}