fetch 0.13.0

HTTP client with resilience, observability, and Tokio runtime support.
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
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

//! Demonstrates the HTTP circuit breaker with per-origin isolation.
//!
//! This example uses a fake handler that returns 500 Internal Server Error for
//! requests to `https://failing.example.com` and 200 OK for requests to
//! `https://healthy.example.com`.
//!
//! 1. We send many requests to the failing host to trip its circuit breaker.
//! 2. Once the breaker is open, requests to the failing host are rejected
//!    immediately with a "circuit breaker open" error.
//! 3. Requests to the healthy host continue to succeed, demonstrating that
//!    breaker state is tracked per-origin (scheme + authority).

use std::time::Duration;

use fetch::fake::{FakeDeps, FakeHandler};
use fetch::{HttpClient, HttpResponseBuilder};
use http::StatusCode;
use ohno::ErrorExt;

const FAILING_HOST: &str = "https://failing.example.com";
const HEALTHY_HOST: &str = "https://healthy.example.com";

#[tokio::main]
async fn main() -> Result<(), ohno::AppError> {
    // Fake handler: 500 for the failing host, 200 for everything else.
    let fake_handler = FakeHandler::from_fn(|req| {
        let status = if req.uri().host() == Some("failing.example.com") {
            StatusCode::INTERNAL_SERVER_ERROR
        } else {
            StatusCode::OK
        };

        HttpResponseBuilder::new_fake().status(status).build()
    });

    let client = HttpClient::builder_fake(fake_handler, FakeDeps::default())
        .standard_pipeline(|pipeline, _| {
            pipeline
                // Disable retries so we can observe the breaker directly.
                .retry(|retry| retry.max_retry_attempts(0))
                // Lower thresholds so the breaker trips quickly in this demo.
                .breaker(|breaker| {
                    breaker
                        .min_throughput(5)
                        .failure_threshold(0.5)
                        .break_duration(Duration::from_secs(30))
                })
        })
        .build();

    // ---------------------------------------------------------------
    // Step 1: Send requests to the failing host to trip the breaker.
    // ---------------------------------------------------------------
    println!("--- Sending requests to {FAILING_HOST} (expect 500s) ---");

    for i in 1..=10 {
        let result = client.get(FAILING_HOST).fetch().await;
        match result {
            Ok(resp) => println!("  request {i}: {}", resp.status()),
            Err(e) => println!("  request {i}: error — {}", e.message()),
        }
    }

    // ---------------------------------------------------------------
    // Step 2: The breaker should now be open — next request is rejected
    //         immediately without reaching the handler.
    // ---------------------------------------------------------------
    println!("\n--- Breaker should be open for {FAILING_HOST} ---");

    let result = client.get(FAILING_HOST).fetch().await;
    match result {
        Ok(resp) => println!("  unexpected success: {}", resp.status()),
        Err(e) => println!("  rejected: {}", e.message()),
    }

    // ---------------------------------------------------------------
    // Step 3: Requests to the healthy host still succeed — the breaker
    //         for a different origin is independent.
    // ---------------------------------------------------------------
    println!("\n--- Sending request to {HEALTHY_HOST} (should succeed) ---");

    let response = client.get(HEALTHY_HOST).fetch().await?;
    println!("  response: {}", response.status());

    assert_eq!(
        response.status(),
        StatusCode::OK,
        "healthy host should not be affected by the failing host's breaker"
    );

    println!("\nDone — circuit breaker isolation between origins is working.");

    Ok(())
}