Structured Logging with slog

package main

import (
	"log"
	"os"
)

func main() {
	l := log.New(os.Stdout, "shelf: ", 0)
	l.Println("catalogue loaded", 3, "books")
	l.Printf("lent %s to %s", "978-0-13-468599-1", "ada")

	l.SetFlags(log.Lmsgprefix)
	l.SetPrefix("[loans] ")
	l.Print("returned late")

	l.SetFlags(log.Lshortfile)
	l.Print("with a file position")

	// log.Fatal prints and then calls os.Exit(1): deferred calls do not run.
	// log.Panic prints and then panics.
}

shelf: catalogue loaded 3 books
shelf: lent 978-0-13-468599-1 to ada
[loans] returned late
[loans] main.go:18: with a file position

package main

import (
	"log/slog"
	"os"
)

// noTime drops the time attribute so the output is the same on every run.
func noTime(groups []string, a slog.Attr) slog.Attr {
	if len(groups) == 0 && a.Key == slog.TimeKey {
		return slog.Attr{}
	}
	return a
}

func main() {
	opts := &slog.HandlerOptions{ReplaceAttr: noTime}

	text := slog.New(slog.NewTextHandler(os.Stdout, opts))
	text.Info("book lent", "isbn", "9780134685991", "member", "ada", "days", 14)
	text.Warn("overdue", "isbn", "9780134685991", "title", "The Go Programming Language")

	js := slog.New(slog.NewJSONHandler(os.Stdout, opts))
	js.Info("book lent", "isbn", "9780134685991", "member", "ada", "days", 14)
	js.Warn("overdue", "isbn", "9780134685991", "title", "The Go Programming Language")
}

level=INFO msg="book lent" isbn=9780134685991 member=ada days=14
level=WARN msg=overdue isbn=9780134685991 title="The Go Programming Language"
{"level":"INFO","msg":"book lent","isbn":"9780134685991","member":"ada","days":14}
{"level":"WARN","msg":"overdue","isbn":"9780134685991","title":"The Go Programming Language"}

package main

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

func noTime(groups []string, a slog.Attr) slog.Attr {
	if len(groups) == 0 && a.Key == slog.TimeKey {
		return slog.Attr{}
	}
	return a
}

func main() {
	var level slog.LevelVar // zero value: LevelInfo
	h := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: &level, ReplaceAttr: noTime})
	log := slog.New(h)

	log.Debug("not shown: below Info")
	log.Info("shown")

	level.Set(slog.LevelDebug)
	log.Debug("shown now", "level", level.Level())

	// Any int is a level; the text form is relative to the nearest named one.
	const LevelAudit = slog.LevelWarn + 2
	log.Log(context.Background(), LevelAudit, "member suspended", "member", "ada")
	log.Log(context.Background(), slog.LevelError+4, "disk full")
	log.Log(context.Background(), slog.LevelDebug-2, "very chatty")

	for _, l := range []slog.Level{slog.LevelDebug, slog.LevelInfo, slog.LevelWarn, slog.LevelError, LevelAudit} {
		fmt.Println(int(l), l.String(), log.Enabled(context.Background(), l))
	}

	var parsed slog.Level
	if err := parsed.UnmarshalText([]byte("warn+1")); err != nil {
		panic(err)
	}
	fmt.Println("parsed", int(parsed), parsed.String())
}

level=INFO msg=shown
level=DEBUG msg="shown now" level=DEBUG
level=WARN+2 msg="member suspended" member=ada
level=ERROR+4 msg="disk full"
-4 DEBUG true
0 INFO true
4 WARN true
8 ERROR true
6 WARN+2 true
parsed 5 WARN+1

package main

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

