Why does calling inspect.stack() in a per-document logging helper blow a rebuilder's latency budget?

`inspect.stack()` looks like a cheap accessor and is not. It walks from the caller's frame all the way to the top of the stack and builds a record for *every* frame on the way, regardless of how many you intended to look at. Each record carries the frame itself, the filename, the line number, the function name, and — with the default `context` of 1 — the **source line**, which is fetched through the standard library's line cache. The first time a given file is touched that cache reads and stores the whole file, and subsequent lookups still stat the file to check the cache is valid. So one call costs: object construction proportional to stack depth, plus filesystem work per distinct source file, plus the garbage that all of it becomes a moment later. Measured on a stack roughly 35 frames deep, on CPython 3.14: `inspect.stack()` runs about 0.3 ms per call, `inspect.stack(0)` — the same walk with source lookup disabled — about 0.14 ms, and `sys._getframe(1)` about 0.00003 ms. Four orders of magnitude separate "tell me my caller" from "give me the entire stack". ### Why the rebuilder's tail latency is where it shows A per-document logging helper on a search-index rebuild runs once per document, and a 92nd-percentile budget is decided by the slow calls, not the median. Three things push `inspect.stack()` into the tail specifically. Stack depth is not constant: a document that goes through the deep path — nested enrichment, a retry wrapper, a few decorators — pays for more frames than the shallow path, so cost correlates with exactly the documents that were already slowest. Source-line lookups miss the cache whenever a new module appears in the walk, turning a CPU cost into a filesystem cost at unpredictable moments. And the churn — thousands of short-lived records and tuples per second — raises collection pressure, which lands as pauses rather than as uniformly slower calls. There is a second, worse failure mode on the rollback path. Every record holds a live reference to a frame, and each frame holds its locals and, through `f_back`, the frames outward from it. If the partial-failure handler captures the stack and stores it — on an error object, in a retry queue, in a structured log buffer waiting to be flushed — it pins the locals of every function on that stack, which during a rebuild means the partially built batch each of those functions was holding. Memory climbs precisely while you are unwinding and trying to free things. Capturing stacks for diagnostics and then holding them is a well-worn way to turn a recoverable failure into an out-of-memory one. ### What to do instead **Use the narrow tool.** If you want the caller, take `sys._getframe(1)` (or `inspect.currentframe().f_back`) and read the two or three things you need — `f_code.co_name`, `f_lineno`, `f_globals["__name__"]` — into plain strings. It is a pointer hop plus attribute reads, it is not depth-dependent, and it retains nothing once the strings are extracted. **Let the logging library do it.** Standard logging already resolves the call site, does it only for records that pass the level check, and accepts a `stacklevel` argument so a wrapper can say how many of its own frames to skip. That removes both the frame walk and the off-by-one bug from your code. If you only need module attribution, a module-level logger named `__name__` costs nothing at call time at all. **Drop the source lookup when you do need a walk.** Passing `0` as the context argument to `inspect.stack()` skips the per-frame source read and roughly halves the cost. It is still O(depth). **Move the walk to the cold path.** Full stack capture is a reasonable thing to do once per failure — a rollback that fires rarely can afford 0.3 ms and the diagnostic is worth it. It is not a reasonable thing to do once per document. The general principle: pay introspection cost per *event you care about*, never per unit of throughput. **Never store frames.** Extract strings at capture time. If a frame must be held briefly, `clear()` it when done to drop its local references. The interview point behind all of this is the habit, not the number: before putting an introspection call in a hot path, ask what it costs and what it *retains*. Frame walking answers both badly.