Implementing Interceptors

func LoggingUnary(ctx context.Context, req any, info *grpc.UnaryServerInfo,
    handler grpc.UnaryHandler) (any, error) {
    start := time.Now()
    res, err := handler(ctx, req)
    log.Printf("%s %v code=%s", info.FullMethod, time.Since(start), status.Code(err))
    return res, err
}

func StreamLog(srv any, ss grpc.ServerStream, info *grpc.StreamServerInfo,
    handler grpc.StreamHandler) error {
    start := time.Now()
    err := handler(srv, ss)
    log.Printf("stream %s %v", info.FullMethod, time.Since(start))
    return err
}

func AuthUnary(token string) grpc.UnaryClientInterceptor {
    return func(ctx context.Context, method string, req, reply any,
        cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
        ctx = metadata.AppendToOutgoingContext(ctx, "authorization", "Bearer "+token)
        return invoker(ctx, method, req, reply, cc, opts...)
    }
}

srv := grpc.NewServer(
    grpc.ChainUnaryInterceptor(Recovery, Logging, Auth, Validation),
    grpc.ChainStreamInterceptor(StreamRecovery, StreamLog),
)
conn, _ := grpc.NewClient(addr,
    grpc.WithChainUnaryInterceptor(Retry, Tracing, AuthUnary(token)),
)

func AuthInterceptor(ctx context.Context, req any, info *grpc.UnaryServerInfo,
    handler grpc.UnaryHandler) (any, error) {
    if isPublic(info.FullMethod) { return handler(ctx, req) }
    md, _ := metadata.FromIncomingContext(ctx)
    tok := strings.TrimPrefix(first(md, "authorization"), "Bearer ")
    claims, err := jwt.Parse(tok, key)
    if err != nil { return nil, status.Error(codes.Unauthenticated, "invalid token") }
    return handler(context.WithValue(ctx, ctxKey{}, claims), req)
}

func Recovery(ctx context.Context, req any, info *grpc.UnaryServerInfo,
    handler grpc.UnaryHandler) (res any, err error) {
    defer func() {
        if r := recover(); r != nil {
            log.Printf("panic %s: %v\n%s", info.FullMethod, r, debug.Stack())
            err = status.Error(codes.Internal, "internal error")
        }
    }()
    return handler(ctx, req)
}