使用zap的log库，可配日志文件大小maxSize，压缩文件个数maxBackups，旧文件天数maxAge

liuxiaolong

2020-11-10 285da749e7ce7e1bd48a6f20e8ac9d7583c6d5e1

使用zap的log库，可配日志文件大小maxSize，压缩文件个数maxBackups，旧文件天数maxAge

 logger.go

@@ -1,225 +1,99 @@
package logger

import (
    "fmt"
    "log"
    "os"
    "os/exec"
    "strings"
    "github.com/natefinch/lumberjack"
    "go.uber.org/zap"
    "go.uber.org/zap/zapcore"
    "time"
)

var logger *zap.SugaredLogger

const (
    PanicLevel int = iota
    FatalLevel
    ErrorLevel
    WarnLevel
    DebugLevel = iota -1
    InfoLevel
    DebugLevel
    WarnLevel
    ErrorLevel
    DPanicLevel
    PanicLevel
    FatalLevel
)

const (
    color_red = uint8(iota + 91)
    color_green        //    绿
    color_yellow        //    黄
    color_blue            //     蓝
    color_magenta         //    洋红
)

const (
    fatalPrefix        =    "[FATAL] "
    errorPrefix        =    "[ERROR] "
    warnPrefix        =    "[WARN] "
    infoPrefix        =    "[INFO] "
    debugPrefix        =    "[DEBUG] "
)

const (
    ByDay    int = iota
    ByWeek
    ByMonth
    BySize
)

type LogFile struct {
    level    int        // 日志等级
    saveMode int        // 保存模式
    saveDays int        // 日志保存天数
    logTime  int64        //
    fileName string        // 日志文件名
    filesize int64        // 文件大小, 需要设置 saveMode 为 BySize 生效
    fileFd   *os.File
}

var logFile LogFile

func init()  {
    //logFile.logTime = time.Now().Unix()
    logFile.saveMode = ByDay    // 默认按天保存
    logFile.saveDays = 15        // 默认保存三天的
    logFile.level = ErrorLevel
    logFile.filesize = 1024 * 1024 * 10    // 默认10M， 需要设置 saveMode 为 BySize
}

func Config(logFolder string, level int) {
    logFile.fileName = logFolder
    logFile.level = level

    log.SetOutput(logFile)
    //log.SetFlags(log.Lmicroseconds | log.Lshortfile)
    log.SetFlags(log.Ldate | log.Ltime | log.Lshortfile)
}
func GetLogFile() (*LogFile) {
    return &logFile
}

func SetLevel(level int) {
    logFile.level = level
}

func SetSaveMode(saveMode int)  {
    logFile.saveMode = saveMode
}

func SetSaveDays(saveDays int)  {
    logFile.saveDays = saveDays
}

func SetSaveSize(saveSize int64)  {
    logFile.filesize = saveSize
}

