feat(log):日志系统切换至zap。

logger/logger.go

@@ -1,75 +1,123 @@
 package logger
 
 import (
-	"io"
 	"os"
 
-	jsoniter "github.com/json-iterator/go"
-	"github.com/rs/zerolog"
-	"github.com/samber/lo"
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
 )
 
-var logger *zerolog.Logger
+var (
+	logger        *zap.Logger
+	sugaredLogger *zap.SugaredLogger
+)
 
 func init() {
-	var writers []io.Writer
+	consoleWriterSync := zapcore.AddSync(os.Stderr)
+	rollingWriterSync := zapcore.AddSync(newRollingWriter())
+	encoderConfig := zap.NewProductionEncoderConfig()
+	encoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
+	encoderConfig.EncodeLevel = zapcore.CapitalLevelEncoder
+	consoleEncoder := zapcore.NewConsoleEncoder(encoderConfig)
+	jsonEncoder := zapcore.NewJSONEncoder(encoderConfig)
+	core := zapcore.NewTee(
+		zapcore.NewCore(
+			consoleEncoder,
+			consoleWriterSync,
+			zapcore.DebugLevel,
+		),
+		zapcore.NewCore(
+			jsonEncoder,
+			rollingWriterSync,
+			zapcore.DebugLevel,
+		),
+	)
 
-	writers = append(writers, zerolog.ConsoleWriter{Out: os.Stderr})
-	writers = append(writers, newRollingWriter())
-	mw := io.MultiWriter(writers...)
-	logger = lo.ToPtr(zerolog.New(mw).With().Timestamp().Logger())
-	logger.Info().Msg("Logger initialized.")
+	logger = zap.New(core)
+	sugaredLogger = logger.Sugar()
+	logger.Info("Logger initialized.")
 }
 
