camber 0.1.6

Opinionated async Rust for IO-bound services on top of Tokio
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

#![cfg(feature = "profiling")]

mod common;

use camber::http::{Request, Response, Router};
use camber::{runtime, spawn};
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use std::time::Duration;

#[test]
fn profiling_endpoint_returns_flamegraph() {
    common::test_runtime()
        .shutdown_timeout(Duration::from_secs(3))
        .with_profiling()
        .run(|| {
            let mut router = Router::new();
            router.get("/hello", |_req: &Request| async {
                Response::text(200, "hello")
            });

            let addr = common::spawn_server(router);

            // Spawn multiple tasks that burn CPU while profiling captures samples.
            let running = Arc::new(AtomicBool::new(true));
            let mut workers = Vec::new();
            for _ in 0..4 {
                let flag = Arc::clone(&running);
                workers.push(spawn(move || {
                    let mut x = 0u64;
                    while flag.load(Ordering::Relaxed) {
                        for _ in 0..10_000 {
                            x = x.wrapping_mul(6364136223846793005).wrapping_add(1);
                        }
                    }
                    std::hint::black_box(x);
                }));
            }

            // Let workers saturate CPU before starting the profile capture
            std::thread::sleep(Duration::from_millis(200));

            // Request a 1-second CPU profile
            let resp = common::block_on(camber::http::get(&format!(
                "http://{addr}/debug/pprof/cpu?seconds=1"
            )))
            .unwrap();
            assert_eq!(resp.status(), 200);

            let body = resp.body();
            assert!(
                !body.is_empty(),
                "expected non-empty flamegraph SVG, got empty body"
            );

            // Stop the work-generating tasks
            running.store(false, Ordering::Relaxed);
            for w in workers {
                let _ = w.join();
            }

            runtime::request_shutdown();
        })
        .unwrap();
}