From f2c893709d14167c06e08a63cafe4a6de017fc20 Mon Sep 17 00:00:00 2001 From: yanghao05 Date: Mon, 30 Jan 2023 11:23:04 +0800 Subject: [PATCH] fix logger issues --- providers/http/engine.go | 8 +- providers/log/gin_level_writer.go | 23 +++++ providers/log/logger.go | 144 +++++++++++++++++++++++++++ providers/log/zap.go | 18 ++++ providers/logger/gin_level_writer.go | 3 +- providers/logger/logger.go | 5 + 6 files changed, 194 insertions(+), 7 deletions(-) create mode 100644 providers/log/gin_level_writer.go create mode 100644 providers/log/logger.go create mode 100644 providers/log/zap.go diff --git a/providers/http/engine.go b/providers/http/engine.go index f887cb1..8bb78e1 100644 --- a/providers/http/engine.go +++ b/providers/http/engine.go @@ -30,11 +30,9 @@ func (e *Service) Serve() error { return e.Engine.Run(e.conf.Http.PortString()) } -func NewService(cfg *config.Config) *Service { - logger.Info("init http service with gin...") - - gin.DefaultWriter = &logger.LevelWriter{Level: zap.InfoLevel} - gin.DefaultErrorWriter = &logger.LevelWriter{Level: zap.ErrorLevel} +func NewService(cfg *config.Config, logger *logger.Logger) *Service { + gin.DefaultWriter = logger.LevelWriter(zap.InfoLevel) + gin.DefaultErrorWriter = logger.LevelWriter(zap.ErrorLevel) if cfg.App.IsDebug() { gin.SetMode(gin.DebugMode) diff --git a/providers/log/gin_level_writer.go b/providers/log/gin_level_writer.go new file mode 100644 index 0000000..30479df --- /dev/null +++ b/providers/log/gin_level_writer.go @@ -0,0 +1,23 @@ +package log + +import ( + "strings" + + "go.uber.org/zap/zapcore" +) + +type LevelWriter struct { + Logger *Logger + Level zapcore.Level +} + +func (w LevelWriter) Write(p []byte) (n int, err error) { + str := strings.TrimSpace(string(p)) + switch w.Level { + case zapcore.InfoLevel: + Info(str) + case zapcore.ErrorLevel: + Error(str) + } + return len(p), nil +} diff --git a/providers/log/logger.go b/providers/log/logger.go new file mode 100644 index 0000000..1dc0730 --- /dev/null +++ b/providers/log/logger.go @@ -0,0 +1,144 @@ +package log + +import ( + "atom/container" + "log" + + "go.uber.org/zap" +) + +func init() { + if err := container.Container.Provide(NewZapLogger); err != nil { + log.Fatal(err) + } +} + +var DefaultLogger *Logger + +type Logger struct { + logger *zap.SugaredLogger +} + +// Debug uses fmt.Sprint to construct and log a message. +func Debug(args ...interface{}) { + DefaultLogger.logger.Debug(args...) +} + +// Info uses fmt.Sprint to construct and log a message. +func Info(args ...interface{}) { + DefaultLogger.logger.Info(args...) +} + +// Warn uses fmt.Sprint to construct and log a message. +func Warn(args ...interface{}) { + DefaultLogger.logger.Warn(args...) +} + +// Error uses fmt.Sprint to construct and log a message. +func Error(args ...interface{}) { + DefaultLogger.logger.Error(args...) +} + +// DPanic uses fmt.Sprint to construct and log a message. In development, the +// logger then panics. (See DPanicLevel for details.) +func DPanic(args ...interface{}) { + DefaultLogger.logger.DPanic(args...) +} + +// Panic uses fmt.Sprint to construct and log a message, then panics. +func Panic(args ...interface{}) { + DefaultLogger.logger.Panic(args...) +} + +// Fatal uses fmt.Sprint to construct and log a message, then calls os.Exit. +func Fatal(args ...interface{}) { + DefaultLogger.logger.Fatal(args...) +} + +// Debugf uses fmt.Sprintf to log a templated message. +func Debugf(template string, args ...interface{}) { + DefaultLogger.logger.Debugf(template, args...) +} + +// Infof uses fmt.Sprintf to log a templated message. +func Infof(template string, args ...interface{}) { + DefaultLogger.logger.Infof(template, args...) +} + +// Warnf uses fmt.Sprintf to log a templated message. +func Warnf(template string, args ...interface{}) { + DefaultLogger.logger.Warnf(template, args...) +} + +// Errorf uses fmt.Sprintf to log a templated message. +func Errorf(template string, args ...interface{}) { + DefaultLogger.logger.Errorf(template, args...) +} + +// DPanicf uses fmt.Sprintf to log a templated message. In development, the +// logger then panics. (See DPanicLevel for details.) +func DPanicf(template string, args ...interface{}) { + DefaultLogger.logger.DPanicf(template, args...) +} + +// Panicf uses fmt.Sprintf to log a templated message, then panics. +func Panicf(template string, args ...interface{}) { + DefaultLogger.logger.Panicf(template, args...) +} + +// Fatalf uses fmt.Sprintf to log a templated message, then calls os.Exit. +func Fatalf(template string, args ...interface{}) { + DefaultLogger.logger.Fatalf(template, args...) +} + +// Debugw logs a message with some additional context. The variadic key-value +// pairs are treated as they are in With. +// +// When debug-level logging is disabled, this is much faster than +// +// s.With(keysAndValues).Debug(msg) +func Debugw(msg string, keysAndValues ...interface{}) { + DefaultLogger.logger.Debugw(msg, keysAndValues...) +} + +// Infow logs a message with some additional context. The variadic key-value +// pairs are treated as they are in With. +func Infow(msg string, keysAndValues ...interface{}) { + DefaultLogger.logger.Infow(msg, keysAndValues...) +} + +// Warnw logs a message with some additional context. The variadic key-value +// pairs are treated as they are in With. +func Warnw(msg string, keysAndValues ...interface{}) { + DefaultLogger.logger.Warnw(msg, keysAndValues...) +} + +// Errorw logs a message with some additional context. The variadic key-value +// pairs are treated as they are in With. +func Errorw(msg string, keysAndValues ...interface{}) { + DefaultLogger.logger.Errorw(msg, keysAndValues...) +} + +// DPanicw logs a message with some additional context. In development, the +// logger then panics. (See DPanicLevel for details.) The variadic key-value +// pairs are treated as they are in With. +func DPanicw(msg string, keysAndValues ...interface{}) { + DefaultLogger.logger.DPanicw(msg, keysAndValues...) +} + +// Panicw logs a message with some additional context, then panics. The +// variadic key-value pairs are treated as they are in With. +func Panicw(msg string, keysAndValues ...interface{}) { + DefaultLogger.logger.Panicw(msg, keysAndValues...) +} + +// Fatalw logs a message with some additional context, then calls os.Exit. The +// variadic key-value pairs are treated as they are in With. +func Fatalw(msg string, keysAndValues ...interface{}) { + DefaultLogger.logger.Fatalw(msg, keysAndValues...) +} + +// Sync flushes any buffered log entries. +func Sync() error { + return DefaultLogger.logger.Sync() +} diff --git a/providers/log/zap.go b/providers/log/zap.go new file mode 100644 index 0000000..db34f39 --- /dev/null +++ b/providers/log/zap.go @@ -0,0 +1,18 @@ +package log + +import ( + "atom/providers/config" + "log" + + "go.uber.org/zap" +) + +func NewZapLogger(conf *config.Config) (*Logger, error) { + log.Print("init logger") + logger, err := zap.NewDevelopment() + if err != nil { + return nil, err + } + DefaultLogger = &Logger{logger: logger.Sugar()} + return DefaultLogger, nil +} diff --git a/providers/logger/gin_level_writer.go b/providers/logger/gin_level_writer.go index 6066270..a0300c5 100644 --- a/providers/logger/gin_level_writer.go +++ b/providers/logger/gin_level_writer.go @@ -7,8 +7,7 @@ import ( ) type LevelWriter struct { - Logger *Logger - Level zapcore.Level + Level zapcore.Level } func (w LevelWriter) Write(p []byte) (n int, err error) { diff --git a/providers/logger/logger.go b/providers/logger/logger.go index 561213b..6ad5b35 100644 --- a/providers/logger/logger.go +++ b/providers/logger/logger.go @@ -5,6 +5,7 @@ import ( "log" "go.uber.org/zap" + "go.uber.org/zap/zapcore" ) func init() { @@ -19,6 +20,10 @@ type Logger struct { logger *zap.SugaredLogger } +func (l *Logger) LevelWriter(level zapcore.Level) *LevelWriter { + return &LevelWriter{Level: level} +} + // Debug uses fmt.Sprint to construct and log a message. func Debug(args ...interface{}) { DefaultLogger.logger.Debug(args...)