-func GetLogger() *zerolog.Logger {
+func GetLogger() *zap.Logger {
 	return logger
 }
 
-func Panic() *zerolog.Event {
-	return logger.Panic()
+func Panic(msg string, fields ...zap.Field) {
+	logger.Panic(msg, fields...)
 }
 
-func Fatal() *zerolog.Event {
-	return logger.Fatal()
+func Fatal(msg string, fields ...zap.Field) {
+	logger.Fatal(msg, fields...)
 }
 
-func Error() *zerolog.Event {
-	return logger.Error()
+func Error(msg string, fields ...zap.Field) {
+	logger.Error(msg, fields...)
 }
 
-func Warn() *zerolog.Event {
-	return logger.Warn()
+func Warn(msg string, fields ...zap.Field) {
+	logger.Warn(msg, fields...)
 }
 
-func Info() *zerolog.Event {
-	return logger.Info()
+func Info(msg string, fields ...zap.Field) {
+	logger.Info(msg, fields...)
 }
 
-func Debug() *zerolog.Event {
-	return logger.Debug()
+func Debug(msg string, fields ...zap.Field) {
+	logger.Debug(msg, fields...)
 }
 
-func Trace() *zerolog.Event {
-	return logger.Trace()
+func Panicr(v ...interface{}) {
+	sugaredLogger.Panic(v...)
 }
 
-func Print(v ...interface{}) {
-	logger.Print(v...)
+func Panicf(format string, v ...interface{}) {
+	sugaredLogger.Panicf(format, v...)
 }
 
-func Printf(format string, v ...interface{}) {
-	logger.Printf(format, v...)
+func Errorr(v ...interface{}) {
+	sugaredLogger.Panic(v...)
 }
 
-func With() zerolog.Context {
-	return logger.With()
+func Errorf(format string, v ...interface{}) {
+	sugaredLogger.Panicf(format, v...)
 }
 
-func FormatAny(v interface{}) string {
-	b, err := jsoniter.MarshalToString(v)
-	if err != nil {
-		logger.Error().Str("process", "log").Err(err).Stack().Msg("Value marshal failed.")
-		return ""
-	}
-	return b
+func Warnr(v ...interface{}) {
+	sugaredLogger.Warn(v...)
+}
+
+func Warnf(format string, v ...interface{}) {
+	sugaredLogger.Warnf(format, v...)
+}
+
+func Infor(v ...interface{}) {
+	sugaredLogger.Info(v...)
+}
+
+func Infof(format string, v ...interface{}) {
+	sugaredLogger.Infof(format, v...)
+}
+
+func Debugr(v ...interface{}) {
+	sugaredLogger.Debug(v...)
+}
+
+func Debugf(format string, v ...interface{}) {
+	sugaredLogger.Debugf(format, v...)
+}
+
+func Named(name string) *zap.Logger {
+	return logger.Named(name)
+}
+
+func NamedSugar(name string) *zap.SugaredLogger {
+	return logger.Named(name).Sugar()
+}
+
+func With(fields ...zap.Field) *zap.Logger {
+	return logger.With(fields...)
+}
+
+func WithSugar(fields ...zap.Field) *zap.SugaredLogger {
+	return logger.With(fields...).Sugar()
 }

logger/middleware.go

@@ -1,9 +1,11 @@
 package logger
 
 import (
+	"fmt"
 	"time"
 
 	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
 )
 
 func Logger() gin.HandlerFunc {
@@ -27,17 +29,20 @@ func Logger() gin.HandlerFunc {
 			path = path + "?" + raw
 		}
 
-		event := logger.Info()
-		if comment != "" {
-			event = logger.Error()
+		fields := []zap.Field{
+			zap.Int("statusCode", statusCode),
+			zap.Duration("latency", latency),
+			zap.String("clientIP", clientIP),
+			zap.String("method", method),
+			zap.String("path", path),
+		}
+		if comment != "" {
+			logger.Named("Gin").Error(
+				comment,
+				fields...,
+			)
+		} else {
+			logger.Named("Gin").Info(fmt.Sprintf("%s -> [%d] %s %s.", clientIP, statusCode, method, path), fields...)
 		}
-
-		event.
-			Int("statusCode", statusCode).
-			Dur("latency", latency).
-			Str("clientIP", clientIP).
-			Str("method", method).
-			Str("path", path).
-			Msg(comment)
 	}
 }

logger/xormlogger.go

@@ -1,22 +1,20 @@
 package logger
 
 import (
-	"fmt"
-
-	"github.com/rs/zerolog"
-	"github.com/samber/lo"
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
 	"xorm.io/xorm/log"
 )
 
 type XormZeroLogger struct {
-	logger *zerolog.Logger
+	logger *zap.Logger
 	off    bool
 	show   bool
 }
 
-func NewXormZeroLogger(oLogger *zerolog.Logger) *XormZeroLogger {
+func NewXormZeroLogger(oLogger *zap.Logger) *XormZeroLogger {
 	return &XormZeroLogger{
-		logger: lo.ToPtr(oLogger.With().Str("process", "Xorm").Logger()),
+		logger: oLogger.Named("Xorm"),
 		off:    false,
 		show:   true,
 	}
@@ -26,46 +24,57 @@ func (l XormZeroLogger) BeforeSQL(_ log.LogContext) {}
 
 func (l XormZeroLogger) AfterSQL(c log.LogContext) {
 	if c.Err == nil {
-		l.logger.Info().Str("SQL", c.SQL).Str("args", FormatAny(c.Args)).Dur("execution", c.ExecuteTime).Send()
+		l.logger.Info(
+			"",
+			zap.String("SQL", c.SQL),
+			zap.Any("args", c.Args),
+			zap.Duration("execution", c.ExecuteTime),
+		)
 		return
 	}
-	l.logger.Error().Err(c.Err).Stack().Str("SQL", c.SQL).Str("args", FormatAny(c.Args)).Dur("execution", c.ExecuteTime).Msg(c.Err.Error())
+	l.logger.Error(
+		c.Err.Error(),
+		zap.Error(c.Err),
+		zap.String("SQL", c.SQL),
+		zap.Any("args", c.Args),
+		zap.Duration("execution", c.ExecuteTime),
+	)
 }
 
 func (l XormZeroLogger) Debug(v ...interface{}) {
-	l.logger.Debug().Str("args", FormatAny(v)).Msg(fmt.Sprint(v...))
+	l.logger.Sugar().Debug(v...)
 }
 
 func (l XormZeroLogger) Debugf(format string, v ...interface{}) {
-	l.logger.Debug().Str("args", FormatAny(v)).Msg(fmt.Sprintf(format, v...))
+	l.logger.Sugar().Debugf(format, v...)
 }
 
 func (l XormZeroLogger) Info(v ...interface{}) {
-	l.logger.Info().Str("args", FormatAny(v)).Msg(fmt.Sprint(v...))
+	l.logger.Sugar().Info(v...)
 }
 
 func (l XormZeroLogger) Infof(format string, v ...interface{}) {
-	l.logger.Info().Str("args", FormatAny(v)).Msg(fmt.Sprintf(format, v...))
+	l.logger.Sugar().Infof(format, v...)
 }
 
 func (l XormZeroLogger) Warn(v ...interface{}) {
-	l.logger.Warn().Str("args", FormatAny(v)).Msg(fmt.Sprint(v...))
+	l.logger.Sugar().Warn(v...)
 }
 
 func (l XormZeroLogger) Warnf(format string, v ...interface{}) {
-	l.logger.Warn().Str("args", FormatAny(v)).Msg(fmt.Sprintf(format, v...))
+	l.logger.Sugar().Warnf(format, v...)
 }
 
 func (l XormZeroLogger) Error(v ...interface{}) {
-	l.logger.Error().Str("args", FormatAny(v)).Msg(fmt.Sprint(v...))
+	l.logger.Sugar().Error(v...)
 }
 
 func (l XormZeroLogger) Errorf(format string, v ...interface{}) {
-	l.logger.Error().Str("args", FormatAny(v)).Msg(fmt.Sprintf(format, v...))
+	l.logger.Sugar().Errorf(format, v...)
 }
 
 func (l XormZeroLogger) SetLevel(lvl log.LogLevel) {
-	l.logger.Warn().Msg("Change log level is not supported.")
+	l.logger.Warn("Change log level is not supported.")
 }
 
 func (l *XormZeroLogger) ShowSQL(b ...bool) {
@@ -81,15 +90,15 @@ func (l XormZeroLogger) Level() log.LogLevel {
 		return log.LOG_OFF
 	}
 
-	for _, lvl := range []zerolog.Level{zerolog.DebugLevel, zerolog.InfoLevel, zerolog.WarnLevel, zerolog.ErrorLevel, zerolog.FatalLevel, zerolog.PanicLevel} {
+	for _, lvl := range []zapcore.Level{zapcore.DebugLevel, zapcore.InfoLevel, zapcore.WarnLevel, zapcore.ErrorLevel, zapcore.FatalLevel, zapcore.PanicLevel} {
 		switch lvl {
-		case zerolog.DebugLevel:
+		case zapcore.DebugLevel:
 			return log.LOG_DEBUG
-		case zerolog.InfoLevel:
+		case zapcore.InfoLevel:
 			return log.LOG_INFO
-		case zerolog.WarnLevel:
+		case zapcore.WarnLevel:
 			return log.LOG_WARNING
-		case zerolog.ErrorLevel:
+		case zapcore.ErrorLevel:
 			return log.LOG_ERR
 		}
 	}