In a web framework, how can a service deep in the call chain read request-scoped values without receiving them as parameters?

## The problem: the value is five frames away A request arrives, an early stage resolves who the caller is, and a service three or four calls beneath the handler needs that fact — to filter a query by tenant, to stamp an audit row, to decide an authorization outcome. The service never received it, because every function between the handler and it would have had to declare and forward a parameter it does not itself care about. Frameworks answer this with **ambient (implicit) context**: a value that is bound to the current unit of execution when the request starts and read by any code running inside that unit, without appearing in a single signature. ## The three mechanisms you should be able to name 1. **Storage bound to the current thread of execution.** In a framework that dedicates one thread to a request for its whole duration, a value written to a per-thread slot on entry is readable by anything that thread later calls. The framework sets it in an early stage and clears it when the request ends; clearing matters because worker threads are reused. 2. **Context carried by the asynchronous runtime.** Where a request is not pinned to one thread, the per-thread trick fails at the first suspension or callback boundary. Such runtimes instead offer a context value attached to the logical task, which the runtime re-establishes each time the task resumes — possibly on a different thread — and which child tasks inherit at creation. 3. **A resolving accessor injected as a long-lived object.** The service is given, once at construction, an object that is not the request but a *resolver*: every call on it looks up the current request's instance from whatever ambient mechanism the framework uses, and forwards. The service's signature never mentions the request, yet each call sees the right one. The alternative is **explicit context**: a first parameter carrying the request-scoped facts, threaded through every layer by hand. ## What each style costs | Style | What a reader sees | Breaks when | Testing | |---|---|---|---| | Implicit ambient context | nothing in the signature | execution leaves the managed unit | needs the ambient value established first | | Resolving accessor | a dependency, not the value | called outside any request | needs a stub resolver | | Explicit parameter | the dependency, exactly | never silently — it fails to compile or is obviously null | pass a value and call | Implicit context buys **reach** — code that was never designed to know about requests can still be correct — and pays with **invisibility**. The dependency is not in the signature, so nothing warns you when the function is called from a place where no context exists; the failure is a null, an empty value, or, worse, a stale one, discovered at runtime. ## Where implicit context stops working - Work handed to a separate executor or scheduler, which is not the unit the value was bound to. - Continuations that resume elsewhere, if the runtime's context mechanism is not used or not propagated. - Anything that runs after the request completes, when the framework has cleared the binding. - Code called from startup, a scheduled job, or a message consumer — paths that have no request at all and will read an empty context rather than fail loudly. ## A practical division - Use ambient context for **cross-cutting infrastructure facts** that every layer might want and no layer wants to forward: correlation identifiers, caller identity, tenant, locale. - Pass **explicitly** anything a function's own logic is about. If removing a parameter only removes it from the signature and not from the behaviour, the function still depends on it — now invisibly. - At the boundary, **read once and convert**: the outermost application layer reads the ambient value and passes it down as ordinary arguments, so the core stays free of ambient lookups and is trivial to test. - Make the read **fail loudly** where absence is a bug, rather than returning a silent default that turns a missing binding into wrong data. Whichever mechanism a framework uses, the mental model is the same: the value is not travelling in your call chain, it is travelling in the runtime's notion of "the work currently in progress". Reasoning about where that notion ends is the whole skill.