目录结构
Protocol
GRPC Server
GRPC Client
效果查看
- GRPC Client
  - Attributes
  - Events/Logs
- GRPC Server
  - Attributes
  - Events

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

本章节的示例代码位于：https://github.com/gogf/gf-tracing/tree/master/examples/grpc_db_redis_log

目录结构

Protocol

syntax = "proto3";
package user;
option go_package = "protobuf/user";
import "github.com/gogo/protobuf/gogoproto/gogo.proto";
// User service for tracing demo.
service User {
  rpc Insert(InsertReq) returns (InsertRes) {}
  rpc Query(QueryReq) returns (QueryRes) {}
  rpc Delete(DeleteReq) returns (DeleteRes) {}
}
message InsertReq {
  string Name = 1 [(gogoproto.moretags) = 'v:"required#Please input user name."'];
}
message InsertRes {
  int32 Id = 1;
}
message QueryReq {
  int32 Id = 1 [(gogoproto.moretags) = 'v:"min:1#User id is required for querying."'];
}
message QueryRes {
  int32  Id = 1;
  string Name = 2;
}
message DeleteReq {
  int32 Id = 1 [(gogoproto.moretags) = 'v:"min:1#User id is required for deleting."'];
}
message DeleteRes {}

这里使用到了第三方的 github.com/gogo/protobuf 开源项目，用于注入自定义的Golang struct标签。这里不详细介绍，感兴趣的小伙伴可以自行了解。未来Katyusha微服务框架的官网文档也会做对这块详细介绍，包括GRPC工程目录、开发规范、开发工具、拦截器、注册发现、负载均衡等设计话题。

GRPC Server

package main
import (
    "context"
    "fmt"
    "gftracing/examples/grpc+db+redis+log/protobuf/user"
    "gftracing/tracing"
    "github.com/gogf/gcache-adapter/adapter"
    "github.com/gogf/gf/frame/g"
    "github.com/gogf/katyusha/krpc"
    "google.golang.org/grpc"
    "net"
    "time"
)
type server struct{}
const (
    ServiceName       = "tracing-grpc-server"
    JaegerUdpEndpoint = "localhost:6831"
)
func main() {
    flush, err := tracing.InitJaeger(ServiceName, JaegerUdpEndpoint)
    if err != nil {
        g.Log().Fatal(err)
    }
    defer flush()
    g.DB().GetCache().SetAdapter(adapter.NewRedis(g.Redis()))
    address := ":8000"
    listen, err := net.Listen("tcp", address)
    if err != nil {
        g.Log().Fatalf("failed to listen: %v", err)
    }
    s := grpc.NewServer(
        grpc.ChainUnaryInterceptor(
            krpc.Server.UnaryError,
            krpc.Server.UnaryRecover,
            krpc.Server.UnaryTracing,
            krpc.Server.UnaryValidate,
        ),
    )
    user.RegisterUserServer(s, &server{})
    g.Log().Printf("grpc server starts listening on %s", address)
    if err := s.Serve(listen); err != nil {
        g.Log().Fatalf("failed to serve: %v", err)
    }
}
// Insert is a route handler for inserting user info into dtabase.
func (s *server) Insert(ctx context.Context, req *user.InsertReq) (*user.InsertRes, error) {
    res := user.InsertRes{}
    result, err := g.Table("user").Ctx(ctx).Insert(g.Map{
        "name": req.Name,
    })
    if err != nil {
        return nil, err
    }
    id, _ := result.LastInsertId()
    res.Id = int32(id)
    return &res, nil
}
// Query is a route handler for querying user info. It firstly retrieves the info from redis,
// if there's nothing in the redis, it then does db select.
func (s *server) Query(ctx context.Context, req *user.QueryReq) (*user.QueryRes, error) {
    res := user.QueryRes{}
    err := g.Table("user").
        Ctx(ctx).
        Cache(5*time.Second, s.userCacheKey(req.Id)).
        WherePri(req.Id).
        Scan(&res)
    if err != nil {
        return nil, err
    }
    return &res, nil
}
// Delete is a route handler for deleting specified user info.
func (s *server) Delete(ctx context.Context, req *user.DeleteReq) (*user.DeleteRes, error) {
    res := user.DeleteRes{}
    _, err := g.Table("user").
        Ctx(ctx).
        Cache(-1, s.userCacheKey(req.Id)).
        WherePri(req.Id).
        Delete()
    if err != nil {
        return nil, err
    }
    return &res, nil
}
func (s *server) userCacheKey(id int32) string {
    return fmt.Sprintf(`userInfo:%d`, id)
}

