在本章节中，我们将之前介绍 HTTP Client&Server 的示例修改为 GRPC 微服务，并演示如何使用 GoFrame 框架开发一个简单的 GRPC 服务端和客户端，并且为 GRPC 微服务增加链路跟踪特性。

本章节的示例代码位于： https://github.com/gogf/gf/tree/master/example/trace/grpc_with_db

目录结构

链路跟踪-GRPC示例 - 图1

Protobuf

  1. syntax = "proto3";
  3. package user;
  5. option go_package = "protobuf/user";
  7. // User service for tracing demo.
  8. service User {
  9.   rpc Insert(InsertReq) returns (InsertRes) {}
  10.   rpc Query(QueryReq) returns (QueryRes) {}
  11.   rpc Delete(DeleteReq) returns (DeleteRes) {}
  12. }
  14. message InsertReq {
  15.   string Name = 1; // v: required#Please input user name.
  16. }
  17. message InsertRes {
  18.   int32 Id = 1;
  19. }
  21. message QueryReq {
  22.   int32 Id = 1; // v: min:1#User id is required for querying.
  23. }
  24. message QueryRes {
  25.   int32  Id = 1;
  26.   string Name = 2;
  27. }
  29. message DeleteReq {
  30.   int32 Id = 1; // v:min:1#User id is required for deleting.
  31. }
  32. message DeleteRes {}

使用 gf gen pb 命令编译该 proto 文件，将会生成对应的 grpc 接口文件和数据结构文件。

GRPC Server

  1. package main
  3. import (
  4.     _ "github.com/gogf/gf/contrib/drivers/mysql/v2"
  5.     _ "github.com/gogf/gf/contrib/nosql/redis/v2"
  6.     "github.com/gogf/gf/contrib/registry/etcd/v2"
  7.     "github.com/gogf/gf/example/trace/grpc_with_db/protobuf/user"
  9.     "context"
  10.     "fmt"
  11.     "time"
  13.     "github.com/gogf/gf/contrib/rpc/grpcx/v2"
  14.     "github.com/gogf/gf/contrib/trace/otlpgrpc/v2"
  15.     "github.com/gogf/gf/v2/database/gdb"
  16.     "github.com/gogf/gf/v2/frame/g"
  17.     "github.com/gogf/gf/v2/os/gcache"
  18.     "github.com/gogf/gf/v2/os/gctx"
  19. )
  21. type Controller struct {
  22.     user.UnimplementedUserServer
  23. }
  25. const (
  26.     serviceName = "otlp-grpc-server"
  27.     endpoint    = "tracing-analysis-dc-bj.aliyuncs.com:8090"
  28.     traceToken  = "******_******"
  29. )
  31. func main() {
  32.     grpcx.Resolver.Register(etcd.New("127.0.0.1:2379"))
  34.     var ctx = gctx.New()
  35.     shutdown, err := otlpgrpc.Init(serviceName, endpoint, traceToken)
  36.     if err != nil {
  37.         g.Log().Fatal(ctx, err)
  38.     }
  39.     defer shutdown()
  41.     // Set ORM cache adapter with redis.
  42.     g.DB().GetCache().SetAdapter(gcache.NewAdapterRedis(g.Redis()))
  44.     s := grpcx.Server.New()
  45.     user.RegisterUserServer(s.Server, &Controller{})
  46.     s.Run()
  47. }
  49. // Insert is a route handler for inserting user info into database.
  50. func (s *Controller) Insert(ctx context.Context, req *user.InsertReq) (res *user.InsertRes, err error) {
  51.     result, err := g.Model("user").Ctx(ctx).Insert(g.Map{
  52.         "name": req.Name,
  53.     })
  54.     if err != nil {
  55.         return nil, err
  56.     }
  57.     id, _ := result.LastInsertId()
  58.     res = &user.InsertRes{
  59.         Id: int32(id),
  60.     }
  61.     return
  62. }
  64. // Query is a route handler for querying user info. It firstly retrieves the info from redis,
  65. // if there's nothing in the redis, it then does db select.
  66. func (s *Controller) Query(ctx context.Context, req *user.QueryReq) (res *user.QueryRes, err error) {
  67.     err = g.Model("user").Ctx(ctx).Cache(gdb.CacheOption{
  68.         Duration: 5 * time.Second,
  69.         Name:     s.userCacheKey(req.Id),
  70.         Force:    false,
  71.     }).WherePri(req.Id).Scan(&res)
  72.     if err != nil {
  73.         return nil, err
  74.     }
  75.     return
  76. }
  78. // Delete is a route handler for deleting specified user info.
  79. func (s *Controller) Delete(ctx context.Context, req *user.DeleteReq) (res *user.DeleteRes, err error) {
  80.     err = g.Model("user").Ctx(ctx).Cache(gdb.CacheOption{
  81.         Duration: -1,
  82.         Name:     s.userCacheKey(req.Id),
  83.         Force:    false,
  84.     }).WherePri(req.Id).Scan(&res)
  85.     return
  86. }
  88. func (s *Controller) userCacheKey(id int32) string {
  89.     return fmt.Sprintf(`userInfo:%d`, id)
  90. }

