Skip to main content

gwr_track/tracker/
multi_tracker.rs

1// Copyright (c) 2023 Graphcore Ltd. All rights reserved.
2
3use crate::Id;
4use crate::entity::Capacity;
5use crate::tracker::aka::AlternativeNames;
6use crate::tracker::{EntityManager, Track, Tracker};
7
8/// Container for multiple [`Tracker`]s
9pub struct MultiTracker {
10    entity_manager: EntityManager,
11    trackers: Vec<Tracker>,
12}
13
14impl MultiTracker {
15    /// Basic constructor
16    /// Add a new tracker
17    pub fn add_tracker(&mut self, tracker: Tracker) {
18        self.trackers.push(tracker);
19    }
20}
21
22impl Default for MultiTracker {
23    fn default() -> Self {
24        Self {
25            // Create a local entity_manager that will just be used for handling
26            // IDs
27            entity_manager: EntityManager::new(log::Level::Error),
28            trackers: Vec::new(),
29        }
30    }
31}
32
33impl Track for MultiTracker {
34    fn unique_id(&self) -> Id {
35        self.entity_manager.unique_id()
36    }
37
38    fn enabled_level(&self, id: Id) -> log::Level {
39        self.trackers
40            .iter()
41            .map(|tracker| tracker.enabled_level(id))
42            .max()
43            .unwrap_or(log::Level::Error)
44    }
45
46    fn monitoring_window_size_for(&self, id: Id) -> Option<u64> {
47        for tracker in &self.trackers {
48            if let Some(window_size_ticks) = tracker.monitoring_window_size_for(id) {
49                return Some(window_size_ticks);
50            }
51        }
52        None
53    }
54
55    fn add_entity(
56        &self,
57        id: Id,
58        entity_name: &str,
59        alternative_names: AlternativeNames,
60    ) -> log::Level {
61        self.trackers
62            .iter()
63            .map(|tracker| tracker.add_entity(id, entity_name, alternative_names))
64            .max()
65            .unwrap_or(log::Level::Error)
66    }
67
68    fn enter(&self, id: Id, object: Id) {
69        for tracker in &self.trackers {
70            tracker.enter(id, object);
71        }
72    }
73
74    fn exit(&self, id: Id, object: Id) {
75        for tracker in &self.trackers {
76            tracker.exit(id, object);
77        }
78    }
79
80    fn value(&self, id: Id, value: f64) {
81        for tracker in &self.trackers {
82            tracker.value(id, value);
83        }
84    }
85
86    fn begin_activity(&self, activity: Id, lane: Id, name: &str) {
87        for tracker in &self.trackers {
88            tracker.begin_activity(activity, lane, name);
89        }
90    }
91
92    fn add_to_group(&self, activity: Id, group_id: Id) {
93        for tracker in &self.trackers {
94            tracker.add_to_group(activity, group_id);
95        }
96    }
97
98    fn remove_from_group(&self, activity: Id, group_id: Id) {
99        for tracker in &self.trackers {
100            tracker.remove_from_group(activity, group_id);
101        }
102    }
103
104    fn end_activity(&self, activity: Id) {
105        for tracker in &self.trackers {
106            tracker.end_activity(activity);
107        }
108    }
109
110    fn create_entity(&self, created_by: Id, id: Id, name: &str) {
111        for tracker in &self.trackers {
112            tracker.create_entity(created_by, id, name);
113        }
114    }
115
116    fn create_monitor(&self, created_by: Id, id: Id, name: &str) {
117        for tracker in &self.trackers {
118            tracker.create_monitor(created_by, id, name);
119        }
120    }
121
122    fn create_lane(&self, created_by: Id, id: Id, name: &str) {
123        for tracker in &self.trackers {
124            tracker.create_lane(created_by, id, name);
125        }
126    }
127
128    fn create_group(&self, created_by: Id, id: Id, name: &str) {
129        for tracker in &self.trackers {
130            tracker.create_group(created_by, id, name);
131        }
132    }
133
134    fn create_object(
135        &self,
136        created_by: Id,
137        id: Id,
138        size: usize,
139        units: &str,
140        req_type: u8,
141        details: &str,
142    ) {
143        for tracker in &self.trackers {
144            tracker.create_object(created_by, id, size, units, req_type, details);
145        }
146    }
147
148    fn capacity(&self, id: Id, capacity: Capacity) {
149        for tracker in &self.trackers {
150            tracker.capacity(id, capacity.clone());
151        }
152    }
153
154    fn destroy(&self, destroyed_by: Id, id: Id) {
155        for tracker in &self.trackers {
156            tracker.destroy(destroyed_by, id);
157        }
158    }
159
160    fn connect(&self, connect_from: Id, connect_to: Id) {
161        for tracker in &self.trackers {
162            tracker.connect(connect_from, connect_to);
163        }
164    }
165
166    fn log(&self, id: Id, level: log::Level, msg: std::fmt::Arguments) {
167        for tracker in &self.trackers {
168            tracker.log(id, level, msg);
169        }
170    }
171
172    fn time(&self, set_by: Id, time_ns: f64) {
173        for tracker in &self.trackers {
174            tracker.time(set_by, time_ns);
175        }
176    }
177
178    fn shutdown(&self) {
179        for tracker in &self.trackers {
180            tracker.shutdown();
181        }
182    }
183}
184
185#[cfg(test)]
186mod tests {
187    use std::rc::Rc;
188
189    use log::Level;
190
191    use super::MultiTracker;
192    use crate::Id;
193    use crate::test_helpers::{TestTracker, check_and_clear};
194    use crate::tracker::{Track, Tracker};
195
196    #[test]
197    fn log_events_are_delivered_to_all_sub_trackers_even_if_only_one_enables_the_level() {
198        let trace_tracker = Rc::new(TestTracker::new(100, Level::Trace));
199        let error_tracker = Rc::new(TestTracker::new(200, Level::Error));
200
201        let mut multi_tracker = MultiTracker::default();
202        let trace_tracker_dyn: Tracker = trace_tracker.clone();
203        let error_tracker_dyn: Tracker = error_tracker.clone();
204        multi_tracker.add_tracker(trace_tracker_dyn);
205        multi_tracker.add_tracker(error_tracker_dyn);
206
207        let entity_id = Id(42);
208        assert!(multi_tracker.is_entity_enabled(entity_id, Level::Trace));
209
210        multi_tracker.log(entity_id, Level::Trace, format_args!("fanout"));
211
212        check_and_clear(&trace_tracker, &["42:TRACE: fanout"]);
213        check_and_clear(&error_tracker, &["42:TRACE: fanout"]);
214    }
215}