sightloom_analysis/
scoped_baseline.rs1#![allow(
6 clippy::cast_possible_truncation,
7 clippy::cast_precision_loss,
8 clippy::cast_sign_loss
9)]
10
11extern crate alloc;
12
13use crate::input::AnalysisSeries;
14use crate::stat_anomaly::{BaselineStats, StatAnomalyConfig, build_baseline, detect_statistical};
15use alloc::collections::BTreeMap;
16use alloc::vec::Vec;
17use sightloom_core::{SourceId, SubjectId};
18
19#[derive(Clone, Copy, Debug, Eq, PartialEq)]
21pub enum BaselineScope {
22 Global,
24 Subject(SubjectId),
26 Source(SourceId),
28}
29
30#[derive(Clone, Debug, Default, PartialEq)]
32pub struct ScopedBaselineStore {
33 pub global: BaselineStats,
35 pub by_subject: BTreeMap<u64, BaselineStats>,
37 pub by_source: BTreeMap<u32, BaselineStats>,
39}
40
41impl ScopedBaselineStore {
42 #[must_use]
44 pub fn from_series(series: &AnalysisSeries, config: StatAnomalyConfig) -> Self {
45 let global = build_baseline(series, config);
46 let mut by_subject: BTreeMap<u64, BaselineStats> = BTreeMap::new();
47 let mut by_source: BTreeMap<u32, BaselineStats> = BTreeMap::new();
48
49 let mut subjects: Vec<SubjectId> = Vec::new();
51 let mut sources: Vec<SourceId> = Vec::new();
52 for e in &series.timed {
53 if let Some(s) = e.subject_id
54 && !subjects.contains(&s)
55 {
56 subjects.push(s);
57 }
58 if let Some(src) = e.source_id
59 && !sources.contains(&src)
60 {
61 sources.push(src);
62 }
63 }
64 for d in &series.durations {
65 if let Some(s) = d.subject_id
66 && !subjects.contains(&s)
67 {
68 subjects.push(s);
69 }
70 if let Some(src) = d.source_id
71 && !sources.contains(&src)
72 {
73 sources.push(src);
74 }
75 }
76
77 for s in subjects {
78 let sub = filter_series_subject(series, s);
79 let b = build_baseline(&sub, config);
80 if b.dwell_n >= config.min_samples
81 || b.gap_n >= config.min_samples
82 || b.timed_n >= config.min_samples
83 {
84 by_subject.insert(s.0, b);
85 }
86 }
87 for src in sources {
88 let sub = filter_series_source(series, src);
89 let b = build_baseline(&sub, config);
90 if b.dwell_n >= config.min_samples
91 || b.gap_n >= config.min_samples
92 || b.timed_n >= config.min_samples
93 {
94 by_source.insert(src.0, b);
95 }
96 }
97
98 Self {
99 global,
100 by_subject,
101 by_source,
102 }
103 }
104
105 #[must_use]
107 pub fn resolve(
108 &self,
109 subject_id: Option<SubjectId>,
110 source_id: Option<SourceId>,
111 ) -> &BaselineStats {
112 if let Some(s) = subject_id
113 && let Some(b) = self.by_subject.get(&s.0)
114 {
115 return b;
116 }
117 if let Some(src) = source_id
118 && let Some(b) = self.by_source.get(&src.0)
119 {
120 return b;
121 }
122 &self.global
123 }
124
125 #[must_use]
127 pub fn subject_count(&self) -> usize {
128 self.by_subject.len()
129 }
130
131 #[must_use]
133 pub fn source_count(&self) -> usize {
134 self.by_source.len()
135 }
136}
137
138#[must_use]
143pub fn detect_statistical_scoped(
144 live: &AnalysisSeries,
145 store: &ScopedBaselineStore,
146 config: StatAnomalyConfig,
147 next_id: &mut u64,
148) -> Vec<crate::anomaly::AnomalyEvent> {
149 let mut out = detect_statistical(live, &store.global, config, next_id);
150
151 let mut subjects: Vec<SubjectId> = Vec::new();
153 for e in &live.timed {
154 if let Some(s) = e.subject_id
155 && !subjects.contains(&s)
156 {
157 subjects.push(s);
158 }
159 }
160 for d in &live.durations {
161 if let Some(s) = d.subject_id
162 && !subjects.contains(&s)
163 {
164 subjects.push(s);
165 }
166 }
167 for s in subjects {
168 if let Some(b) = store.by_subject.get(&s.0) {
169 let slice = filter_series_subject(live, s);
170 out.extend(detect_statistical(&slice, b, config, next_id));
171 }
172 }
173
174 let mut sources: Vec<SourceId> = Vec::new();
176 for e in &live.timed {
177 if let Some(src) = e.source_id
178 && !sources.contains(&src)
179 {
180 sources.push(src);
181 }
182 }
183 for d in &live.durations {
184 if let Some(src) = d.source_id
185 && !sources.contains(&src)
186 {
187 sources.push(src);
188 }
189 }
190 for src in sources {
191 if let Some(b) = store.by_source.get(&src.0) {
192 let slice = filter_series_source(live, src);
193 out.extend(detect_statistical(&slice, b, config, next_id));
194 }
195 }
196 out
197}
198
199fn filter_series_subject(series: &AnalysisSeries, subject: SubjectId) -> AnalysisSeries {
200 AnalysisSeries {
201 timed: series
202 .timed
203 .iter()
204 .copied()
205 .filter(|e| e.subject_id == Some(subject))
206 .collect(),
207 durations: series
208 .durations
209 .iter()
210 .copied()
211 .filter(|d| d.subject_id == Some(subject))
212 .collect(),
213 routes: series
214 .routes
215 .iter()
216 .filter(|r| r.subject_id == subject)
217 .cloned()
218 .collect(),
219 pairs: series
220 .pairs
221 .iter()
222 .copied()
223 .filter(|p| p.subject_a == subject || p.subject_b == subject)
224 .collect(),
225 }
226}
227
228fn filter_series_source(series: &AnalysisSeries, source: SourceId) -> AnalysisSeries {
229 AnalysisSeries {
230 timed: series
231 .timed
232 .iter()
233 .copied()
234 .filter(|e| e.source_id == Some(source))
235 .collect(),
236 durations: series
237 .durations
238 .iter()
239 .copied()
240 .filter(|d| d.source_id == Some(source))
241 .collect(),
242 routes: series.routes.clone(),
243 pairs: series
244 .pairs
245 .iter()
246 .copied()
247 .filter(|p| p.source_id == Some(source))
248 .collect(),
249 }
250}
251
252#[cfg(test)]
253mod tests {
254 use super::*;
255 use crate::input::{DurationSample, TimedSubjectEvent};
256
257 #[test]
258 fn builds_subject_and_source_scopes() {
259 let mut series = AnalysisSeries::default();
260 for i in 0..10 {
261 series.timed.push(TimedSubjectEvent {
262 subject_id: Some(SubjectId(1)),
263 source_id: Some(SourceId(7)),
264 at_ns: i * 3_600_000_000_000,
265 event_id: None,
266 kind_tag: 0,
267 });
268 series.durations.push(DurationSample {
269 subject_id: Some(SubjectId(1)),
270 source_id: Some(SourceId(7)),
271 zone_id: None,
272 duration_ns: 1_000_000_000 + i * 1_000,
273 at_ns: i * 3_600_000_000_000,
274 event_id: None,
275 });
276 }
277 for i in 0..10 {
278 series.timed.push(TimedSubjectEvent {
279 subject_id: Some(SubjectId(2)),
280 source_id: Some(SourceId(8)),
281 at_ns: i * 3_600_000_000_000,
282 event_id: None,
283 kind_tag: 0,
284 });
285 }
286 let store = ScopedBaselineStore::from_series(&series, StatAnomalyConfig::default());
287 assert!(store.subject_count() >= 1);
288 assert!(store.source_count() >= 1);
289 let b = store.resolve(Some(SubjectId(1)), Some(SourceId(7)));
290 assert!(b.dwell_n >= 5 || b.timed_n >= 5);
291 }
292}