Axum Tokio Hierarchical CancellationToken Propagation Standard

--- description: Axum Tokio Hierarchical CancellationToken Propagation Standard - Enforces deterministic, tree-structured CancellationToken propagation across all asynchronous tasks spawned from Axum HTTP handlers. Ensures that client disconnections, upstream timeouts, or handler drops immediately cascade cancellation to detached futures, preventing zombie execution and resource starvation. Mandates child token derivation and select loop integration across all spawned Tokio background work. globs: src/**/*.rs alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/axum-tokio-cancellation-token-hierarchy-standard" --- # Axum Tokio Hierarchical CancellationToken Propagation Standard > **Severity**: CRITICAL | **Category**: backend > **Anti-Pattern Warning**: Orphaned Tokio Task Execution via Unmonitored Spawns During Client Disconnects ## System Constraints You are a Principal Rust Concurrency Architect enforcing Axum and Tokio async lifecycle invariants. You must mandate that no Axum handler spawns detached asynchronous tasks without deriving and attaching a child CancellationToken from the request scope. Ensure all background worker loops and secondary futures yield immediately upon token cancellation to guarantee zero-latency resource reclamation on HTTP connection drops. ## Strict Guidelines - Engineers MUST ALWAYS construct a request-scoped CancellationToken or derive a child token using `parent_token.child_token()` before invoking `tokio::spawn`. - Engineers MUST NOT spawn detached futures (`tokio::spawn`) within Axum handlers that rely solely on top-level runtime termination. - Code MUST monitor cancellation using `tokio::select!` against `token.cancelled()` across all I/O, heavy computation, and loop iterations within spawned tasks. - Services MUST implement RAII drop guards in Axum handlers to automatically trigger cancellation of derived child tokens when a client aborts the connection. - Background worker futures MUST NEVER ignore cancellation signals or suppress cleanup procedures when unwinding active transactions or locks. ## Bad vs Good Implementations ### Hierarchical Cancellation Propagation in Axum Handler #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: The spawned task is detached with no link to client connection lifecycle. If the client disconnects or times out, the background task continues executing 10,000 iterations, exhausting database connections and CPU cycles. ```rust use axum::{extract::State, http::StatusCode, response::IntoResponse}; use std::sync::Arc; pub async fn export_report_handler( State(state): State<Arc<AppState>>, ) -> impl IntoResponse { // ANTI-PATTERN: Spawning unmonitored background task with no link // to request lifecycle or hierarchical token. Client disconnection // leaves this task running indefinitely, leaking memory and DB pool connections. tokio::spawn(async move { for chunk_id in 0..10_000 { state.db.process_chunk(chunk_id).await; tokio::time::sleep(tokio::time::Duration::from_millis(50)).await; } }); StatusCode::ACCEPTED } ``` #### Production Standard (Correct) > **Standard**: Uses hierarchical CancellationToken propagation: a child token is derived from the app shutdown token and coupled with an RAII drop guard tied to the request scope. If the client drops the request or the app shuts down, the background task aborts immediately via biased select. ```rust use axum::{extract::State, http::StatusCode, response::IntoResponse}; use std::sync::Arc; use tokio_util::sync::{CancellationToken, DropGuard}; pub async fn export_report_handler( State(state): State<Arc<AppState>>, ) -> impl IntoResponse { // Create request-scoped token and an RAII drop guard to trigger on client abort let request_token = CancellationToken::new(); let _drop_guard: DropGuard = request_token.clone().drop_guard(); // Derive a child token hierarchically linked to root shutdown and request scope let child_token = state.app_token.child_token(); let task_token = request_token.child_token(); tokio::spawn(async move { for chunk_id in 0..10_000 { tokio::select! { biased; _ = child_token.cancelled() => { tracing::info!("Global shutdown initiated; aborting report generation."); break; } _ = task_token.cancelled() => { tracing::warn!("Client disconnected; aborting chunk processing immediately."); break; } result = state.db.process_chunk(chunk_id) => { if let Err(err) = result { tracing::error!(error = ?err, "Failed processing chunk"); break; } } } } }); StatusCode::ACCEPTED } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: Axum Tokio Hierarchical CancellationToken Propagation Standard

Axum Tokio Hierarchical CancellationToken Propagation Standard defines an industrial-grade behavioral standard for backend engineering. Enforces deterministic, tree-structured CancellationToken propagation across all asynchronous tasks spawned from Axum HTTP handlers. Ensures that client disconnections, upstream timeouts, or handler drops immediately cascade cancellation to detached futures, preventing zombie execution and resource starvation. Mandates child token derivation and select loop integration across all spawned Tokio background work. Modern software architectures require strict adherence to deterministic patterns to guarantee high availability, maintainability, and zero security vulnerabilities.

Framework Paradigm Shift & Drift MechanicsLLMs are trained on millions of open-source repositories containing outdated code, legacy idioms, and unpatched antipatterns. When coding assistants generate implementations for this stack, they default to common statistical tokens: Orphaned Tokio Task Execution via Unmonitored Spawns During Client Disconnects Without an explicit system instruction file, developers spend hours debugging silent failures.

Failure Modes & Production Blast Radius

Hazard Analysis: What Breaks Without This Rule

The following failure modes have been cataloged from hundreds of hours of production code reviews where AI assistants produced non-compliant implementations:

Failure Mode	AI Symptom (The Anti-Pattern)	Severity	Production Impact & Remedy
AI Hallucination & Deprecation Drift	Orphaned Tokio Task Execution via Unmonitored Spawns During Client Disconnects	Critical	Violating this industrial standard introduces regression bugs, security risks, and unexpected runtime failures in production. Enforce explicit behavioral system directives across all AI coding assistants in your repository.
Silent Architecture Inconsistency	AI assistants produce mixed paradigms across files, creating fragmented codebase conventions.	Medium	Increases cognitive load during code reviews and leads to maintenance debt across engineering teams. Pin project conventions in .cursor/rules, CLAUDE.md, and AGENTS.md so all team agents follow identical guardrails.

Architectural Directives in Detail

Step-by-Step Production Directives

Each rule constraint below is injected into the AI agent's system prompt to establish deterministic boundaries:

Engineers MUST ALWAYS construct a request-scoped CancellationToken or derive a child token using `parent_token.child_token()` before invoking `tokio

Engineers MUST ALWAYS construct a request-scoped CancellationToken or derive a child token using `parent_token.child_token()` before invoking `tokio::spawn`.

Rationale:AI models frequently generate unconstrained code here because statistical language distributions lack project-specific architectural context. Mandating this directive ensures that generated code adheres to verified industrial production requirements.