From a79a43431385c62701f82f2724f8d3bafa4d4850 Mon Sep 17 00:00:00 2001 From: ycdeng <402979006@qq.com> Date: Fri, 5 Jun 2020 18:51:21 +0800 Subject: [PATCH] recover log module (#33) * recover log module * recover log module Co-authored-by: dengyucheng --- federation/.gitignore | 1 + go.mod | 2 - skunkworks/log/log.go | 280 ++++++++++++++++++++++++++++++++++++ skunkworks/log/log_test.go | 56 ++++++++ skunkworks/log/logger.go | 32 +++++ skunkworks/log/zapLogger.go | 219 ++++++++++++++++++++++++++++ 6 files changed, 588 insertions(+), 2 deletions(-) create mode 100644 federation/.gitignore create mode 100644 skunkworks/log/log.go create mode 100644 skunkworks/log/log_test.go create mode 100644 skunkworks/log/logger.go create mode 100644 skunkworks/log/zapLogger.go diff --git a/federation/.gitignore b/federation/.gitignore new file mode 100644 index 00000000..99e87519 --- /dev/null +++ b/federation/.gitignore @@ -0,0 +1 @@ +/federation diff --git a/go.mod b/go.mod index a4e49bfb..869e444e 100644 --- a/go.mod +++ b/go.mod @@ -15,8 +15,6 @@ require ( github.com/json-iterator/go v1.1.9 github.com/lib/pq v1.5.2 github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1 - github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect - github.com/modern-go/reflect2 v1.0.1 // indirect github.com/nats-io/gnatsd v1.4.1 // indirect github.com/nats-io/go-nats v1.7.2 github.com/nats-io/nkeys v0.1.4 // indirect diff --git a/skunkworks/log/log.go b/skunkworks/log/log.go new file mode 100644 index 00000000..0c161f55 --- /dev/null +++ b/skunkworks/log/log.go @@ -0,0 +1,280 @@ +package log + +import ( + deflog "log" +) + +type KeysAndValues []interface{} + +type LogConfig struct { + Level string + Files []string + Underlying string + WriteToStdout bool + ZapConfig struct { + MaxSize int + MaxBackups int + MaxAge int + LocalTime bool + Compress bool + JsonFormat bool + BtEnabled bool + BtLevel string + FieldSeparator string + } +} + +var logger Logger + +func Setup(cfg *LogConfig) { + switch cfg.Underlying { + case "zap": + logger = newZapLogger(cfg) + default: + logger = newZapLogger(cfg) + } +} + +func Print(args ...interface{}) { + Info(args...) +} + +func Printf(template string, args ...interface{}) { + Infof(template, args...) +} + +func Println(args ...interface{}) { + Infoln(args...) +} + +func Printw(msg string, kv KeysAndValues) { + if logger != nil { + logger.Infow(msg, kv) + } else { + deflog.Print(msg) + } +} + +func Debug(args ...interface{}) { + if logger != nil { + logger.Debug(args...) + } else { + deflog.Print(args...) + } +} + +func Debugf(template string, args ...interface{}) { + if logger != nil { + logger.Debugf(template, args...) + } else { + deflog.Printf(template, args...) + } +} + +func Debugln(args ...interface{}) { + if logger != nil { + logger.Debugln(args...) + } else { + deflog.Println(args...) + } +} + +func Debugw(msg string, kv KeysAndValues) { + if logger != nil { + logger.Debugw(msg, kv) + } else { + deflog.Print(msg, kv) + } +} + +func Info(args ...interface{}) { + if logger != nil { + logger.Info(args...) + } else { + deflog.Print(args...) + } +} + +func Infof(template string, args ...interface{}) { + if logger != nil { + logger.Infof(template, args...) + } else { + deflog.Printf(template, args...) + } +} + +func Infoln(args ...interface{}) { + if logger != nil { + logger.Infoln(args...) + } else { + deflog.Println(args...) + } +} + +func Infow(msg string, kv KeysAndValues) { + if logger != nil { + logger.Infow(msg, kv) + } else { + deflog.Print(msg, kv) + } +} + +func Warn(args ...interface{}) { + if logger != nil { + logger.Warn(args...) + } else { + deflog.Print(args...) + } +} + +func Warnf(template string, args ...interface{}) { + if logger != nil { + logger.Warnf(template, args...) + } else { + deflog.Printf(template, args...) + } +} + +func Warnln(args ...interface{}) { + if logger != nil { + logger.Warnln(args...) + } else { + deflog.Println(args...) + } +} + +func Warnw(msg string, kv KeysAndValues) { + if logger != nil { + logger.Warnw(msg, kv) + } else { + deflog.Print(msg, kv) + } +} + +func Error(args ...interface{}) { + if logger != nil { + logger.Error(args...) + } else { + deflog.Print(args...) + } +} + +func Errorf(template string, args ...interface{}) { + if logger != nil { + logger.Errorf(template, args...) + } else { + deflog.Printf(template, args...) + } +} + +func Errorln(args ...interface{}) { + if logger != nil { + logger.Errorln(args...) + } else { + deflog.Println(args...) + } +} + +func Errorw(msg string, kv KeysAndValues) { + if logger != nil { + logger.Errorw(msg, kv) + } else { + deflog.Print(msg, kv) + } +} + +func DPanic(args ...interface{}) { + if logger != nil { + logger.DPanic(args...) + } else { + deflog.Panic(args...) + } +} + +func DPanicf(template string, args ...interface{}) { + if logger != nil { + logger.DPanicf(template, args...) + } else { + deflog.Panicf(template, args...) + } +} + +func DPanicln(args ...interface{}) { + if logger != nil { + logger.DPanicln(args...) + } else { + deflog.Panicln(args...) + } +} + +func DPanicw(msg string, kv KeysAndValues) { + if logger != nil { + logger.DPanicw(msg, kv) + } else { + deflog.Panic(msg, kv) + } +} + +func Panic(args ...interface{}) { + if logger != nil { + logger.Panic(args...) + } else { + deflog.Panic(args...) + } +} + +func Panicf(template string, args ...interface{}) { + if logger != nil { + logger.Panicf(template, args...) + } else { + deflog.Panicf(template, args...) + } +} + +func Panicln(args ...interface{}) { + if logger != nil { + logger.Panicln(args...) + } else { + deflog.Panicln(args...) + } +} + +func Panicw(msg string, kv KeysAndValues) { + if logger != nil { + logger.Panicw(msg, kv) + } else { + deflog.Panic(msg, kv) + } +} + +func Fatal(args ...interface{}) { + if logger != nil { + logger.Fatal(args...) + } else { + deflog.Fatal(args...) + } +} + +func Fatalf(template string, args ...interface{}) { + if logger != nil { + logger.Fatalf(template, args...) + } else { + deflog.Fatalf(template, args...) + } +} + +func Fatalln(args ...interface{}) { + if logger != nil { + logger.Fatalln(args...) + } else { + deflog.Fatalln(args...) + } +} + +func Fatalw(msg string, kv KeysAndValues) { + if logger != nil { + logger.Fatalw(msg, kv) + } else { + deflog.Fatal(msg, kv) + } +} diff --git a/skunkworks/log/log_test.go b/skunkworks/log/log_test.go new file mode 100644 index 00000000..cf25c57b --- /dev/null +++ b/skunkworks/log/log_test.go @@ -0,0 +1,56 @@ +// Unfinished test +package log + +import ( + "testing" +) + +func TestDefaultCfg(t *testing.T) { + cfg := LogConfig{ + Level: "info", + Files: []string{"./test.log"}, + Underlying: "zap", + } + cfg.ZapConfig.MaxSize = 100 + cfg.ZapConfig.MaxBackups = 0 + cfg.ZapConfig.MaxAge = 0 + cfg.ZapConfig.LocalTime = true + cfg.ZapConfig.Compress = true + cfg.ZapConfig.JsonFormat = false + cfg.ZapConfig.BtEnabled = true + cfg.ZapConfig.BtLevel = "error" + Setup(&cfg) + + Debug("debug msg", 33, "33") + Debugf("debug msg %d %s", 33, "33") + Debugln("debug msg", 33, "33") + Debugw("debug msg", KeysAndValues{"33", 44, "55", 66}) + Print("print msg", 33, "33") + Printf("print msg %d %s", 33, "33") + Println("print msg", 33, "33") + Printw("print msg", KeysAndValues{"33", 44, "55", 66}) + Info("info msg", 33, "33") + Infof("info msg %d %s", 33, "33") + Infoln("info msg", 33, "33") + Infow("info msg", KeysAndValues{"33", 44, "55", 66}) + Warn("warn msg", 33, "33") + Warnf("warn msg %d %s", 33, "33") + Warnln("warn msg", 33, "33") + Warnw("warn msg", KeysAndValues{"33", 44, "55", 66}) + Error("error msg", 33, "33") + Errorf("error msg %d %s", 33, "33") + Errorln("error msg", 33, "33") + Errorw("error msg", KeysAndValues{"33", 44, "55", 66}) + DPanic("dpanic msg", 33, "33") + DPanicf("dpanic msg %d %s", 33, "33") + DPanicln("dpanic msg", 33, "33") + DPanicw("dpanic msg", KeysAndValues{"33", 44, "55", 66}) + Panic("panic msg", 33, "33") + Panicf("panic msg %d %s", 33, "33") + Panicln("panic msg", 33, "33") + Panicw("panic msg", KeysAndValues{"33", 44, "55", 66}) + Fatal("fatal msg", 33, "33") + Fatalf("fatal msg %d %s", 33, "33") + Fatalln("fatal msg", 33, "33") + Fatalw("fatal msg", KeysAndValues{"33", 44, "55", 66}) +} diff --git a/skunkworks/log/logger.go b/skunkworks/log/logger.go new file mode 100644 index 00000000..81fc9ab9 --- /dev/null +++ b/skunkworks/log/logger.go @@ -0,0 +1,32 @@ +package log + +type Logger interface { + Debug(args ...interface{}) + Debugf(template string, args ...interface{}) + Debugln(args ...interface{}) + Debugw(msg string, kv KeysAndValues) + Info(args ...interface{}) + Infof(template string, args ...interface{}) + Infoln(args ...interface{}) + Infow(msg string, kv KeysAndValues) + Warn(args ...interface{}) + Warnf(template string, args ...interface{}) + Warnln(args ...interface{}) + Warnw(msg string, kv KeysAndValues) + Error(args ...interface{}) + Errorf(template string, args ...interface{}) + Errorln(args ...interface{}) + Errorw(msg string, kv KeysAndValues) + DPanic(args ...interface{}) + DPanicf(template string, args ...interface{}) + DPanicln(args ...interface{}) + DPanicw(msg string, kv KeysAndValues) + Panic(args ...interface{}) + Panicf(template string, args ...interface{}) + Panicln(args ...interface{}) + Panicw(msg string, kv KeysAndValues) + Fatal(args ...interface{}) + Fatalf(template string, args ...interface{}) + Fatalln(args ...interface{}) + Fatalw(msg string, kv KeysAndValues) +} diff --git a/skunkworks/log/zapLogger.go b/skunkworks/log/zapLogger.go new file mode 100644 index 00000000..10dbbbb7 --- /dev/null +++ b/skunkworks/log/zapLogger.go @@ -0,0 +1,219 @@ +package log + +import ( + "fmt" + "os" + + "github.com/finogeeks/ligase/skunkworks/zap" + "github.com/finogeeks/ligase/skunkworks/zap/zapcore" + "gopkg.in/natefinch/lumberjack.v2" +) + +type ZapLogger struct { + logger *zap.SugaredLogger +} + +func getLevel(level string) zapcore.Level { + var l zapcore.Level + switch level { + case "debug": + l = zapcore.DebugLevel + case "info": + l = zapcore.InfoLevel + case "warn": + l = zapcore.WarnLevel + case "error": + l = zapcore.ErrorLevel + case "dpanic": + l = zapcore.DPanicLevel + case "panic": + l = zapcore.PanicLevel + case "fatal": + l = zapcore.FatalLevel + } + return l +} + +func getSeparator(separator string) byte { + var sep byte + switch separator { + case "space": + sep = ' ' + case "tab": + sep = '\t' + default: + sep = ' ' + } + return sep +} + +func newZapLogger(cfg *LogConfig) Logger { + zapLogger := &ZapLogger{ + logger: zap.S(), + } + syncers := make([]zapcore.WriteSyncer, 0, len(cfg.Files)+1) + if cfg.WriteToStdout { + syncers = append(syncers, zapcore.AddSync(os.Stdout)) + } + + for _, v := range cfg.Files { + syncers = append(syncers, zapcore.AddSync(&lumberjack.Logger{ + Filename: v, + MaxSize: cfg.ZapConfig.MaxSize, + MaxBackups: cfg.ZapConfig.MaxBackups, + MaxAge: cfg.ZapConfig.MaxAge, + LocalTime: cfg.ZapConfig.LocalTime, + Compress: cfg.ZapConfig.Compress, + })) + } + + encCfg := zapcore.EncoderConfig{ + MessageKey: "msg", + LevelKey: "level", + TimeKey: "time", + CallerKey: "caller", + StacktraceKey: "bt", + EncodeLevel: zapcore.CapitalLevelEncoder, + EncodeTime: zapcore.ISO8601TimeEncoder, + EncodeCaller: zapcore.ShortCallerEncoder, + FieldSeparator: getSeparator(cfg.ZapConfig.FieldSeparator), + } + + var encoder zapcore.Encoder + if cfg.ZapConfig.JsonFormat { + encoder = zapcore.NewJSONEncoder(encCfg) + } else { + encoder = zapcore.NewConsoleEncoder(encCfg) + } + logger := zap.New(zapcore.NewCore( + encoder, + zapcore.NewMultiWriteSyncer(syncers...), + getLevel(cfg.Level), + )) + + if cfg.ZapConfig.BtEnabled { + logger = logger.WithOptions(zap.AddStacktrace(getLevel(cfg.ZapConfig.BtLevel))) + } + zap.ReplaceGlobals(logger) + zapLogger.logger = zap.S() + return zapLogger +} + +func (l *ZapLogger) Debug(args ...interface{}) { + l.logger.Debug(args...) +} + +func (l *ZapLogger) Debugf(template string, args ...interface{}) { + l.logger.Debugf(template, args...) +} + +func (l *ZapLogger) Debugln(args ...interface{}) { + argsWithBlank := fmt.Sprintln(args...) + Debug(argsWithBlank[:len(argsWithBlank)-1]) +} + +func (l *ZapLogger) Debugw(msg string, kv KeysAndValues) { + l.logger.Debugw(msg, kv...) +} + +func (l *ZapLogger) Info(args ...interface{}) { + l.logger.Info(args...) +} + +func (l *ZapLogger) Infof(template string, args ...interface{}) { + l.logger.Infof(template, args...) +} + +func (l *ZapLogger) Infoln(args ...interface{}) { + argsWithBlank := fmt.Sprintln(args...) + Info(argsWithBlank[:len(argsWithBlank)-1]) +} + +func (l *ZapLogger) Infow(msg string, kv KeysAndValues) { + l.logger.Infow(msg, kv...) +} + +func (l *ZapLogger) Warn(args ...interface{}) { + l.logger.Warn(args...) +} + +func (l *ZapLogger) Warnf(template string, args ...interface{}) { + l.logger.Warnf(template, args...) +} + +func (l *ZapLogger) Warnln(args ...interface{}) { + argsWithBlank := fmt.Sprintln(args...) + Warn(argsWithBlank[:len(argsWithBlank)-1]) +} + +func (l *ZapLogger) Warnw(msg string, kv KeysAndValues) { + l.logger.Warnw(msg, kv...) +} + +func (l *ZapLogger) Error(args ...interface{}) { + l.logger.Error(args...) +} + +func (l *ZapLogger) Errorf(template string, args ...interface{}) { + l.logger.Errorf(template, args...) +} + +func (l *ZapLogger) Errorln(args ...interface{}) { + argsWithBlank := fmt.Sprintln(args...) + Error(argsWithBlank[:len(argsWithBlank)-1]) +} + +func (l *ZapLogger) Errorw(msg string, kv KeysAndValues) { + l.logger.Errorw(msg, kv...) +} + +func (l *ZapLogger) DPanic(args ...interface{}) { + l.logger.DPanic(args...) +} + +func (l *ZapLogger) DPanicf(template string, args ...interface{}) { + l.logger.DPanicf(template, args...) +} + +func (l *ZapLogger) DPanicln(args ...interface{}) { + argsWithBlank := fmt.Sprintln(args...) + DPanic(argsWithBlank[:len(argsWithBlank)-1]) +} + +func (l *ZapLogger) DPanicw(msg string, kv KeysAndValues) { + l.logger.DPanicw(msg, kv...) +} + +func (l *ZapLogger) Panic(args ...interface{}) { + l.logger.Panic(args...) +} + +func (l *ZapLogger) Panicf(template string, args ...interface{}) { + l.logger.Panicf(template, args...) +} + +func (l *ZapLogger) Panicln(args ...interface{}) { + argsWithBlank := fmt.Sprintln(args...) + Panic(argsWithBlank[:len(argsWithBlank)-1]) +} + +func (l *ZapLogger) Panicw(msg string, kv KeysAndValues) { + l.logger.Panicw(msg, kv...) +} + +func (l *ZapLogger) Fatal(args ...interface{}) { + l.logger.Fatal(args...) +} + +func (l *ZapLogger) Fatalf(template string, args ...interface{}) { + l.logger.Fatalf(template, args...) +} + +func (l *ZapLogger) Fatalln(args ...interface{}) { + argsWithBlank := fmt.Sprintln(args...) + Fatal(argsWithBlank[:len(argsWithBlank)-1]) +} + +func (l *ZapLogger) Fatalw(msg string, kv KeysAndValues) { + l.logger.Fatalw(msg, kv...) +} -- GitLab