Struct RequestIdMiddleware 

pub struct RequestIdMiddleware { /* private fields */ }

Middleware that adds unique request IDs to requests and responses.

This middleware:

1. Checks for an existing X-Request-ID header from the client
2. If present and valid, uses it; otherwise generates a new ID
3. Stores the ID in request extensions for handlers to access
4. Adds the ID to response headers

Example

use fastapi_core::middleware::RequestIdMiddleware;

let mut stack = MiddlewareStack::new();
stack.push(RequestIdMiddleware::new());

// In your handler:
async fn handler(ctx: &RequestContext, req: &Request) -> Response {
    if let Some(request_id) = req.get_extension::<RequestId>() {
        println!("Request ID: {}", request_id);
    }
    Response::ok()
}

Implementations

impl RequestIdMiddleware

pub fn new() -> RequestIdMiddleware

Creates a new request ID middleware with default configuration.

Examples found in repository

examples/getting_started.rs (line 77)

fn main() {
    println!("Getting Started Guide - Code Validation\n");

    // === Basic App Example ===
    println!("1. Basic app with two routes:");
    let app = App::builder()
        .get("/", hello)
        .get("/health", health)
        .build();

    println!("   Routes: {}", app.route_count());
    let client = TestClient::new(app);

    let response = client.get("/").send();
    println!(
        "   GET / -> {} ({})",
        response.status().as_u16(),
        response.text()
    );
    if !check_eq(response.status().as_u16(), 200, "GET / should return 200") {
        return;
    }
    if !check_eq(response.text(), "Hello, World!", "GET / should return body") {
        return;
    }

    let response = client.get("/health").send();
    println!(
        "   GET /health -> {} ({})",
        response.status().as_u16(),
        response.text()
    );
    if !check_eq(
        response.status().as_u16(),
        200,
        "GET /health should return 200",
    ) {
        return;
    }

    // === App with Middleware ===
    println!("\n2. App with middleware:");
    let app = App::builder()
        .middleware(RequestIdMiddleware::new())
        .middleware(SecurityHeaders::new())
        .get("/", hello)
        .build();

    let client = TestClient::new(app);
    let response = client.get("/").send();
    println!("   GET / -> {}", response.status().as_u16());
    if !check_eq(
        response.status().as_u16(),
        200,
        "GET / with middleware should return 200",
    ) {
        return;
    }

    // === App with Configuration ===
    println!("\n3. App with configuration:");
    let config = AppConfig::new()
        .name("My API")
        .version("1.0.0")
        .debug(true)
        .max_body_size(10 * 1024 * 1024)
        .request_timeout_ms(30_000);

    let app = App::builder().config(config).get("/", hello).build();

    println!("   App name: {}", app.config().name);
    println!("   Version: {}", app.config().version);
    if !check_eq(
        app.config().name.as_str(),
        "My API",
        "Config name should match",
    ) {
        return;
    }
    if !check_eq(
        app.config().version.as_str(),
        "1.0.0",
        "Config version should match",
    ) {
        return;
    }

    // === 404 for unknown routes ===
    println!("\n4. 404 for unknown routes:");
    let app = App::builder().get("/", hello).build();

    let client = TestClient::new(app);
    let response = client.get("/nonexistent").send();
    println!("   GET /nonexistent -> {}", response.status().as_u16());
    if !check_eq(
        response.status().as_u16(),
        404,
        "Unknown routes should return 404",
    ) {
        return;
    }

    println!("\nAll getting started examples validated successfully!");
}

pub fn with_config(config: RequestIdConfig) -> RequestIdMiddleware

Creates a new request ID middleware with the given configuration.

Trait Implementations

impl Clone for RequestIdMiddleware

fn clone(&self) -> RequestIdMiddleware

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RequestIdMiddleware

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for RequestIdMiddleware

fn default() -> RequestIdMiddleware

Returns the “default value” for a type.

impl Middleware for RequestIdMiddleware

fn before<'a>( &'a self, _ctx: &'a RequestContext, req: &'a mut Request, ) -> Pin<Box<dyn Future<Output = ControlFlow> + Send + 'a>>

Called before the handler executes.

fn after<'a>( &'a self, _ctx: &'a RequestContext, req: &'a Request, response: Response, ) -> Pin<Box<dyn Future<Output = Response> + Send + 'a>>

Called after the handler executes.

fn name(&self) -> &'static str

Returns the middleware name for debugging and logging.