recover log module (#33)

* recover log module

* recover log module
Co-authored-by: Ndengyucheng <dengyucheng@finogeeks.com>

federation/.gitignore

+/federation

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

skunkworks/log/log.go

+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)
+	}
+}

skunkworks/log/log_test.go

+// 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})
+}

skunkworks/log/logger.go

+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)
+}

skunkworks/log/zapLogger.go

+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...)
+}