logging_zap

Server Interceptor的json格式

{
  "level": "info",                    // string  logrus log levels
  "msg": "finished unary call",                // string  log message
  "grpc.code": "OK",                    // string  grpc status code
  "grpc.method": "Ping",                // string  method name
  "grpc.service": "mwitkow.testproto.TestService",      // string  full name of the called service
  "grpc.start_time": "2006-01-02T15:04:05Z07:00",       // string  RFC3339 representation of the start time
  "grpc.request.deadline": "2006-01-02T15:04:05Z07:00",   // string  RFC3339 deadline of the current request if supplied
  "grpc.request.value": "something",            // string  value on the request
  "grpc.time_ms": 1.234,                // float32 run time of the call in ms
  "peer.address": {
    "IP": "127.0.0.1",                    // string  IP address of calling party
    "Port": 60216,                    // int     port call is coming in on
    "Zone": ""                        // string  peer zone for caller
  },
  "span.kind": "server",                // string  client | server
  "system": "grpc"                    // string
  "custom_field": "custom_value",            // string  user defined field
  "custom_tags.int": 1337,                // int     user defined tag on the ctx
  "custom_tags.string": "something",            // string  user defined tag on the ctx
}

Payload Interceptor的json格式

{
  "level": "info",                            // string logrus log levels
  "msg": "client request payload logged as grpc.request.content",       // string log message
  "grpc.request.content": {                        // object content of RPC request
    "value": "something",                        // string defined by caller
    "sleepTimeMs": 9999                            // int    defined by caller
  },
  "grpc.method": "Ping",                        // string method being called
  "grpc.service": "mwitkow.testproto.TestService",            // string service being called
  "span.kind": "client",                        // string client | server
  "system": "grpc"                            // string
}

e1:Initialization

package main
import (
    grpc_middleware "github.com/grpc-ecosystem/go-grpc-middleware"
    grpc_zap "github.com/grpc-ecosystem/go-grpc-middleware/logging/zap"
    grpc_ctxtags "github.com/grpc-ecosystem/go-grpc-middleware/tags"
    "go.uber.org/zap"
    "google.golang.org/grpc"
)
var (
    zapLogger  *zap.Logger
    customFunc grpc_zap.CodeToLevel
)
func main() {
    // Shared options for the logger, with a custom gRPC code to log level function.
    opts := []grpc_zap.Option{
        grpc_zap.WithLevels(customFunc),
    }
    // Make sure that log statements internal to gRPC library are logged using the zapLogger as well.
    grpc_zap.ReplaceGrpcLoggerV2(zapLogger)
    // Create a server, make sure we put the grpc_ctxtags context before everything else.
    _ = grpc.NewServer(
        grpc_middleware.WithUnaryServerChain(
            grpc_ctxtags.UnaryServerInterceptor(grpc_ctxtags.WithFieldExtractor(grpc_ctxtags.CodeGenRequestFieldExtractor)),
            grpc_zap.UnaryServerInterceptor(zapLogger, opts...),
        ),
        grpc_middleware.WithStreamServerChain(
            grpc_ctxtags.StreamServerInterceptor(grpc_ctxtags.WithFieldExtractor(grpc_ctxtags.CodeGenRequestFieldExtractor)),
            grpc_zap.StreamServerInterceptor(zapLogger, opts...),
        ),
    )
}

e2:InitializationWithDecider

package main
import (
    "time"
    grpc_middleware "github.com/grpc-ecosystem/go-grpc-middleware"
    grpc_zap "github.com/grpc-ecosystem/go-grpc-middleware/logging/zap"
    grpc_ctxtags "github.com/grpc-ecosystem/go-grpc-middleware/tags"
    "go.uber.org/zap"
    "go.uber.org/zap/zapcore"
    "google.golang.org/grpc"
)
var zapLogger *zap.Logger
func main() {
    opts := []grpc_zap.Option{
        grpc_zap.WithDurationField(func(duration time.Duration) zapcore.Field {
            return zap.Int64("grpc.time_ns", duration.Nanoseconds())
        }),
    }
    _ = grpc.NewServer(
        grpc_middleware.WithUnaryServerChain(
            grpc_ctxtags.UnaryServerInterceptor(),
            grpc_zap.UnaryServerInterceptor(zapLogger, opts...),
        ),
        grpc_middleware.WithStreamServerChain(
            grpc_ctxtags.StreamServerInterceptor(),
            grpc_zap.StreamServerInterceptor(zapLogger, opts...),
        ),
    )
}

func ReplaceGrpcLoggerV2(logger zap.Logger) 替换grpclog，应该在初始化就调用
func UnaryClientInterceptor(logger zap.Logger, opts …Option) grpc.UnaryClientInterceptor
func UnaryServerInterceptor(logger zap.Logger, opts …Option) grpc.UnaryServerInterceptor
func StreamClientInterceptor(logger zap.Logger, opts …Option) grpc.StreamClientInterceptor
func StreamServerInterceptor(logger *zap.Logger, opts …Option) grpc.StreamServerInterceptor

func PayloadUnaryClientInterceptor(logger *zap.Logger, decider grpc_logging.ClientPayloadLoggingDecider) grpc.UnaryClientInterceptor
func PayloadUnaryServerInterceptor(logger *zap.Logger, decider grpc_logging.ServerPayloadLoggingDecider) grpc.UnaryServerInterceptor
func PayloadStreamClientInterceptor(logger *zap.Logger, decider grpc_logging.ClientPayloadLoggingDecider) grpc.StreamClientInterceptor
func PayloadStreamServerInterceptor(logger *zap.Logger, decider grpc_logging.ServerPayloadLoggingDecider) grpc.StreamServerInterceptor

type CodeToLevel

type CodeToLevel func(code codes.Code) zapcore.Level

type DurationToField

type DurationToField func(duration time.Duration) zapcore.Field

type MessageProducer

type MessageProducer func(ctx context.Context, msg string, level zapcore.Level, code codes.Code, err error, duration zapcore.Field)

type Option

func WithCodes(f grpc_logging.ErrorToCode) Option
func WithDecider(f grpc_logging.Decider) Option
func WithDurationField(f DurationToField) Option
func WithLevels(f CodeToLevel) Option
func WithMessageProducer(f MessageProducer) Option
func WithTimestampFormat(format string) Option

zap/ctxzap

func AddFields(ctx context.Context, fields …zapcore.Field)
func TagsToFields(ctx context.Context) []zapcore.Field
func ToContext(ctx context.Context, logger zap.Logger) context.Context
func Extract(ctx context.Context) zap.Logger

package main
import (
    "context"
    "github.com/grpc-ecosystem/go-grpc-middleware/logging/zap/ctxzap"
    "github.com/grpc-ecosystem/go-grpc-middleware/tags"
    pb_testproto "github.com/grpc-ecosystem/go-grpc-middleware/testing/testproto"
    "go.uber.org/zap"
)
var zapLogger *zap.Logger
// Simple unary handler that adds custom fields to the requests's context. These will be used for all log statements.
func main() {
    _ = func(ctx context.Context, ping *pb_testproto.PingRequest) (*pb_testproto.PingResponse, error) {
        // Add fields the ctxtags of the request which will be added to all extracted loggers.
        grpc_ctxtags.Extract(ctx).Set("custom_tags.string", "something").Set("custom_tags.int", 1337)
        // Extract a single request-scoped zap.Logger and log messages.
        l := ctxzap.Extract(ctx)
        l.Info("some ping")
        l.Info("another ping")
        return &pb_testproto.PingResponse{Value: ping.Value}, nil
    }
}