优化日志，新增rotatelogs库支持

log/log.go

@@ -1,31 +1,37 @@
 package log
 
 import (
+	"github.com/duanhf2012/rotatelogs"
 	"go.uber.org/zap"
 	"go.uber.org/zap/zapcore"
 	"gopkg.in/natefinch/lumberjack.v2"
 	"os"
+	"path/filepath"
+	"strings"
 	"time"
 )
 
 var isSetLogger bool
 var gLogger = NewDefaultLogger()
+var LogLevel zapcore.Level
+var MaxSize int
+var LogPath string
+var OpenConsole *bool
+var LogChanLen int
 
 type Logger struct {
 	*zap.Logger
 	stack bool
 
-	OpenConsole   *bool
-	LogPath       string
-	FileName      string
-	Skip          int
-	LogLevel      zapcore.Level
-	Encoder       zapcore.Encoder
-	LogConfig     *lumberjack.Logger
-	SugaredLogger *zap.SugaredLogger
-	CoreList      []zapcore.Core
+	FileName       string
+	Skip           int
+	Encoder        zapcore.Encoder
+	SugaredLogger  *zap.SugaredLogger
+	CoreList       []zapcore.Core
+	WriteSyncerFun []func() zapcore.WriteSyncer
 }
 
+// 设置Logger
 func SetLogger(logger *Logger) {
 	if logger != nil {
 		gLogger = logger
@@ -33,6 +39,15 @@ func SetLogger(logger *Logger) {
 	}
 }
 
+// 设置ZapLogger
+func SetZapLogger(zapLogger *zap.Logger) {
+	if zapLogger != nil {
+		gLogger = &Logger{}
+		gLogger.Logger = zapLogger
+		isSetLogger = true
+	}
+}
+
 func GetLogger() *Logger {
 	return gLogger
 }
@@ -47,8 +62,8 @@ func (logger *Logger) SetSkip(skip int) {
 
 func GetJsonEncoder() zapcore.Encoder {
 	encoderConfig := zap.NewProductionEncoderConfig()
-	encoderConfig.EncodeLevel = zapcore.CapitalLevelEncoder
 	encoderConfig.EncodeCaller = zapcore.ShortCallerEncoder
+	encoderConfig.EncodeLevel = zapcore.CapitalLevelEncoder
 	encoderConfig.EncodeTime = func(t time.Time, enc zapcore.PrimitiveArrayEncoder) {
 		enc.AppendString(t.Format("2006-01-02 15:04:05.000"))
 	}
@@ -67,51 +82,100 @@ func GetTxtEncoder() zapcore.Encoder {
 	return zapcore.NewConsoleEncoder(encoderConfig)
 }
 
-func getLogConfig() *lumberjack.Logger {
+func (logger *Logger) getLogConfig() *lumberjack.Logger {
 	return &lumberjack.Logger{
-		Filename:   "",
-		MaxSize:    2048,
+		Filename:   filepath.Join(LogPath, logger.FileName),
+		MaxSize:    MaxSize,
 		MaxBackups: 0,
 		MaxAge:     0,
 		Compress:   false,
+		LocalTime:  true,
 	}
 }
 
 func NewDefaultLogger() *Logger {
 	logger := Logger{}
 	logger.Encoder = GetJsonEncoder()
-	logger.LogConfig = getLogConfig()
-	logger.LogConfig.LocalTime = true
+	core := zapcore.NewCore(logger.Encoder, zapcore.AddSync(os.Stdout), zap.InfoLevel)
+	logger.Logger = zap.New(core, zap.AddCaller(), zap.AddCallerSkip(1))
 
-	logger.Init()
 	return &logger
 }
 
-func (logger *Logger) SetLogLevel(level zapcore.Level) {
-	logger.LogLevel = level
+func (logger *Logger) SetSyncers(syncers ...func() zapcore.WriteSyncer) {
+	logger.WriteSyncerFun = syncers
+}
+
+func (logger *Logger) AppendSyncerFun(syncerFun func() zapcore.WriteSyncer) {
+	logger.WriteSyncerFun = append(logger.WriteSyncerFun, syncerFun)
+}
+
+func SetLogLevel(level zapcore.Level) {
+	LogLevel = level
 }
 
 func (logger *Logger) Enabled(zapcore.Level) bool {
 	return logger.stack
 }
 
+func (logger *Logger) NewLumberjackWriter() zapcore.WriteSyncer {
+	return zapcore.AddSync(
+		&lumberjack.Logger{
+			Filename:   filepath.Join(LogPath, logger.FileName),
+			MaxSize:    MaxSize,
+			MaxBackups: 0,
+			MaxAge:     0,
+			Compress:   false,
+			LocalTime:  true,
+		})
+}
+
+func (logger *Logger) NewRotatelogsWriter() zapcore.WriteSyncer {
+	var options []rotatelogs.Option
+
+	if MaxSize > 0 {
+		options = append(options, rotatelogs.WithRotateMaxSize(int64(MaxSize)))
+	}
+	if LogChanLen > 0 {
+		options = append(options, rotatelogs.WithChannelLen(LogChanLen))
+	}
+	options = append(options, rotatelogs.WithRotationTime(time.Hour*24))
+
+	fileName := strings.TrimRight(logger.FileName, filepath.Ext(logger.FileName))
+	rotateLogs, err := rotatelogs.NewRotateLogs(LogPath, "20060102/"+fileName+"_20060102_150405", options...)
+	if err != nil {
+		panic(err)
+	}
+
+	return zapcore.AddSync(rotateLogs)
+}
+
 func (logger *Logger) Init() {
 	if isSetLogger {
 		return
 	}
 
+	var syncerList []zapcore.WriteSyncer
+	if logger.WriteSyncerFun == nil {
+		syncerList = append(syncerList, logger.NewLumberjackWriter())
+	} else {
+		for _, syncer := range logger.WriteSyncerFun {
+			syncerList = append(syncerList, syncer())
+		}
+	}
+
 	var coreList []zapcore.Core
-	if logger.OpenConsole == nil || *logger.OpenConsole {
-		core := zapcore.NewCore(logger.Encoder, zapcore.AddSync(os.Stdout), logger.LogLevel)
+	if OpenConsole == nil || *OpenConsole {
+		syncerList = append(syncerList, zapcore.AddSync(os.Stdout))
+	}
+
+	for _, writer := range syncerList {
+		core := zapcore.NewCore(logger.Encoder, writer, LogLevel)
 		coreList = append(coreList, core)
 	}
 
 	if logger.CoreList != nil {
 		coreList = append(coreList, logger.CoreList...)
-	}else if logger.LogPath != "" {
-		WriteSyncer := zapcore.AddSync(logger.LogConfig)
-		core := zapcore.NewCore(logger.Encoder, WriteSyncer, logger.LogLevel)
-		coreList = append(coreList, core)
 	}
 
 	core := zapcore.NewTee(coreList...)

node/node.go

@@ -17,7 +17,6 @@ import (
 	_ "net/http/pprof"
 	"os"
 	"os/signal"
-	"path/filepath"
 	"strconv"
 	"strings"
 	"syscall"
@@ -59,6 +58,7 @@ func init() {
 	console.RegisterCommandString("loglevel", "debug", "<-loglevel debug|info|warn|error|stackerror|fatal> Set loglevel.", setLevel)
 	console.RegisterCommandString("logpath", "", "<-logpath path> Set log file path.", setLogPath)
 	console.RegisterCommandInt("logsize", 0, "<-logsize size> Set log size(MB).", setLogSize)
+	console.RegisterCommandInt("logchanlen", 0, "<-logchanlen len> Set log channel len.", setLogChanLen)
 	console.RegisterCommandString("pprof", "", "<-pprof ip:port> Open performance analysis.", setPprof)
 }
 
@@ -220,7 +220,7 @@ func initNode(id string) {
 
 func initLog() error {
 	logger := log.GetLogger()
-	if logger.LogPath == "" {
+	if log.LogPath == "" {
 		err := setLogPath("./log")
 		if err != nil {
 			return err
@@ -230,7 +230,6 @@ func initLog() error {
 	localNodeInfo := cluster.GetCluster().GetLocalNodeInfo()
 	fileName := fmt.Sprintf("%s.log", localNodeInfo.NodeId)
 	logger.FileName = fileName
-	logger.LogConfig.Filename = filepath.Join(logger.LogPath, logger.FileName)
 
 	logger.Init()
 	return nil
@@ -440,10 +439,10 @@ func openConsole(args interface{}) error {
 	strOpen := strings.ToLower(strings.TrimSpace(args.(string)))
 	if strOpen == "false" {
 		bOpenConsole := false
-		log.GetLogger().OpenConsole = &bOpenConsole
+		log.OpenConsole = &bOpenConsole
 	} else if strOpen == "true" {
 		bOpenConsole := true
-		log.GetLogger().OpenConsole = &bOpenConsole
+		log.OpenConsole = &bOpenConsole
 	} else {
 		return errors.New("parameter console error")
 	}
@@ -458,17 +457,17 @@ func setLevel(args interface{}) error {
 	strlogLevel := strings.TrimSpace(args.(string))
 	switch strlogLevel {
 	case "debug":
-		log.GetLogger().LogLevel = zapcore.DebugLevel
+		log.LogLevel = zapcore.DebugLevel
 	case "info":
-		log.GetLogger().LogLevel = zapcore.InfoLevel
+		log.LogLevel = zapcore.InfoLevel
 	case "warn":
-		log.GetLogger().LogLevel = zapcore.WarnLevel
+		log.LogLevel = zapcore.WarnLevel
 	case "error":
-		log.GetLogger().LogLevel = zapcore.ErrorLevel
+		log.LogLevel = zapcore.ErrorLevel
 	case "stackerror":
-		log.GetLogger().LogLevel = zapcore.ErrorLevel
+		log.LogLevel = zapcore.ErrorLevel
 	case "fatal":
-		log.GetLogger().LogLevel = zapcore.FatalLevel
+		log.LogLevel = zapcore.FatalLevel
 	default:
 		return errors.New("unknown level: " + strlogLevel)
 	}
@@ -481,7 +480,7 @@ func setLogPath(args interface{}) error {
 	}
 	logPath := strings.TrimSpace(args.(string))
 	dir, err := os.Stat(logPath)
-	if err == nil && dir.IsDir() == false {
+	if err != nil || dir.IsDir() == false {
 		return errors.New("Not found dir " + logPath)
 	}
 
@@ -492,7 +491,7 @@ func setLogPath(args interface{}) error {
 		}
 	}
 
-	log.GetLogger().LogPath = logPath
+	log.LogPath = logPath
 	return nil
 }
 
@@ -505,7 +504,20 @@ func setLogSize(args interface{}) error {
 		return nil
 	}
 
-	log.GetLogger().LogConfig.MaxSize = logSize
+	log.MaxSize = logSize
 
 	return nil
 }
+
+func setLogChanLen(args interface{}) error {
+	logChanLen, ok := args.(int)
+	if ok == false {
+		return errors.New("param logsize is error")
+	}
+	if logChanLen == 0 {
+		return nil
+	}
+
+	log.LogChanLen = logChanLen
+	return nil
+}