登录
推荐 文章 Go 技术 课程 下载 专题 AI
首页 >  Golang >  Go问答

Go slog Handler 怎样按级别过滤而不是在调用处判断

来源:17golang原创

时间:2026-11-16 15:43:20 180浏览 收藏

如果每个日志调用点都先写一段“当前级别是否允许”的判断,规则很快会散落在业务代码里。Go 的 log/slog 已经把这件事放在 Handler 契约中:内置处理器用 HandlerOptions.Level 配置阈值,自定义处理器则在 Enabled 中返回是否接收该级别。这样调用处只描述“记录什么”,过滤策略由处理器统一承担。

结论:普通级别过滤放到 Handler 层;只有为了避免昂贵参数在低级别日志中被提前计算,才在调用处使用一次 Logger.Enabled 或 LogValuer 做成本控制。

本文范围:只讲 Enabled、WithAttrs 和性能边界,不讨论第三方日志框架的配置格式。

先把过滤位置从调用处迁到 Handler

Handler.Enabled(ctx, level) 会在参数处理前被调用;返回 false 时,Handle 不会收到这条记录。这个时机很关键:它既统一了规则,也能让处理器在记录被丢弃时少做格式化工作。

package main

import (
    "context"
    "io"
    "log/slog"
)

// LevelHandler 只负责级别门槛,其余行为交给底层 Handler。
type LevelHandler struct {
    min slog.Leveler
    next slog.Handler
}

// Enabled 在记录进入 Handle 前统一判断最小级别。
func (h *LevelHandler) Enabled(_ context.Context, level slog.Level) bool {
    return level >= h.min.Level()
}

// Handle 保留底层处理器的格式化和输出能力。
func (h *LevelHandler) Handle(ctx context.Context, record slog.Record) error {
    return h.next.Handle(ctx, record)
}

// WithAttrs 继续包装底层处理器,不能只返回 h 本身。
func (h *LevelHandler) WithAttrs(attrs []slog.Attr) slog.Handler {
    return &LevelHandler{min: h.min, next: h.next.WithAttrs(attrs)}
}

// WithGroup 保留分组字段语义,再把新处理器交给同一门槛。
func (h *LevelHandler) WithGroup(name string) slog.Handler {
    return &LevelHandler{min: h.min, next: h.next.WithGroup(name)}
}

func main() {
    // 这里的 io.Discard 只表示示例不关心输出位置。
    base := slog.NewTextHandler(io.Discard, nil)
    logger := slog.New(&LevelHandler{min: slog.LevelWarn, next: base})

    // Info 会被 Handler.Enabled 拦截,调用处不再复制级别规则。
    logger.Info("被过滤")
    logger.Warn("会交给底层 Handler")
}
Go slog Logger、Handler.Enabled、Handler.Handle 和 HandlerOptions.Level 的静态关系结构说明图
图1:结构说明图,调用契约域把日志级别交给处理器策略域,输出实现域只接收通过 Enabled 的记录。

这里的包装器只改变 Enabled,Handle、WithAttrs 和 WithGroup 都继续委托。若遗漏后两个方法,业务代码通过 logger.With(...) 或 logger.WithGroup(...) 创建新 Logger 后,公共属性可能无法获得底层处理器的预处理优化,分组字段也可能丢失。

内置处理器优先使用 HandlerOptions.Level

如果使用 TextHandler 或 JSONHandler,不必先写一个自定义包装器。把最小级别放进 HandlerOptions 就够了;没有设置 Level 时,内置处理器默认按 Info 作为最低级别。

package main

import (
    "log/slog"
    "os"
)

func main() {
    // Warn 以下的记录由内置 Handler 统一丢弃。
    opts := &slog.HandlerOptions{Level: slog.LevelWarn}
    logger := slog.New(slog.NewJSONHandler(os.Stdout, opts))

    logger.Info("不会写出")
    logger.Warn("会写出")
    logger.Error("也会写出")

    // LevelVar 适合运行期间调整阈值,不需要替换 Logger。
    var level slog.LevelVar
    level.Set(slog.LevelError)
    dynamic := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: &level}))
    dynamic.Warn("当前阈值为 Error,因此不会写出")
}