// newLogger builds the process logger from SHELF_LOG_LEVEL and SHELF_LOG_FORMAT.
func newLogger(w io.Writer, getenv func(string) string) (*slog.Logger, error) {
	var level slog.Level
	if v := getenv("SHELF_LOG_LEVEL"); v != "" {
		if err := level.UnmarshalText([]byte(v)); err != nil {
			return nil, fmt.Errorf("SHELF_LOG_LEVEL: %w", err)
		}
	}
	opts := &slog.HandlerOptions{
		Level: level,
		ReplaceAttr: func(groups []string, a slog.Attr) slog.Attr {
			if len(groups) == 0 && a.Key == slog.TimeKey {
				return slog.Attr{} // for stable output in this page only
			}
			return a
		},
	}
	switch f := strings.ToLower(getenv("SHELF_LOG_FORMAT")); f {
	case "", "text":
		return slog.New(slog.NewTextHandler(w, opts)), nil
	case "json":
		return slog.New(slog.NewJSONHandler(w, opts)), nil
	default:
		return nil, fmt.Errorf("SHELF_LOG_FORMAT: unknown format %q", f)
	}
}

func main() {
	for _, env := range []map[string]string{
		{},
		{"SHELF_LOG_LEVEL": "debug", "SHELF_LOG_FORMAT": "json"},
		{"SHELF_LOG_LEVEL": "warn"},
		{"SHELF_LOG_LEVEL": "loud"},
		{"SHELF_LOG_FORMAT": "xml"},
	} {
		log, err := newLogger(os.Stdout, func(k string) string { return env[k] })
		if err != nil {
			fmt.Println("error:", err)
			continue
		}
		log.Debug("debug line")
		log.Info("info line")
		log.Warn("warn line")
	}
}

level=INFO msg="info line"
level=WARN msg="warn line"
{"level":"DEBUG","msg":"debug line"}
{"level":"INFO","msg":"info line"}
{"level":"WARN","msg":"warn line"}
level=WARN msg="warn line"
error: SHELF_LOG_LEVEL: slog: level string "loud": unknown name
error: SHELF_LOG_FORMAT: unknown format "xml"

package main

import (
	"context"
	"errors"
	"log/slog"
	"os"
	"time"
)

func noTime(groups []string, a slog.Attr) slog.Attr {
	if len(groups) == 0 && a.Key == slog.TimeKey {
		return slog.Attr{}
	}
	return a
}

type Member struct {
	ID   int
	Name string
}

func main() {
	h := slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{ReplaceAttr: noTime})
	log := slog.New(h)

	// Alternating keys and values.
	log.Info("loan", "isbn", "9780134685991", "days", 14, "renewable", true)

	// Typed attributes: no boxing, no mistakes with pairs.
	log.LogAttrs(context.Background(), slog.LevelInfo, "loan",
		slog.String("isbn", "9780134685991"),
		slog.Int("days", 14),
		slog.Duration("grace", 36*time.Hour),
		slog.Float64("fine", 1.5),
		slog.Time("due", time.Date(2026, 11, 1, 0, 0, 0, 0, time.UTC)),
	)

	// Mixing both forms in one call is allowed.
	log.Info("mixed", slog.Int("a", 1), "b", 2)

	// Any values: structs, slices, maps, errors.
	err := errors.New("catalog: invalid ISBN")
	log.Error("lookup failed", "err", err, "member", Member{ID: 7, Name: "Ada"}, "tags", []string{"a", "b"})
	log.Error("lookup failed", slog.Any("err", err))
}

{"level":"INFO","msg":"loan","isbn":"9780134685991","days":14,"renewable":true}
{"level":"INFO","msg":"loan","isbn":"9780134685991","days":14,"grace":129600000000000,"fine":1.5,"due":"2026-11-01T00:00:00Z"}
{"level":"INFO","msg":"mixed","a":1,"b":2}
{"level":"ERROR","msg":"lookup failed","err":"catalog: invalid ISBN","member":{"ID":7,"Name":"Ada"},"tags":["a","b"]}
{"level":"ERROR","msg":"lookup failed","err":"catalog: invalid ISBN"}

package main

import (
	"log/slog"
	"os"
)

func noTime(groups []string, a slog.Attr) slog.Attr {
	if len(groups) == 0 && a.Key == slog.TimeKey {
		return slog.Attr{}
	}
	return a
}

