415 lines
9.5 KiB
Go
415 lines
9.5 KiB
Go
package log
|
|
|
|
import (
|
|
"compress/gzip"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"io/ioutil"
|
|
"os"
|
|
"path/filepath"
|
|
"sort"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
const (
|
|
backupTimeFormat = "2006-01-02T15-04-05.000"
|
|
compressSuffix = ".gz"
|
|
defaultMaxSize = 100
|
|
)
|
|
|
|
var (
|
|
currentTime = time.Now
|
|
osStat = os.Stat
|
|
megabyte = 1024 * 1024
|
|
)
|
|
|
|
//日志文件输出
|
|
type LogFileOut struct {
|
|
Filename string `json:"filename" yaml:"filename"` //日志文件名称
|
|
MaxSize int `json:"maxsize" yaml:"maxsize"` //日志文件的大小
|
|
CupTime time.Duration `json:"cuptime" yaml:"cuptime"` //日志切割间隔时间
|
|
MaxAge int `json:"maxage" yaml:"maxage"` //日志的最大备份天数
|
|
MaxBackups int `json:"maxbackups" yaml:"maxbackups"` //备份日志的最大数量
|
|
LocalTime bool `json:"localtime" yaml:"localtime"` //是使用本地时间还是使用世界标准时间
|
|
Compress bool `json:"compress" yaml:"compress"` //是否压缩备份日志
|
|
UniqueLog bool `json:"uniquelog" yaml:"uniquelog"` //是否唯一日志文件
|
|
size int64
|
|
ctime time.Time
|
|
file *os.File
|
|
mu sync.Mutex
|
|
millCh chan bool
|
|
startMill sync.Once
|
|
}
|
|
|
|
func (l *LogFileOut) filename() string {
|
|
if l.Filename != "" {
|
|
return l.Filename
|
|
}
|
|
name := filepath.Base(os.Args[0]) + "-lumberjack.log"
|
|
return filepath.Join(os.TempDir(), name)
|
|
}
|
|
func (l *LogFileOut) dir() string {
|
|
return filepath.Dir(l.filename())
|
|
}
|
|
|
|
func (l *LogFileOut) max() int64 {
|
|
if l.MaxSize == 0 {
|
|
return int64(defaultMaxSize * megabyte)
|
|
}
|
|
return int64(l.MaxSize) * int64(megabyte)
|
|
}
|
|
func (l *LogFileOut) 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
|
|
}
|
|
}
|
|
n, err = l.file.Write(p)
|
|
l.size += int64(n)
|
|
return n, err
|
|
}
|
|
|
|
func (this *LogFileOut) openExistingOrNew(writeLen int) error {
|
|
this.mill()
|
|
|
|
filename := this.filename()
|
|
info, err := osStat(filename)
|
|
if os.IsNotExist(err) {
|
|
return this.openNew()
|
|
}
|
|
if err != nil {
|
|
return fmt.Errorf("error getting log file info: %s", err)
|
|
}
|
|
|
|
//校验是否需要切割日志
|
|
if !this.UniqueLog && (info.Size()+int64(writeLen) >= this.max() || (!this.ctime.IsZero() && time.Since(this.ctime) > this.CupTime)) {
|
|
return this.rotate()
|
|
}
|
|
mode := os.FileMode(0666)
|
|
if !this.UniqueLog {
|
|
file, err := os.OpenFile(filename, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, mode)
|
|
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 this.openNew()
|
|
}
|
|
this.file = file
|
|
this.size = info.Size()
|
|
} else {
|
|
//最佳写入
|
|
f, err := os.OpenFile(filename, os.O_APPEND|os.O_CREATE|os.O_WRONLY, mode)
|
|
if err != nil {
|
|
return fmt.Errorf("can't open new logfile: %s", err)
|
|
}
|
|
this.file = f
|
|
this.size = 0
|
|
this.ctime = currentTime()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//日志切割
|
|
func (l *LogFileOut) rotate() error {
|
|
if err := l.close(); err != nil {
|
|
return err
|
|
}
|
|
if err := l.openNew(); err != nil {
|
|
return err
|
|
}
|
|
l.mill()
|
|
return nil
|
|
}
|
|
|
|
func (l *LogFileOut) 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 *LogFileOut) millRun() {
|
|
for range l.millCh {
|
|
// what am I going to do, log this?
|
|
_ = l.millRunOnce()
|
|
}
|
|
}
|
|
|
|
//触发日志备份管理
|
|
func (l *LogFileOut) mill() {
|
|
l.startMill.Do(func() {
|
|
l.millCh = make(chan bool, 1)
|
|
go l.millRun()
|
|
})
|
|
select {
|
|
case l.millCh <- true:
|
|
default:
|
|
}
|
|
}
|
|
|
|
//备份老的日志文件创建新的日志文件
|
|
func (this *LogFileOut) openNew() error {
|
|
err := os.MkdirAll(this.dir(), 0755)
|
|
if err != nil {
|
|
return fmt.Errorf("can't make directories for new logfile: %s", err)
|
|
}
|
|
|
|
name := this.filename()
|
|
mode := os.FileMode(0666)
|
|
info, err := osStat(name)
|
|
//备份老的日志文件
|
|
if !this.UniqueLog && err == nil {
|
|
// Copy the mode off the old logfile.
|
|
mode = info.Mode()
|
|
// move the existing file
|
|
newname := backupName(name, this.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
|
|
}
|
|
}
|
|
|
|
if !this.UniqueLog {
|
|
//创建新的日志文件
|
|
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)
|
|
}
|
|
this.file = f
|
|
this.size = 0
|
|
this.ctime = currentTime()
|
|
} else {
|
|
//最佳写入
|
|
f, err := os.OpenFile(name, os.O_APPEND|os.O_CREATE|os.O_WRONLY, mode)
|
|
if err != nil {
|
|
return fmt.Errorf("can't open new logfile: %s", err)
|
|
}
|
|
this.file = f
|
|
this.size = 0
|
|
this.ctime = currentTime()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//关闭当前日志文件
|
|
func (l *LogFileOut) close() error {
|
|
if l.file == nil {
|
|
return nil
|
|
}
|
|
err := l.file.Close()
|
|
l.file = nil
|
|
return err
|
|
}
|
|
|
|
//获取备份的日子文件集合
|
|
func (l *LogFileOut) 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 *LogFileOut) prefixAndExt() (prefix, ext string) {
|
|
filename := filepath.Base(l.filename())
|
|
ext = filepath.Ext(filename)
|
|
prefix = filename[:len(filename)-len(ext)] + "-"
|
|
return prefix, ext
|
|
}
|
|
func (l *LogFileOut) 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)
|
|
}
|
|
|
|
//日志备份名
|
|
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))
|
|
}
|
|
|
|
//压缩日志文件
|
|
func compressLogFile(src, dst string) (err error) {
|
|
f, err := os.Open(src)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to open log file: %v", err)
|
|
}
|
|
defer f.Close()
|
|
|
|
fi, err := osStat(src)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to stat log file: %v", err)
|
|
}
|
|
|
|
if err := chown(dst, fi); err != nil {
|
|
return fmt.Errorf("failed to chown compressed log file: %v", err)
|
|
}
|
|
|
|
// If this file already exists, we presume it was created by
|
|
// a previous attempt to compress the log file.
|
|
gzf, err := os.OpenFile(dst, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, fi.Mode())
|
|
if err != nil {
|
|
return fmt.Errorf("failed to open compressed log file: %v", err)
|
|
}
|
|
defer gzf.Close()
|
|
|
|
gz := gzip.NewWriter(gzf)
|
|
|
|
defer func() {
|
|
if err != nil {
|
|
os.Remove(dst)
|
|
err = fmt.Errorf("failed to compress log file: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := io.Copy(gz, f); err != nil {
|
|
return err
|
|
}
|
|
if err := gz.Close(); err != nil {
|
|
return err
|
|
}
|
|
if err := gzf.Close(); err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := f.Close(); err != nil {
|
|
return err
|
|
}
|
|
if err := os.Remove(src); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
type logInfo struct {
|
|
timestamp time.Time
|
|
os.FileInfo
|
|
}
|
|
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)
|
|
}
|