Struct ProcessingTimeoutMiddleware 

pub struct ProcessingTimeoutMiddleware { /* private fields */ }

Middleware that enforces a processing timeout on message handling.

This middleware wraps message processing with tokio::time::timeout to ensure that messages don’t exceed a maximum processing time. If processing exceeds the timeout, the message is negative-acknowledged (nacked) with requeue before the broker’s consumer timeout can kill the connection.

Why This Matters

Message brokers like RabbitMQ have consumer timeouts (default 30 seconds). If a worker receives a message but doesn’t ack/nack within that window, the broker assumes the consumer is dead and closes the channel with a PRECONDITION_FAILED error.

This middleware prevents that by enforcing a timeout shorter than the broker’s timeout, ensuring graceful nack with proper error handling.

Example

use foxtive_worker::ProcessingTimeoutMiddleware;
use std::time::Duration;

// Enforce 25-second timeout (less than RabbitMQ's 30s default)
let middleware = ProcessingTimeoutMiddleware::new(Duration::from_secs(25));

Architecture

The middleware uses tokio::time::timeout which does NOT spawn detached tasks. It runs the future inline and cancels it if the timeout expires. This maintains controlled concurrency without unbounded task spawning.

Message → [Timeout Check] → [Next Handler] → Result
             ↓ (if timeout)
          Nack + Error

Implementations

impl ProcessingTimeoutMiddleware

pub fn new(timeout: Duration) -> Self

Create a new processing timeout middleware.

Arguments

• timeout - Maximum time allowed for message processing

Panics

Panics if timeout is zero

pub fn timeout(&self) -> Duration

Get the configured timeout duration.

Trait Implementations

impl Clone for ProcessingTimeoutMiddleware

fn clone(&self) -> ProcessingTimeoutMiddleware

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProcessingTimeoutMiddleware

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

Formats the value using the given formatter.

impl Middleware for ProcessingTimeoutMiddleware

fn name(&self) -> &str

Get the name of this middleware for debugging and logging.

fn handle<'life0, 'async_trait>( &'life0 self, message: ReceivedMessage<Value>, next: Box<dyn MessageHandler>, ) -> Pin<Box<dyn Future<Output = Result<MiddlewareResult, WorkerError>> + Send + 'async_trait>>

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

Process a message with access to the next handler in the chain.