lobe-core 0.1.3

Local HTTP performance profiling engine — the shared library behind the Lobe CLI. Captures DNS/TCP/TLS/TTFB/download phases per request with grounded network baselines.
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

use crate::models::TimingReport;

#[derive(Debug, Clone, Copy, Default)]
pub struct TimingPhases {
    pub dns_ms: u64,
    pub tcp_ms: u64,
    pub tls_ms: u64,
    pub ttfb_ms: u64,
    pub download_ms: u64,
}

pub fn build_report(
    dns_ms: u64,
    tcp_ms: u64,
    tls_ms: u64,
    ttfb_ms: u64,
    download_ms: u64,
) -> TimingReport {
    let total_ms = calculate_total_ms(dns_ms, tcp_ms, tls_ms, ttfb_ms, download_ms);

    TimingReport {
        dns_ms,
        tcp_ms,
        tls_ms,
        ttfb_ms,
        download_ms,
        total_ms,
        // Filled in by the capture proxy once the response is written back to
        // the client (see engine::capture); the probe path leaves it at 0.
        proxy_overhead_us: 0,
    }
}

pub fn build_report_from_phases(phases: TimingPhases) -> TimingReport {
    build_report(
        phases.dns_ms,
        phases.tcp_ms,
        phases.tls_ms,
        phases.ttfb_ms,
        phases.download_ms,
    )
}

pub fn calculate_total_ms(
    dns_ms: u64,
    tcp_ms: u64,
    tls_ms: u64,
    ttfb_ms: u64,
    download_ms: u64,
) -> u64 {
    dns_ms + tcp_ms + tls_ms + ttfb_ms + download_ms
}

#[cfg(test)]
mod tests {
    use super::{build_report, build_report_from_phases, calculate_total_ms, TimingPhases};

    #[test]
    fn calculate_total_ms_sums_all_phases() {
        let total_ms = calculate_total_ms(10, 20, 30, 40, 50);

        assert_eq!(total_ms, 150);
    }

    #[test]
    fn calculate_total_ms_handles_zero_values() {
        let total_ms = calculate_total_ms(0, 0, 0, 0, 0);

        assert_eq!(total_ms, 0);
    }

    #[test]
    fn build_report_populates_each_field() {
        let report = build_report(15, 25, 35, 45, 55);

        assert_eq!(report.dns_ms, 15);
        assert_eq!(report.tcp_ms, 25);
        assert_eq!(report.tls_ms, 35);
        assert_eq!(report.ttfb_ms, 45);
        assert_eq!(report.download_ms, 55);
        assert_eq!(report.total_ms, 175);
    }

    #[test]
    fn build_report_from_phases_uses_phase_values() {
        let phases = TimingPhases {
            dns_ms: 5,
            tcp_ms: 10,
            tls_ms: 15,
            ttfb_ms: 20,
            download_ms: 25,
        };

        let report = build_report_from_phases(phases);

        assert_eq!(report.dns_ms, 5);
        assert_eq!(report.tcp_ms, 10);
        assert_eq!(report.tls_ms, 15);
        assert_eq!(report.ttfb_ms, 20);
        assert_eq!(report.download_ms, 25);
        assert_eq!(report.total_ms, 75);
    }
}