ferrflow 7.0.4

Universal semantic versioning for monorepos and classic repos
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

use std::time::{Duration, Instant};

pub struct Timing {
    enabled: bool,
    stages: Vec<Stage>,
}

enum Stage {
    Measured(&'static str, Duration),
    Skipped(&'static str, &'static str),
}

impl Timing {
    pub fn new(enabled: bool) -> Self {
        Self {
            enabled,
            stages: Vec::new(),
        }
    }

    pub fn stage<T>(&mut self, name: &'static str, f: impl FnOnce() -> T) -> T {
        if !self.enabled {
            return f();
        }
        let start = Instant::now();
        let out = f();
        self.stages.push(Stage::Measured(name, start.elapsed()));
        out
    }

    pub fn record(&mut self, name: &'static str, elapsed: Duration) {
        if self.enabled {
            self.stages.push(Stage::Measured(name, elapsed));
        }
    }

    pub fn skip(&mut self, name: &'static str, reason: &'static str) {
        if self.enabled {
            self.stages.push(Stage::Skipped(name, reason));
        }
    }

    pub fn total(&self) -> Duration {
        self.stages
            .iter()
            .filter_map(|s| match s {
                Stage::Measured(_, d) => Some(*d),
                Stage::Skipped(..) => None,
            })
            .sum()
    }

    pub fn report(&self) {
        if !self.enabled || self.stages.is_empty() {
            return;
        }

        let label_width = self
            .stages
            .iter()
            .map(|s| match s {
                Stage::Measured(name, _) | Stage::Skipped(name, _) => name.len(),
            })
            .chain(std::iter::once("total".len()))
            .max()
            .unwrap_or(0);

        tracing::info!("");
        tracing::info!("Timing breakdown:");
        for stage in &self.stages {
            match stage {
                Stage::Measured(name, d) => {
                    tracing::info!("  {name:<label_width$}  {:>6} ms", d.as_millis());
                }
                Stage::Skipped(name, reason) => {
                    tracing::info!("  {name:<label_width$}  — ({reason})");
                }
            }
        }
        let rule = "─".repeat(label_width + 12);
        tracing::info!("  {rule}");
        tracing::info!(
            "  {:<label_width$}  {:>6} ms",
            "total",
            self.total().as_millis()
        );
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn disabled_records_nothing() {
        let mut t = Timing::new(false);
        let out = t.stage("noop", || 42);
        t.record("manual", Duration::from_millis(5));
        t.skip("phase", "dry-run");
        assert_eq!(out, 42);
        assert!(t.stages.is_empty());
        assert_eq!(t.total(), Duration::ZERO);
    }

    #[test]
    fn enabled_accumulates_measured_stages() {
        let mut t = Timing::new(true);
        t.record("a", Duration::from_millis(10));
        t.record("b", Duration::from_millis(20));
        t.skip("c", "dry-run");
        assert_eq!(t.total(), Duration::from_millis(30));
        assert_eq!(t.stages.len(), 3);
    }

    #[test]
    fn stage_returns_value_and_records_when_enabled() {
        let mut t = Timing::new(true);
        let out = t.stage("compute", || 7 * 6);
        assert_eq!(out, 42);
        assert_eq!(t.stages.len(), 1);
        assert!(t.total() < Duration::from_secs(1));
    }
}