Retries, Timeouts & Backoff

async fn with_retry<F, Fut, T, E>(mut f: F, max: u32) -> Result<T, E>
where
    F: FnMut() -> Fut,
    Fut: std::future::Future<Output = Result<T, E>>,
{
    let mut attempt = 0;
    loop {
        match f().await {
            Ok(v) => return Ok(v),
            Err(e) if attempt >= max => return Err(e),
            Err(_) => {
                let delay = std::time::Duration::from_millis(100 * 2u64.pow(attempt));
                tokio::time::sleep(delay).await;
                attempt += 1;
            }
        }
    }
}

use reqwest::StatusCode;
use std::time::Duration;
 
async fn fetch_with_policy(client: &reqwest::Client, url: &str) -> Result<String, reqwest::Error> {
    let mut attempt = 0u32;
    loop {
        let result = client.get(url).send().await;
        match result {
            Ok(resp) if resp.status().is_success() => return resp.text().await,
            Ok(resp) if resp.status() == StatusCode::TOO_MANY_REQUESTS => {
                let retry_after = resp.headers()
                    .get("retry-after")
                    .and_then(|v| v.to_str().ok())
                    .and_then(|s| s.parse::<u64>().ok())
                    .unwrap_or(2u64.pow(attempt.min(5)));
                tokio::time::sleep(Duration::from_secs(retry_after)).await;
            }
            Ok(_) | Err(_) if attempt < 3 => {
                let base = 100u64 * 2u64.pow(attempt);
                let jitter = rand::random::<u64>() % 50;
                tokio::time::sleep(Duration::from_millis(base + jitter)).await;
            }
            Ok(resp) => return resp.error_for_status().map(|_| unreachable!()),
            Err(e) if e.is_timeout() && attempt < 3 => {}
            Err(e) => return Err(e),
        }
        attempt += 1;
    }
}

// reqwest-middleware + reqwest-retry crates for production policies