277 lines
7.7 KiB
Go
277 lines
7.7 KiB
Go
package logging
|
||
|
||
import (
|
||
"os"
|
||
"path/filepath"
|
||
"sync"
|
||
"time"
|
||
|
||
"go.uber.org/zap"
|
||
"go.uber.org/zap/zapcore"
|
||
"gopkg.in/natefinch/lumberjack.v2"
|
||
)
|
||
|
||
type ModOptions func(options *Options)
|
||
|
||
// Options 日志文件配置选项
|
||
type Options struct {
|
||
Path string // 文件保存地方
|
||
Prefix string // 日志文件前缀
|
||
ErrorFileSuffix string // error日志文件后缀
|
||
WarnFileSuffix string // warn日志文件后缀
|
||
InfoFileSuffix string // info日志文件后缀
|
||
DebugFileSuffix string // debug日志文件后缀
|
||
Level zapcore.Level // 日志等级
|
||
MaxSize int // 日志文件大小（M）
|
||
MaxBackups int // 最多存在多少个切片文件
|
||
MaxAge int // 保存的最大天数
|
||
Development bool // 是否是开发模式
|
||
zap.Config
|
||
}
|
||
|
||
var (
|
||
logger *Logger
|
||
sp = string(filepath.Separator)
|
||
errWS, warnWS, infoWS, debugWS zapcore.WriteSyncer // IO输出
|
||
debugConsoleWS = zapcore.Lock(os.Stdout) // 控制台标准输出
|
||
errorConsoleWS = zapcore.Lock(os.Stderr)
|
||
LogLevel = make(map[string]zapcore.Level)
|
||
)
|
||
|
||
type Logger struct {
|
||
*zap.Logger
|
||
sync.RWMutex
|
||
Opts *Options `json:"opts"`
|
||
zapConfig zap.Config
|
||
initialized bool
|
||
}
|
||
|
||
func NewLogger(mod ...ModOptions) *zap.Logger {
|
||
logger = &Logger{}
|
||
logger.Lock()
|
||
defer logger.Unlock()
|
||
if logger.initialized {
|
||
logger.Info("[NewLogger] logger initEd")
|
||
return nil
|
||
}
|
||
logger.Opts = &Options{
|
||
Path: "",
|
||
Prefix: "app",
|
||
ErrorFileSuffix: "error.log",
|
||
WarnFileSuffix: "warn.log",
|
||
InfoFileSuffix: "info.log",
|
||
DebugFileSuffix: "debug.log",
|
||
Level: zapcore.DebugLevel,
|
||
MaxSize: 100,
|
||
MaxBackups: 60,
|
||
MaxAge: 30,
|
||
}
|
||
|
||
if logger.Opts.Path == "" {
|
||
logger.Opts.Path, _ = filepath.Abs(filepath.Dir(filepath.Join(".")))
|
||
logger.Opts.Path += sp + "logs" + sp
|
||
}
|
||
if logger.Opts.Development {
|
||
logger.zapConfig = zap.NewDevelopmentConfig()
|
||
logger.zapConfig.EncoderConfig.EncodeTime = timeEncoder
|
||
} else {
|
||
logger.zapConfig = zap.NewProductionConfig()
|
||
logger.zapConfig.EncoderConfig.EncodeTime = timeEncoder
|
||
}
|
||
if logger.Opts.OutputPaths == nil || len(logger.Opts.OutputPaths) == 0 {
|
||
logger.zapConfig.OutputPaths = []string{"stdout"}
|
||
}
|
||
if logger.Opts.ErrorOutputPaths == nil || len(logger.Opts.ErrorOutputPaths) == 0 {
|
||
logger.zapConfig.OutputPaths = []string{"stderr"}
|
||
}
|
||
for _, fn := range mod {
|
||
fn(logger.Opts)
|
||
}
|
||
logger.zapConfig.Level.SetLevel(logger.Opts.Level)
|
||
logger.init()
|
||
logger.initialized = true
|
||
return logger.Logger
|
||
}
|
||
|
||
func (logger *Logger) init() {
|
||
logger.setSyncs()
|
||
var err error
|
||
logger.Logger, err = logger.zapConfig.Build(logger.cores())
|
||
if err != nil {
|
||
panic(err)
|
||
}
|
||
|
||
LogLevel["debug"] = zap.DebugLevel
|
||
LogLevel["info"] = zap.InfoLevel
|
||
LogLevel["warn"] = zap.WarnLevel
|
||
LogLevel["error"] = zap.ErrorLevel
|
||
LogLevel["dpanic"] = zap.DPanicLevel
|
||
LogLevel["panic"] = zap.PanicLevel
|
||
LogLevel["fatal"] = zap.FatalLevel
|
||
|
||
defer logger.Logger.Sync()
|
||
}
|
||
|
||
func (logger *Logger) setSyncs() {
|
||
f := func(fN string) zapcore.WriteSyncer {
|
||
return zapcore.AddSync(&lumberjack.Logger{
|
||
Filename: logger.Opts.Path + sp + logger.Opts.Prefix + "-" + fN,
|
||
MaxSize: logger.Opts.MaxSize,
|
||
MaxBackups: logger.Opts.MaxBackups,
|
||
MaxAge: logger.Opts.MaxAge,
|
||
Compress: true,
|
||
LocalTime: true,
|
||
})
|
||
}
|
||
errWS = f(logger.Opts.ErrorFileSuffix)
|
||
warnWS = f(logger.Opts.WarnFileSuffix)
|
||
infoWS = f(logger.Opts.InfoFileSuffix)
|
||
debugWS = f(logger.Opts.DebugFileSuffix)
|
||
}
|
||
|
||
func SetMaxSize(MaxSize int) ModOptions {
|
||
return func(option *Options) {
|
||
option.MaxSize = MaxSize
|
||
}
|
||
}
|
||
|
||
func SetMaxBackups(MaxBackups int) ModOptions {
|
||
return func(option *Options) {
|
||
option.MaxBackups = MaxBackups
|
||
}
|
||
}
|
||
|
||
func SetMaxAge(MaxAge int) ModOptions {
|
||
return func(option *Options) {
|
||
option.MaxAge = MaxAge
|
||
}
|
||
}
|
||
|
||
func SetPath(Path string) ModOptions {
|
||
return func(option *Options) {
|
||
option.Path = Path
|
||
}
|
||
}
|
||
|
||
func SetPrefix(Prefix string) ModOptions {
|
||
return func(option *Options) {
|
||
option.Prefix = Prefix
|
||
}
|
||
}
|
||
|
||
func SetLevel(Level zapcore.Level) ModOptions {
|
||
return func(option *Options) {
|
||
option.Level = Level
|
||
}
|
||
}
|
||
|
||
func SetErrorFileSuffix(ErrorFileSuffix string) ModOptions {
|
||
return func(option *Options) {
|
||
option.ErrorFileSuffix = ErrorFileSuffix
|
||
}
|
||
}
|
||
|
||
func SetWarnFileSuffix(WarnFileSuffix string) ModOptions {
|
||
return func(option *Options) {
|
||
option.WarnFileSuffix = WarnFileSuffix
|
||
}
|
||
}
|
||
|
||
func SetInfoFileSuffix(InfoFileSuffix string) ModOptions {
|
||
return func(option *Options) {
|
||
option.InfoFileSuffix = InfoFileSuffix
|
||
}
|
||
}
|
||
|
||
func SetDebugFileSuffix(DebugFileSuffix string) ModOptions {
|
||
return func(option *Options) {
|
||
option.DebugFileSuffix = DebugFileSuffix
|
||
}
|
||
}
|
||
|
||
func SetDevelopment(Development bool) ModOptions {
|
||
return func(option *Options) {
|
||
option.Development = Development
|
||
}
|
||
}
|
||
|
||
// getDefaultLogger returns the default logger.
|
||
func getDefaultLogger() *Logger {
|
||
return logger
|
||
}
|
||
|
||
// L returns the default logger.
|
||
func L() *Logger {
|
||
return getDefaultLogger()
|
||
}
|
||
|
||
func (logger *Logger) cores() zap.Option {
|
||
fileEncoder := zapcore.NewJSONEncoder(logger.zapConfig.EncoderConfig)
|
||
encoderConfig := zap.NewDevelopmentEncoderConfig()
|
||
encoderConfig.EncodeTime = timeEncoder
|
||
encoderConfig.EncodeLevel = zapcore.CapitalColorLevelEncoder
|
||
consoleEncoder := zapcore.NewConsoleEncoder(zapcore.EncoderConfig{
|
||
TimeKey: "ts",
|
||
LevelKey: "level",
|
||
NameKey: "logger",
|
||
CallerKey: "caller_line",
|
||
FunctionKey: zapcore.OmitKey,
|
||
MessageKey: "msg",
|
||
StacktraceKey: "stacktrace",
|
||
LineEnding: " ",
|
||
EncodeLevel: encodeLevel,
|
||
EncodeTime: encodeTime,
|
||
EncodeDuration: zapcore.SecondsDurationEncoder,
|
||
EncodeCaller: encodeCaller,
|
||
})
|
||
|
||
errPriority := zap.LevelEnablerFunc(func(lvl zapcore.Level) bool {
|
||
return lvl == zapcore.ErrorLevel && zapcore.ErrorLevel-logger.zapConfig.Level.Level() > -1
|
||
})
|
||
warnPriority := zap.LevelEnablerFunc(func(lvl zapcore.Level) bool {
|
||
return lvl == zapcore.WarnLevel && zapcore.WarnLevel-logger.zapConfig.Level.Level() > -1
|
||
})
|
||
infoPriority := zap.LevelEnablerFunc(func(lvl zapcore.Level) bool {
|
||
return lvl == zapcore.InfoLevel && zapcore.InfoLevel-logger.zapConfig.Level.Level() > -1
|
||
})
|
||
debugPriority := zap.LevelEnablerFunc(func(lvl zapcore.Level) bool {
|
||
return lvl == zapcore.DebugLevel && zapcore.DebugLevel-logger.zapConfig.Level.Level() > -1
|
||
})
|
||
cores := []zapcore.Core{
|
||
zapcore.NewCore(fileEncoder, errWS, errPriority),
|
||
zapcore.NewCore(fileEncoder, warnWS, warnPriority),
|
||
zapcore.NewCore(fileEncoder, infoWS, infoPriority),
|
||
zapcore.NewCore(fileEncoder, debugWS, debugPriority),
|
||
}
|
||
if logger.Opts.Development {
|
||
cores = append(cores, []zapcore.Core{
|
||
zapcore.NewCore(consoleEncoder, errorConsoleWS, errPriority),
|
||
zapcore.NewCore(consoleEncoder, debugConsoleWS, warnPriority),
|
||
zapcore.NewCore(consoleEncoder, debugConsoleWS, infoPriority),
|
||
zapcore.NewCore(consoleEncoder, debugConsoleWS, debugPriority),
|
||
}...)
|
||
}
|
||
return zap.WrapCore(func(c zapcore.Core) zapcore.Core {
|
||
return zapcore.NewTee(cores...)
|
||
})
|
||
}
|
||
|
||
func timeEncoder(t time.Time, enc zapcore.PrimitiveArrayEncoder) {
|
||
enc.AppendString(t.Format("2006-01-02 15:04:05.000"))
|
||
}
|
||
|
||
// encodeLevel 自定义日志级别显示
|
||
func encodeLevel(level zapcore.Level, enc zapcore.PrimitiveArrayEncoder) {
|
||
enc.AppendString("[" + level.CapitalString() + "]")
|
||
}
|
||
|
||
// encodeTime 自定义时间格式显示
|
||
func encodeTime(t time.Time, enc zapcore.PrimitiveArrayEncoder) {
|
||
enc.AppendString("[" + t.Format("2006-01-02 15:04:05.000") + "]")
|
||
}
|
||
|
||
// encodeCaller 自定义行号显示
|
||
func encodeCaller(caller zapcore.EntryCaller, enc zapcore.PrimitiveArrayEncoder) {
|
||
enc.AppendString("[" + caller.TrimmedPath() + "]")
|
||
}
|