timed 0.2.1

Macros to time function execution
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

use crate::chrome_trace;
use crate::hop::{Hop, Phase};
use crate::statistics;

pub struct Trace {
    id: String,
    start_timestamp: u128,
}

impl Trace {
    fn register(id: &str) {
        crate::TRACES.lock().unwrap().insert(id.to_string(), vec![]);
    }

    pub fn record(hop: Hop) {
        for trace_group in crate::TRACES.lock().unwrap().iter_mut() {
            trace_group.1.push(hop.clone());
        }
    }

    pub fn new(id: &str) -> Self {
        let start_timestamp = std::time::SystemTime::now()
            .duration_since(std::time::SystemTime::UNIX_EPOCH)
            .unwrap()
            .as_micros();

        let trace = Self {
            id: id.to_string(),
            start_timestamp,
        };

        Trace::register(id);
        Trace::record(Hop {
            function_name: id.to_string(),
            timestamp: start_timestamp,
            phase: Phase::Start,
        });

        // record the original too
        trace
    }

    fn generate_current_end_hop(&self) -> Hop {
        let end_timestamp = std::time::SystemTime::now()
            .duration_since(std::time::SystemTime::UNIX_EPOCH)
            .unwrap()
            .as_micros();

        let duration =
            std::time::Duration::from_micros((end_timestamp - self.start_timestamp) as u64);

        Hop {
            function_name: self.id.to_string(),
            timestamp: end_timestamp,
            phase: Phase::Finish(duration),
        }
    }

    pub fn chrome_tracing(&self) -> String {
        let mut traces = crate::TRACES.lock().unwrap();
        let entries = traces.entry(self.id.clone()).or_insert(vec![]);

        entries.push(self.generate_current_end_hop());

        chrome_trace::from(entries)
    }

    pub fn statistics(&self) -> String {
        let mut traces = crate::TRACES.lock().unwrap();
        let entries = traces.entry(self.id.clone()).or_insert(vec![]);

        entries.push(self.generate_current_end_hop());

        statistics::from(entries)
    }
}