In Go's log/slog, why does a `slog.Debug` call still cost work when the logger's level is Info?

## The shape of a slog call `log/slog` gives a `*slog.Logger` one method per level, each with the same signature shape: `Debug(msg string, args ...any)`, and likewise `Info`, `Warn` and `Error`. A typical call looks like this: ```go logger.Debug("decoded record", "summary", summarize(buf)) ``` That is an ordinary Go function call, and Go has exactly one calling discipline: **every argument expression is evaluated, left to right, before the callee's first statement runs.** Go has no macros, no lazily-evaluated parameters, and no compile-time knowledge of your logging level. So `summarize(buf)` executes whether or not a single byte is ever written. ## What is built before slog sees anything Two separate costs land at the call site, before the level is consulted. **Argument evaluation.** Anything you wrote as an argument runs: a `fmt.Sprintf`, a `json.Marshal`, a `string(buf)` conversion that copies a whole buffer, a walk over a struct. This is the cost that actually hurts, because you control how big it is. **Interface boxing.** The parameter is `...any`, so the compiler builds a `[]any` at the call site and converts each argument to an interface value. An interface value is a pair of words: a type descriptor and a pointer to the data. A value that is not already pointer-shaped — an `int`, a `time.Duration`, a struct, a string header — has to live somewhere the pointer can point at, and when the compiler cannot prove the value stays within the frame, that means a heap allocation. In practice a variadic slog call costs the slice plus roughly one allocation per non-pointer value. ## What the disabled level really saves The level comparison happens inside the logging method, and it happens early — before the record exists. Once it fails, slog skips: - reading the clock for the record's timestamp; - capturing the caller's program counter (the source location, if the handler wants it); - constructing the `slog.Record` and converting your alternating key/value arguments into `slog.Attr` values; - the handler entirely: no formatting, no JSON escaping, no lock, no write. That is a large saving, and it is why a disabled level is cheap. It is not free, and "cheap" stops being good enough when the call sits inside a loop running tens of thousands of times a second. ## The guard The escape hatch is `Logger.Enabled`: ```go if logger.Enabled(ctx, slog.LevelDebug) { logger.Debug("decoded record", "summary", summarize(buf)) } ``` `Enabled(ctx context.Context, level Level) bool` forwards to the handler's own `Enabled` method, so it answers the same question the logging method would have asked, just early enough that you can skip building the argument. For the built-in text and JSON handlers that comparison is against `HandlerOptions.Level`, which defaults to Info when you pass `nil` options. A custom handler may answer differently — that is precisely why the question goes through the handler rather than reading a package variable. ## When to reach for it Guard when the argument is expensive relative to the guard itself: a dump, a marshal, a large string conversion, a computed summary. Do not guard a line that logs two fields you already have in hand — you have added a branch and a handler call to save one small allocation, and you have made the code harder to read. The honest way to settle it in a hot path is a benchmark with `-benchmem`, comparing `allocs/op` with and without the guard, rather than instinct. ## Two misconceptions worth naming The first is that the compiler removes calls below the configured level. It cannot: the level lives in a handler built at run time, possibly from configuration, and the call is a normal method call on an interface-holding struct. The second is that slog evaluates arguments lazily, pulling values only if the record survives. It does not. The value you pass is computed before the callee starts. Deferring the *work* requires either the explicit guard above or passing a value that knows how to produce itself later — and even then the value itself still has to be constructed and boxed at the call site.