Service Telemetry

log/slog reads its variadic arguments as alternating pairs: a string key followed by its value, or a ready-made slog.Attr such as slog.String("pkg", p). A key left with no value is logged under the placeholder key !BADKEY.

HandlerOptions.Level sets the minimum severity a slog handler emits: records at that level or higher are written, lower ones are dropped. Leave it nil and the handler defaults to slog.LevelInfo, so Debug records disappear.

slog.SetDefault installs a *slog.Logger as the process-wide default, so the package-level slog.Info, slog.Warn and slog.Error use its handler. Before that call, those functions use a built-in handler that prints plain, unstructured lines to standard error.

slog.Group builds one attribute whose value is a nested set of attributes, for a single record. Logger.WithGroup returns a derived logger that qualifies everything added afterwards under that group name, on every record.

slog.Level is an int — Debug -4, Info 0, Warn 4, Error 8 — and the gaps exist so you can define levels in between. Declare a constant such as slog.LevelInfo+2 and emit records with Logger.Log.

Go evaluates every argument before the call runs, so work you do to build a log line happens even at a disabled level. slog only checks the level inside the call, after the arguments are boxed into interfaces.

slog.Handler has four methods: Enabled reports whether a level should be logged, Handle formats and writes one Record, WithAttrs returns a new handler carrying extra attributes, and WithGroup returns one that nests later keys under a name.

Go's log package writes to standard error through the one logger returned by log.Default(), prefixing each line with the date and time (log.LstdFlags). It has no severity levels: log.Print, log.Printf and log.Println all produce identical, unlabelled lines.

A type that implements LogValuer supplies a LogValue method returning a slog.Value, and slog logs that substitute instead of the value itself. Every handler sees the substitute, so a secret can be replaced with a fixed placeholder in one place.

Both streams are collected by the container runtime, so the real rule is to pick one and send every record there. Most teams choose os.Stdout for the application's log stream and leave os.Stderr to the runtime's own panic output.

Read start := time.Now() before calling next.ServeHTTP, then record time.Since(start) inside a deferred closure. Deferring means the duration is still recorded when the handler panics or returns early.

r.URL.Path holds the concrete requested path, so /items/1 and /items/2 become separate label values and the number of counters grows with traffic. http.Request.Pattern holds the ServeMux pattern that matched, a fixed string that changes only when you add a route.

runtime.ReadMemStats stops the world for the whole call so that every field of the MemStats struct is one mutually consistent snapshot. runtime/metrics.Read instead aggregates the runtime's per-P statistics under an internal lock, so it adds no stop-the-world pause.

ReadBuildInfo returns the build record the linker embedded in the binary: the Go toolchain version, the main module's path and version, the dependency modules linked in, and build settings such as flags and the VCS revision. It reports false when no record is present.

Importing expvar runs its init, which registers a handler for /debug/vars on http.DefaultServeMux and publishes two variables of its own, cmdline and memstats. The endpoint returns every published variable as one JSON object.

Wrap another slog.Handler. In Handle(ctx, record), look the run id up with ctx.Value, attach it with Record.AddAttrs, then call the wrapped handler's Handle. Callers must use the Context-taking log methods for the id to arrive.

http.NewRequest gives the request context.Background(), so the outbound call ignores the caller's deadline and cancellation and carries none of the per-request state your code keeps in a context.Context. NewRequestWithContext attaches the caller's context instead.

Logger.InfoContext passes your context.Context down to the handler's Handle method, so the handler can read request-scoped data such as a run id out of it. Logger.Info passes context.Background() instead, so that data never arrives.

Build the request, then call req.Header.Set("X-Trace-Id", id) before sending it. Set replaces every value already stored under that key; Add appends another value and keeps the earlier ones. Both store the key in canonical form.

A span belongs to one request, but a service struct is shared by every concurrent request, so a field is raced on and overwritten. context.Context is per request and flows down to exactly that request's callees.