Merge pull request #15 from KyberNetwork/phu/allow-config-logger

feat: allow configuring logger

Author: NgoKimPhu

pkg/observe/trace.go

@@ -26,7 +26,7 @@ func EnsureTracerProvider() {
 				constant.OtelDefaultServiceVersion)),
 		))
 	if err == nil {
-		resources, err = resource.Merge(resources, extraResources)
+		resources, _ = resource.Merge(resources, extraResources)
 	}
 	tracerProvider := sdktrace.NewTracerProvider(
 		sdktrace.WithResource(resources),

pkg/server/grpcserver/server.go

@@ -104,7 +104,7 @@ func (s *Server) Register(services ...Service) error {
 func (s *Server) Serve(ctx context.Context) (err error) {
 	stop := make(chan os.Signal, 1)
 	errCh := make(chan error)
-	signal.Notify(stop, os.Interrupt, os.Kill, syscall.SIGTERM)
+	signal.Notify(stop, os.Interrupt, syscall.SIGTERM)
 
 	go func() {
 		listener, err := net.Listen("tcp", s.cfg.GRPC.String())

pkg/server/middleware/logging/log.go

@@ -5,6 +5,7 @@ import (
 	"time"
 
 	"github.com/KyberNetwork/kutils/klog"
+	"github.com/KyberNetwork/logger"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/metadata"
 	"google.golang.org/grpc/peer"
@@ -21,15 +22,30 @@ type InterceptorLogger interface {
 // LoggerFunc is a function that also implements InterceptorLogger interface.
 type LoggerFunc func(ctx context.Context, meta CallMeta, req any, resp any, err error, duration time.Duration)
 
+// Log implements InterceptorLogger interface by triggering itself.
 func (f LoggerFunc) Log(ctx context.Context, meta CallMeta, req any, resp any, err error, duration time.Duration) {
 	f(ctx, meta, req, resp, err, duration)
 }
 
+// opt is the option struct for logging interceptors.
 type opt struct {
 	ignoreReq  map[string]struct{}
 	ignoreResp map[string]struct{}
 }
 
+// newOpt returns a new opt struct with the given option funcs.
+func newOpt(opts ...func(opt *opt)) *opt {
+	opt := &opt{
+		ignoreReq:  make(map[string]struct{}),
+		ignoreResp: make(map[string]struct{}),
+	}
+	for _, o := range opts {
+		o(opt)
+	}
+	return opt
+}
+
+// IgnoreReq ignores logging requests for commands with given specified full method names.
 func IgnoreReq(ignoreReq ...string) func(opt *opt) {
 	return func(opt *opt) {
 		for _, v := range ignoreReq {
@@ -38,6 +54,7 @@ func IgnoreReq(ignoreReq ...string) func(opt *opt) {
 	}
 }
 
+// IgnoreResp ignores logging responses for commands with given specified full method names.
 func IgnoreResp(ignoreResp ...string) func(opt *opt) {
 	return func(opt *opt) {
 		for _, v := range ignoreResp {
@@ -46,16 +63,17 @@ func IgnoreResp(ignoreResp ...string) func(opt *opt) {
 	}
 }
 
+// ignored is a string that indicates that the request or response is ignored.
 const ignored = "<...>"
 
+// DefaultLogger is the default logging interceptor which logs requests and responses in plain format.
 func DefaultLogger(loggerFromCtx func(context.Context) Logger, opts ...func(opt *opt)) LoggerFunc {
-	opt := &opt{
-		ignoreReq:  make(map[string]struct{}),
-		ignoreResp: make(map[string]struct{}),
-	}
-	for _, o := range opts {
-		o(opt)
+	if loggerFromCtx == nil {
+		loggerFromCtx = func(ctx context.Context) Logger {
+			return klog.LoggerFromCtx(ctx)
+		}
 	}
+	opt := newOpt(opts...)
 	return func(ctx context.Context, meta CallMeta, req any, resp any, err error, duration time.Duration) {
 		code := status.Code(err)
 		if _, ok := opt.ignoreReq[meta.FullMethod]; ok {
@@ -74,8 +92,38 @@ func DefaultLogger(loggerFromCtx func(context.Context) Logger, opts ...func(opt
 	}
 }
 
-func KlogLogger(ctx context.Context) Logger {
-	return klog.LoggerFromCtx(ctx)
+// FieldsLogger is the fields-enabled logging interceptor which logs requests and responses in JSON format.
+func FieldsLogger(loggerFromCtx func(context.Context) logger.Logger, opts ...func(opt *opt)) LoggerFunc {
+	if loggerFromCtx == nil {
+		loggerFromCtx = func(ctx context.Context) logger.Logger {
+			return klog.LoggerFromCtx(ctx)
+		}
+	}
+	opt := newOpt(opts...)
+	return func(ctx context.Context, meta CallMeta, req any, resp any, err error, duration time.Duration) {
+		code := status.Code(err)
+		if _, ok := opt.ignoreReq[meta.FullMethod]; ok {
+			req = ignored
+		}
+		if _, ok := opt.ignoreResp[meta.FullMethod]; ok {
+			resp = ignored
+		}
+		from := metadata.ValueFromIncomingContext(ctx, common.HeaderXForwardedFor)
+		if peerInfo, ok := peer.FromContext(ctx); ok {
+			from = append(from, peerInfo.Addr.String())
+		}
+		logFields := logger.Fields{
+			"cmd":  meta.FullMethod,
+			"code": code,
+			"err":  err,
+			"req":  req,
+			"resp": resp,
+			"dur":  duration,
+			"from": from,
+		}
+		log := loggerFromCtx(ctx).WithFields(logFields)
+		Logf(log, code, "response sent")
+	}
 }
 
 // Logger is a logger with infof/warnf/errorf methods.

pkg/server/option.go

@@ -0,0 +1,53 @@
+package server
+
+import (
+	"context"
+
+	"google.golang.org/grpc"
+
+	"github.com/KyberNetwork/service-framework/pkg/server/grpcserver"
+	"github.com/KyberNetwork/service-framework/pkg/server/middleware/logging"
+)
+
+type option struct {
+	services           []grpcserver.Service                     // services to register
+	loggingInterceptor logging.InterceptorLogger                // to override default interceptor logger
+	logger             func(ctx context.Context) logging.Logger // to override logger used by default interceptor logger
+	grpcServerOptions  []grpc.ServerOption                      // additional grpc server options
+}
+
+func (o *option) Build(optFns ...OptFn) *option {
+	if o == nil {
+		*o = option{}
+	}
+	for _, opt := range optFns {
+		opt(o)
+	}
+	return o
+}
+
+type OptFn func(*option)
+
+func WithServices(services ...grpcserver.Service) OptFn {
+	return func(o *option) {
+		o.services = append(o.services, services...)
+	}
+}
+
+func WithLoggingInterceptor(interceptor logging.InterceptorLogger) OptFn {
+	return func(o *option) {
+		o.loggingInterceptor = interceptor
+	}
+}
+
+func WithLogger(logger func(ctx context.Context) logging.Logger) OptFn {
+	return func(o *option) {
+		o.logger = logger
+	}
+}
+
+func WithGRPCServerOptions(options ...grpc.ServerOption) OptFn {
+	return func(o *option) {
+		o.grpcServerOptions = append(o.grpcServerOptions, options...)
+	}
+}

pkg/server/serve.go

@@ -33,18 +33,27 @@ import (
 
 var internalServerErr = status.New(codes.Internal, "Internal server error")
 
-func Serve(ctx context.Context, cfg grpcserver.Config, services ...grpcserver.Service) {
+// Serve starts gRPC server and HTTP grpc gateway server. It blocks until os.Interrupt or syscall.SIGTERM.
+// Example usage:
+//
+//	server.Serve(ctx, cfg, server.WithServices(service1, service2), server.WithLogger(myLoggerFactory))
+func Serve(ctx context.Context, cfg grpcserver.Config, opts ...OptFn) {
 	defer shutdownKyberTrace()
 
+	opt := new(option).Build(opts...)
+
 	appMode := grpcserver.GetAppMode(cfg.Mode)
 	isDevMode := appMode == grpcserver.Development
 	unaryOpts := []grpc.UnaryServerInterceptor{
 		trace.UnaryServerInterceptor(isDevMode, internalServerErr),
 	}
 	var streamOpts []grpc.StreamServerInterceptor
 
-	loggingLogger := logging.DefaultLogger(logging.KlogLogger,
-		logging.IgnoreReq(cfg.Log.IgnoreReq...), logging.IgnoreResp(cfg.Log.IgnoreResp...))
+	loggingLogger := opt.loggingInterceptor
+	if loggingLogger == nil {
+		loggingLogger = logging.DefaultLogger(opt.logger,
+			logging.IgnoreReq(cfg.Log.IgnoreReq...), logging.IgnoreResp(cfg.Log.IgnoreResp...))
+	}
 	recoveryOpt := recovery.WithRecoveryHandler(func(err any) error {
 		klog.WithFields(ctx, klog.Fields{"error": err}).Errorf("recovered from:\n%s", string(debug.Stack()))
 		kmetric.IncPanicTotal(context.Background())
@@ -70,7 +79,7 @@ func Serve(ctx context.Context, cfg grpcserver.Config, services ...grpcserver.Se
 	}
 	s := grpcserver.NewServer(&cfg, appMode, serverOptions...)
 
-	if err := s.Register(services...); err != nil {
+	if err := s.Register(opt.services...); err != nil {
 		klog.Fatalf(ctx, "Error register servers %v", err)
 	}