Emit slog attributes from every handler (closes #19)

The handlers took attributes and dropped them on the floor. Handle never
read record.Attrs, so the inline slog.Info("casting", "device", d) form
lost its fields; WithAttrs returned the receiver unchanged, so anything
attached to a derived logger vanished; and WithGroup did the same, so
grouping silently did nothing. The JSON and webhook handlers marshaled
the slog.Record value directly, which cannot work: a record keeps its
attributes in unexported fields, so encoding/json only ever saw Time,
Message, Level and PC.

The consequence was perverse. Converting log.Printf("[%s] Casting %s",
device, file) into structured attributes, as the Go styleguide asks,
left the output with strictly less information than before, and the
calling code reviewed as correct because it was correct.

A small shared attribute layer now holds the accumulated attributes and
open groups. It is copy-on-write, so two loggers derived from one parent
cannot leak attributes into each other, and it qualifies attributes by
the groups open at the time they were attached, per the slog.Handler
contract. Rendering follows each handler's format: the JSON and webhook
handlers emit attributes as object fields with groups as nested objects,
merging a group named twice rather than duplicating its key; the console
handler appends key=value pairs, groups flattened to dotted keys, with
key and value each quoted where leaving it bare would be ambiguous. The
key is quoted as one token, prefix included, so the "=" that separates
the pair is always the first one outside quotes: a key of "a=b" reads as
"a=b"=v rather than as a=b=v, which parses as the key "a" holding the
value "b=v". That is what slog.NewTextHandler does, and the console
rendering was compared against it key by key.

Values the caller logged go into the json payload by reference, because
rendering only reads them, which leaves the group merge as the one place
a value already in the payload is written to. It merges only into the
unexported groupMap type this package allocates for its own groups: a
caller's map[string]any is a different type and can never satisfy that
type assertion, so it is replaced rather than written into. The
invariant holds by construction - nothing reachable from the caller is
modified by logging it.

Values are resolved through slog.Value.Resolve, so LogValuer values are
reported as the value they stand for instead of as a struct, and errors
are reported as their message rather than as the empty object
encoding/json makes of them. Anything encoding/json cannot marshal falls
back to its slog string form rather than rendering as an empty object.

A duration is nanoseconds as a number in the json and webhook payloads,
matching slog.NewJSONHandler, so a consumer can compare and aggregate
the field without parsing it first. The console line keeps the readable
"3s" form, matching slog.NewTextHandler, because a person reads that
one.

The record's own fields keep the names they have always had - Time,
Level, Message, PC - and win a collision with an attribute key, so
existing consumers of the json output see no change beyond the added
fields. That, and a repeated key keeping its last value - except where
both are groups, which merge - are the two ways an attribute can go
missing from the json output; both are now written down in the README,
merge exception included, rather than left to be discovered.

All three handlers are covered, including WebhookHandler, which had the
same defect and is reached through the same MultiplexHandler.

README.md

@@ -91,8 +91,11 @@ it.
 The record's own fields are named `Time`, `Level`, `Message` and `PC`, and
 they own those names: an attribute keyed after one of them is dropped from
 the json and webhook output. A key logged more than once keeps its last
-value there for the same reason. Neither applies to the console output,
+value there for the same reason, with one exception: when both are
-which is a line of text: both pairs appear, in order. If you need a field
+`slog.Group` values sharing a key, the two groups are merged into one
+object holding the members of both, rather than the second replacing the
+first. Neither the collision nor the merge applies to the console output,
+which is a line of text: every pair appears, in order. If you need a field
 called `message`, pick a key that does not collide - the collision is
 silent.
 

attrs.go

@@ -229,23 +229,27 @@ func appendAttrText(out *strings.Builder, prefix string, attr slog.Attr) {
 	}
 
 	out.WriteString(" ")
-	out.WriteString(prefix)
+	// The key is quoted on the same terms as the value, and as a whole
-	out.WriteString(attr.Key)
+	// including its group prefix, because that is the token a reader has to
+	// find the "=" in. slog.NewTextHandler quotes "prefix+key" the same way,
+	// so a key like "a=b" reads as "a=b"=v2 rather than the ambiguous
+	// a=b=v2, which parses as the key "a" with the value "b=v2".
+	out.WriteString(quoteIfNeeded(prefix + attr.Key))
 	out.WriteString("=")
 	out.WriteString(quoteIfNeeded(value.String()))
 }
 
