cc @jba

A related question is whether slog.GroupValue should invoke resolve (aka call LogValue) its attributes when String is called. The text and JSON handlers resolve, String doesn't.

Example (playground:

package main

import (
	"fmt"
	"log/slog"
	"os"
)

var _ slog.LogValuer = coordinatesValuer{}

type coordinatesValuer struct {
	x, y int
}

func (c coordinatesValuer) LogValue() slog.Value {
	return slog.GroupValue(slog.Attr{Key: "X", Value: slog.IntValue(c.x)}, slog.Attr{Key: "Y", Value: slog.IntValue(c.y)})
}

func main() {
	jsonHandler := slog.NewJSONHandler(os.Stdout, nil)
	textHandler := slog.NewTextHandler(os.Stdout, nil)
	coordinates := coordinatesValuer{1, 2}
	coordinatesAttr := slog.Any("coordinates", coordinates)
	coordinatesGroup := slog.Group("group", coordinatesAttr)
	slog.New(jsonHandler).Info("JSON", "value", coordinates, coordinatesGroup)
	slog.New(textHandler).Info("Text", "value", coordinates, coordinatesGroup)
	fmt.Println(coordinatesGroup)
}

Output:

{"time":"2009-11-10T23:00:00Z","level":"INFO","msg":"JSON","value":{"X":1,"Y":2},"group":{"coordinates":{"X":1,"Y":2}}}
time=2009-11-10T23:00:00.000Z level=INFO msg=Text value.X=1 value.Y=2 group.coordinates.X=1 group.coordinates.Y=2
group=[coordinates={1 2}]

I can think of two cases to call Value.String:

1. You're in your Handler.Handle method and you want to output the value in a format that you don't care a lot about. In that case, you should have already resolved the value. (You can't process groups correctly if you don't.)

2. You're debugging. In that case, you want String to do as little as possible, so you can find the bug. So it shouldn't resolve.

So I lean towards "no." Are there other cases I haven't thought of?

Same answer for GroupValue.

Anyway, unless we think this is a real bug, we can't change it.

You're in your Handler.Handle method and you want to output the value in a format that you don't care a lot about. In that case, you should have already resolved the value. (You can't process groups correctly if you don't.)

Correct.

You're debugging. In that case, you want String to do as little as possible, so you can find the bug. So it shouldn't resolve.

While debugging, I want useful output. {1 2} is less useful than [X=1 Y=2], in particular when I am debugging code where I don't know the structures. I can't quite nail it anymore, but I think there were cases where String included less information than available.

Anyway, this is subjective. I'm okay with leaving it as-is.