func main() {
	opts := &slog.HandlerOptions{ReplaceAttr: noTime}
	text := slog.New(slog.NewTextHandler(os.Stdout, opts))
	js := slog.New(slog.NewJSONHandler(os.Stdout, opts))

	for _, l := range []*slog.Logger{text, js} {
		l.Info("request",
			slog.Group("http", "method", "GET", "path", "/books"),
			slog.Int("status", 200))

		// WithGroup qualifies every attribute that comes after it.
		l.With("service", "shelfd").WithGroup("loan").With("member", "ada").Info("lent", "isbn", "9780134685991")

		// An empty group is dropped; an empty key inlines the group.
		l.Info("edge cases", slog.Group("empty"), slog.Group("", "inline", 1))

		// GroupAttrs (Go 1.25) takes Attr values only.
		l.Info("typed group", slog.GroupAttrs("book", slog.String("isbn", "9780134685991"), slog.Int("copies", 3)))
	}
}

level=INFO msg=request http.method=GET http.path=/books status=200
level=INFO msg=lent service=shelfd loan.member=ada loan.isbn=9780134685991
level=INFO msg="edge cases" inline=1
level=INFO msg="typed group" book.isbn=9780134685991 book.copies=3
{"level":"INFO","msg":"request","http":{"method":"GET","path":"/books"},"status":200}
{"level":"INFO","msg":"lent","service":"shelfd","loan":{"member":"ada","isbn":"9780134685991"}}
{"level":"INFO","msg":"edge cases","inline":1}
{"level":"INFO","msg":"typed group","book":{"isbn":"9780134685991","copies":3}}

package main

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

func noTime(groups []string, a slog.Attr) slog.Attr {
	if len(groups) == 0 && a.Key == slog.TimeKey {
		return slog.Attr{}
	}
	return a
}

func main() {
	// Before SetDefault: the default handler writes through package log.
	log.SetOutput(os.Stdout)
	log.SetFlags(0)
	slog.Info("default handler", "k", 1)
	slog.Debug("dropped: the default level is Info")

	// A library that still uses package log...
	legacy := func() { log.Printf("legacy message from package log") }

	// ...goes through the new handler once SetDefault is called.
	slog.SetDefault(slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{ReplaceAttr: noTime})))
	slog.Info("after SetDefault", "k", 2)
	legacy()
	log.Print("also bridged")

	// SetLogLoggerLevel (Go 1.22) chooses the level used for those bridged log calls.
	slog.SetLogLoggerLevel(slog.LevelWarn)
	log.Print("now a warning")

	// The other direction: give a library an *log.Logger that writes through a handler.
	h := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{ReplaceAttr: noTime})
	std := slog.NewLogLogger(h, slog.LevelError)
	std.Printf("http: TLS handshake error from %s", "192.0.2.1:5000")
}

INFO default handler k=1
{"level":"INFO","msg":"after SetDefault","k":2}
{"level":"INFO","msg":"legacy message from package log"}
{"level":"INFO","msg":"also bridged"}
{"level":"WARN","msg":"now a warning"}
level=ERROR msg="http: TLS handshake error from 192.0.2.1:5000"

package main

import (
	"log/slog"
	"os"
	"path/filepath"
)

func shortSource(groups []string, a slog.Attr) slog.Attr {
	switch {
	case len(groups) == 0 && a.Key == slog.TimeKey:
		return slog.Attr{}
	case a.Key == slog.SourceKey:
		src := a.Value.Any().(*slog.Source)
		src.File = filepath.Base(src.File)
		return a
	}
	return a
}

func main() {
	h := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{AddSource: true, ReplaceAttr: shortSource})
	slog.New(h).Info("with source")
	slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{AddSource: true, ReplaceAttr: shortSource})).Warn("json source")
}

level=INFO source=main.go:23 msg="with source"
{"level":"WARN","source":{"function":"main.main","file":"main.go","line":24},"msg":"json source"}

package main

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

// renamed maps slog's built-in keys to the names a log pipeline expects,
// lower-cases levels and redacts any attribute whose key looks sensitive.
func renamed(groups []string, a slog.Attr) slog.Attr {
	switch a.Key {
	case slog.TimeKey:
		if len(groups) == 0 {
			return slog.Attr{} // dropped here only to keep the output stable
		}
	case slog.MessageKey:
		if len(groups) == 0 {
			a.Key = "message"
		}
	case slog.LevelKey:
		if len(groups) == 0 {
			a.Key = "severity"
			a.Value = slog.StringValue(strings.ToLower(a.Value.String()))
		}
	case "password", "token", "api_key":
		a.Value = slog.StringValue("[redacted]")
	}
	return a
}