服务端代码简要说明：

1、首先，服务端需要通过 jaeger.Init 方法初始化 Jaeger。

2、可以看到，业务逻辑和之前HTTP示例项目完全一致，只是接入层修改为了GRPC协议。

3、我们仍然通过缓存适配器的方式注入Redis缓存：

  1. g.DB().GetCache().SetAdapter(gcache.NewAdapterRedis(g.Redis()))

5、这里也是通过 Cache 方法启用 ORM 的缓存特性，之前已经做过介绍，这里不再赘述。

GRPC Client

  1. package main
  3. import (
  4.     "github.com/gogf/gf/contrib/registry/etcd/v2"
  5.     "github.com/gogf/gf/contrib/rpc/grpcx/v2"
  6.     "github.com/gogf/gf/contrib/trace/otlpgrpc/v2"
  7.     "github.com/gogf/gf/example/trace/grpc_with_db/protobuf/user"
  8.     "github.com/gogf/gf/v2/frame/g"
  9.     "github.com/gogf/gf/v2/net/gtrace"
  10.     "github.com/gogf/gf/v2/os/gctx"
  11. )
  13. const (
  14.      serviceName = "otlp-grpc-client"
  15.     endpoint    = "tracing-analysis-dc-bj.aliyuncs.com:8090"
  16.     traceToken  = "******_******"
  17. )
  19. func main() {
  20.     grpcx.Resolver.Register(etcd.New("127.0.0.1:2379"))
  22.     var ctx = gctx.New()
  23.     shutdown, err := otlpgrpc.Init(serviceName, endpoint, traceToken)
  24.     if err != nil {
  25.         g.Log().Fatal(ctx, err)
  26.     }
  27.     defer shutdown()
  29.     StartRequests()
  30. }
  32. func StartRequests() {
  33.     ctx, span := gtrace.NewSpan(gctx.New(), "StartRequests")
  34.     defer span.End()
  36.     client := user.NewUserClient(grpcx.Client.MustNewGrpcClientConn("demo"))
  38.     // Baggage.
  39.     ctx = gtrace.SetBaggageValue(ctx, "uid", 100)
  41.     // Insert.
  42.     insertRes, err := client.Insert(ctx, &user.InsertReq{
  43.         Name: "john",
  44.     })
  45.     if err != nil {
  46.         g.Log().Fatalf(ctx, `%+v`, err)
  47.     }
  48.     g.Log().Info(ctx, "insert id:", insertRes.Id)
  50.     // Query.
  51.     queryRes, err := client.Query(ctx, &user.QueryReq{
  52.         Id: insertRes.Id,
  53.     })
  54.     if err != nil {
  55.         g.Log().Errorf(ctx, `%+v`, err)
  56.         return
  57.     }
  58.     g.Log().Info(ctx, "query result:", queryRes)
  60.     // Delete.
  61.     _, err = client.Delete(ctx, &user.DeleteReq{
  62.         Id: insertRes.Id,
  63.     })
  64.     if err != nil {
  65.         g.Log().Errorf(ctx, `%+v`, err)
  66.         return
  67.     }
  68.     g.Log().Info(ctx, "delete id:", insertRes.Id)
  70.     // Delete with error.
  71.     _, err = client.Delete(ctx, &user.DeleteReq{
  72.         Id: -1,
  73.     })
  74.     if err != nil {
  75.         g.Log().Errorf(ctx, `%+v`, err)
  76.         return
  77.     }
  78.     g.Log().Info(ctx, "delete id:", -1)
  79. }

