gRPC内置了客户端和服务端的请求追踪，基于golang.org/x/net/trace包实现，默认是开启状态，可以查看事件和请求日志，对于基本的请求状态查看调试也是很有帮助的，客户端与服务端基本一致，这里以服务端开启trace server为例，代码如下。

目录结构

代码

• 服务端
  

1. package main
   
2. 
   
3. import (
   
4.         "context"
   
5.         "fmt"
   
6.         "log"
   
7.         "net"
   
8.         "net/http"
   
9.         hello "sample-app/grpc/proto"
   
10. 
    
11.         "golang.org/x/net/trace"
    
12.         "google.golang.org/grpc"
    
13. )
    
14. 
    
15. // gprc服务器地址
    
16. var Addr = "127.0.0.1:8080"
    
17. 
    
18. // 定义结构 实现约定接口
    
19. type helloService struct{}
    
20. 
    
21. // 服务
    
22. var HelloService = helloService{}
    
23. 
    
24. // 实现服务接口
    
25. func (h helloService) SayHello(c context.Context, req *hello.HelloRequest) (*hello.HelloResponse, error) {
    
26.         resp := new(hello.HelloResponse)
    
27.         resp.Message = fmt.Sprintf("Hello %s", req.Name)
    
28. 
    
29.         return resp, nil
    
30. }
    
31. 
    
32. func init() {
    
33.         //使用trace
    
34.         grpc.EnableTracing = true
    
35. }
    
36. 
    
37. func main() {
    
38.         ls, err := net.Listen("tcp", Addr)
    
39.         if err != nil {
    
40.                 fmt.Println(err)
    
41.                 return
    
42.         }
    
43.         //实例化grpc server
    
44.         server := grpc.NewServer()
    
45.         //注册HelloService
    
46.         hello.RegisterHelloServer(server, HelloService)
    
47.         //开启trace
    
48.         go startTrace()
    
49. 
    
50.         fmt.Println("Listen on " + Addr)
    
51.         server.Serve(ls)
    
52. }
    
53. 
    
54. func startTrace() {
    
55.         trace.AuthRequest = func(req *http.Request) (any, sensitive bool) {
    
56.                 return true, true
    
57.         }
    
58. 
    
59.         go http.ListenAndServe(":8081", nil)
    
60.         log.Println("trace listen on 8081")
    
61. }

复制代码

这里我们开启一个http服务监听8081端口，用来查看grpc请求的trace信息。
运行：

• 客户端
  

1. package main
   
2. 
   
3. import (
   
4.         "context"
   
5.         "fmt"
   
6.         hello "sample-app/grpc/proto"
   
7. 
   
8.         "google.golang.org/grpc"
   
9. )
   
10. 
    
11. const (
    
12.         Addr = "127.0.0.1:8080"
    
13. )
    
14. 
    
15. func main() {
    
16.         conn, err := grpc.Dial(Addr, grpc.WithInsecure())
    
17.         if err != nil {
    
18.                 fmt.Println("Dial fail", err)
    
19.                 return
    
20.         }
    
21.         defer conn.Close()
    
22.         //初始化服务器
    
23.         c := hello.NewHelloClient(conn)
    
24.         //单项请求
    
25.         req := new(hello.HelloRequest)
    
26.         req.Name = "gRPC"
    
27.         resp, err := c.SayHello(context.Background(), req)
    
28.         if err != nil {
    
29.                 fmt.Println("say hello fail", err)
    
30.                 return
    
31.         }
    
32.         fmt.Println(resp.Message)
    
33. }

复制代码

• 请求
  

服务器事件查看

访问：localhost:8081/debug/events，结果如图所示：

可以看到服务端注册的服务和服务正常启动的事件信息。

请求日志信息查看

访问：localhost:8081/debug/requests

这里可以显示最近的请求状态，包括请求的服务，参数，耗时，响应，对于简单的状态查看还是很方便，默认显示最近10条记录。
到此这篇关于Golang中gRPC内置Trace的实现的文章就介绍到这了,更多相关Golang gRPC内置Trace内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

来源：互联网
免责声明：如果侵犯了您的权益，请联系站长（1277306191@qq.com），我们会及时删除侵权内容，谢谢合作！