Explain how context propagation keeps a trace whole across an async boundary

OTel keeps the currently active span in a Context object. When you create a child span, the SDK reads the Context and links the new span to the active one. The challenge is that async code runs in pieces; a function might `await` a database call and resume later. The Context needs to be the same when the function resumes as when it paused. Each runtime has a carrier that handles this. **Python** uses `contextvars`. asyncio's event loop carries contextvars across `await` boundaries automatically, and from Python 3.11 onward `asyncio.create_task` does too. **Node** uses `AsyncLocalStorage`. The `@opentelemetry/context async hooks` package wires AsyncLocalStorage into the event loop so any `await` correctly preserves the active context. The trace breaks when code escapes these mechanisms. Spawning a raw `threading.Thread` in Python loses the context unless you call `contextvars.copy_context()` and run inside it. `ProcessPoolExecutor` always loses it because contextvars do not cross process boundaries. In Node, scheduling work directly on `process.nextTick` outside of an instrumented framework can lose AsyncLocalStorage if the instrumentation is not installed.

**The Context object is the carrier.** OTel's Context API stores the active span (and a few other values) keyed by typed accessors. Every child span creation reads the active Context to set its parent. **Python: contextvars.** The `contextvars` module provides `ContextVar` objects whose values are scoped per-task in asyncio. asyncio's event loop preserves contextvars across `await` automatically. `asyncio.create_task` copies the current context into the new task; in Python 3.11+ this is the default behavior, in earlier versions you sometimes needed `loop.create_task(coro, context=copy_context())`. Synchronous code shares the contextvars naturally because there is no task switch. **Node: AsyncLocalStorage.** Node's `AsyncLocalStorage` API ties values to the async resource graph (the chain of callbacks and promises that descend from a given operation). The `@opentelemetry/context async hooks` package registers a context manager that uses AsyncLocalStorage as the carrier. Any code that runs through standard `await`, Promise resolution, or setTimeout maintains the context. **Breakage patterns.** - Python: raw `threading.Thread.start()` (no contextvars across threads), `multiprocessing` and `ProcessPoolExecutor` (no contextvars across processes), `concurrent.futures.ThreadPoolExecutor` submitted without context copying. - Node: scheduling outside the instrumented event loop, e.g. native add-ons that callback through their own mechanism without AsyncLocalStorage support; some worker_threads patterns drop context. **The fix is explicit context copying.** `contextvars.copy_context()` in Python; `asyncLocalStorage.run(store, callback)` in Node. Standard OTel instrumentations for Celery, BullMQ, Kafka, and similar boundary-crossing libraries do this on your behalf, but custom wrappers need manual handling.