reqx 0.1.35

Rust HTTP transport client for API SDK libraries with retry, timeout, idempotency, proxy, and pluggable TLS backends
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

use std::time::Duration;

use reqx::advanced::{
    AdaptiveConcurrencyPolicy, CircuitBreakerPolicy, RetryBudgetPolicy, TimeoutPhase,
    TransportErrorKind,
};
use reqx::prelude::{Client, RetryPolicy};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::builder("https://api.example.com")
        .client_name("resilience-demo")
        .request_timeout(Duration::from_secs(3))
        .total_timeout(Duration::from_secs(10))
        .retry_policy(
            RetryPolicy::standard()
                .max_attempts(5)
                .base_backoff(Duration::from_millis(100))
                .max_backoff(Duration::from_millis(800))
                .jitter_ratio(0.1)
                .retryable_transport_error_kinds([
                    TransportErrorKind::Connect,
                    TransportErrorKind::Read,
                    TransportErrorKind::Dns,
                ])
                .retryable_timeout_phases([TimeoutPhase::Transport, TimeoutPhase::ResponseBody])
                .status_retry_window(429, 5)
                .status_retry_window(503, 4)
                .timeout_retry_window(TimeoutPhase::ResponseBody, 2)
                .transport_retry_window(TransportErrorKind::Dns, 2)
                .response_body_read_retry_window(2),
        )
        .retry_budget_policy(
            RetryBudgetPolicy::standard()
                .window(Duration::from_secs(10))
                .retry_ratio(0.2)
                .min_retries_per_window(2),
        )
        .circuit_breaker_policy(
            CircuitBreakerPolicy::standard()
                .failure_threshold(5)
                .open_timeout(Duration::from_secs(10))
                .half_open_max_requests(2)
                .half_open_success_threshold(2),
        )
        .adaptive_concurrency_policy(
            AdaptiveConcurrencyPolicy::standard()
                .min_limit(2)
                .initial_limit(8)
                .max_limit(64)
                .increase_step(1)
                .decrease_ratio(0.8)
                .high_latency_threshold(Duration::from_millis(250)),
        )
        .build()?;

    let response = client.get("/v1/health").send().await?;
    println!("status={}", response.status());
    Ok(())
}