Struct RequestIdMiddleware 

pub struct RequestIdMiddleware { /* private fields */ }

HTTP Request ID middleware for distributed tracing and request correlation.

This middleware automatically assigns unique identifiers to HTTP requests, enabling better debugging, logging, and distributed tracing capabilities.

Behavior

1. Request Processing:

   • Checks for existing X-Request-ID header from client
   • Validates existing ID format and length
   • Generates new ID if missing or invalid
   • Sets ID in request context for downstream use

2. Response Processing:

   • Always includes X-Request-ID header in response
   • Enables client-side request correlation
   • Supports debugging and audit trails

Security Considerations

• Request IDs are limited to 200 characters maximum
• Only ASCII alphanumeric and safe characters allowed
• Invalid IDs are replaced with server-generated ones

Examples

Basic Usage

use ignitia::{Router, RequestIdMiddleware};

let app = Router::new()
    .middleware(RequestIdMiddleware::new())
    .get("/health", || async {
        // Request ID available in tracing spans automatically
        ignitia::Response::text("OK")
    });

Custom Configuration

use ignitia::{RequestIdMiddleware, IdGenerator};

let request_id_mw = RequestIdMiddleware::new()
    .with_generator(IdGenerator::NanoId { length: 16 })
    .with_header_name("x-trace-id")
    .with_validation(true);

With Logging Integration

use ignitia::{RequestIdMiddleware, LoggerMiddleware};

let app = Router::new()
    .middleware(RequestIdMiddleware::new())  // Must come first
    .middleware(LoggerMiddleware::new())     // Will include request ID
    .get("/api/data", handler);

Implementations

impl RequestIdMiddleware

pub fn new() -> Self

Creates a new RequestIdMiddleware with default settings.

This is equivalent to calling RequestIdMiddleware::default().

pub fn with_generator(self, generator: IdGenerator) -> Self

Sets the ID generation strategy.

Parameters

• generator - The ID generation strategy to use

Examples

use ignitia::{RequestIdMiddleware, IdGenerator};

// Use shorter NanoIDs
let middleware = RequestIdMiddleware::new()
    .with_generator(IdGenerator::NanoId { length: 12 });

// Use custom generator
let middleware = RequestIdMiddleware::new()
    .with_generator(IdGenerator::Custom(|| {
        format!("req_{}", chrono::Utc::now().timestamp_millis())
    }));

pub fn with_header_name(self, header_name: &str) -> Self

Sets the header name for the request ID.

Parameters

• header_name - The HTTP header name to use

Examples

use ignitia::RequestIdMiddleware;

// Use custom header name
let middleware = RequestIdMiddleware::new()
    .with_header_name("x-trace-id");

// Use correlation ID header
let middleware = RequestIdMiddleware::new()
    .with_header_name("x-correlation-id");

pub fn with_validation(self, validate: bool) -> Self

Enables or disables validation of incoming request IDs.

When enabled, incoming request IDs are validated for format and length. Invalid IDs are replaced with server-generated ones.

Parameters

• validate - Whether to validate incoming request IDs

Examples

use ignitia::RequestIdMiddleware;

// Trust all client-provided request IDs
let middleware = RequestIdMiddleware::new()
    .with_validation(false);

pub fn with_logging(self, enable: bool) -> Self

Enables or disables structured logging integration.

When enabled, request IDs are automatically included in log spans.

Parameters

• enable - Whether to enable logging integration

impl RequestIdMiddleware

pub fn for_microservices() -> Self

Creates request ID middleware optimized for microservices.

This configuration is designed for distributed systems:

• Short NanoID for reduced header size
• Standard X-Request-ID header
• Strict validation enabled
• Logging enabled for observability

Examples

use ignitia::{Router, RequestIdMiddleware};

let api = Router::new()
    .middleware(RequestIdMiddleware::for_microservices())request_id.rs
    .get("/api/users", get_users_handler);

pub fn for_development() -> Self

Creates request ID middleware for development and debugging.

This configuration prioritizes debugging convenience:

• UUID for maximum uniqueness
• Custom trace header
• Relaxed validation
• Verbose logging

Examples

use ignitia::{Router, RequestIdMiddleware};

let dev_app = Router::new()
    .middleware(RequestIdMiddleware::for_development())
    .get("/debug", debug_handler);

pub fn for_performance() -> Self

Creates request ID middleware for high-performance scenarios.

This configuration minimizes overhead:

• Short NanoID for performance
• Minimal validation
• Reduced logging

Examples

use ignitia::{Router, RequestIdMiddleware};

let fast_api = Router::new()
    .middleware(RequestIdMiddleware::for_performance())
    .get("/api/fast", fast_handler);

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

Formats the value using the given formatter.

impl Default for RequestIdMiddleware

fn default() -> Self

Creates a new RequestIdMiddleware with sensible defaults.

Default Configuration

• Generator: UUID v4
• Header: “x-request-id”
• Validation: Enabled
• Logging: Enabled

Examples

use ignitia::RequestIdMiddleware;

let middleware = RequestIdMiddleware::default();
// Equivalent to:
let middleware = RequestIdMiddleware::new();

impl Middleware for RequestIdMiddleware

fn handle<'life0, 'async_trait>( &'life0 self, req: Request, next: Next, ) -> Pin<Box<dyn Future<Output = Response> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Process a request and optionally pass it to the next middleware.