gRPC
是微软在.NET Core
及其后续版本中主推的 RPC 框架,它使用 Google
的 Protocol Buffers
作为序列化协议,使用 HTTP/2 作为通信协议,具有跨语言、高性能、双向流式调用等优点。考虑到,接下来要参与的是,一个以gRPC
为核心而构建的微服务项目。因此,博主准备调研一下gRPC
的相关内容,而首当其冲的,则是从 .NET Core 3.1 开始就有的拦截器,它类似于ASP.NET Core
中的过滤器和中间件,体现了一种面向切面编程(AOP)的思想,非常适合在 RPC 服务调用的时候做某种统一处理,譬如参数校验、身份验证、日志记录等等。在今天这篇博客中,博主主要和大家分享的是,利用 .NET Core gRPC 中的拦截器实现日志记录的简单技巧,希望能给大家带来一点启发。
关于 Interceptor 类
Interceptor
类是 gRPC 服务拦截器的基类,它本身是一个抽象类,其中定义了下面的虚方法:
1public virtual AsyncClientStreamingCall<TRequest, TResponse> AsyncClientStreamingCall<TRequest, TResponse>();
2public virtual AsyncDuplexStreamingCall<TRequest, TResponse> AsyncDuplexStreamingCall<TRequest, TResponse>();
3public virtual AsyncUnaryCall<TResponse> AsyncUnaryCall<TRequest, TResponse>();
4public virtual TResponse BlockingUnaryCall<TRequest, TResponse>();
5public virtual Task<TResponse> ClientStreamingServerHandler<TRequest, TResponse>();
6public virtual AsyncServerStreamingCall<TResponse> AsyncServerStreamingCall<TRequest, TResponse>();
7public virtual Task DuplexStreamingServerHandler<TRequest, TResponse>();
8public virtual Task ServerStreamingServerHandler<TRequest, TResponse>();
9public virtual Task<TResponse> UnaryServerHandler<TRequest, TResponse>();
整体而言,如果从通信方式上来划分,可以分为:流式调用 和 普通调用;而如果从使用方来划分,则可以分为:客户端 和 服务端。进一步讲的话,针对流式调用,它还分为:"单向流" 和 “双向流"。关于这些细节上的差异,大家可以通过 gRPC
的 官方文档 来了解,这里我们给出的是每一种方法对应的用途:
方法名 | 描述 |
---|---|
AsyncClientStreamingCall | 拦截异步客户端流式调用 |
AsyncDuplexStreamingCall | 拦截双向流式调用 |
AsyncUnaryCall | 拦截异步普通调用 |
BlockingUnaryCall | 拦截阻塞普通调用 |
AsyncServerStreamingCall | 拦截异步服务端流式调用 |
ClientStreamingServerHandler | 拦截客户端流式调用的服务端处理程序 |
DuplexStreamingServerHandler | 拦截双向流式调用的服务端处理程序 |
ServerStreamingServerHandler | 拦截服务端流式调用的服务端处理程序 |
UnaryServerHandler | 拦截普通调用的服务端处理程序 |
实现一个拦截器
好了,下面我们一起实现一个拦截器。这里,我们使用的是微软官方的例子:
1public class GreeterService : Greeter.GreeterBase
2{
3 private readonly ILogger<GreeterService> _logger;
4 public GreeterService(ILogger<GreeterService> logger)
5 {
6 _logger = logger;
7 }
8
9 public override Task<HelloReply> SayHello(HelloRequest request, ServerCallContext context)
10 {
11 return Task.FromResult(new HelloReply
12 {
13 Message = "Hello " + request.Name
14 });
15 }
16}
服务器端
实现服务器端的普通调用拦截,我们需要重写的方法是UnaryServerHandler
:
1public class GRPCServerLoggingInterceptor : Interceptor
2{
3 private readonly ILogger<GRPCServerLoggingInterceptor> _logger;
4 public GRPCServerLoggingInterceptor(ILogger<GRPCServerLoggingInterceptor> logger)
5 {
6 _logger = logger;
7 }
8
9 // 重写 UnaryServerHandler() 方法
10 public override Task<TResponse> UnaryServerHandler<TRequest, TResponse>(
11 TRequest request, ServerCallContext context,
12 UnaryServerMethod<TRequest, TResponse> continuation
13 )
14 {
15 var builder = new StringBuilder();
16
17 // Call gRPC begin
18 builder.AppendLine($"Call gRPC {context.Host}/{context.Method} begin.");
19
20 // Logging Request
21 builder.AppendLine(LogRequest(request));
22
23 // Logging Response
24 var reply = continuation(request, context);
25 var response = reply.Result;
26 var exception = reply.Exception;
27 builder.AppendLine(LogResponse(response, exception));
28
29 // Call gRPC finish
30 builder.AppendLine($"Call gRPC {context.Host}/{context.Method} finish.");
31 _logger.LogInformation(builder.ToString());
32
33 return reply;
34 }
35
36 // 记录gRPC请求
37 private string LogRequest<TRequest>(TRequest request)
38 {
39 var payload = string.Empty;
40 if (request is IMessage)
41 payload = JsonConvert.SerializeObject(
42 (request as IMessage)
43 .Descriptor.Fields.InDeclarationOrder()
44 .ToDictionary(x => x.Name, x => x.Accessor.GetValue(request as IMessage))
45 );
46 return $"Send request of {typeof(TRequest)}:{payload}";
47 }
48
49 // 记录gRPC响应
50 private string LogResponse<TResponse>(TResponse response, AggregateException exception)
51 {
52 var payload = string.Empty;
53 if (exception == null)
54 {
55 if (response is IMessage)
56 payload = JsonConvert.SerializeObject(
57 (response as IMessage)
58 .Descriptor.Fields.InDeclarationOrder()
59 .ToDictionary(x => x.Name, x => x.Accessor.GetValue(response as IMessage))
60 );
61 return $"Receive response of {typeof(TResponse)}:{payload}";
62 }
63 else
64 {
65 var errorMsgs = string.Join(";", exception.InnerExceptions.Select(x => x.Message));
66 return $"Receive response of {typeof(TResponse)} throws exceptions: {errorMsgs}";
67 }
68 }
69}
对于gRPC
而言,每一个由.proto
声明文件生成的类,都带有一个叫做Descriptor
的属性,我们可以利用这个属性获得gRPC
请求和响应的详细信息。所以,在LogRequest()
和LogResponse()
两个方法中,我们均使用了这一思路来记录gRPC
的报文信息,因为传输层的gRPC
使用了二进制作为数据载体,这可以说是一种用可读性换取高效率的做法,不过幸运的是,我们在这里实现了这个小目标。
接下来,为了让这个拦截器真正生效,我们还需要修改一下Startup
类中注册gRPC
这部分的代码:
1services.AddGrpc(options => options.Interceptors.Add<GRPCServerLoggingInterceptor>());
此时,我们可以得到下面的结果:
客户端
实现客户端的普通调用拦截,我们需要重写的方法是AsyncUnaryCall()
,依样画葫芦即可:
1public class GRPCClientLoggingInterceptor : Interceptor
2{
3 // 重写 AsyncUnaryCall() 方法
4 public override AsyncUnaryCall<TResponse> AsyncUnaryCall<TRequest, TResponse>(
5 TRequest request,
6 ClientInterceptorContext<TRequest, TResponse> context,
7 AsyncUnaryCallContinuation<TRequest, TResponse> continuation
8 )
9 {
10 var builder = new StringBuilder();
11
12 // Call gRPC begin
13 builder.AppendLine($"Call gRPC {context.Host}/{context.Method} begin.");
14
15 // Logging Request
16 builder.AppendLine(LogRequest(request));
17
18 // Logging Response
19 var reply = continuation(request, context);
20 var response = reply.ResponseAsync.Result;
21 var exception = reply.ResponseAsync.Exception;
22 builder.AppendLine(LogResponse(response, exception));
23
24 // Call gRPC finish
25 builder.AppendLine($"Call gRPC {context.Host}/{context.Method} finish.");
26 Console.WriteLine(builder.ToString());
27
28 return reply;
29 }
30}
类似地,为了让拦截器在客户端生效,我们需要这样:
1using Grpc.Core.Interceptors;
2
3var channel = GrpcChannel.ForAddress("https://localhost:5001");
4// 简化写法
5channel.Intercept(new GRPCClientLoggingInterceptor());
6// 完整写法
7var invoker = channel.CreateCallInvoker().Intercept(new GRPCClientLoggingInterceptor());
8var client = new Greeter.GreeterClient(invoker);
9await client.SayHelloAsync(new HelloRequest() { Name = "长安书小妆" });
此时,我们可以得到下面的结果:
客户端感觉不太好的一点就是,这个Interceptor
传入的必须是一个实例,考虑到拦截器内部可能会依赖类似ILogger
等等的组件,建议还是通过IoC
容器来取得一个拦截器的实例,然后再传入Intercept()
方法中。博主所在的项目中,则是非常“土豪”地使用了PostSharp
,直接走动态编织的方案,果然,“这次第,怎一个羡字了得”。当然,gRPC
的客户端,其实提供了日志相关的支持,不过,我个人感觉这个有一点无力:
1var loggerFactory = LoggerFactory.Create(logging =>
2{
3 logging.AddConsole();
4 logging.SetMinimumLevel(LogLevel.Debug);
5});
6var channel = GrpcChannel.ForAddress(
7 "https://localhost:5001",
8 new GrpcChannelOptions { LoggerFactory = loggerFactory }
9);
本文小结
本文主要分享了gRPC
拦截器的使用技巧,gRPC
支持一元调用(UnaryCall)、流式调用(StreamingCall)、阻塞调用(BlockingCall),因为区分客户端和服务器端,所以,实际上会有各种各样的组合方式。gRPC
的拦截器实际上就是选择对应的场景去重写相应的方法,其中,拦截器的基类为Interceptor
类,这里我们都是以普通的一元调用为例的,大家可以结合各自的业务场景,去做进一步的调整和优化。这里,我们使用IMessage
类的Descriptor
属性来“反射”报文中定义的字段,这样就实现了针对gRPC
服务请求/响应的日志记录功能。关于gRPC
中日志和诊断的更进一步的话题,大家可以参考微软的 官方文档 。好了,以上就是这篇博客的全部内容啦,谢谢大家!