context propagation

Observability

Meaning

Context propagation is the technique of carrying request-scoped data, cancellation signals, and deadlines alongside function calls. It solves the pain of losing coordination across asynchronous boundaries or service layers. Developers reach for it when they need to cancel work early, enforce timeouts, or share metadata like request IDs throughout a call chain.

Primary Function

Context management

Communicative Purpose

Ensures request-scoped values and cancellation signals are available across API boundaries.

Pattern

create Context → pass Context through function calls → extract values or cancellation

Core Structure

Context = (deadline, cancel, values)

Função primária

Context management

Propósito comunicativo

Ensures request-scoped values and cancellation signals are available across API boundaries.

Situações de gatilho

Web services: passing request IDs and timeouts through handler chains Distributed systems: propagating tracing spans across microservice calls CLI tools: canceling long‑running operations on user interrupt

Contextos

Go's context package, Java ThreadLocal, Python contextvars, async frameworks, microservice architectures

Padrão

create Context → pass Context through function calls → extract values or cancellation

Estrutura central

Context = (deadline, cancel, values)

Colocados típicos

middleware
request handlers
tracing libraries
cancellation tokens
dependency injection

Substituições comuns

ThreadLocal instead of explicit Context object (less explicit)
global variables (simpler but unsafe)
passing individual parameters separately (more verbose)

Erros comuns

Omitting the Context parameter in a downstream call → loss of cancellation capability; Using a single global Context for all requests → data leakage between requests; Forgetting to check Context cancellation → wasted work and delayed shutdown

Similar / contraste

Cancellation token (focuses only on aborting work) vs. Context (carries values, deadlines, and cancellation); ThreadLocal (implicit, thread‑bound) vs. explicit Context (explicit, portable across async tasks)

Interferências

Coming from JavaScript: assuming async functions automatically carry request metadata → need explicit Context propagation in Go or Python; Coming from C#: using ThreadStatic for request data → may break in async/await scenarios

Família do chunk

cancellation token
request ID propagation
tracing span
async timeout handling

Nuance

Do not use Context for large payloads; it is intended for small metadata and control signals. Propagating Context adds negligible overhead but excessive values can increase memory usage. Context cancellation is cooperative; if a callee ignores the signal, work continues.

Efeito pragmático

Correct use prevents resource leaks, enables graceful shutdown, and makes tracing and logging consistent across service boundaries.

Dica de memória

Think of Context as a courier that carries a sealed envelope (metadata and cancellation token) through every door of a building, ensuring every room knows when to stop work.

Nota

Context propagation is orthogonal to error handling; both should be combined for robust systems.

Upgrade path

Distributed tracing with OpenTelemetry

Frequência: HighFormulaicidade: FlexibleTipo de construção: conceptPrioridade de aquisição: Recognition firstPrioridade de output: BothTag de espaçamento: Medium-term

Examples

import contextvars request_id = contextvars.ContextVar('request_id') def handler(req): token = request_id.set(req.headers.get('X-Request-ID')) process(req) request_id.reset(token) def process(req): # downstream function can retrieve the same request_id without it being passed explicitly rid = request_id.get() print(f'Processing request {rid}') # Simulate a request class Req: pass req = Req() req.headers = {'X-Request-ID': 'abc123'} handler(req)

import asyncio import contextvars cancel_event = contextvars.ContextVar('cancel_event') async def long_task(): ev = cancel_event.get() for i in range(10): if ev.is_set(): print('Task cancelled') return await asyncio.sleep(0.5) print(f'Iteration {i}') async def main(): ev = asyncio.Event() cancel_event.set(ev) task = asyncio.create_task(long_task()) await asyncio.sleep(2) # let the task run a bit ev.set() # trigger cancellation await task asyncio.run(main())

from fastapi import FastAPI, Request, Depends import contextvars request_id = contextvars.ContextVar('request_id') app = FastAPI() def get_request_id(req: Request): rid = req.headers.get('X-Request-ID', 'unknown') request_id.set(rid) return rid @app.get('/') async def root(rid: str = Depends(get_request_id)): # downstream code can access request_id without passing it explicitly return {'request_id': request_id.get()}