hotpath 0.9.0

Simple Rust profiler with memory and async data-flow insights - quickly find and debug performance bottlenecks.
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

#[cfg(test)]
pub mod tests {
    use hotpath::threads::ThreadsJson;
    use std::process::Command;
    use std::thread::sleep;
    use std::time::Duration;

    #[test]
    fn test_threads_endpoint() {
        let mut child = Command::new("cargo")
            .args([
                "run",
                "-p",
                "test-tokio-async",
                "--example",
                "basic",
                "--features",
                "hotpath",
            ])
            .env("HOTPATH_HTTP_PORT", "6775")
            .env("TEST_SLEEP_SECONDS", "10")
            .spawn()
            .expect("Failed to spawn command");

        let mut json_text = String::new();
        let mut last_error = None;

        // Test /threads endpoint
        for _attempt in 0..30 {
            sleep(Duration::from_millis(1000));

            match ureq::get("http://127.0.0.1:6775/threads").call() {
                Ok(mut response) => {
                    json_text = response
                        .body_mut()
                        .read_to_string()
                        .expect("Failed to read response body");
                    last_error = None;
                    break;
                }
                Err(e) => {
                    last_error = Some(format!("Request error: {}", e));
                }
            }
        }

        if let Some(error) = last_error {
            let _ = child.kill();
            panic!("Failed after 30 retries: {}", error);
        }

        // Parse JSON response
        let threads_response: ThreadsJson =
            serde_json::from_str(&json_text).expect("Failed to parse threads JSON");

        // Assert we have at least some threads
        assert!(
            threads_response.thread_count > 0,
            "Expected at least 1 thread, got {}",
            threads_response.thread_count
        );

        assert_eq!(
            threads_response.thread_count,
            threads_response.threads.len(),
            "thread_count should match threads.len()"
        );

        let hp_threads: Vec<_> = threads_response
            .threads
            .iter()
            .filter(|t| t.name.starts_with("hp-"))
            .collect();

        assert!(
            !hp_threads.is_empty(),
            "Expected at least one hp- thread, found none. Threads: {:?}",
            threads_response
                .threads
                .iter()
                .map(|t| &t.name)
                .collect::<Vec<_>>()
        );

        for thread in &threads_response.threads {
            assert!(thread.os_tid > 0, "Thread should have valid os_tid");
            assert!(thread.cpu_total >= 0.0, "CPU total should be non-negative");
        }

        let _ = child.kill();
        let _ = child.wait();
    }
}