texted 1.2.1

A markdown blog platform that lets you in control of your data
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

use crate::metrics::event_slot::EventSlot;
use crate::metrics::metric_types::MetricEvent;
use chrono::{DateTime, Duration, Utc};
use spdlog::debug;
use std::collections::HashMap;

pub struct Event {
    pub metric_event: MetricEvent,
    pub date_time: DateTime<Utc>,
    pub total: u64,
}

pub struct MetricAggregator {
    slot_size: Duration,
    slots: HashMap<String, EventSlot>,
    history: Vec<EventSlot>,
}

impl MetricAggregator {
    pub fn new(slot_size: Duration) -> Self {
        Self {
            slot_size,
            slots: Default::default(),
            history: vec![],
        }
    }

    pub fn flush(&mut self) {
        let date_time = Utc::now();
        let mut should_drain = false;
        for (_, slot) in self.slots.iter_mut() {
            if date_time >= slot.stats_date_end {
                should_drain = true;
                break;
            }
        }

        debug!(
            "Flush called for {}. Should_drain={}",
            date_time, should_drain
        );
        if should_drain {
            let values: Vec<EventSlot> = self.slots.drain().map(|(_, v)| v).collect();
            self.history.extend(values);
        }
    }

    pub fn add_event(&mut self, event: Event) {
        let hash_key = EventSlot::key_from(&event);
        if let Some(slot) = self.slots.get_mut(&hash_key) {
            // We need to check if the event is inside the slot duration.
            if event.date_time < slot.stats_date_end {
                // If yes, add origin into the hashset and increase total
                let inserted = slot.origins.insert(event.metric_event.origin);
                if inserted {
                    slot.unique_total += event.total;
                }
                slot.total += event.total;
                return;
            } else {
                // If not, add to history and reset
                let values: Vec<EventSlot> = self.slots.drain().map(|(_, v)| v).collect();
                self.history.extend(values);
            }
        }

        let slot = EventSlot::from_event(event, &self.slot_size);
        self.slots.insert(hash_key, slot);
    }

    pub fn take_events(&mut self) -> Option<Vec<EventSlot>> {
        if self.history.is_empty() {
            return None;
        }

        Some(std::mem::take(&mut self.history))
    }
}

/*
#[cfg(test)]
mod tests {
    use super::*;
    use chrono::TimeZone;
    use std::collections::HashSet;

    fn create(post_no: i32, origin_no: i32, secs: u32, total: u64) -> Event {
        Event {
            event_api: format!("post-{}", post_no),
            origin: format!("10.0.0.{}", origin_no),
            date_time: Utc.with_ymd_and_hms(2024, 11, 01, 01, 02, secs).unwrap(),
            total,
        }
    }

    #[test]
    fn test_slots() {
        let mut m = MetricAggregator::new(Duration::seconds(5));
        assert_eq!(m.take_events(), None);
        m.add_event(create(1, 1, 0, 1));
        m.add_event(create(1, 1, 0, 1));
        m.add_event(create(1, 2, 1, 1));
        m.add_event(create(1, 1, 5, 1));
        let events = m.take_events();
        let expected = vec![EventSlot {
            event_api: "post-1".to_string(),
            unique_total: 2,
            total: 3,
            origins: HashSet::from(["10.0.0.1".to_string(), "10.0.0.2".to_string()]),
            stats_date_start: DateTime::parse_from_rfc3339("2024-11-01T01:02:00Z")
                .unwrap()
                .into(),
            stats_date_end: DateTime::parse_from_rfc3339("2024-11-01T01:02:05Z")
                .unwrap()
                .into(),
        }];
        assert_eq!(events.unwrap(), expected);

        m.add_event(create(1, 1, 10, 1));
        let events = m.take_events();
        let expected = vec![EventSlot {
            event_api: "post-1".to_string(),
            unique_total: 1,
            total: 1,
            origins: HashSet::from(["10.0.0.1".to_string()]),
            stats_date_start: DateTime::parse_from_rfc3339("2024-11-01T01:02:05Z")
                .unwrap()
                .into(),
            stats_date_end: DateTime::parse_from_rfc3339("2024-11-01T01:02:10Z")
                .unwrap()
                .into(),
        }];
        assert_eq!(events.unwrap(), expected);
        assert_eq!(m.take_events(), None);
    }
}
*/