[Go] 新一代官方标准日志库 slog 将日志按级别写入到不同文件

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

        switch s {
		case fatalLog:
			l.file[fatalLog].Write(data)
			fallthrough
		case errorLog:
			l.file[errorLog].Write(data)
			fallthrough
		case warningLog:
			l.file[warningLog].Write(data)
			fallthrough
		case infoLog:
			l.file[infoLog].Write(data)
		}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

package main
 
import (
    "go.uber.org/zap"
    "go.uber.org/zap/zapcore"
    "os"
)
 
func main() {
    // 创建不同级别的日志配置
    highPriority := zap.LevelEnablerFunc(func(lvl zapcore.Level) bool {
        return lvl >= zapcore.ErrorLevel
    })
    lowPriority := zap.LevelEnablerFunc(func(lvl zapcore.Level) bool {
        return lvl < zapcore.ErrorLevel
    })
 
    // 创建核心（core）并写入不同文件
    debugLog, _ := os.OpenFile("debug.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
    infoLog, _ := os.OpenFile("info.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
    errorLog, _ := os.OpenFile("error.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
    defer debugLog.Close()
    defer infoLog.Close()
    defer errorLog.Close()
 
    debugCore := zapcore.NewCore(zapcore.NewJSONEncoder(zap.NewProductionEncoderConfig()), zapcore.AddSync(debugLog), lowPriority)
    infoCore := zapcore.NewCore(zapcore.NewJSONEncoder(zap.NewProductionEncoderConfig()), zapcore.AddSync(infoLog), lowPriority)
    errorCore := zapcore.NewCore(zapcore.NewJSONEncoder(zap.NewProductionEncoderConfig()), zapcore.AddSync(errorLog), highPriority)
 
    // 组合核心，创建Logger实例
    logger := zap.New(zapcore.NewTee(debugCore, infoCore, errorCore))
    defer logger.Sync() // 刷新缓冲区中的日志信息到文件。
 
    logger.Debug("This is a debug message") // 将会写入 debug.log 或 info/error 日志文件（取决于具体配置）
    logger.Info("This is an info message")  // 将会写入 info/error 日志文件（取决于具体配置）
    logger.Error("This is an error message") // 将会写入 error 日志文件（取决于具体配置）
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

func main() {
	var v = &slog.LevelVar{}
	v.Set(slog.LevelDebug)

	handler := NewLevelHandler(v, fileHandler2("./app.debug.log", v))
	logger := slog.New(handler)

	slog.SetDefault(logger)

	logger.Debug("This is a debug message")
	logger.Info("Starting qkp platform log", "version", "v3.2.2")
	logger.Warn("Low disk space", "remaining", "500MB")
	logger.Error("Failed to connect to ETCD cluster", "error", "connection timeout")
}

func fileHandler(filename string, l slog.Leveler) slog.Handler {
	lumberjackLogger := &lumberjack.Logger{
		Filename:   filename, // 日志文件路径
		MaxSize:    10,       // 单个日志文件最大大小（单位：MB）
		MaxBackups: 5,        // 保留的旧日志文件个数
		MaxAge:     30,       // 保留的旧日志文件最大天数（单位：天）
		Compress:   true,     // 是否压缩旧日志文件
	}

	handler := slog.NewJSONHandler(lumberjackLogger, &slog.HandlerOptions{
		AddSource: true,
		Level:     l,
		ReplaceAttr: func(groups []string, a slog.Attr) slog.Attr {
			if a.Key == slog.TimeKey {
				return slog.Time("timestamp", a.Value.Time())
			}
			return a
		},
	})
	return handler
}

// A LevelHandler wraps a Handler with an Enabled method
// that returns false for levels below a minimum.
type LevelHandler struct {
	level       slog.Leveler
	handler     slog.Handler
	infohandler slog.Handler
	warnhandler slog.Handler
	errhandler  slog.Handler
}

// NewLevelHandler returns a LevelHandler with the given level.
// All methods except Enabled delegate to h.
func NewLevelHandler(level slog.Leveler, h slog.Handler) *LevelHandler {
	// Optimization: avoid chains of LevelHandlers.
	if lh, ok := h.(*LevelHandler); ok {
		h = lh.Handler()
	}
	i := fileHandler2("./app.info.log", level)
	w := fileHandler2("./app.warn.log", level)
	e := fileHandler2("./app.error.log", level)
	return &LevelHandler{level, h, i, w, e}
}

// Enabled implements Handler.Enabled by reporting whether
// level is at least as large as h's level.
func (h *LevelHandler) Enabled(_ context.Context, level slog.Level) bool {
	return level >= h.level.Level()
}

// Handle implements Handler.Handle.
func (h *LevelHandler) Handle(ctx context.Context, r slog.Record) error {
	switch r.Level {
	case slog.LevelError:
		h.errhandler.Handle(ctx, r)
		fallthrough
	case slog.LevelWarn:
		h.warnhandler.Handle(ctx, r)
		fallthrough
	case slog.LevelInfo:
		h.infohandler.Handle(ctx, r)
	}
	return h.handler.Handle(ctx, r)
}

// WithAttrs implements Handler.WithAttrs.
func (h *LevelHandler) WithAttrs(attrs []slog.Attr) slog.Handler {
	return NewLevelHandler(h.level, h.handler.WithAttrs(attrs))
}

// WithGroup implements Handler.WithGroup.
func (h *LevelHandler) WithGroup(name string) slog.Handler {
	return NewLevelHandler(h.level, h.handler.WithGroup(name))
}

// Handler returns the Handler wrapped by h.
func (h *LevelHandler) Handler() slog.Handler {
	return h.handler
}