Go log/slog Attr.Resolve 怎样展开 LogValuer 返回值

很多 Go 开发者会把这个问题叫作“slog.Attr.Resolve”，但标准库真正提供方法的是 slog.Value.Resolve：Attr 只是保存 Key 和 Value。当一个字段的值实现了 slog.LogValuer 时，Handler 应先对 attr.Value 调用 Resolve，再根据解析后的 Kind 做输出、脱敏或分组处理。

最小规则是：Resolve 会反复调用 LogValue，直到得到非 LogValuer 的 Value；如果最终得到 Group，只保证 Group 本身已经解析，Group 内部属性不会被再次递归展开。

先区分 Attr、Value 和 LogValuer

slog.Attr 是键值对，Attr.Value 的类型是 slog.Value。普通整数、字符串可以直接读取；自定义类型则可以实现 LogValue() slog.Value，把敏感字段替换掉，或者把多个字段组织成一个 Group。

因此，Handler 不能把 Attr 当成“可解析对象”，而应把解析边界放在 Value 上：

package main

import "log/slog"

// UserID 只把内部标识转换成适合日志输出的字符串。
type UserID string

// LogValue 是 LogValuer 的实现，返回值会被 Resolve 继续处理。
func (id UserID) LogValue() slog.Value {
	// 这里展示脱敏后的字段，避免 Handler 直接接触内部表示。
	return slog.StringValue("user:" + string(id))
}

func resolveAttr(attr slog.Attr) slog.Value {
	// Attr 没有 Resolve；需要解析的是它携带的 Value。
	return attr.Value.Resolve()
}

Resolve 怎样展开嵌套 LogValuer

Resolve 不只调用一次 LogValue。如果第一次返回的 slog.Value 仍然承载另一个 LogValuer，它会继续展开，直到返回普通 Kind。下面的例子把外层对象转换成另一个带业务字段的 LogValuer：

package main

import "log/slog"

type Order struct {
	ID string
}

type orderLogValue struct {
	order Order
}

// LogValue 返回一个 Group，让 Handler 继续按字段处理订单信息。
func (v orderLogValue) LogValue() slog.Value {
	// GroupValue 中的 Attr 是输出结构，不是新的日志调用。
	return slog.GroupValue(
		slog.String("order_id", v.order.ID),
		slog.String("source", "api"),
	)
}

func main() {
	attr := slog.Any("order", orderLogValue{order: Order{ID: "A-100"}})
	resolved := attr.Value.Resolve()

	// KindGroup 表示 LogValue 已经把对象转换成字段组。
	if resolved.Kind() == slog.KindGroup {
		for _, child := range resolved.Group() {
			// child.Value 已经属于 Group 内容；是否继续解析由 Handler 决定。
			_ = child
		}
	}
}

这里最容易误判的是“Resolve 会把整棵属性树都展开”。实际上官方语义只保证返回值本身不再是 KindLogValuer；如果返回的是 Group，Group 中每个 Attr 的 Value 不会由这次 Resolve 自动递归处理。自定义 Handler 如果需要统一处理嵌套字段，就要在遍历 Group 时明确决定是否再次调用 Resolve。

递归返回时为什么会得到错误值

LogValuer 可以错误地返回自身，或者几个类型互相返回，形成无限解析。标准库不会让 Handler 无限调用，而是在 LogValue 调用次数超过内部阈值后返回一个包含错误信息的 Value。它仍然是普通 Value，不会继续保持 KindLogValuer。

package main

import "log/slog"

type Loop struct{}

// LogValue 故意返回自身对应的 LogValuer，用来说明递归保护边界。
func (Loop) LogValue() slog.Value {
	// 真实代码不要这样写，否则 Resolve 会触发标准库的递归保护。
	return slog.AnyValue(Loop{})
}

func inspect(v slog.Value) string {
	resolved := v.Resolve()
	// 先观察 Kind，再决定调用 String、Group 等类型专用方法。
	if resolved.Kind() == slog.KindLogValuer {
		return "仍是 LogValuer"
	}
	return resolved.String()
}

生产代码不要依赖错误文本做业务分支。更稳妥的做法是记录解析后的 Kind，必要时把这个 Value 交给 Handler 的统一错误呈现逻辑。对于 Group，也不要直接假设所有子属性都已解析。

放进自定义 Handler 时的处理顺序

自定义 Handler 的 Handle 方法通常逐个处理 slog.Record 中的 Attr。正确顺序是先取出 Attr，再解析 Value，最后根据 Kind 读取标量或 Group。不要直接对 Value.LogValuer() 做强制断言，也不要把 Group 当成已经完全解析的平面字段。

func handleAttr(attr slog.Attr) {
	// 先展开 LogValuer，避免把自定义类型直接写入输出。
	v := attr.Value.Resolve()

	switch v.Kind() {
	case slog.KindGroup:
		// Group 内的 Attr 仍需要按 Handler 的递归策略单独处理。
		for _, child := range v.Group() {
			handleAttr(child)
		}
	case slog.KindString:
		// 标量按 Kind 读取，避免把 Group 或错误值当成字符串。
		_ = v.String()
	default:
		// 其他 Kind 交给统一的格式化分支处理。
		_ = v
	}
}

常见边界速查

相关问题

为什么不用直接调用 LogValue？

直接调用只处理一层，而且调用方还要自己判断返回值是否继续实现 LogValuer。Resolve 把多层展开和递归保护集中到标准库，Handler 只需要处理最终 Kind。

Resolve 会修改原来的 Attr 吗？

不会。它返回一个新的 slog.Value，Attr 本身仍是原来的键值对；如果要输出解析后的结果，应使用返回值而不是再次读取原 Attr.Value。

Group 的子字段为什么还可能需要 Resolve？

因为 Resolve 的保证只覆盖外层返回值。Group 内的 Attr 是否继续展开，属于 Handler 自己的递归策略。