func main() {
	log := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{ReplaceAttr: renamed}))
	log.Warn("login", "member", "ada", "token", "not-a-real-token")
	log.Info("nested", slog.Group("auth", "password", "not-a-real-password", "method", "basic"))
}

{"severity":"warn","message":"login","member":"ada","token":"[redacted]"}
{"severity":"info","message":"nested","auth":{"password":"[redacted]","method":"basic"}}

package main

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

// Levels that slog does not name but many log pipelines do.
const (
	LevelTrace  = slog.Level(-8)
	LevelNotice = slog.Level(2)
	LevelFatal  = slog.Level(12)
)

var levelNames = map[slog.Leveler]string{
	LevelTrace:  "TRACE",
	LevelNotice: "NOTICE",
	LevelFatal:  "FATAL",
}

func replace(groups []string, a slog.Attr) slog.Attr {
	switch a.Key {
	case slog.TimeKey:
		if len(groups) == 0 {
			return slog.Attr{}
		}
	case slog.LevelKey:
		level := a.Value.Any().(slog.Level)
		if name, ok := levelNames[level]; ok {
			a.Value = slog.StringValue(name)
		}
	}
	return a
}

func main() {
	log := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{Level: LevelTrace, ReplaceAttr: replace}))
	ctx := context.Background()
	log.Log(ctx, LevelTrace, "entering Lend")
	log.Info("an ordinary record")
	log.Log(ctx, LevelNotice, "nightly overdue scan started")
	log.Log(ctx, LevelFatal, "cannot open the catalogue")
}

{"level":"TRACE","msg":"entering Lend"}
{"level":"INFO","msg":"an ordinary record"}
{"level":"NOTICE","msg":"nightly overdue scan started"}
{"level":"FATAL","msg":"cannot open the catalogue"}

package main

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

func noTime(groups []string, a slog.Attr) slog.Attr {
	if len(groups) == 0 && a.Key == slog.TimeKey {
		return slog.Attr{}
	}
	return a
}

// Token is a secret that must never reach the logs.
type Token string

func (Token) LogValue() slog.Value { return slog.StringValue("REDACTED") }

// Member groups its fields and leaves out the password hash.
type Member struct {
	ID           int
	Name         string
	PasswordHash string
}

func (m Member) LogValue() slog.Value {
	return slog.GroupValue(
		slog.Int("id", m.ID),
		slog.String("name", m.Name),
	)
}

// Expensive does its work only if the record is actually logged.
type Expensive struct{ n int }

var calls int

func (e Expensive) LogValue() slog.Value {
	calls++
	return slog.IntValue(e.n * e.n)
}

func main() {
	log := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{ReplaceAttr: noTime}))
	log.Info("login", "member", Member{ID: 7, Name: "Ada", PasswordHash: "not-a-real-hash"}, "token", Token("not-a-real-token"))

	log.Debug("below the level", "square", Expensive{9})
	fmt.Println("LogValue calls after a disabled record:", calls)
	log.Info("enabled", "square", Expensive{9})
	fmt.Println("LogValue calls after an enabled record:", calls)
}

level=INFO msg=login member.id=7 member.name=Ada token=REDACTED
LogValue calls after a disabled record: 0
level=INFO msg=enabled square=81
LogValue calls after an enabled record: 1

package main

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

func noTime(groups []string, a slog.Attr) slog.Attr {
	if len(groups) == 0 && a.Key == slog.TimeKey {
		return slog.Attr{}
	}
	return a
}

type ctxKey struct{}

// WithRequestID returns a context carrying the request ID.
func WithRequestID(ctx context.Context, id string) context.Context {
	return context.WithValue(ctx, ctxKey{}, id)
}

// ContextHandler adds the request ID found in the context to every record.
type ContextHandler struct{ slog.Handler }

func (h ContextHandler) Handle(ctx context.Context, r slog.Record) error {
	if id, ok := ctx.Value(ctxKey{}).(string); ok {
		r.AddAttrs(slog.String("request_id", id))
	}
	return h.Handler.Handle(ctx, r)
}

