聊聊golang的lumberjack

type Logger struct {
    // Filename is the file to write logs to.  Backup log files will be retained
    // in the same directory.  It uses <processname>-lumberjack.log in
    // os.TempDir() if empty.
    Filename string `json:"filename" yaml:"filename"`

    // MaxSize is the maximum size in megabytes of the log file before it gets
    // rotated. It defaults to 100 megabytes.
    MaxSize int `json:"maxsize" yaml:"maxsize"`

    // MaxAge is the maximum number of days to retain old log files based on the
    // timestamp encoded in their filename.  Note that a day is defined as 24
    // hours and may not exactly correspond to calendar days due to daylight
    // savings, leap seconds, etc. The default is not to remove old log files
    // based on age.
    MaxAge int `json:"maxage" yaml:"maxage"`

    // MaxBackups is the maximum number of old log files to retain.  The default
    // is to retain all old log files (though MaxAge may still cause them to get
    // deleted.)
    MaxBackups int `json:"maxbackups" yaml:"maxbackups"`

    // LocalTime determines if the time used for formatting the timestamps in
    // backup files is the computer's local time.  The default is to use UTC
    // time.
    LocalTime bool `json:"localtime" yaml:"localtime"`

    // Compress determines if the rotated log files should be compressed
    // using gzip. The default is not to perform compression.
    Compress bool `json:"compress" yaml:"compress"`

    size int64
    file *os.File
    mu   sync.Mutex

    millCh    chan bool
    startMill sync.Once
}

const (
    backupTimeFormat = "2006-01-02T15-04-05.000"
    compressSuffix   = ".gz"
    defaultMaxSize   = 100
)

func (l *Logger) Write(p []byte) (n int, err error) {
    l.mu.Lock()
    defer l.mu.Unlock()

    writeLen := int64(len(p))
    if writeLen > l.max() {
        return 0, fmt.Errorf(
            "write length %d exceeds maximum file size %d", writeLen, l.max(),
        )
    }

    if l.file == nil {
        if err = l.openExistingOrNew(len(p)); err != nil {
            return 0, err
        }
    }

    if l.size+writeLen > l.max() {
        if err := l.rotate(); err != nil {
            return 0, err
        }
    }

    n, err = l.file.Write(p)
    l.size += int64(n)

    return n, err
}

func (l *Logger) max() int64 {
    if l.MaxSize == 0 {
        return int64(defaultMaxSize * megabyte)
    }
    return int64(l.MaxSize) * int64(megabyte)
}

func (l *Logger) openExistingOrNew(writeLen int) error {
    l.mill()

    filename := l.filename()
    info, err := os_Stat(filename)
    if os.IsNotExist(err) {
        return l.openNew()
    }
    if err != nil {
        return fmt.Errorf("error getting log file info: %s", err)
    }

    if info.Size()+int64(writeLen) >= l.max() {
        return l.rotate()
    }

    file, err := os.OpenFile(filename, os.O_APPEND|os.O_WRONLY, 0644)
    if err != nil {
        // if we fail to open the old log file for some reason, just ignore
        // it and open a new log file.
        return l.openNew()
    }
    l.file = file
    l.size = info.Size()
    return nil
}

func (l *Logger) mill() {
    l.startMill.Do(func() {
        l.millCh = make(chan bool, 1)
        go l.millRun()
    })
    select {
    case l.millCh <- true:
    default:
    }
}

func (l *Logger) millRun() {
    for _ = range l.millCh {
        // what am I going to do, log this?
        _ = l.millRunOnce()
    }
}

func (l *Logger) millRunOnce() error {
    if l.MaxBackups == 0 && l.MaxAge == 0 && !l.Compress {
        return nil
    }

    files, err := l.oldLogFiles()
    if err != nil {
        return err
    }

    var compress, remove []logInfo

    if l.MaxBackups > 0 && l.MaxBackups < len(files) {
        preserved := make(map[string]bool)
        var remaining []logInfo
        for _, f := range files {
            // Only count the uncompressed log file or the
            // compressed log file, not both.
            fn := f.Name()
            if strings.HasSuffix(fn, compressSuffix) {
                fn = fn[:len(fn)-len(compressSuffix)]
            }
            preserved[fn] = true

            if len(preserved) > l.MaxBackups {
                remove = append(remove, f)
            } else {
                remaining = append(remaining, f)
            }
        }
        files = remaining
    }
    if l.MaxAge > 0 {
        diff := time.Duration(int64(24*time.Hour) * int64(l.MaxAge))
        cutoff := currentTime().Add(-1 * diff)

        var remaining []logInfo
        for _, f := range files {
            if f.timestamp.Before(cutoff) {
                remove = append(remove, f)
            } else {
                remaining = append(remaining, f)
            }
        }
        files = remaining
    }

    if l.Compress {
        for _, f := range files {
            if !strings.HasSuffix(f.Name(), compressSuffix) {
                compress = append(compress, f)
            }
        }
    }

    for _, f := range remove {
        errRemove := os.Remove(filepath.Join(l.dir(), f.Name()))
        if err == nil && errRemove != nil {
            err = errRemove
        }
    }
    for _, f := range compress {
        fn := filepath.Join(l.dir(), f.Name())
        errCompress := compressLogFile(fn, fn+compressSuffix)
        if err == nil && errCompress != nil {
            err = errCompress
        }
    }

    return err
}

