معترضات gRPC والبيانات الوصفية

func LoggingInterceptor(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
    log.Printf("RPC: %s", info.FullMethod)
    resp, err := handler(ctx, req)
    log.Printf("done: %v", err)
    return resp, err
}

grpcSrv := grpc.NewServer(grpc.UnaryInterceptor(LoggingInterceptor))

func StreamLogging(srv interface{}, ss grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error {
    log.Printf("stream: %s", info.FullMethod)
    return handler(srv, ss)
}

grpcSrv := grpc.NewServer(
    grpc.ChainUnaryInterceptor(LoggingInterceptor, AuthInterceptor, MetricsInterceptor),
)

conn, _ := grpc.NewClient(addr,
    grpc.WithUnaryInterceptor(ClientAuthInterceptor),
    grpc.WithTransportCredentials(insecure.NewCredentials()),
)

md := metadata.New(map[string]string{"authorization": "Bearer " + token})
ctx := metadata.NewOutgoingContext(context.Background(), md)

md, ok := metadata.FromIncomingContext(ctx)
if !ok { return nil, status.Error(codes.Unauthenticated, "no metadata") }
token := md["authorization"]

grpc.SetHeader(ctx, metadata.Pairs("x-request-id", requestID))

func AuthInterceptor(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
    md, _ := metadata.FromIncomingContext(ctx)
    if !validateToken(md["authorization"]) {
        return nil, status.Error(codes.Unauthenticated, "invalid token")
    }
    return handler(ctx, req)
}

defer func() {
    if r := recover(); r != nil {
        err = status.Errorf(codes.Internal, "panic: %v", r)
    }
}()