// WithAttrs and WithGroup must return the wrapper again, or the context
// behaviour is lost as soon as a caller uses With.
func (h ContextHandler) WithAttrs(attrs []slog.Attr) slog.Handler {
	return ContextHandler{h.Handler.WithAttrs(attrs)}
}

func (h ContextHandler) WithGroup(name string) slog.Handler {
	return ContextHandler{h.Handler.WithGroup(name)}
}

func lend(ctx context.Context, log *slog.Logger, isbn string) {
	log.InfoContext(ctx, "lending", "isbn", isbn)
}

func main() {
	base := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{ReplaceAttr: noTime})
	log := slog.New(ContextHandler{base}).With("service", "shelfd")

	ctx := WithRequestID(context.Background(), "req-42")
	lend(ctx, log, "9780134685991")
	lend(context.Background(), log, "9780134685991")

	// Without the Context variant the handler receives context.Background().
	log.Info("no context here", "isbn", "9780134685991")
}

level=INFO msg=lending service=shelfd isbn=9780134685991 request_id=req-42
level=INFO msg=lending service=shelfd isbn=9780134685991
level=INFO msg="no context here" service=shelfd isbn=9780134685991

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"io"
	"log/slog"
	"net/http"
	"net/http/httptest"
	"os"
	"sync/atomic"
	"time"

	"example.com/shelf/catalog"
)

type loggerKey struct{}

// FromContext returns the request-scoped logger, or the default logger.
func FromContext(ctx context.Context) *slog.Logger {
	if l, ok := ctx.Value(loggerKey{}).(*slog.Logger); ok {
		return l
	}
	return slog.Default()
}

// statusRecorder remembers the status code written by the handler.
type statusRecorder struct {
	http.ResponseWriter
	status int
}

func (r *statusRecorder) WriteHeader(code int) {
	r.status = code
	r.ResponseWriter.WriteHeader(code)
}

var nextID atomic.Int64

// logRequests logs one line per request and hands a request-scoped logger to the handler.
func logRequests(log *slog.Logger, next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		start := time.Now()
		reqLog := log.With("request_id", fmt.Sprintf("req-%d", nextID.Add(1)))
		ctx := context.WithValue(r.Context(), loggerKey{}, reqLog)

		rec := &statusRecorder{ResponseWriter: w, status: http.StatusOK}
		next.ServeHTTP(rec, r.WithContext(ctx))

		level := slog.LevelInfo
		if rec.status >= 500 {
			level = slog.LevelError
		}
		reqLog.LogAttrs(ctx, level, "request",
			slog.Group("http",
				slog.String("method", r.Method),
				slog.String("path", r.URL.Path),
				slog.Int("status", rec.status)),
			slog.Duration("duration", time.Since(start)))
	})
}

func main() {
	opts := &slog.HandlerOptions{
		ReplaceAttr: func(groups []string, a slog.Attr) slog.Attr {
			if len(groups) == 0 && (a.Key == slog.TimeKey || a.Key == "duration") {
				return slog.Attr{} // these vary between runs; dropped for stable output
			}
			return a
		},
	}
	log := slog.New(slog.NewJSONHandler(os.Stdout, opts)).With("service", "shelfd")

	store := catalog.NewMemStore()
	store.Put(catalog.Book{ISBN: "9780134685991", Title: "Effective Go (sample)"})

	mux := http.NewServeMux()
	mux.HandleFunc("GET /books/{isbn}", func(w http.ResponseWriter, r *http.Request) {
		isbn, err := catalog.ParseISBN(r.PathValue("isbn"))
		if err != nil {
			FromContext(r.Context()).WarnContext(r.Context(), "rejected ISBN", "err", err)
			http.Error(w, "invalid ISBN", http.StatusBadRequest)
			return
		}
		b, ok := store.Get(isbn)
		if !ok {
			http.NotFound(w, r)
			return
		}
		FromContext(r.Context()).DebugContext(r.Context(), "found", "isbn", isbn) // Debug: not enabled
		_ = json.NewEncoder(w).Encode(b)
	})

	srv := httptest.NewServer(logRequests(log, mux))
	defer srv.Close()

	for _, path := range []string{"/books/9780134685991", "/books/9780134685992", "/books/12", "/books/9783161484100"} {
		resp, err := http.Get(srv.URL + path)
		if err != nil {
			panic(err)
		}
		_, _ = io.Copy(io.Discard, resp.Body)
		resp.Body.Close()
	}
}