-// quoteIfNeeded quotes a value only when leaving it bare would make the
+// quoteIfNeeded quotes a key or a value only when leaving it bare would make
-// key=value pairs ambiguous, matching how the stdlib text handler reads.
+// the key=value pairs ambiguous, matching how the stdlib text handler reads.
-func quoteIfNeeded(value string) string {
+func quoteIfNeeded(text string) string {
-	if value == "" {
+	if text == "" {
 		return `""`
 	}
-	for _, r := range value {
+	for _, r := range text {
 		if unicode.IsSpace(r) || !unicode.IsPrint(r) ||
 			r == '"' || r == '=' {
-			return strconv.Quote(value)
+			return strconv.Quote(text)
 		}
 	}
-	return value
+	return text
 }

attrs_test.go

@@ -297,6 +297,97 @@ func TestConsoleHandlerQuotesValuesNeedingIt(t *testing.T) {
 	wantContains(t, output, `file="The Movie.mp4"`)
 }
 
+// TestConsoleHandlerQuotesKeysNeedingIt pins the key side of the same rule.
+// A key is quoted on the same terms as a value, and as one token including
+// its group prefix, so that the "=" separating the pair is always the first
+// one outside quotes. Every case here was compared against
+// slog.NewTextHandler, which renders each of them identically.
+func TestConsoleHandlerQuotesKeysNeedingIt(t *testing.T) {
+	tests := []struct {
+		name    string
+		build   func() slog.Handler
+		attrs   []slog.Attr
+		want    string
+		notWant string
+	}{
+		{
+			name:    "an ordinary key is left bare",
+			build:   func() slog.Handler { return NewConsoleHandler() },
+			attrs:   []slog.Attr{slog.String("device", "livingroom")},
+			want:    " device=livingroom",
+			notWant: `"device"`,
+		},
+		{
+			name:    "a key containing an equals sign is quoted",
+			build:   func() slog.Handler { return NewConsoleHandler() },
+			attrs:   []slog.Attr{slog.String("a=b", "v2")},
+			want:    ` "a=b"=v2`,
+			notWant: " a=b=v2",
+		},
+		{
+			name:    "a key containing a space is quoted",
+			build:   func() slog.Handler { return NewConsoleHandler() },
+			attrs:   []slog.Attr{slog.String("my key", "v")},
+			want:    ` "my key"=v`,
+			notWant: " my key=v",
+		},
+		{
+			name:    "a key containing a quote is escaped",
+			build:   func() slog.Handler { return NewConsoleHandler() },
+			attrs:   []slog.Attr{slog.String(`he"llo`, "v")},
+			want:    ` "he\"llo"=v`,
+			notWant: ` he"llo=v`,
+		},
+		{
+			name:    "a printable non-ascii key is left bare",
+			build:   func() slog.Handler { return NewConsoleHandler() },
+			attrs:   []slog.Attr{slog.String("キー", "v")},
+			want:    " キー=v",
+			notWant: `"キー"`,
+		},
+		{
+			name:  "a group prefix is quoted together with its key",
+			build: func() slog.Handler { return NewConsoleHandler() },
+			attrs: []slog.Attr{
+				slog.Group("grp", slog.String("a=b", "v")),
+			},
+			want:    ` "grp.a=b"=v`,
+			notWant: " grp.a=b=v",
+		},
+		{
+			name: "a WithGroup prefix needing quotes quotes the whole key",
+			build: func() slog.Handler {
+				return NewConsoleHandler().WithGroup("my grp")
+			},
+			attrs:   []slog.Attr{slog.String("k", "v")},
+			want:    ` "my grp.k"=v`,
+			notWant: " my grp.k=v",
+		},
+		{
+			name:    "an empty key is quoted rather than left as a gap",
+			build:   func() slog.Handler { return NewConsoleHandler() },
+			attrs:   []slog.Attr{slog.String("", "v")},
+			want:    ` ""=v`,
+			notWant: " =v",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			output := captureStdout(t, func() {
+				handler := test.build()
+				record := testRecord("casting", test.attrs...)
+				if err := handler.Handle(context.Background(), record); err != nil {
+					t.Fatalf("Handle: %v", err)
+				}
+			})
+
+			wantContains(t, output, test.want)
+			wantNotContains(t, output, test.notWant)
+		})
+	}
+}
+
 func TestConsoleHandlerWithAttrsAccumulates(t *testing.T) {
 	output := captureStdout(t, func() {
 		handler := NewConsoleHandler().