内置方案的迁移方式很直接:删除调用处重复的 if level >= ...,把固定阈值迁移到 HandlerOptions.Level;需要动态调整时使用 LevelVar。业务代码仍然可以按不同模块创建不同 Logger,但每个 Logger 的过滤规则应当能从它使用的 Handler 一眼看出来。

WithAttrs 为什么关系到性能

请求 ID、服务名、租户等公共字段适合通过 Logger.With 绑定一次。slog 会把它转成 Handler 的 WithAttrs 调用;内置 Handler 可以在创建派生 Logger 时预处理这些属性,而不是每条日志都重新整理。自定义包装器必须把属性继续传给底层 Handler。

Go slog WithAttrs、公共属性、LogAttrs 与 LogValuer 的属性复用和调用成本边界结构说明图
图2:结构说明图,属性复用域解释 WithAttrs 的职责,调用成本域解释 LogAttrs 与 LogValuer 的延迟计算边界。
package main

import (
    "context"
    "log/slog"
)

type snapshot struct{ ID int }

// LogValue 把昂贵的快照计算推迟到记录真正启用时。
func (s snapshot) LogValue() slog.Value {
    // 真实项目中这里可以读取或整理较重的诊断数据。
    return slog.Int("snapshot_id", s.ID)
}

func writeLog(ctx context.Context, logger *slog.Logger, id int) {
    // LogAttrs 只接受 Attr,减少交替 key/value 带来的解析工作。
    logger.LogAttrs(ctx, slog.LevelDebug, "调试信息", slog.Any("snapshot", snapshot{ID: id}))
}

要注意一个容易误判的边界:日志级别被过滤,并不代表调用参数表达式不会求值。像 buildSnapshot()、url.String() 这种昂贵计算仍可能在调用处提前发生。优先传递结构化对象,让处理器或 LogValuer 在需要时处理;如果计算本身非常重,也可以只包住这一小段:

// 只有昂贵参数需要保护时,才在调用处做一次能力询问。
if logger.Enabled(ctx, slog.LevelDebug) {
    // 低级别未启用时,不创建诊断快照。
    logger.DebugContext(ctx, "调试信息", "snapshot", buildSnapshot())
}

迁移后的回归检查

可以按下面四点检查改造是否完整:

  • 业务调用处是否只记录消息和属性,级别门槛是否集中在 Handler。
  • 自定义 Handler 的 WithAttrs、WithGroup 是否都对底层 Handler 做同名委托。
  • 固定阈值是否使用 HandlerOptions.Level,动态阈值是否使用并发安全的 LevelVar。
  • 昂贵参数是否通过 LogValuer、直接传结构化值或局部 Logger.Enabled 延后计算。

最后还要记住 Handler 的并发边界:Handler 的方法可能并发调用,状态应由 Handler 自己安全管理;不要为了过滤级别而在每个业务函数里复制一套可变阈值。把策略留在 Handler,把昂贵计算留在必要的局部守卫,通常就能同时得到清晰的调用代码和可控的日志成本。

相关问题

为什么已经设置 HandlerOptions.Level,还要调用 Logger.Enabled?
普通过滤不需要。只有日志参数要执行昂贵计算,且希望在构造参数前就退出时,才使用局部的 Logger.Enabled。

WithAttrs 能不能直接返回原 Handler?
只有当传入属性为空且你的 Handler 明确保证语义不变时才可能优化;一般实现应把属性交给底层 Handler,再用同一过滤策略重新包装。

声明:本文转载于:17golang原创 如有侵犯,请联系study_golang@163.com删除
相关阅读
更多>
最新阅读
更多>
课程推荐
更多>