Structured Logging with slog

log/slog is Go's standard library structured logger: key-value fields, leveled output, and pluggable handlers for JSON, text, or custom sinks.

Summary

Structured logging means every line carries machine-parseable fields (user_id, trace_id, err) instead of free-form prose.

Go 1.21 added log/slog to replace ad hoc log.Printf and reduce dependency on third-party loggers for most services.

Handlers control output format and filtering; Logger methods attach contextual attributes that flow to child loggers.

Migration from log and from zap often starts by wrapping handlers and matching field names your log platform already indexes.

Recipe

Quick-reference recipe card - copy-paste ready.

logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
    Level: slog.LevelInfo,
    AddSource: true,
}))
slog.SetDefault(logger)
slog.Info("payment captured", "order_id", orderID, "amount_cents", amount)

When to reach for this:

• New Go services that want stdlib-only dependencies
• JSON logs shipped to Loki, Elasticsearch, or Cloud Logging
• Middleware that logs HTTP requests with consistent attribute names
• Libraries that accept *slog.Logger for injectable logging
• Gradual migration off log.Printf without rewriting every call site at once

Working Example

package main
 
import (
    "context"
    "log/slog"
    "net/http"
    "os"
    "time"
)
 
type ctxKey string
 
const loggerKey ctxKey = "logger"
 
func main() {
    base := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
        Level: slog.LevelDebug,
    }))
    slog.SetDefault(base)
 
    mux := http.NewServeMux()
    mux.Handle("GET /orders/{id}", injectLogger(base.With("service", "orders-api"))(
        accessLog(http.HandlerFunc(getOrder)),
    ))
 
    srv := &http.Server{Addr: ":8080", Handler: mux}
    slog.Info("listening", "addr", srv.Addr)
    if err := srv.ListenAndServe(); err != nil {
        slog.Error("server stopped", "err", err)
        os.Exit(1)
    }
}
 
func injectLogger(l *slog.Logger) func(http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            reqLog := l.With("request_id", r.Header.Get("X-Request-ID"))
            ctx := context.WithValue(r.Context(), loggerKey, reqLog)
            next.ServeHTTP(w, r.WithContext(ctx))
        })
    }
}
 
func loggerFrom(ctx context.Context) *slog.Logger {
    if l, ok := ctx.Value(loggerKey).(*slog.Logger); ok {
        return l
    }
    return slog.Default()
}
 
func accessLog(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        next.ServeHTTP(w, r)
        loggerFrom(r.Context()).Info("request complete",
            "method", r.Method,
            "path", r.URL.Path,
            "duration_ms", time.Since(start).Milliseconds(),
        )
    })
}
 
func getOrder(w http.ResponseWriter, r *http.Request) {
    id := r.PathValue("id")
    loggerFrom(r.Context()).Info("fetch order", "order_id", id)
    w.Write([]byte(`{"id":"` + id + `"}`))
}

What this demonstrates:

• JSON handler with explicit level and service-wide default logger
• Child loggers via With for per-request request_id without mutating the parent
• Context-carried *slog.Logger for handlers deep in the call stack
• Access logging separated from business logging with shared correlation fields

Deep Dive

How It Works

• slog.Logger holds a Handler and optional persistent attributes from With / WithGroup.
• Each Info, Warn, Error call builds a slog.Record (time, level, message, attrs) and passes it to the handler.
• Handlers implement Enabled, Handle, and WithAttrs / WithGroup for immutability when deriving child loggers.
• slog.SetDefault wires the process-wide logger used by top-level slog.Info calls.

Handlers at a Glance

Levels

Set HandlerOptions.Level to filter below-threshold records before Handle runs.

Go Notes

// Lazy expensive fields - evaluated only if level enabled
slog.Info("snapshot", "payload", slog.LogValuerFunc(func() slog.Value {
    return slog.StringValue(expensiveSerialize())
}))
 
// Groups nest attributes in JSON: {"request":{"method":"GET"}}
log := logger.WithGroup("request")
log.Info("in", "method", r.Method, "path", r.URL.Path)

Migrating from log and zap

Gotchas

• Logging before SetDefault - Early main logs use the text default. Configure the handler before other packages log.
• Duplicate attribute keys - Later keys with the same name can confuse JSON parsers; use consistent naming conventions.
• Logging secrets - Never log auth headers, passwords, or full PANs. Redact in a custom Handle wrapper.
• Error attribute name - Use "err", err consistently; some platforms map error to special columns.
• High-cardinality fields - Logging raw user IDs on every debug line increases storage cost; sample or aggregate in metrics instead.
• Missing AddSource in prod - Source lines help debugging but add allocation; enable selectively.
• Global default in tests - Tests that parse logs should inject a slog.New(slog.NewTextHandler(&buf, nil)) handler.

Alternatives

FAQs

Related

• Observability Basics - slog and health quick starts
• Production Go: Logs, Metrics, Traces, and Signals - three pillars overview
• OpenTelemetry Tracing in Go Services - trace IDs in log fields
• Observability Best Practices - cardinality and on-call rules
• Middleware Chains & Request Context - HTTP middleware patterns

Stack versions: This page was written for Go 1.26.x (Green Tea GC default, go fix modernizers - verify patch at build), chi (latest - verify at build), gin (latest - verify at build), echo (latest - verify at build), google.golang.org/grpc (latest - verify at build), sigs.k8s.io/controller-runtime (latest - verify at build), kubebuilder (latest - verify at build), tinygo (latest - verify board targets at build), wazero (latest - verify at build), and golangci-lint (latest - verify linter set at build).