mirror of
https://github.com/duanhf2012/origin.git
synced 2026-02-03 22:45:13 +08:00
402 lines
9.0 KiB
Go
402 lines
9.0 KiB
Go
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
|
|
|
|
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
|
|
isSetLogger = true
|
|
}
|
|
}
|
|
|
|
// 设置ZapLogger
|
|
func SetZapLogger(zapLogger *zap.Logger) {
|
|
if zapLogger != nil {
|
|
gLogger = &Logger{}
|
|
gLogger.Logger = zapLogger
|
|
isSetLogger = true
|
|
}
|
|
}
|
|
|
|
func GetLogger() *Logger {
|
|
return gLogger
|
|
}
|
|
|
|
func (logger *Logger) SetEncoder(encoder zapcore.Encoder) {
|
|
logger.Encoder = encoder
|
|
}
|
|
|
|
func (logger *Logger) SetSkip(skip int) {
|
|
logger.Skip = skip
|
|
}
|
|
|
|
func GetJsonEncoder() zapcore.Encoder {
|
|
encoderConfig := zap.NewProductionEncoderConfig()
|
|
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"))
|
|
}
|
|
|
|
return zapcore.NewJSONEncoder(encoderConfig)
|
|
}
|
|
|
|
func GetTxtEncoder() zapcore.Encoder {
|
|
encoderConfig := zap.NewProductionEncoderConfig()
|
|
encoderConfig.EncodeLevel = zapcore.CapitalLevelEncoder
|
|
encoderConfig.EncodeCaller = zapcore.ShortCallerEncoder
|
|
encoderConfig.EncodeTime = func(t time.Time, enc zapcore.PrimitiveArrayEncoder) {
|
|
enc.AppendString(t.Format("2006-01-02 15:04:05.000"))
|
|
}
|
|
|
|
return zapcore.NewConsoleEncoder(encoderConfig)
|
|
}
|
|
|
|
func (logger *Logger) getLogConfig() *lumberjack.Logger {
|
|
return &lumberjack.Logger{
|
|
Filename: filepath.Join(LogPath, logger.FileName),
|
|
MaxSize: MaxSize,
|
|
MaxBackups: 0,
|
|
MaxAge: 0,
|
|
Compress: false,
|
|
LocalTime: true,
|
|
}
|
|
}
|
|
|
|
func NewDefaultLogger() *Logger {
|
|
logger := Logger{}
|
|
logger.Encoder = GetJsonEncoder()
|
|
core := zapcore.NewCore(logger.Encoder, zapcore.AddSync(os.Stdout), zap.InfoLevel)
|
|
logger.Logger = zap.New(core, zap.AddCaller(), zap.AddCallerSkip(1))
|
|
|
|
return &logger
|
|
}
|
|
|
|
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, fileName,"20060102","_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.NewRotatelogsWriter())
|
|
} else {
|
|
for _, syncer := range logger.WriteSyncerFun {
|
|
syncerList = append(syncerList, syncer())
|
|
}
|
|
}
|
|
|
|
var coreList []zapcore.Core
|
|
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...)
|
|
}
|
|
|
|
core := zapcore.NewTee(coreList...)
|
|
logger.Logger = zap.New(core, zap.AddCaller(), zap.AddStacktrace(logger), zap.AddCallerSkip(1+logger.Skip))
|
|
logger.SugaredLogger = logger.Logger.Sugar()
|
|
}
|
|
|
|
func (logger *Logger) Debug(msg string, fields ...zap.Field) {
|
|
logger.Logger.Debug(msg, fields...)
|
|
}
|
|
|
|
func (logger *Logger) Info(msg string, fields ...zap.Field) {
|
|
logger.Logger.Info(msg, fields...)
|
|
}
|
|
|
|
func (logger *Logger) Warn(msg string, fields ...zap.Field) {
|
|
logger.Logger.Warn(msg, fields...)
|
|
}
|
|
|
|
func (logger *Logger) Error(msg string, fields ...zap.Field) {
|
|
logger.Logger.Error(msg, fields...)
|
|
}
|
|
|
|
func (logger *Logger) StackError(msg string, args ...zap.Field) {
|
|
logger.stack = true
|
|
logger.Logger.Log(zapcore.ErrorLevel, msg, args...)
|
|
logger.stack = false
|
|
}
|
|
|
|
func (logger *Logger) Fatal(msg string, fields ...zap.Field) {
|
|
gLogger.stack = true
|
|
logger.Logger.Fatal(msg, fields...)
|
|
gLogger.stack = false
|
|
}
|
|
|
|
func Debug(msg string, fields ...zap.Field) {
|
|
gLogger.Logger.Debug(msg, fields...)
|
|
}
|
|
|
|
func Info(msg string, fields ...zap.Field) {
|
|
gLogger.Logger.Info(msg, fields...)
|
|
}
|
|
|
|
func Warn(msg string, fields ...zap.Field) {
|
|
gLogger.Logger.Warn(msg, fields...)
|
|
}
|
|
|
|
func Error(msg string, fields ...zap.Field) {
|
|
gLogger.Logger.Error(msg, fields...)
|
|
}
|
|
|
|
func StackError(msg string, fields ...zap.Field) {
|
|
gLogger.stack = true
|
|
gLogger.Logger.Error(msg, fields...)
|
|
gLogger.stack = false
|
|
}
|
|
|
|
func Fatal(msg string, fields ...zap.Field) {
|
|
gLogger.stack = true
|
|
gLogger.Logger.Fatal(msg, fields...)
|
|
gLogger.stack = false
|
|
}
|
|
|
|
func Debugf(template string, args ...any) {
|
|
gLogger.SugaredLogger.Debugf(template, args...)
|
|
}
|
|
|
|
func Infof(template string, args ...any) {
|
|
gLogger.SugaredLogger.Infof(template, args...)
|
|
}
|
|
|
|
func Warnf(template string, args ...any) {
|
|
gLogger.SugaredLogger.Warnf(template, args...)
|
|
}
|
|
|
|
func Errorf(template string, args ...any) {
|
|
gLogger.SugaredLogger.Errorf(template, args...)
|
|
}
|
|
|
|
func StackErrorf(template string, args ...any) {
|
|
gLogger.stack = true
|
|
gLogger.SugaredLogger.Errorf(template, args...)
|
|
gLogger.stack = false
|
|
}
|
|
|
|
func Fatalf(template string, args ...any) {
|
|
gLogger.SugaredLogger.Fatalf(template, args...)
|
|
}
|
|
|
|
func (logger *Logger) SDebug(args ...interface{}) {
|
|
logger.SugaredLogger.Debugln(args...)
|
|
}
|
|
|
|
func (logger *Logger) SInfo(args ...interface{}) {
|
|
logger.SugaredLogger.Infoln(args...)
|
|
}
|
|
|
|
func (logger *Logger) SWarn(args ...interface{}) {
|
|
logger.SugaredLogger.Warnln(args...)
|
|
}
|
|
|
|
func (logger *Logger) SError(args ...interface{}) {
|
|
logger.SugaredLogger.Errorln(args...)
|
|
}
|
|
|
|
func (logger *Logger) SStackError(args ...interface{}) {
|
|
gLogger.stack = true
|
|
logger.SugaredLogger.Errorln(args...)
|
|
gLogger.stack = false
|
|
}
|
|
|
|
func (logger *Logger) SFatal(args ...interface{}) {
|
|
gLogger.stack = true
|
|
logger.SugaredLogger.Fatalln(args...)
|
|
gLogger.stack = false
|
|
}
|
|
|
|
func SDebug(args ...interface{}) {
|
|
gLogger.SugaredLogger.Debugln(args...)
|
|
}
|
|
|
|
func SInfo(args ...interface{}) {
|
|
gLogger.SugaredLogger.Infoln(args...)
|
|
}
|
|
|
|
func SWarn(args ...interface{}) {
|
|
gLogger.SugaredLogger.Warnln(args...)
|
|
}
|
|
|
|
func SError(args ...interface{}) {
|
|
gLogger.SugaredLogger.Errorln(args...)
|
|
}
|
|
|
|
func SStackError(args ...interface{}) {
|
|
gLogger.stack = true
|
|
gLogger.SugaredLogger.Errorln(args...)
|
|
gLogger.stack = false
|
|
}
|
|
|
|
func SFatal(args ...interface{}) {
|
|
gLogger.stack = true
|
|
gLogger.SugaredLogger.Fatalln(args...)
|
|
gLogger.stack = false
|
|
}
|
|
|
|
func ErrorField(key string, value error) zap.Field {
|
|
if value == nil {
|
|
return zap.String(key, "nil")
|
|
}
|
|
return zap.String(key, value.Error())
|
|
}
|
|
|
|
func String(key, value string) zap.Field {
|
|
return zap.String(key, value)
|
|
}
|
|
|
|
func Int(key string, value int) zap.Field {
|
|
return zap.Int(key, value)
|
|
}
|
|
|
|
func Int64(key string, value int64) zap.Field {
|
|
return zap.Int64(key, value)
|
|
}
|
|
|
|
func Int32(key string, value int32) zap.Field {
|
|
return zap.Int32(key, value)
|
|
}
|
|
|
|
func Int16(key string, value int16) zap.Field {
|
|
return zap.Int16(key, value)
|
|
}
|
|
|
|
func Int8(key string, value int8) zap.Field {
|
|
return zap.Int8(key, value)
|
|
}
|
|
|
|
func Uint(key string, value uint) zap.Field {
|
|
return zap.Uint(key, value)
|
|
}
|
|
|
|
func Uint64(key string, v uint64) zap.Field {
|
|
return zap.Uint64(key, v)
|
|
}
|
|
|
|
func Uint32(key string, value uint32) zap.Field {
|
|
return zap.Uint32(key, value)
|
|
}
|
|
|
|
func Uint16(key string, value uint16) zap.Field {
|
|
return zap.Uint16(key, value)
|
|
}
|
|
|
|
func Uint8(key string, value uint8) zap.Field {
|
|
return zap.Uint8(key, value)
|
|
}
|
|
|
|
func Float64(key string, v float64) zap.Field {
|
|
return zap.Float64(key, v)
|
|
}
|
|
|
|
func Bool(key string, v bool) zap.Field {
|
|
return zap.Bool(key, v)
|
|
}
|
|
|
|
func Bools(key string, v []bool) zap.Field {
|
|
return zap.Bools(key, v)
|
|
}
|
|
|
|
func Time(key string, v time.Time) zap.Field {
|
|
return zap.Time(key, v)
|
|
}
|
|
|
|
func Duration(key string, v time.Duration) zap.Field {
|
|
return zap.Duration(key, v)
|
|
}
|
|
|
|
func Durations(key string, v []time.Duration) zap.Field {
|
|
return zap.Durations(key, v)
|
|
}
|
|
|
|
func Any(key string, value any) zap.Field {
|
|
return zap.Any(key, value)
|
|
}
|