服务端代码简要说明：

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

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

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

g.DB().GetCache().SetAdapter(adapter.NewRedis(g.Redis()))

4、关键技术点来了，拦截器。这里我们添加了若干个拦截器，并且都由Katyusha微服务框架提供，由于这里使用的GRPC原生的服务端创建方式，因此只是复用了Katyusha的一些拦截器，所有拦截器便需要显式设置：

Unary Interceptor	说明
`krpc.Server.UnaryError`	错误处理，增加了对`gerror`组件的支持，支持业务方便地定义错误码。
`krpc.Server.UnaryRecover`	异常捕获，防止业务处理逻辑抛一个`panic`整个进程就崩溃。
`krpc.Server.UnaryTracing`	链路跟踪，通过该拦截器启用服务端的链路跟踪特性。
`krpc.Server.UnaryValidate`	数据校验，通过拦截器的形式自动对输入对象调用`gvalid`组件执行数据校验，校验失败直接返回。如果对象`struct`定义中不包含校验标签时，该拦截器什么都不会做，快速返回，不影响性能。

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

GRPC Client

package main
import (
    "context"
    "gftracing/examples/grpc+db+redis+log/protobuf/user"
    "gftracing/tracing"
    "github.com/gogf/gf/frame/g"
    "github.com/gogf/gf/net/gtrace"
    "github.com/gogf/katyusha/krpc"
    "google.golang.org/grpc"
)
const (
    ServiceName       = "tracing-grpc-client"
    JaegerUdpEndpoint = "localhost:6831"
)
func main() {
    flush, err := tracing.InitJaeger(ServiceName, JaegerUdpEndpoint)
    if err != nil {
        g.Log().Fatal(err)
    }
    defer flush()
    StartRequests()
}
func StartRequests() {
    ctx, span := gtrace.NewSpan(context.Background(), "StartRequests")
    defer span.End()
    grpcClientOptions := make([]grpc.DialOption, 0)
    grpcClientOptions = append(
        grpcClientOptions,
        grpc.WithInsecure(),
        grpc.WithBlock(),
        grpc.WithChainUnaryInterceptor(
            krpc.Client.UnaryError,
            krpc.Client.UnaryTracing,
        ),
    )
    conn, err := grpc.Dial(":8000", grpcClientOptions...)
    if err != nil {
        g.Log().Fatalf("did not connect: %v", err)
    }
    defer conn.Close()
    client := user.NewUserClient(conn)
    // Baggage.
    ctx = gtrace.SetBaggageValue(ctx, "uid", 100)
    // Insert.
    insertRes, err := client.Insert(ctx, &user.InsertReq{
        Name: "john",
    })
    if err != nil {
        g.Log().Ctx(ctx).Fatalf(`%+v`, err)
    }
    g.Log().Ctx(ctx).Println("insert:", insertRes.Id)
    // Query.
    queryRes, err := client.Query(ctx, &user.QueryReq{
        Id: insertRes.Id,
    })
    if err != nil {
        g.Log().Ctx(ctx).Printf(`%+v`, err)
        return
    }
    g.Log().Ctx(ctx).Println("query:", queryRes)
    // Delete.
    _, err = client.Delete(ctx, &user.DeleteReq{
        Id: insertRes.Id,
    })
    if err != nil {
        g.Log().Ctx(ctx).Printf(`%+v`, err)
        return
    }
    g.Log().Ctx(ctx).Println("delete:", insertRes.Id)
    // Delete with error.
    _, err = client.Delete(ctx, &user.DeleteReq{
        Id: -1,
    })
    if err != nil {
        g.Log().Ctx(ctx).Printf(`%+v`, err)
        return
    }
    g.Log().Ctx(ctx).Println("delete:", -1)
}

客户端代码简要说明：

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

2、主要的也是UnaryError和UnaryTracing两个拦截器的使用，作用同上服务端介绍。

效果查看

启动服务端：

启动客户端：

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

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

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

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

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

GRPC Client

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

Attributes

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

Events/Logs

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