Golang Slog日志格式化与自定义构建插件库

Slog日志格式化基础

Go 1.21引入了新的结构化日志库slog，它提供了高性能的结构化日志记录功能。下面是一个基本的使用示例：

package main

import (
    "log/slog"
    "os"
)

func main() {
    // 基本文本输出
    textLogger := slog.New(slog.NewTextHandler(os.Stdout, nil))
    textLogger.Info("hello world", "count", 3)
    
    // JSON格式输出
    jsonLogger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
    jsonLogger.Info("hello world", "count", 3)
}

自定义日志格式化

要实现自定义格式化，我们需要创建自己的Handler：

package main

import (
    "context"
    "fmt"
    "io"
    "log/slog"
    "os"
    "time"
)

type CustomHandler struct {
    handler slog.Handler
    writer  io.Writer
}

func (h *CustomHandler) Enabled(ctx context.Context, level slog.Level) bool {
    return h.handler.Enabled(ctx, level)
}

func (h *CustomHandler) Handle(ctx context.Context, r slog.Record) error {
    // 自定义格式
    timeStr := r.Time.Format(time.DateTime)
    msg := fmt.Sprintf("[%s] %s: %s", timeStr, r.Level, r.Message)
    
    // 添加属性
    r.Attrs(func(attr slog.Attr) bool {
        msg += fmt.Sprintf(" %s=%v", attr.Key, attr.Value)
        return true
    })
    
    msg += "\n"
    
    _, err := h.writer.Write([]byte(msg))
    return err
}

func (h *CustomHandler) WithAttrs(attrs []slog.Attr) slog.Handler {
    return &CustomHandler{handler: h.handler.WithAttrs(attrs), writer: h.writer}
}

func (h *CustomHandler) WithGroup(name string) slog.Handler {
    return &CustomHandler{handler: h.handler.WithGroup(name), writer: h.writer}
}

func NewCustomHandler(w io.Writer) *CustomHandler {
    return &CustomHandler{
        writer: w,
    }
}

func main() {
    logger := slog.New(NewCustomHandler(os.Stdout))
    logger.Info("custom formatted message", "key1", "value1", "key2", 123)
}

使用slog-formatter插件库

slog-formatter是一个第三方库，提供了更多灵活的格式化选项。首先安装：

go get github.com/samber/slog-formatter

使用示例：

package main

import (
    "os"
    "time"

    "github.com/samber/slog-formatter"
    "log/slog"
)

func main() {
    // 1. 基础格式化器
    logger := slog.New(
        formatter.NewFormatterHandler(
            formatter.TimeFormatter(time.DateTime),
            formatter.LevelFormatter("LEVEL"),
            formatter.MessageFormatter("MESSAGE"),
            formatter.AttrsFormatter("ATTRS"),
        )(
            slog.NewJSONHandler(os.Stdout, nil),
        ),
    )
    
    logger.Info("hello world", "count", 3)
    
    // 2. 彩色输出
    logger = slog.New(
        formatter.NewColorFormatter(
            os.Stdout,
            formatter.ColorFormatterOpts{
                Time:    formatter.ColorTime(time.DateTime),
                Level:   formatter.ColorLevel(),
                Message: formatter.ColorMessage(),
            },
        ),
    )
    
    logger.Info("colored message", "key", "value")
    
    // 3. 自定义模板
    logger = slog.New(
        formatter.NewTemplateFormatter(
            os.Stdout,
            "{{.Time}} | {{.Level}} | {{.Message}} | {{range .Attrs}}{{.Key}}={{.Value}} {{end}}\n",
        ),
    )
    
    logger.Warn("template message", "user", "Alice", "age", 30)
}

高级自定义插件开发

如果你想开发自己的slog插件，可以遵循以下模式：

package myformatter

import (
    "context"
    "log/slog"
)

type MyFormatter struct {
    next slog.Handler
    // 添加你的配置字段
    prefix string
}

func NewMyFormatter(next slog.Handler, prefix string) *MyFormatter {
    return &MyFormatter{
        next:   next,
        prefix: prefix,
    }
}

func (f *MyFormatter) Enabled(ctx context.Context, level slog.Level) bool {
    return f.next.Enabled(ctx, level)
}

func (f *MyFormatter) Handle(ctx context.Context, r slog.Record) error {
    // 修改记录
    r.Message = f.prefix + r.Message
    
    // 可以添加或修改属性
    r.AddAttrs(slog.String("formatted_by", "my_formatter"))
    
    return f.next.Handle(ctx, r)
}

func (f *MyFormatter) WithAttrs(attrs []slog.Attr) slog.Handler {
    return NewMyFormatter(f.next.WithAttrs(attrs), f.prefix)
}

func (f *MyFormatter) WithGroup(name string) slog.Handler {
    return NewMyFormatter(f.next.WithGroup(name), f.prefix)
}

使用示例：

package main

import (
    "log/slog"
    "os"
    "your/package/path/myformatter"
)

func main() {
    logger := slog.New(
        myformatter.NewMyFormatter(
            slog.NewJSONHandler(os.Stdout, nil),
            "[PREFIX] ",
        ),
    )
    
    logger.Info("custom formatted message")
}

总结

1. Go的slog库提供了强大的结构化日志功能
2. 可以通过实现slog.Handler接口来自定义日志格式
3. 第三方库如slog-formatter提供了更多现成的格式化选项
4. 开发自定义插件需要实现Handler接口并包装现有的Handler

选择哪种方式取决于你的需求：简单自定义可以直接实现Handler，复杂需求可以使用现有插件库，特定需求可以开发自己的插件。