What does (*http.Request).WithContext return, and why must middleware pass on that copy?

## The field you cannot assign An `*http.Request` carries its `context.Context` in an unexported field. You can read it with `r.Context()` — documented to always return non-nil, defaulting to the background context — but you cannot write `r.ctx = ...` from outside `net/http`. The supported way to attach a context is: ```go func (r *Request) WithContext(ctx context.Context) *Request ``` Its implementation is short: it panics if `ctx` is nil, allocates a fresh `Request`, does `*r2 = *r` to copy every field, overwrites the context on the copy, and returns `r2`. Two consequences follow directly, and interviewers probe both. **It returns a value; it does not mutate.** The request you were handed is exactly as it was. If you drop the result, nothing you attached exists anywhere your chain can reach. **The copy is shallow.** `*r2 = *r` copies the struct fields, which means the copy shares the same `Header` map, the same `*url.URL`, the same `Body` reader and the same form values as the original. Only the context differs. That is fine when all you are doing is attaching a value; it matters the moment you also want to modify headers, which is what `(*http.Request).Clone` exists for. ## The bug this produces in a multi-tenant service A middleware resolves the tenant for each request and attaches it so downstream handlers can scope their queries: ```go type tenantKey struct{} func withTenant(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { ctx := context.WithValue(r.Context(), tenantKey{}, resolveTenant(r)) r.WithContext(ctx) // result discarded next.ServeHTTP(w, r) // the ORIGINAL request }) } ``` Go lets a call stand alone as a statement, so discarding the returned `*Request` is legal code. There is no compiler error and no standard `go vet` check that flags it. Everything builds, the middleware runs, and the inner handler logs `tenant=""` because `r.Context().Value(tenantKey{})` walks a chain that never had the key and returns nil, which a comma-ok string assertion turns into the empty string. In a multi-tenant service that empty string is dangerous rather than merely wrong: a query scoped to `""` either returns nothing or, if some layer treats empty as "all", returns another tenant's rows. The symptom that reaches the engineer on call is a cross-tenant data mix-up; the cause is one missing assignment. The correct middleware differs by six characters: ```go r = r.WithContext(ctx) next.ServeHTTP(w, r) ``` Or, avoiding the shadowing question entirely, `next.ServeHTTP(w, r.WithContext(ctx))`. ## Why the design is a copy rather than a setter A `context.Context` is immutable by design: every derivation — `WithValue`, `WithCancel`, `WithTimeout` — produces a new context that points at its parent. Values flow downward from parent to child and are never inserted into an existing context. Making the request follow the same rule keeps the two consistent: an outer frame's request and context are stable no matter what the frames below it derive. It also keeps the handler chain safe to reason about, because a middleware cannot reach back and alter the request an outer middleware still holds and will use after `next.ServeHTTP` returns. The cost of that design is exactly the mistake above: the caller has to thread the new value through by hand, and forgetting to do so fails silently instead of loudly. ## Practical points - Reassign the local variable (`r = r.WithContext(ctx)`) at the top of your handler func, before any code that might use `r`, so there is no window in which some lines see the old request and some the new one. - Do the same in a handler, not just in middleware — attaching a deadline-free value or deriving a context inside a handler and then passing the old `r` to a helper has the identical failure mode. - Never pass nil: `r.WithContext(nil)` panics. If you have no context of your own, derive from `r.Context()`. - If the middleware also needs to change headers or the URL for the downstream handler, `WithContext` is the wrong tool, because the shallow copy shares those maps with the caller's request; `Clone` deep-copies them. - Keep whatever you attach request-scoped. A value that belongs to one request must live on that request's context and nowhere longer-lived, or two concurrent requests will read each other's data.