func (l *Logger) oldLogFiles() ([]logInfo, error) {
    files, err := ioutil.ReadDir(l.dir())
    if err != nil {
        return nil, fmt.Errorf("can't read log file directory: %s", err)
    }
    logFiles := []logInfo{}

    prefix, ext := l.prefixAndExt()

    for _, f := range files {
        if f.IsDir() {
            continue
        }
        if t, err := l.timeFromName(f.Name(), prefix, ext); err == nil {
            logFiles = append(logFiles, logInfo{t, f})
            continue
        }
        if t, err := l.timeFromName(f.Name(), prefix, ext+compressSuffix); err == nil {
            logFiles = append(logFiles, logInfo{t, f})
            continue
        }
        // error parsing means that the suffix at the end was not generated
        // by lumberjack, and therefore it's not a backup file.
    }

    sort.Sort(byFormatTime(logFiles))

    return logFiles, nil
}

func (l *Logger) prefixAndExt() (prefix, ext string) {
    filename := filepath.Base(l.filename())
    ext = filepath.Ext(filename)
    prefix = filename[:len(filename)-len(ext)] + "-"
    return prefix, ext
}

func (l *Logger) timeFromName(filename, prefix, ext string) (time.Time, error) {
    if !strings.HasPrefix(filename, prefix) {
        return time.Time{}, errors.New("mismatched prefix")
    }
    if !strings.HasSuffix(filename, ext) {
        return time.Time{}, errors.New("mismatched extension")
    }
    ts := filename[len(prefix) : len(filename)-len(ext)]
    return time.Parse(backupTimeFormat, ts)
}

type byFormatTime []logInfo

func (b byFormatTime) Less(i, j int) bool {
    return b[i].timestamp.After(b[j].timestamp)
}

func (b byFormatTime) Swap(i, j int) {
    b[i], b[j] = b[j], b[i]
}

func (b byFormatTime) Len() int {
    return len(b)
}

func (l *Logger) rotate() error {
    if err := l.close(); err != nil {
        return err
    }
    if err := l.openNew(); err != nil {
        return err
    }
    l.mill()
    return nil
}

func (l *Logger) close() error {
    if l.file == nil {
        return nil
    }
    err := l.file.Close()
    l.file = nil
    return err
}

func (l *Logger) openNew() error {
    err := os.MkdirAll(l.dir(), 0744)
    if err != nil {
        return fmt.Errorf("can't make directories for new logfile: %s", err)
    }

    name := l.filename()
    mode := os.FileMode(0644)
    info, err := os_Stat(name)
    if err == nil {
        // Copy the mode off the old logfile.
        mode = info.Mode()
        // move the existing file
        newname := backupName(name, l.LocalTime)
        if err := os.Rename(name, newname); err != nil {
            return fmt.Errorf("can't rename log file: %s", err)
        }

        // this is a no-op anywhere but linux
        if err := chown(name, info); err != nil {
            return err
        }
    }

    // we use truncate here because this should only get called when we've moved
    // the file ourselves. if someone else creates the file in the meantime,
    // just wipe out the contents.
    f, err := os.OpenFile(name, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, mode)
    if err != nil {
        return fmt.Errorf("can't open new logfile: %s", err)
    }
    l.file = f
    l.size = 0
    return nil
}

func backupName(name string, local bool) string {
    dir := filepath.Dir(name)
    filename := filepath.Base(name)
    ext := filepath.Ext(filename)
    prefix := filename[:len(filename)-len(ext)]
    t := currentTime()
    if !local {
        t = t.UTC()
    }

    timestamp := t.Format(backupTimeFormat)
    return filepath.Join(dir, fmt.Sprintf("%s-%s%s", prefix, timestamp, ext))
}