Crate tower_resilience_timelimiter 

Advanced timeout handling for Tower services.

Provides timeout functionality with:

• Configurable timeout duration (fixed or per-request)
• Optional future cancellation on timeout
• Event system for observability (onSuccess, onError, onTimeout)
• Metrics integration

Presets

use tower_resilience_timelimiter::TimeLimiterLayer;

let fast = TimeLimiterLayer::fast().build();        // 1s, cancel on timeout
let standard = TimeLimiterLayer::standard().build(); // 5s, cancel on timeout
let slow = TimeLimiterLayer::slow().build();         // 30s, cancel on timeout
let stream = TimeLimiterLayer::streaming().build();  // 60s, no cancellation

Presets return builders, so you can customize further:

use tower_resilience_timelimiter::TimeLimiterLayer;

let layer = TimeLimiterLayer::fast()
    .name("api-timeout")
    .on_timeout(|| eprintln!("Request timed out!"))
    .build();

Basic Example (Fixed Timeout - No Type Parameters!)

use tower_resilience_timelimiter::TimeLimiterLayer;
use tower::{Layer, service_fn};
use std::time::Duration;

// No type parameters needed for fixed timeout!
let layer = TimeLimiterLayer::builder()
    .timeout_duration(Duration::from_secs(5))
    .cancel_running_future(true)
    .on_timeout(|| {
        eprintln!("Request timed out!");
    })
    .build();

let svc = service_fn(|req: String| async move {
    Ok::<String, ()>(req)
});

let mut service = layer.layer(svc);

Per-Request Timeout

Extract timeout from the request itself for different SLAs:

use tower_resilience_timelimiter::TimeLimiterLayer;
use tower::{Layer, service_fn};
use std::time::Duration;

#[derive(Clone)]
struct MyRequest {
    operation: String,
    timeout_ms: Option<u64>,
}

// Types inferred from closure signature
let layer = TimeLimiterLayer::builder()
    .timeout_fn(|req: &MyRequest| {
        req.timeout_ms
            .map(Duration::from_millis)
            .unwrap_or(Duration::from_secs(5))
    })
    .build();

let svc = service_fn(|req: MyRequest| async move {
    Ok::<String, ()>(format!("Processed: {}", req.operation))
});

let mut service = layer.layer(svc);

Event Listeners

use tower_resilience_timelimiter::TimeLimiterLayer;
use std::time::Duration;

let layer = TimeLimiterLayer::builder()
    .timeout_duration(Duration::from_secs(5))
    .on_success(|duration| {
        println!("Call succeeded in {:?}", duration);
    })
    .on_error(|duration| {
        println!("Call failed after {:?}", duration);
    })
    .on_timeout(|| {
        println!("Call timed out");
    })
    .build();

Structs

DynamicTimeout

Dynamic timeout extracted from the request.

FixedTimeout

Fixed timeout that works with any request type.

TimeLimiter

A Tower service that applies timeout limiting to an inner service.

TimeLimiterConfig

Configuration for the time limiter pattern.

TimeLimiterConfigBuilder

Builder for configuring and constructing a time limiter.

TimeLimiterLayer

A Tower layer that applies time limiting to a service.

Enums

TimeLimiterError

Errors that can occur in the time limiter.

TimeLimiterEvent

Events emitted by the time limiter.

Traits

TimeoutFn

Trait for determining timeout duration from a request.