{"level":"INFO","msg":"request","service":"shelfd","request_id":"req-1","http":{"method":"GET","path":"/books/9780134685991","status":200}}
{"level":"WARN","msg":"rejected ISBN","service":"shelfd","request_id":"req-2","err":"catalog: invalid ISBN: \"9780134685992\""}
{"level":"INFO","msg":"request","service":"shelfd","request_id":"req-2","http":{"method":"GET","path":"/books/9780134685992","status":400}}
{"level":"WARN","msg":"rejected ISBN","service":"shelfd","request_id":"req-3","err":"catalog: invalid ISBN: \"12\""}
{"level":"INFO","msg":"request","service":"shelfd","request_id":"req-3","http":{"method":"GET","path":"/books/12","status":400}}
{"level":"INFO","msg":"request","service":"shelfd","request_id":"req-4","http":{"method":"GET","path":"/books/9783161484100","status":404}}

package main

import (
	"bytes"
	"context"
	"errors"
	"fmt"
	"log/slog"
	"os"
	"strings"
	"time"
)

func noTime(groups []string, a slog.Attr) slog.Attr {
	if len(groups) == 0 && a.Key == slog.TimeKey {
		return slog.Attr{}
	}
	return a
}

// failing is a handler whose Handle always fails.
type failing struct{ slog.Handler }

func (failing) Handle(context.Context, slog.Record) error { return errors.New("sink unavailable") }

func main() {
	var audit bytes.Buffer

	// Human-readable records on stdout from Info up; every record, as JSON, in a second sink.
	console := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelInfo, ReplaceAttr: noTime})
	archive := slog.NewJSONHandler(&audit, &slog.HandlerOptions{Level: slog.LevelDebug, ReplaceAttr: noTime})

	log := slog.New(slog.NewMultiHandler(console, archive)).With("service", "shelfd")
	log.Debug("cache miss", "isbn", "9780134685991")
	log.Info("book lent", "isbn", "9780134685991")

	fmt.Print("--- archive ---\n", audit.String())

	// Enabled is true when any handler is enabled; the others are skipped.
	fmt.Println("enabled at Debug:", log.Enabled(context.Background(), slog.LevelDebug))

	// Handle errors are joined, but a Logger discards them: call the handler to see them.
	m := slog.NewMultiHandler(failing{console}, console, failing{archive})
	err := m.Handle(context.Background(), slog.NewRecord(time.Time{}, slog.LevelInfo, "direct call", 0))
	fmt.Println("joined error:", strings.ReplaceAll(err.Error(), "\n", " | "))
}

level=INFO msg="book lent" service=shelfd isbn=9780134685991
--- archive ---
{"level":"DEBUG","msg":"cache miss","service":"shelfd","isbn":"9780134685991"}
{"level":"INFO","msg":"book lent","service":"shelfd","isbn":"9780134685991"}
enabled at Debug: true
level=INFO msg="direct call"
joined error: sink unavailable | sink unavailable

package main

import (
	"context"
	"encoding/json"
	"io"
	"log/slog"
	"slices"
	"sync"
)

// groupOrAttrs is one WithGroup or WithAttrs call, kept in call order.
type groupOrAttrs struct {
	group string      // set for WithGroup
	attrs []slog.Attr // set for WithAttrs
}

// LineHandler writes one JSON object per record. It is a teaching
// implementation; slog.JSONHandler is the production choice.
type LineHandler struct {
	// OmitTime drops the time key; handy for deterministic output.
	OmitTime bool

	mu    *sync.Mutex // shared by all handlers derived from the same root
	w     io.Writer
	level slog.Leveler
	goas  []groupOrAttrs
}

// NewLineHandler returns a handler that writes to w at or above level.
func NewLineHandler(w io.Writer, level slog.Leveler) *LineHandler {
	if level == nil {
		level = slog.LevelInfo
	}
	return &LineHandler{mu: new(sync.Mutex), w: w, level: level}
}

