corsa 0.3.1

Production-oriented Rust bindings, orchestration layers, and Node integration for typescript-go
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

use std::time::Duration;

use corsa::fast::SmallVec;

#[derive(Clone, Debug)]
pub struct Stats {
    sample_count: usize,
    min: Duration,
    max: Duration,
    mean: Duration,
    median: Duration,
    p95: Duration,
    p99: Duration,
    stddev: Duration,
}

impl Stats {
    pub fn from_samples(mut samples: SmallVec<[Duration; 32]>) -> Self {
        samples.sort_unstable();
        let sample_count = samples.len();
        let min = samples[0];
        let max = samples[samples.len() - 1];
        let median = samples[samples.len() / 2];
        let p95 = samples[percentile_index(samples.len(), 95)];
        let p99 = samples[percentile_index(samples.len(), 99)];
        let total_nanos = samples
            .iter()
            .fold(0_u128, |acc, sample| acc + sample.as_nanos());
        let mean_nanos = total_nanos as f64 / sample_count as f64;
        let mean = Duration::from_secs_f64(mean_nanos / 1_000_000_000.0);
        let variance_nanos = samples
            .iter()
            .map(|sample| {
                let delta = sample.as_nanos() as f64 - mean_nanos;
                delta * delta
            })
            .sum::<f64>()
            / sample_count as f64;
        let stddev = Duration::from_secs_f64(variance_nanos.sqrt() / 1_000_000_000.0);
        Self {
            sample_count,
            min,
            max,
            mean,
            median,
            p95,
            p99,
            stddev,
        }
    }

    pub fn sample_count(&self) -> usize {
        self.sample_count
    }

    pub fn mean_ms(&self) -> f64 {
        millis(self.mean)
    }

    pub fn median_ms(&self) -> f64 {
        millis(self.median)
    }

    pub fn p95_ms(&self) -> f64 {
        millis(self.p95)
    }

    pub fn p99_ms(&self) -> f64 {
        millis(self.p99)
    }

    pub fn stddev_ms(&self) -> f64 {
        millis(self.stddev)
    }

    pub fn cv_percent(&self) -> f64 {
        if self.mean.is_zero() {
            return 0.0;
        }
        (self.stddev.as_secs_f64() / self.mean.as_secs_f64()) * 100.0
    }

    pub fn min_ms(&self) -> f64 {
        millis(self.min)
    }

    pub fn max_ms(&self) -> f64 {
        millis(self.max)
    }
}

fn millis(duration: Duration) -> f64 {
    duration.as_secs_f64() * 1000.0
}

fn percentile_index(len: usize, percentile: usize) -> usize {
    len.saturating_mul(percentile)
        .div_ceil(100)
        .saturating_sub(1)
}

#[cfg(test)]
mod tests {
    use std::time::Duration;

    use corsa::fast::SmallVec;

    use super::Stats;

    #[test]
    fn stats_compute_expected_percentiles() {
        let mut samples = SmallVec::<[Duration; 32]>::new();
        samples.push(Duration::from_millis(9));
        samples.push(Duration::from_millis(1));
        samples.push(Duration::from_millis(5));
        samples.push(Duration::from_millis(7));
        samples.push(Duration::from_millis(3));
        let stats = Stats::from_samples(samples);
        assert_eq!(stats.sample_count(), 5);
        assert_eq!(stats.min_ms(), 1.0);
        assert_eq!(stats.median_ms(), 5.0);
        assert_eq!(stats.p95_ms(), 9.0);
        assert_eq!(stats.p99_ms(), 9.0);
        assert_eq!(stats.max_ms(), 9.0);
        assert!(stats.stddev_ms() > 0.0);
        assert!(stats.cv_percent() > 0.0);
    }
}