func Debug(args ...interface{}) {
    if logFile.level >= DebugLevel {
        log.SetPrefix(blue(debugPrefix))
        _ = log.Output(2, fmt.Sprintln(args...))
func InitLogger(logPath string, logLevel int,maxSize int, maxBackups int, maxAge int) {
    hook := lumberjack.Logger {
        Filename: logPath,   //日志文件的位置
        MaxSize: maxSize,        //在进行切割之前，日志文件的最大大小（以MB为单位）
        MaxBackups: maxBackups,      //保留旧文件的最大个数
        MaxAge: maxAge,              //保留旧文件的最大天数
        Compress: true,        //是否压缩
        LocalTime: true,
    }
}
    w := zapcore.AddSync(&hook)

func Info(args ...interface{}) {
    if logFile.level >= InfoLevel {
        log.SetPrefix(green(infoPrefix))
        _ = log.Output(2, fmt.Sprintln(args...))
    var level zapcore.Level
    switch logLevel {
    case DebugLevel:
        level = zap.DebugLevel
    case InfoLevel:
        level = zap.InfoLevel
    case WarnLevel:
        level = zap.WarnLevel
    case ErrorLevel:
        level = zap.ErrorLevel
    case DPanicLevel:
        level = zap.DPanicLevel
    case PanicLevel:
        level = zap.PanicLevel
    case FatalLevel:
        level = zap.FatalLevel
    default:
        level = zap.InfoLevel
    }
}

func Warn(args ...interface{}) {
    if logFile.level >= WarnLevel {
        log.SetPrefix(magenta(warnPrefix))
        _ = log.Output(2, fmt.Sprintln(args...))
    }
}

func Error(args ...interface{}) {
    if logFile.level >= ErrorLevel {
        log.SetPrefix(red(errorPrefix))
        _ = log.Output(2, fmt.Sprintln(args...))
    }
}

func Fatal(args ...interface{}) {
    if logFile.level >= FatalLevel {
        log.SetPrefix(red(fatalPrefix))
        _ = log.Output(2, fmt.Sprintln(args...))
    }
}

func GetRedPrefix(s string) string {
    return fmt.Sprintf("\x1b[%dm%s\x1b[0m", color_red, s)
}

func red(s string) string {
    return fmt.Sprintf("\x1b[%dm%s\x1b[0m", color_red, s)
}

func green(s string) string {
    return fmt.Sprintf("\x1b[%dm%s\x1b[0m", color_green, s)
}

func yellow(s string) string {
    return fmt.Sprintf("\x1b[%dm%s\x1b[0m", color_yellow, s)
}

func blue(s string) string {
    return fmt.Sprintf("\x1b[%dm%s\x1b[0m", color_blue, s)
}

func magenta(s string) string {
    return fmt.Sprintf("\x1b[%dm%s\x1b[0m", color_magenta, s)
}

func (me LogFile) Write(buf []byte) (n int, err error) {
    if me.fileName == "" {
        fmt.Printf("consol: %s", buf)
        return len(buf), nil
    encoderConfig := zap.NewProductionEncoderConfig()
    encoderConfig.EncodeLevel = zapcore.CapitalColorLevelEncoder
    encoderConfig.CallerKey = "file"
    encoderConfig.EncodeCaller = zapcore.ShortCallerEncoder
    encoderConfig.EncodeTime = func(t time.Time, enc zapcore.PrimitiveArrayEncoder) {
        enc.AppendString(t.Format("2006-01-02 15:04:05"))
    }

    switch logFile.saveMode {
    case BySize:
        fileInfo, err := os.Stat(logFile.fileName)
        if  err != nil {
            logFile.createLogFile()
            logFile.logTime = time.Now().Unix()
        }else {
            filesize:= fileInfo.Size();
            if logFile.fileFd == nil ||
                filesize > logFile.filesize {
                logFile.createLogFile()
                logFile.logTime = time.Now().Unix()
            }
        }
    default:    // 默认按天  ByDay
        if logFile.logTime+3600*24 < time.Now().Unix() {
            logFile.createLogFile()
            logFile.logTime = time.Now().Unix()
        }
    }

    if logFile.fileFd == nil {
        fmt.Printf("log fileFd is nil !\n")
        return len(buf), nil
    }

    return logFile.fileFd.Write(buf)
    core := zapcore.NewCore(
        zapcore.NewConsoleEncoder(encoderConfig),
        w,
        level,
    )
    log := zap.New(core, zap.AddCaller(), zap.AddCallerSkip(1))
    logger = log.Sugar()
    logger.Info("init logger success")
}

func (me *LogFile) createLogFile() {
    logdir := "./logger/"
    if index := strings.LastIndex(me.fileName, "/"); index != -1 {
        logdir = me.fileName[0:index] + "/"
        os.MkdirAll(me.fileName[0:index], os.ModePerm)
    }

    now := time.Now()
    filename := fmt.Sprintf("%s_%04d%02d%02d%02d",
        me.fileName, now.Year(), now.Month(), now.Day(), now.Hour())
    if err := os.Rename(me.fileName, filename); err == nil {
        go func() {
            filenameTemp := filename + "Temp"
            rmCpCmd := exec.Command("cp",  filename, filenameTemp)
            rmCpCmd.Run()

            tarCmd := exec.Command("tar", "-zcf", filename + ".tar.gz", filenameTemp, "--remove-files")
            tarCmd.Run()

            rmSrcCmd := exec.Command("rm",  filename)
            rmSrcCmd.Run()

            rmCmd := exec.Command("/bin/sh", "-c",
                "find "+logdir+` -type f -mtime +` +string(logFile.saveDays)+ ` -exec rm {} \;`)
            rmCmd.Run()
        }()
    }

    for index := 0; index < 10; index++ {
        if fd, err := os.OpenFile(me.fileName, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0666); nil == err {
            me.fileFd.Sync()
            me.fileFd.Close()
            me.fileFd = fd
            break
        }else {
            fmt.Println("Open logfile error! err: ", err.Error())
        }
        me.fileFd = nil
    }
func Debug(v ...interface{}) {
    logger.Debug(v...)
}

func Debugf(template string, v ...interface{}) {
    logger.Debugf(template, v...)
}

func Info(v ...interface{}) {
    logger.Info(v)
}

func Infof(template string, v ...interface{}) {
    logger.Infof(template, v...)
}

func Warn(v ...interface{}) {
    logger.Warn(v...)
}

func Warnf(template string, v ...interface{}) {
    logger.Warnf(template, v...)
}

func Error(v ...interface{}) {
    logger.Error(v...)
}

func Errorf(template string, v ...interface{}) {
    logger.Errorf(template, v...)
}