From da2649c6bc73eaa2a0959e4f8775e0e865ff912b Mon Sep 17 00:00:00 2001 From: zzm Date: Wed, 24 Apr 2024 18:06:23 +0800 Subject: [PATCH 1/5] logger v2 --- go.mod | 1 + go.sum | 3 + internal/logger/logger_utils.go | 90 ++++++++++++++++++++++++++++ internal/logger/logger_utils_test.go | 40 +++++++++++++ 4 files changed, 134 insertions(+) create mode 100644 internal/logger/logger_utils.go create mode 100644 internal/logger/logger_utils_test.go diff --git a/go.mod b/go.mod index 9047b01..fff1c01 100644 --- a/go.mod +++ b/go.mod @@ -5,6 +5,7 @@ go 1.21 require ( github.com/onsi/ginkgo/v2 v2.9.5 github.com/onsi/gomega v1.27.7 + github.com/sirupsen/logrus v1.9.0 github.com/stretchr/testify v1.8.1 go.uber.org/zap v1.24.0 golang.org/x/net v0.17.0 diff --git a/go.sum b/go.sum index 10b758c..3dfb428 100644 --- a/go.sum +++ b/go.sum @@ -124,6 +124,8 @@ github.com/prometheus/procfs v0.9.0 h1:wzCHvIvM5SxWqYvwgVL7yJY8Lz3PKn49KQtpgMYJf github.com/prometheus/procfs v0.9.0/go.mod h1:+pB4zwohETzFnmlpe6yd2lSc+0/46IYZRB/chUwxUZY= github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ= github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog= +github.com/sirupsen/logrus v1.9.0 h1:trlNQbNUG3OdDrDil03MCb1H2o9nJ1x4/5LYw7byDE0= +github.com/sirupsen/logrus v1.9.0/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA= github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= github.com/stoewer/go-strcase v1.2.0/go.mod h1:IBiWB2sKIp3wVVQ3Y035++gc+knqhUQag1KpM8ahLw8= @@ -193,6 +195,7 @@ golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.13.0 h1:Af8nKPmuFypiUBjVoU9V20FiaFXOcuZI21p0ycVYYGE= golang.org/x/sys v0.13.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= diff --git a/internal/logger/logger_utils.go b/internal/logger/logger_utils.go new file mode 100644 index 0000000..71dcd1c --- /dev/null +++ b/internal/logger/logger_utils.go @@ -0,0 +1,90 @@ +package logger + +import ( + "context" + "github.com/sirupsen/logrus" + "os" + "path/filepath" +) + +type LogLevel string + +const ( + InfoLevel LogLevel = "info" + WarnLevel LogLevel = "warn" + ErrorLevel LogLevel = "error" + TraceID string = "traceID" +) + +type Fields map[string]interface{} + +type Logger struct { + moduleName string + logger *logrus.Entry +} + +type Config struct { + ModuleToFile map[string]string + LogLevel LogLevel + LogFormat logrus.Formatter +} + +var config Config + +func Initialize(cfg Config) { + config = cfg + logrus.SetFormatter(config.LogFormat) + switch config.LogLevel { + case InfoLevel: + logrus.SetLevel(logrus.InfoLevel) + case WarnLevel: + logrus.SetLevel(logrus.WarnLevel) + case ErrorLevel: + logrus.SetLevel(logrus.ErrorLevel) + default: + logrus.SetLevel(logrus.InfoLevel) + } + + for _, file := range config.ModuleToFile { + path := filepath.Dir(file) + if err := os.MkdirAll(path, os.ModePerm); err != nil { + logrus.WithError(err).Fatal("cannot create log directory") + } + file, err := os.OpenFile(file, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666) + if err != nil { + logrus.WithError(err).Fatal("cannot open log file") + } + + logrus.SetOutput(file) + } +} + +func New(moduleName string) *Logger { + return &Logger{ + moduleName: moduleName, + logger: logrus.WithField("module", moduleName), + } +} + +func NewFromContext(ctx context.Context, moduleName string) *Logger { + traceID, ok := ctx.Value(TraceID).(string) + if !ok { + traceID = "unknown" + } + return &Logger{ + moduleName: moduleName, + logger: logrus.WithField("module", moduleName).WithField(TraceID, traceID), + } +} + +func (l *Logger) Info(fields Fields, message string) { + l.logger.WithFields(logrus.Fields(fields)).Info(message) +} + +func (l *Logger) Warn(fields Fields, message string) { + l.logger.WithFields(logrus.Fields(fields)).Warn(message) +} + +func (l *Logger) Error(fields Fields, message string) { + l.logger.WithFields(logrus.Fields(fields)).Error(message) +} diff --git a/internal/logger/logger_utils_test.go b/internal/logger/logger_utils_test.go new file mode 100644 index 0000000..9ceb39c --- /dev/null +++ b/internal/logger/logger_utils_test.go @@ -0,0 +1,40 @@ +package logger + +import ( + "context" + "github.com/sirupsen/logrus" + "testing" +) + +func TestLogger_Schedule_Json(t *testing.T) { + config := Config{ModuleToFile: map[string]string{ + "schedule": "logs/schedule.log", + "module_controller": "logs/module_controller.log", + }, + LogLevel: InfoLevel, + LogFormat: &logrus.JSONFormatter{}, + } + + Initialize(config) + + logger := New("schedule") + logger.Info(Fields{"hello": "word", "foo": "bar"}, "message") + logger.Error(Fields{"key": "value"}, "a mc error occurred") +} + +func TestLogger_module_controller_text(t *testing.T) { + config := Config{ModuleToFile: map[string]string{ + "schedule": "logs/schedule.log", + "module_controller": "logs/module_controller.log", + }, + LogLevel: InfoLevel, + LogFormat: &logrus.TextFormatter{}, + } + + Initialize(config) + + ctx := context.WithValue(context.Background(), TraceID, "12345") + logger := NewFromContext(ctx, "module_controller") + logger.Info(Fields{"hello": "word", "foo": "bar"}, "message") + logger.Error(Fields{"key": "value"}, "a mc error occurred") +} From 86b13efbdbbb26f3990b11d8a7ac4fef4522f61f Mon Sep 17 00:00:00 2001 From: zzm Date: Thu, 25 Apr 2024 14:47:57 +0800 Subject: [PATCH 2/5] logger v2 fix 1 --- internal/logger/logger_utils.go | 40 +++++++++++++++++----------- internal/logger/logger_utils_test.go | 19 +++++++++++++ 2 files changed, 43 insertions(+), 16 deletions(-) diff --git a/internal/logger/logger_utils.go b/internal/logger/logger_utils.go index 71dcd1c..da8e57e 100644 --- a/internal/logger/logger_utils.go +++ b/internal/logger/logger_utils.go @@ -29,40 +29,48 @@ type Config struct { LogFormat logrus.Formatter } +var ModuleToLoggers map[string]*logrus.Logger var config Config func Initialize(cfg Config) { config = cfg - logrus.SetFormatter(config.LogFormat) - switch config.LogLevel { - case InfoLevel: - logrus.SetLevel(logrus.InfoLevel) - case WarnLevel: - logrus.SetLevel(logrus.WarnLevel) - case ErrorLevel: - logrus.SetLevel(logrus.ErrorLevel) - default: - logrus.SetLevel(logrus.InfoLevel) - } + ModuleToLoggers = make(map[string]*logrus.Logger) + + for module, file := range config.ModuleToFile { + // setting log level + switch config.LogLevel { + case InfoLevel: + logrus.SetLevel(logrus.InfoLevel) + case WarnLevel: + logrus.SetLevel(logrus.WarnLevel) + case ErrorLevel: + logrus.SetLevel(logrus.ErrorLevel) + default: + logrus.SetLevel(logrus.InfoLevel) + } - for _, file := range config.ModuleToFile { path := filepath.Dir(file) if err := os.MkdirAll(path, os.ModePerm); err != nil { logrus.WithError(err).Fatal("cannot create log directory") } - file, err := os.OpenFile(file, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666) + logFile, err := os.OpenFile(file, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666) if err != nil { logrus.WithError(err).Fatal("cannot open log file") } - logrus.SetOutput(file) + // create logger instance for each module + logger := logrus.New() + // setting module log output + logger.Out = logFile + logger.Formatter = config.LogFormat + ModuleToLoggers[module] = logger } } func New(moduleName string) *Logger { return &Logger{ moduleName: moduleName, - logger: logrus.WithField("module", moduleName), + logger: ModuleToLoggers[moduleName].WithField("", ""), } } @@ -73,7 +81,7 @@ func NewFromContext(ctx context.Context, moduleName string) *Logger { } return &Logger{ moduleName: moduleName, - logger: logrus.WithField("module", moduleName).WithField(TraceID, traceID), + logger: ModuleToLoggers[moduleName].WithField(TraceID, traceID), } } diff --git a/internal/logger/logger_utils_test.go b/internal/logger/logger_utils_test.go index 9ceb39c..bd15658 100644 --- a/internal/logger/logger_utils_test.go +++ b/internal/logger/logger_utils_test.go @@ -38,3 +38,22 @@ func TestLogger_module_controller_text(t *testing.T) { logger.Info(Fields{"hello": "word", "foo": "bar"}, "message") logger.Error(Fields{"key": "value"}, "a mc error occurred") } + +func TestLogger_Warn(t *testing.T) { + config := Config{ModuleToFile: map[string]string{ + "schedule": "logs/schedule.log", + "module_controller": "logs/module_controller.log", + }, + LogLevel: InfoLevel, + LogFormat: &logrus.TextFormatter{}, + } + + Initialize(config) + + logger := New("schedule") + logger.Info(Fields{"hello": "word", "foo": "bar"}, "message") + + ctx := context.WithValue(context.Background(), TraceID, "12345") + logger = NewFromContext(ctx, "module_controller") + logger.Error(Fields{"key": "value"}, "a mc error occurred") +} From 790bfcd286747d12b71e050334cc18f6ae26e56f Mon Sep 17 00:00:00 2001 From: zzm Date: Thu, 25 Apr 2024 16:34:55 +0800 Subject: [PATCH 3/5] logger v2 fix logType TextV --- internal/logger/logger_utils.go | 13 +++++++++++++ internal/logger/logger_utils_test.go | 4 ++-- 2 files changed, 15 insertions(+), 2 deletions(-) diff --git a/internal/logger/logger_utils.go b/internal/logger/logger_utils.go index da8e57e..f381ad7 100644 --- a/internal/logger/logger_utils.go +++ b/internal/logger/logger_utils.go @@ -2,9 +2,11 @@ package logger import ( "context" + "fmt" "github.com/sirupsen/logrus" "os" "path/filepath" + "time" ) type LogLevel string @@ -29,6 +31,17 @@ type Config struct { LogFormat logrus.Formatter } +type TextVFormatter struct{} + +func (f *TextVFormatter) Format(entry *logrus.Entry) ([]byte, error) { + timestamp := entry.Time.Format(time.RFC3339) + traceID := entry.Data[TraceID] + logLevel := entry.Level.String() + message := entry.Message + log := fmt.Sprintf("%s [%s][%s] %s\n", timestamp, traceID, logLevel, message) + return []byte(log), nil +} + var ModuleToLoggers map[string]*logrus.Logger var config Config diff --git a/internal/logger/logger_utils_test.go b/internal/logger/logger_utils_test.go index bd15658..65eef7d 100644 --- a/internal/logger/logger_utils_test.go +++ b/internal/logger/logger_utils_test.go @@ -22,13 +22,13 @@ func TestLogger_Schedule_Json(t *testing.T) { logger.Error(Fields{"key": "value"}, "a mc error occurred") } -func TestLogger_module_controller_text(t *testing.T) { +func TestLogger_module_controller_CustomVText(t *testing.T) { config := Config{ModuleToFile: map[string]string{ "schedule": "logs/schedule.log", "module_controller": "logs/module_controller.log", }, LogLevel: InfoLevel, - LogFormat: &logrus.TextFormatter{}, + LogFormat: &TextVFormatter{}, } Initialize(config) From 63240275f8dea4db516616ea3e63d5c992f394af Mon Sep 17 00:00:00 2001 From: zzm Date: Sat, 27 Apr 2024 01:12:34 +0800 Subject: [PATCH 4/5] =?UTF-8?q?logger=20v2=20fix=EF=BC=9A=E5=8D=95?= =?UTF-8?q?=E7=8B=AC=E7=BB=9F=E8=AE=A1error=E3=80=81logrotate?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- go.mod | 1 + go.sum | 3 + internal/logger/logger_utils.go | 94 +++++++++++++++++----------- internal/logger/logger_utils_test.go | 45 ++++++------- 4 files changed, 81 insertions(+), 62 deletions(-) diff --git a/go.mod b/go.mod index fff1c01..c6c935d 100644 --- a/go.mod +++ b/go.mod @@ -10,6 +10,7 @@ require ( go.uber.org/zap v1.24.0 golang.org/x/net v0.17.0 golang.org/x/tools v0.9.1 + gopkg.in/natefinch/lumberjack.v2 v2.0.0 k8s.io/api v0.27.2 k8s.io/apimachinery v0.27.2 k8s.io/client-go v0.27.2 diff --git a/go.sum b/go.sum index 3dfb428..c32c82b 100644 --- a/go.sum +++ b/go.sum @@ -1,4 +1,5 @@ cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= +github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ= github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= github.com/benbjohnson/clock v1.1.0 h1:Q92kusRqC1XV2MjkWETPvjJVqKetz1OzxZB7mHJLju8= github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA= @@ -256,6 +257,8 @@ gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntN gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= gopkg.in/inf.v0 v0.9.1 h1:73M5CoZyi3ZLMOyDlQh031Cx6N9NDJ2Vvfl76EDAgDc= gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw= +gopkg.in/natefinch/lumberjack.v2 v2.0.0 h1:1Lc07Kr7qY4U2YPouBjpCLxpiyxIVoxqXgkXLknAOE8= +gopkg.in/natefinch/lumberjack.v2 v2.0.0/go.mod h1:l0ndWWf7gzL7RNwBG7wST/UCcT4T24xpD6X8LsfU/+k= gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= diff --git a/internal/logger/logger_utils.go b/internal/logger/logger_utils.go index f381ad7..cbab6c0 100644 --- a/internal/logger/logger_utils.go +++ b/internal/logger/logger_utils.go @@ -4,7 +4,7 @@ import ( "context" "fmt" "github.com/sirupsen/logrus" - "os" + "gopkg.in/natefinch/lumberjack.v2" "path/filepath" "time" ) @@ -26,9 +26,9 @@ type Logger struct { } type Config struct { - ModuleToFile map[string]string - LogLevel LogLevel - LogFormat logrus.Formatter + ModuleNameToLogFileDir map[string]string + LogLevel LogLevel + LogFormat logrus.Formatter } type TextVFormatter struct{} @@ -42,48 +42,66 @@ func (f *TextVFormatter) Format(entry *logrus.Entry) ([]byte, error) { return []byte(log), nil } -var ModuleToLoggers map[string]*logrus.Logger +var ModuleNameToLoggers map[string]*logrus.Logger var config Config func Initialize(cfg Config) { config = cfg - ModuleToLoggers = make(map[string]*logrus.Logger) - - for module, file := range config.ModuleToFile { - // setting log level - switch config.LogLevel { - case InfoLevel: - logrus.SetLevel(logrus.InfoLevel) - case WarnLevel: - logrus.SetLevel(logrus.WarnLevel) - case ErrorLevel: - logrus.SetLevel(logrus.ErrorLevel) - default: - logrus.SetLevel(logrus.InfoLevel) - } - - path := filepath.Dir(file) - if err := os.MkdirAll(path, os.ModePerm); err != nil { - logrus.WithError(err).Fatal("cannot create log directory") - } - logFile, err := os.OpenFile(file, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666) - if err != nil { - logrus.WithError(err).Fatal("cannot open log file") - } - - // create logger instance for each module - logger := logrus.New() - // setting module log output - logger.Out = logFile - logger.Formatter = config.LogFormat - ModuleToLoggers[module] = logger + ModuleNameToLoggers = make(map[string]*logrus.Logger) + setLogLevel() + + for moduleName, logFileDir := range config.ModuleNameToLogFileDir { + logger := createLogger(moduleName, logFileDir, "info") + ModuleNameToLoggers[fmt.Sprintf("%s_%v", moduleName, "info")] = logger + logger = createLogger(moduleName, logFileDir, "error") + ModuleNameToLoggers[fmt.Sprintf("%s_%v", moduleName, "error")] = logger } } +func createLogger(moduleName, logFileDir, logLevel string) *logrus.Logger { + logFilePath := getLogFilePath(logFileDir, moduleName, logLevel) + logger := logrus.New() + logger.Formatter = config.LogFormat + logger.Out = &lumberjack.Logger{ + Filename: logFilePath, + MaxSize: 1024, + MaxBackups: 5, + MaxAge: 28, + Compress: false, + LocalTime: true, + } + return logger +} + +func setLogLevel() { + switch config.LogLevel { + case InfoLevel: + logrus.SetLevel(logrus.InfoLevel) + case WarnLevel: + logrus.SetLevel(logrus.WarnLevel) + case ErrorLevel: + logrus.SetLevel(logrus.ErrorLevel) + default: + logrus.SetLevel(logrus.InfoLevel) + } +} + +func getLogFilePath(logDir, moduleName, logLevel string) string { + fileName := fmt.Sprintf("%s_%s.log", moduleName, logLevel) + return filepath.Join(logDir, fileName) +} + func New(moduleName string) *Logger { return &Logger{ moduleName: moduleName, - logger: ModuleToLoggers[moduleName].WithField("", ""), + logger: ModuleNameToLoggers[fmt.Sprintf("%s_%v", moduleName, "info")].WithField(TraceID, ""), + } +} + +func NewError(moduleName string) *Logger { + return &Logger{ + moduleName: moduleName, + logger: ModuleNameToLoggers[fmt.Sprintf("%s_%v", moduleName, "error")].WithField(TraceID, ""), } } @@ -94,7 +112,7 @@ func NewFromContext(ctx context.Context, moduleName string) *Logger { } return &Logger{ moduleName: moduleName, - logger: ModuleToLoggers[moduleName].WithField(TraceID, traceID), + logger: ModuleNameToLoggers[fmt.Sprintf("%s_%v", moduleName, "info")].WithField(TraceID, traceID), } } @@ -108,4 +126,6 @@ func (l *Logger) Warn(fields Fields, message string) { func (l *Logger) Error(fields Fields, message string) { l.logger.WithFields(logrus.Fields(fields)).Error(message) + + NewError(l.moduleName).logger.WithFields(logrus.Fields(fields)).Error(message) } diff --git a/internal/logger/logger_utils_test.go b/internal/logger/logger_utils_test.go index 65eef7d..8554a2d 100644 --- a/internal/logger/logger_utils_test.go +++ b/internal/logger/logger_utils_test.go @@ -2,14 +2,15 @@ package logger import ( "context" + "fmt" "github.com/sirupsen/logrus" "testing" ) -func TestLogger_Schedule_Json(t *testing.T) { - config := Config{ModuleToFile: map[string]string{ - "schedule": "logs/schedule.log", - "module_controller": "logs/module_controller.log", +func TestLogger_Json(t *testing.T) { + config := Config{ModuleNameToLogFileDir: map[string]string{ + "schedule": "logs", + "module_controller": "logs", }, LogLevel: InfoLevel, LogFormat: &logrus.JSONFormatter{}, @@ -20,40 +21,34 @@ func TestLogger_Schedule_Json(t *testing.T) { logger := New("schedule") logger.Info(Fields{"hello": "word", "foo": "bar"}, "message") logger.Error(Fields{"key": "value"}, "a mc error occurred") -} - -func TestLogger_module_controller_CustomVText(t *testing.T) { - config := Config{ModuleToFile: map[string]string{ - "schedule": "logs/schedule.log", - "module_controller": "logs/module_controller.log", - }, - LogLevel: InfoLevel, - LogFormat: &TextVFormatter{}, - } - - Initialize(config) ctx := context.WithValue(context.Background(), TraceID, "12345") - logger := NewFromContext(ctx, "module_controller") + logger = NewFromContext(ctx, "module_controller") logger.Info(Fields{"hello": "word", "foo": "bar"}, "message") logger.Error(Fields{"key": "value"}, "a mc error occurred") } -func TestLogger_Warn(t *testing.T) { - config := Config{ModuleToFile: map[string]string{ - "schedule": "logs/schedule.log", - "module_controller": "logs/module_controller.log", +func TestLogger_CustomVText(t *testing.T) { + config := Config{ModuleNameToLogFileDir: map[string]string{ + "schedule": "logs", + "module_controller": "logs", }, - LogLevel: InfoLevel, - LogFormat: &logrus.TextFormatter{}, + LogLevel: ErrorLevel, + LogFormat: &TextVFormatter{}, } Initialize(config) logger := New("schedule") - logger.Info(Fields{"hello": "word", "foo": "bar"}, "message") + logger.Info(Fields{"hello": "word", "foo": "bar"}, "info message") + logger.Error(Fields{"key": "value"}, "error message") ctx := context.WithValue(context.Background(), TraceID, "12345") logger = NewFromContext(ctx, "module_controller") - logger.Error(Fields{"key": "value"}, "a mc error occurred") + for i := 0; i < 10; i++ { + logger.Info(Fields{"hello": "word", "foo": "bar"}, fmt.Sprintf("info message %d", i)) + } + for i := 0; i < 10; i++ { + logger.Error(Fields{"hello": "word", "foo": "bar"}, fmt.Sprintf("info message %d", i)) + } } From 4e0a2638b7457496996a7c41960b31eaa65c9533 Mon Sep 17 00:00:00 2001 From: zzm Date: Sun, 28 Apr 2024 14:58:48 +0800 Subject: [PATCH 5/5] =?UTF-8?q?logger=20v2=20fix=EF=BC=9A=E5=8D=95?= =?UTF-8?q?=E7=8B=AC=E7=BB=9F=E8=AE=A1error=E3=80=81logrotate?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- internal/logger/logger_utils.go | 44 ++++++++++++++++------------ internal/logger/logger_utils_test.go | 22 ++++++++------ 2 files changed, 38 insertions(+), 28 deletions(-) diff --git a/internal/logger/logger_utils.go b/internal/logger/logger_utils.go index cbab6c0..414b333 100644 --- a/internal/logger/logger_utils.go +++ b/internal/logger/logger_utils.go @@ -6,6 +6,7 @@ import ( "github.com/sirupsen/logrus" "gopkg.in/natefinch/lumberjack.v2" "path/filepath" + "strconv" "time" ) @@ -34,7 +35,7 @@ type Config struct { type TextVFormatter struct{} func (f *TextVFormatter) Format(entry *logrus.Entry) ([]byte, error) { - timestamp := entry.Time.Format(time.RFC3339) + timestamp := entry.Time.Format("2006-01-02T15:04:05.999Z07:00") traceID := entry.Data[TraceID] logLevel := entry.Level.String() message := entry.Message @@ -42,23 +43,23 @@ func (f *TextVFormatter) Format(entry *logrus.Entry) ([]byte, error) { return []byte(log), nil } -var ModuleNameToLoggers map[string]*logrus.Logger +var FileNameToLoggers map[string]*logrus.Logger var config Config func Initialize(cfg Config) { config = cfg - ModuleNameToLoggers = make(map[string]*logrus.Logger) + FileNameToLoggers = make(map[string]*logrus.Logger) setLogLevel() for moduleName, logFileDir := range config.ModuleNameToLogFileDir { - logger := createLogger(moduleName, logFileDir, "info") - ModuleNameToLoggers[fmt.Sprintf("%s_%v", moduleName, "info")] = logger - logger = createLogger(moduleName, logFileDir, "error") - ModuleNameToLoggers[fmt.Sprintf("%s_%v", moduleName, "error")] = logger + logger := createLogger(moduleName, logFileDir, InfoLevel) + FileNameToLoggers[fmt.Sprintf("%s_%v", moduleName, InfoLevel)] = logger + logger = createLogger(moduleName, logFileDir, ErrorLevel) + FileNameToLoggers[fmt.Sprintf("%s_%v", moduleName, ErrorLevel)] = logger } } -func createLogger(moduleName, logFileDir, logLevel string) *logrus.Logger { +func createLogger(moduleName, logFileDir string, logLevel LogLevel) *logrus.Logger { logFilePath := getLogFilePath(logFileDir, moduleName, logLevel) logger := logrus.New() logger.Formatter = config.LogFormat @@ -86,7 +87,7 @@ func setLogLevel() { } } -func getLogFilePath(logDir, moduleName, logLevel string) string { +func getLogFilePath(logDir, moduleName string, logLevel LogLevel) string { fileName := fmt.Sprintf("%s_%s.log", moduleName, logLevel) return filepath.Join(logDir, fileName) } @@ -94,25 +95,25 @@ func getLogFilePath(logDir, moduleName, logLevel string) string { func New(moduleName string) *Logger { return &Logger{ moduleName: moduleName, - logger: ModuleNameToLoggers[fmt.Sprintf("%s_%v", moduleName, "info")].WithField(TraceID, ""), + logger: FileNameToLoggers[fmt.Sprintf("%s_%v", moduleName, InfoLevel)].WithField(TraceID, ""), } } -func NewError(moduleName string) *Logger { +func NewFromContext(ctx context.Context, moduleName string) *Logger { + traceId, ok := ctx.Value(TraceID).(string) + if !ok { + traceId = "unknown" + } return &Logger{ moduleName: moduleName, - logger: ModuleNameToLoggers[fmt.Sprintf("%s_%v", moduleName, "error")].WithField(TraceID, ""), + logger: FileNameToLoggers[fmt.Sprintf("%s_%v", moduleName, InfoLevel)].WithField(TraceID, traceId), } } -func NewFromContext(ctx context.Context, moduleName string) *Logger { - traceID, ok := ctx.Value(TraceID).(string) - if !ok { - traceID = "unknown" - } +func NewFromContextError(traceID interface{}, moduleName string) *Logger { return &Logger{ moduleName: moduleName, - logger: ModuleNameToLoggers[fmt.Sprintf("%s_%v", moduleName, "info")].WithField(TraceID, traceID), + logger: FileNameToLoggers[fmt.Sprintf("%s_%v", moduleName, ErrorLevel)].WithField(TraceID, traceID), } } @@ -127,5 +128,10 @@ func (l *Logger) Warn(fields Fields, message string) { func (l *Logger) Error(fields Fields, message string) { l.logger.WithFields(logrus.Fields(fields)).Error(message) - NewError(l.moduleName).logger.WithFields(logrus.Fields(fields)).Error(message) + NewFromContextError(l.logger.Data[TraceID], l.moduleName).logger.WithFields(logrus.Fields(fields)).Error(message) +} + +func GetTraceId() string { + traceId := time.Now().UnixMicro() + return strconv.FormatInt(traceId, 10) } diff --git a/internal/logger/logger_utils_test.go b/internal/logger/logger_utils_test.go index 8554a2d..27be7f5 100644 --- a/internal/logger/logger_utils_test.go +++ b/internal/logger/logger_utils_test.go @@ -5,6 +5,7 @@ import ( "fmt" "github.com/sirupsen/logrus" "testing" + "time" ) func TestLogger_Json(t *testing.T) { @@ -13,19 +14,23 @@ func TestLogger_Json(t *testing.T) { "module_controller": "logs", }, LogLevel: InfoLevel, - LogFormat: &logrus.JSONFormatter{}, + LogFormat: &logrus.JSONFormatter{TimestampFormat: "2006-01-02T15:04:05.000Z07:00"}, } Initialize(config) logger := New("schedule") - logger.Info(Fields{"hello": "word", "foo": "bar"}, "message") - logger.Error(Fields{"key": "value"}, "a mc error occurred") + logger.Info(Fields{"hello": "word", "foo": "bar"}, "schedule info message") + logger.Error(Fields{"key": "value"}, "schedule error message") - ctx := context.WithValue(context.Background(), TraceID, "12345") + ctx := context.WithValue(context.Background(), TraceID, GetTraceId()) logger = NewFromContext(ctx, "module_controller") - logger.Info(Fields{"hello": "word", "foo": "bar"}, "message") - logger.Error(Fields{"key": "value"}, "a mc error occurred") + logger.Info(Fields{"hello": "word", "foo": "bar"}, "module_controller info message") + logger.Error(Fields{"key": "value"}, "module_controller error message") + + logger.Info(Fields{"hello": "word", "foo": "bar"}, "module_controller info message") + logger.Error(Fields{"key": "value"}, "module_controller error message") + } func TestLogger_CustomVText(t *testing.T) { @@ -43,12 +48,11 @@ func TestLogger_CustomVText(t *testing.T) { logger.Info(Fields{"hello": "word", "foo": "bar"}, "info message") logger.Error(Fields{"key": "value"}, "error message") - ctx := context.WithValue(context.Background(), TraceID, "12345") + ctx := context.WithValue(context.Background(), TraceID, GetTraceId()) logger = NewFromContext(ctx, "module_controller") for i := 0; i < 10; i++ { + time.Sleep(time.Millisecond) logger.Info(Fields{"hello": "word", "foo": "bar"}, fmt.Sprintf("info message %d", i)) - } - for i := 0; i < 10; i++ { logger.Error(Fields{"hello": "word", "foo": "bar"}, fmt.Sprintf("info message %d", i)) } }