Axum 0.8 State Extraction and Tower Middleware Stack Production Invariants

--- description: Axum 0.8 State Extraction and Tower Middleware Stack Production Invariants - Mandates type-safe state injection via Axum 0.8 State extractors and FromRef modular sub-state derivation while strictly prohibiting untyped Extension usage for application context. Enforces deterministic Tower ServiceBuilder layer sequencing and mandatory CatchPanicLayer boundaries to guarantee zero unhandled thread panics across async runtimes. globs: src/**/*.rs alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/axum-0-8-state-tower-resilience-guardrail" --- # Axum 0.8 State Extraction and Tower Middleware Stack Production Invariants > **Severity**: CRITICAL | **Category**: backend > **Anti-Pattern Warning**: Untyped runtime Extension extraction coupled with unstructured Tower middleware ordering that drops panic barriers and leaks internal faults. ## System Constraints You are a Principal Rust Architect enforcing Axum 0.8 state extraction and Tower middleware orchestration. Mandate compile-time type-safe State extractors, FromRef sub-state composition, explicit ServiceBuilder ordering, and zero-panic runtime guarantees across all endpoints. ## Strict Guidelines - Engineers MUST ALWAYS use `axum::extract::State` with `FromRef` trait implementations for modular sub-state derivation instead of pulling monolithic application structs or using untyped `Extension`. - Engineers MUST NOT use `axum::extract::Extension` for core application state, database connection pools, or service clients; Extension is reserved strictly for request-scoped metadata derived by middleware (e.g., authenticated principal ID). - Routers MUST ALWAYS wrap global middleware using `tower::ServiceBuilder` placed after router composition, positioning `CatchPanicLayer` at the outer layer before `TraceLayer` to prevent unhandled runtime panics from aborting hyper transport streams. - Services MUST implement explicit custom `IntoResponse` rejections for fallible extractors (e.g., custom JSON or query parsers) to guarantee deterministic status codes and structured errors rather than Axum default unhandled 500 responses. - Handlers MUST NEVER perform direct synchronous, blocking I/O (e.g., `std::fs`, `std::sync::Mutex`) within async Axum handler contexts; all shared mutable state MUST utilize `tokio::sync` primitives or offload to `tokio::task::spawn_blocking`. ## Bad vs Good Implementations ### Type-Safe State Composition and Tower Middleware Ordering #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Using Extension defers type resolution to runtime, causing handlers to panic with an unhandled 500 error if the extension is missing. The route also lacks a panic recovery layer and exposes the entire monolithic state struct to leaf handlers. ```rust use axum::{extract::Extension, routing::get, Router}; use std::sync::Arc; #[derive(Clone)] struct AppState { db_pool: String, } // ANTI-PATTERN: Extension fails at runtime if unregistered, // no panic catch layer, unhandled runtime drop risks. async fn get_db(Extension(state): Extension<Arc<AppState>>) -> String { state.db_pool.clone() } pub fn app() -> Router { let state = Arc::new(AppState { db_pool: "postgres://...".into() }); Router::new() .route("/data", get(get_db)) .layer(Extension(state)) } ``` #### Production Standard (Correct) > **Standard**: State is verified at compile-time via Axum 0.8 State and FromRef sub-states. Tower middleware is correctly composed via ServiceBuilder with CatchPanicLayer at the boundary to ensure panic safety, preventing socket resets on unexpected panics. ```rust use axum::{ extract::{FromRef, State}, http::StatusCode, response::{IntoResponse, Response}, routing::get, Router, }; use std::sync::Arc; use tower::ServiceBuilder; use tower_http::{catch_panic::CatchPanicLayer, trace::TraceLayer}; #[derive(Clone)] pub struct AppState { pub db_pool: Arc<String>, pub cache_pool: Arc<String>, } // Modular sub-state derivation via FromRef impl FromRef<AppState> for Arc<String> { fn from_ref(state: &AppState) -> Self { state.db_pool.clone() } } // Handler only binds to the exact dependency it requires async fn get_db(State(pool): State<Arc<String>>) -> Result<String, AppError> { Ok((*pool).clone()) } enum AppError { Internal, } impl IntoResponse for AppError { fn into_response(self) -> Response { (StatusCode::INTERNAL_SERVER_ERROR, "internal server error").into_response() } } pub fn app() -> Router { let state = AppState { db_pool: Arc::new("postgres://...".into()), cache_pool: Arc::new("redis://...".into()), }; Router::new() .route("/data", get(get_db)) .layer( ServiceBuilder::new() .layer(CatchPanicLayer::new()) .layer(TraceLayer::new_for_http()), ) .with_state(state) } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: Axum 0.8 State Extraction and Tower Middleware Stack Production Invariants

Axum 0.8 State Extraction and Tower Middleware Stack Production Invariants defines an industrial-grade behavioral standard for backend engineering. Mandates type-safe state injection via Axum 0.8 State extractors and FromRef modular sub-state derivation while strictly prohibiting untyped Extension usage for application context. Enforces deterministic Tower ServiceBuilder layer sequencing and mandatory CatchPanicLayer boundaries to guarantee zero unhandled thread panics across async runtimes. 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: Untyped runtime Extension extraction coupled with unstructured Tower middleware ordering that drops panic barriers and leaks internal faults. 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	Untyped runtime Extension extraction coupled with unstructured Tower middleware ordering that drops panic barriers and leaks internal faults.	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 use `axum

Engineers MUST ALWAYS use `axum::extract::State` with `FromRef` trait implementations for modular sub-state derivation instead of pulling monolithic application structs or using untyped `Extension`.

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.