func (h *LineHandler) Enabled(_ context.Context, l slog.Level) bool {
	return l >= h.level.Level()
}

func (h *LineHandler) withGroupOrAttrs(g groupOrAttrs) *LineHandler {
	h2 := *h
	h2.goas = append(slices.Clip(h.goas), g)
	return &h2
}

func (h *LineHandler) WithGroup(name string) slog.Handler {
	if name == "" {
		return h
	}
	return h.withGroupOrAttrs(groupOrAttrs{group: name})
}

func (h *LineHandler) WithAttrs(attrs []slog.Attr) slog.Handler {
	if len(attrs) == 0 {
		return h
	}
	return h.withGroupOrAttrs(groupOrAttrs{attrs: attrs})
}

func (h *LineHandler) Handle(_ context.Context, r slog.Record) error {
	root := map[string]any{}
	if !r.Time.IsZero() && !h.OmitTime {
		root[slog.TimeKey] = r.Time
	}
	root[slog.LevelKey] = r.Level.String()
	root[slog.MessageKey] = r.Message

	// Replay WithGroup/WithAttrs in order; attributes land in the innermost group.
	cur := root
	var openGroups []map[string]any
	var names []string
	for _, g := range h.goas {
		if g.group != "" {
			sub := map[string]any{}
			openGroups = append(openGroups, cur)
			names = append(names, g.group)
			cur = sub
			continue
		}
		for _, a := range g.attrs {
			add(cur, a)
		}
	}
	r.Attrs(func(a slog.Attr) bool {
		add(cur, a)
		return true
	})

	// Close the groups from the innermost outwards, dropping empty ones.
	for i := len(names) - 1; i >= 0; i-- {
		parent := openGroups[i]
		if len(cur) > 0 {
			parent[names[i]] = cur
		}
		cur = parent
	}

	b, err := json.Marshal(root)
	if err != nil {
		return err
	}
	h.mu.Lock()
	defer h.mu.Unlock()
	_, err = h.w.Write(append(b, '\n'))
	return err
}

// add stores a into m, following the rules in the slog.Handler documentation.
func add(m map[string]any, a slog.Attr) {
	a.Value = a.Value.Resolve()
	if a.Equal(slog.Attr{}) {
		return // ignore empty attributes
	}
	if a.Value.Kind() != slog.KindGroup {
		m[a.Key] = a.Value.Any()
		return
	}
	attrs := a.Value.Group()
	if len(attrs) == 0 {
		return // ignore empty groups
	}
	target := m
	if a.Key != "" { // an empty key inlines the group
		target = map[string]any{}
	}
	for _, ga := range attrs {
		add(target, ga)
	}
	if a.Key != "" && len(target) > 0 {
		m[a.Key] = target
	}
}

var _ slog.Handler = (*LineHandler)(nil)

package main

import (
	"log/slog"
	"os"
)

func main() {
	h := NewLineHandler(os.Stdout, slog.LevelDebug)
	h.OmitTime = true
	log := slog.New(h)
	log.Debug("opened", "path", "/var/lib/shelf/books.db")
	log.With("service", "shelfd").WithGroup("loan").With("member", "ada").Info("lent", "isbn", "9780134685991", slog.Group("terms", "days", 14))
}

{"level":"DEBUG","msg":"opened","path":"/var/lib/shelf/books.db"}
{"level":"INFO","loan":{"isbn":"9780134685991","member":"ada","terms":{"days":14}},"msg":"lent","service":"shelfd"}

package main

import (
	"context"
	"log/slog"

	"example.com/shelf/catalog"
)

// Lender lends books and reports what it did to its logger.
type Lender struct {
	Store catalog.Store
	Log   *slog.Logger
}

func (l *Lender) Lend(ctx context.Context, isbn catalog.ISBN, member string) error {
	b, ok := l.Store.Get(isbn)
	if !ok {
		l.Log.WarnContext(ctx, "lend failed", "isbn", isbn, "member", member, "reason", "unknown book")
		return catalog.ErrInvalidISBN
	}
	l.Log.InfoContext(ctx, "book lent", "isbn", b.ISBN, "member", member)
	return nil
}

func main() {}

package main

import (
	"bytes"
	"context"
	"encoding/json"
	"log/slog"
	"strings"
	"testing"

	"example.com/shelf/catalog"
)