客户端代码简要说明：

1、首先，客户端也是需要通过 jaeger.Init 方法初始化 Jaeger。

2、客户端非常简单，内部初始化以及默认拦截器的设置已经由 Katyusha 框架封装好了，开发者只需要关心业务逻辑实现即可，

效果查看

启动服务端：

链路跟踪-GRPC示例 - 图2

启动客户端：

链路跟踪-GRPC示例 - 图3

这里客户端的执行最后报了一个错误，那是我们 故意为之，目的是演示 GRPC 报错时的链路信息展示。我们打开 jaeger 查看一下链路跟踪信息：

链路跟踪-GRPC示例 - 图4

可以看到本次请求涉及到两个服务： tracing-grpc-client 和 tracing-grpc-server，即客户端和服务端。整个请求链路涉及到 17 个 span，客户端 5 个 span，服务端 12 个 span，并且产生了 2 个错误。我们点击查看详情：

链路跟踪-GRPC示例 - 图5

我们点击查看一下最后接口调用错误的 span 情况：

链路跟踪-GRPC示例 - 图6

看起来像个参数校验错误，点击查看 Events/Logs 中的请求参数：

链路跟踪-GRPC示例 - 图7

查看 Process 中的 Log 信息可以看到，是由于传递的参数为 -1，不满足校验规则，因此在数据校验的时候报错返回了。

GRPC Client

由于 orm、 redis、 logging 组件在之前的章节中已经介绍过链路信息，因此我们这里主要介绍 GRPC Client&Server 的链路信息。

Attributes

链路跟踪-GRPC示例 - 图8

Attribute/Tag说明
net.peer.ip请求的目标IP。
net.peer.port请求的目标端口。
rpc.grpc.status_codeGRPC 的内部状态码， 0 表示成功， 非0 表示失败。
rpc.serviceRPC 的服务名称，注意这里是 RPC 而不是 GRPC，因为这里是通用定义，客户端支持多种 RPC 通信协议， GRPC 只是其中一种。
rpc.methodRPC 的方法名称。
rpc.systemRPC 协议类型，如： grpc, thrift 等。

Events/Logs

链路跟踪-GRPC示例 - 图9

Event/Log说明
grpc.metadata.outgoingGRPC 客户端请求提交的 Metadata 信息，可能会比较大。
grpc.request.baggageGRPC 客户端请求提交的 Baggage 信息，用于服务间链路信息传递。
grpc.request.messageGRPC 客户端请求提交的 Message 数据，可能会比较大，最大只记录 512KB，如果超过该大小则忽略。仅对 Unary 请求类型有效。
grpc.response.messageGRPC 客户端请求接收返回的的 Message 信息，可能会比较大。仅对 Unary 请求类型有效。

GRPC Server

Attributes

链路跟踪-GRPC示例 - 图10

GRPC Server 端的 Attributes 含义同 GRPC Client，在同一请求中，打印的数据基本一致。

Events

链路跟踪-GRPC示例 - 图11

GRPC Server 端的 Events 与 GRPC Client 不同的是，在同一请求中，服务端接收到的 metadata 为 grpc.metadata.incoming，其他同 GRPC Client。