hotpath 0.15.0

Simple async Rust profiler with memory and 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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

#[cfg(test)]
pub mod tests {
    use serde_json::Value;
    use std::process::Command;

    fn run_all_guards_json(features: &str, report: &str) -> Value {
        let output = Command::new("cargo")
            .env("HOTPATH_OUTPUT_FORMAT", "json")
            .env("HOTPATH_REPORT", report)
            .env("HOTPATH_METRICS_SERVER_OFF", "true")
            .args([
                "run",
                "-p",
                "test-smol-async",
                "--example",
                "all_guards",
                "--features",
                features,
            ])
            .output()
            .expect("Failed to execute command");

        assert!(
            output.status.success(),
            "Process did not exit successfully.\n\nstderr:\n{}",
            String::from_utf8_lossy(&output.stderr)
        );

        let stdout = String::from_utf8_lossy(&output.stdout);
        serde_json::from_str(stdout.lines().last().expect("No JSON output line"))
            .expect("Failed to parse JSON report")
    }

    fn assert_functions_present(report: &Value) {
        let functions = report["functions_timing"]["data"]
            .as_array()
            .expect("Expected functions_timing.data array");

        let expected = [
            "all_guards::sync_plain",
            "all_guards::sync_log",
            "all_guards::async_plain",
            "all_guards::async_log",
            "all_guards::async_future",
            "all_guards::async_future_log",
        ];

        for name in expected {
            let entry = functions
                .iter()
                .find(|f| f["name"].as_str() == Some(name))
                .unwrap_or_else(|| panic!("Expected {name} in functions_timing"));
            assert_eq!(
                entry["calls"].as_u64(),
                Some(3),
                "Expected 3 calls for {name}"
            );
        }
    }

    fn assert_futures_present(report: &Value) {
        let futures = report["futures"]["data"]
            .as_array()
            .expect("Expected futures.data array");

        let with_future = ["all_guards::async_future", "all_guards::async_future_log"];
        for source in with_future {
            let entry = futures
                .iter()
                .find(|f| f["source"].as_str() == Some(source))
                .unwrap_or_else(|| panic!("Expected future entry for {source}"));
            assert_eq!(
                entry["call_count"].as_u64(),
                Some(3),
                "Expected 3 calls for {source}"
            );
        }

        let without_future = ["all_guards::async_plain", "all_guards::async_log"];
        for source in without_future {
            assert!(
                futures.iter().all(|f| f["source"].as_str() != Some(source)),
                "Did not expect future entry for {source}"
            );
        }
    }

    // HOTPATH_OUTPUT_FORMAT=none cargo run -p test-smol-async --example all_guards --features hotpath,hotpath-alloc
    #[test]
    fn test_measure_impl_guards_example_runs() {
        let output = Command::new("cargo")
            .env("HOTPATH_OUTPUT_FORMAT", "none")
            .args([
                "run",
                "-p",
                "test-smol-async",
                "--example",
                "all_guards",
                "--features",
                "hotpath,hotpath-alloc",
            ])
            .output()
            .expect("Failed to execute command");

        assert!(
            output.status.success(),
            "Process did not exit successfully.\n\nstderr:\n{}",
            String::from_utf8_lossy(&output.stderr)
        );
    }

    // HOTPATH_OUTPUT_FORMAT=json HOTPATH_REPORT=functions-timing,futures cargo run -p test-smol-async --example all_guards --features hotpath
    #[test]
    fn test_measure_impl_guards_json_hotpath() {
        let report = run_all_guards_json("hotpath", "functions-timing,futures");
        assert_functions_present(&report);
        assert_futures_present(&report);
    }

    // HOTPATH_OUTPUT_FORMAT=json HOTPATH_REPORT=functions-timing,functions-alloc,futures cargo run -p test-smol-async --example all_guards --features hotpath,hotpath-alloc
    #[test]
    fn test_measure_impl_guards_json_hotpath_alloc() {
        let report = run_all_guards_json(
            "hotpath,hotpath-alloc",
            "functions-timing,functions-alloc,futures",
        );

        assert_functions_present(&report);
        assert_futures_present(&report);

        let functions_alloc = report["functions_alloc"]["data"]
            .as_array()
            .expect("Expected functions_alloc.data array");
        let expected = [
            "all_guards::sync_plain",
            "all_guards::sync_log",
            "all_guards::async_plain",
            "all_guards::async_log",
            "all_guards::async_future",
            "all_guards::async_future_log",
        ];
        for name in expected {
            functions_alloc
                .iter()
                .find(|f| f["name"].as_str() == Some(name))
                .unwrap_or_else(|| panic!("Expected {name} in functions_alloc"));
        }
    }
}