// capture returns a logger that writes JSON lines into the returned buffer.
func capture() (*slog.Logger, *bytes.Buffer) {
	var buf bytes.Buffer
	h := slog.NewJSONHandler(&buf, &slog.HandlerOptions{Level: slog.LevelDebug})
	return slog.New(h), &buf
}

func records(t *testing.T, buf *bytes.Buffer) []map[string]any {
	t.Helper()
	var out []map[string]any
	for _, line := range strings.Split(strings.TrimSpace(buf.String()), "\n") {
		var m map[string]any
		if err := json.Unmarshal([]byte(line), &m); err != nil {
			t.Fatalf("bad log line %q: %v", line, err)
		}
		out = append(out, m)
	}
	return out
}

func TestLendLogsOutcome(t *testing.T) {
	store := catalog.NewMemStore()
	store.Put(catalog.Book{ISBN: "9780134685991", Title: "Sample"})
	log, buf := capture()
	l := &Lender{Store: store, Log: log}

	if err := l.Lend(context.Background(), "9780134685991", "ada"); err != nil {
		t.Fatal(err)
	}
	if err := l.Lend(context.Background(), "9783161484100", "ada"); err == nil {
		t.Fatal("want an error for an unknown book")
	}

	got := records(t, buf)
	if len(got) != 2 {
		t.Fatalf("got %d records, want 2", len(got))
	}
	if got[0]["level"] != "INFO" || got[0]["msg"] != "book lent" {
		t.Errorf("first record = %v", got[0])
	}
	if got[1]["level"] != "WARN" || got[1]["reason"] != "unknown book" {
		t.Errorf("second record = %v", got[1])
	}
}

func TestLendWithoutLogging(t *testing.T) {
	l := &Lender{Store: catalog.NewMemStore(), Log: slog.New(slog.DiscardHandler)}
	_ = l.Lend(context.Background(), "9780134685991", "ada") // no output, no nil pointer
}

=== RUN   TestLendLogsOutcome
--- PASS: TestLendLogsOutcome (0.00s)
=== RUN   TestLendWithoutLogging
--- PASS: TestLendWithoutLogging (0.00s)
PASS
ok  	example.com/shelf/e17	(cached)

package main

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

type Loan struct {
	Book   string
	Member string
	Days   int
}

func main() {
	ctx := context.Background()
	text := slog.New(slog.NewTextHandler(io.Discard, nil))
	off := slog.New(slog.DiscardHandler)

	l := Loan{Book: "9780134685991", Member: "ada", Days: 14}
	cases := []struct {
		name string
		fn   func()
	}{
		{"disabled Debug, Sprintf argument", func() { text.Debug("lend", "loan", fmt.Sprintf("%+v", l)) }},
		{"disabled Debug, struct argument", func() { text.Debug("lend", "loan", l) }},
		{"disabled Debug, LogAttrs", func() { text.LogAttrs(ctx, slog.LevelDebug, "lend", slog.Any("loan", l)) }},
		{"enabled Info, struct argument", func() { text.Info("lend", "loan", l) }},
		{"enabled Info, string attributes", func() {
			text.LogAttrs(ctx, slog.LevelInfo, "lend", slog.String("book", l.Book), slog.String("member", l.Member), slog.Int("days", l.Days))
		}},
		{"DiscardHandler, Sprintf argument", func() { off.Info("lend", "loan", fmt.Sprintf("%+v", l)) }},
	}
	for _, c := range cases {
		fmt.Printf("%-34s %v allocs/op\n", c.name, testing.AllocsPerRun(1000, c.fn))
	}
}

disabled Debug, Sprintf argument   3 allocs/op
disabled Debug, struct argument    1 allocs/op
disabled Debug, LogAttrs           1 allocs/op
enabled Info, struct argument      2 allocs/op
enabled Info, string attributes    0 allocs/op
DiscardHandler, Sprintf argument   3 allocs/op

e15/main.go:17:2: call to slog.Logger.Info missing a final value
e15/main.go:18:29: slog.Logger.Info arg "42" should be a string or a slog.Attr (possible missing key or value)
e15/main.go:19:2: call to slog.Logger.Info missing a final value