execution-policy 0.0.3

Closure-first, runtime-light reliability policies (retry, timeout, circuit breaking, bounded concurrency, retry budgets) for any async Rust operation.
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

//! Happy-path overhead + structural-size guards.
//!
//! Run with: `cargo bench --features test-util`

use std::hint::black_box;
use std::time::Duration;

use criterion::{Criterion, criterion_group, criterion_main};
use execution_policy::core::{ManualClock, TestCore};
use execution_policy::{ExecutionError, ExecutionPolicyBuilder, Retry};

fn happy_path(c: &mut Criterion) {
    let rt = tokio::runtime::Builder::new_current_thread()
        .build()
        .unwrap();

    c.bench_function("run/success/no-policy", |b| {
        let core = TestCore::new(ManualClock::new());
        let policy = ExecutionPolicyBuilder::<u32, &str>::new()
            .retry(Retry::none())
            .build_with(core);
        b.to_async(&rt).iter(|| async {
            let v = policy
                .run(async || Ok::<_, &str>(black_box(7u32)))
                .await
                .unwrap();
            black_box(v);
        });
    });

    c.bench_function("execute/success/full-policy", |b| {
        let core = TestCore::new(ManualClock::new());
        let policy = ExecutionPolicyBuilder::<u32, &str>::new()
            .retry(Retry::exponential().max_attempts(4))
            .attempt_timeout(Duration::from_secs(5))
            .total_timeout(Duration::from_secs(30))
            .build_with(core);
        b.to_async(&rt).iter(|| async {
            let v = policy
                .execute(async |_a| Ok::<_, &str>(black_box(7u32)))
                .await
                .unwrap();
            black_box(v);
        });
    });
}

fn structural_sizes(_c: &mut Criterion) {
    // Guard: ExecutionError stays small (Box<ErrorContext>), so the hot Result
    // does not bloat. These assert at bench time; failures are loud regressions.
    let err = size_of::<ExecutionError<std::io::Error>>();
    let res = size_of::<Result<u32, ExecutionError<std::io::Error>>>();
    assert!(
        err <= 32,
        "ExecutionError<io::Error> grew to {err} bytes (expected <= 32)"
    );
    assert!(
        res <= 32,
        "Result<u32, ExecutionError> grew to {res} bytes (expected <= 32)"
    );
    eprintln!("size_of ExecutionError<io::Error> = {err}, Result = {res}");
}

criterion_group!(benches, structural_sizes, happy_path);
criterion_main!(benches);