Recoverable

Recovery information and classification for resilience patterns.

This crate provides types for classifying conditions based on their recoverability state, enabling consistent recovery behavior across different error types and resilience middleware.

Recovery information describes whether retrying an operation might help, not whether the operation succeeded or failed. Both successful operations and permanent failures should use RecoveryInfo::never since recovery is not necessary or desirable.

Core Types

• RecoveryInfo: Classifies conditions as recoverable (transient) or non-recoverable (permanent/successful).
• Recovery: A trait for types that can provide their own recovery information.
• RecoveryKind: An enum representing the kind of recovery that can be attempted.

Examples

Classifying Errors

use recoverable::{Recovery, RecoveryInfo, RecoveryKind};

#[derive(Debug)]
enum DatabaseError {
    ConnectionTimeout,
    InvalidCredentials,
    TableNotFound,
}

impl Recovery for DatabaseError {
    fn recovery(&self) -> RecoveryInfo {
        match self {
            // Transient failure - might succeed if retried
            DatabaseError::ConnectionTimeout => RecoveryInfo::retry(),
            // Permanent failures - retrying won't help
            DatabaseError::InvalidCredentials => RecoveryInfo::never(),
            DatabaseError::TableNotFound => RecoveryInfo::never(),
        }
    }
}

let error = DatabaseError::ConnectionTimeout;
assert_eq!(error.recovery().kind(), RecoveryKind::Retry);

// Successful operations also use never() since retry is unnecessary
let success_result: Result<(), DatabaseError> = Ok(());

Retry Delay

You can specify when to retry an operation using the delay method:

use std::time::Duration;

use recoverable::{RecoveryInfo, RecoveryKind};

// Retry with a 30-second delay (e.g., from a Retry-After header)
let recovery = RecoveryInfo::retry().delay(Duration::from_secs(30));
assert_eq!(recovery.kind(), RecoveryKind::Retry);
assert_eq!(recovery.get_delay(), Some(Duration::from_secs(30)));

// Immediate retry
let immediate = RecoveryInfo::retry().delay(Duration::ZERO);
assert_eq!(immediate.get_delay(), Some(Duration::ZERO));