use serde::{Deserialize, Serialize};
use std::time::{SystemTime, UNIX_EPOCH};
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum BehavioralEvent {
PointerMove {
ts: u64,
x: f64,
y: f64,
pressure: f64,
twist: u32,
},
PointerDown {
ts: u64,
x: f64,
y: f64,
button: u8,
pressure: f64,
},
PointerUp {
ts: u64,
x: f64,
y: f64,
button: u8,
pressure: f64,
},
KeyDown {
ts: u64,
key: String,
code: String,
},
KeyUp {
ts: u64,
key: String,
code: String,
},
Scroll {
ts: u64,
delta_x: f64,
delta_y: f64,
delta_mode: u8,
},
TypoCorrection {
ts: u64,
wrong: char,
intended: char,
},
}
impl BehavioralEvent {
pub fn now_ms() -> u64 {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap_or_default()
.as_millis() as u64
}
pub fn timestamp(&self) -> u64 {
match self {
BehavioralEvent::PointerMove { ts, .. }
| BehavioralEvent::PointerDown { ts, .. }
| BehavioralEvent::PointerUp { ts, .. }
| BehavioralEvent::KeyDown { ts, .. }
| BehavioralEvent::KeyUp { ts, .. }
| BehavioralEvent::Scroll { ts, .. }
| BehavioralEvent::TypoCorrection { ts, .. } => *ts,
}
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct TelemetryCollector {
events: Vec<BehavioralEvent>,
cap: Option<usize>,
}
impl TelemetryCollector {
pub fn new() -> Self {
Self {
events: Vec::new(),
cap: None,
}
}
pub fn with_cap(cap: usize) -> Self {
Self {
events: Vec::with_capacity(cap.min(1024)),
cap: Some(cap),
}
}
pub fn record(&mut self, event: BehavioralEvent) {
if let Some(cap) = self.cap {
if self.events.len() >= cap {
self.events.remove(0);
}
}
self.events.push(event);
}
pub fn len(&self) -> usize {
self.events.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.events.is_empty()
}
pub fn events(&self) -> &[BehavioralEvent] {
&self.events
}
pub fn to_json(&self) -> serde_json::Result<String> {
serde_json::to_string(&self.events)
}
pub fn clear(&mut self) {
self.events.clear();
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn collector_records_events() {
let mut c = TelemetryCollector::new();
c.record(BehavioralEvent::PointerMove {
ts: 1,
x: 10.0,
y: 20.0,
pressure: 0.0,
twist: 0,
});
assert_eq!(c.len(), 1);
}
#[test]
fn cap_drops_oldest() {
let mut c = TelemetryCollector::with_cap(3);
for i in 0..5 {
c.record(BehavioralEvent::PointerMove {
ts: i,
x: i as f64,
y: 0.0,
pressure: 0.0,
twist: 0,
});
}
assert_eq!(c.len(), 3);
let first = c.events().first().unwrap();
assert!(
matches!(first, BehavioralEvent::PointerMove { ts: 2, .. }),
"oldest event should be ts=2"
);
}
#[test]
fn json_roundtrip_preserves_tagged_variant() {
let mut c = TelemetryCollector::new();
c.record(BehavioralEvent::KeyDown {
ts: 42,
key: "a".into(),
code: "KeyA".into(),
});
let json = c.to_json().unwrap();
assert!(json.contains("\"type\":\"key_down\""));
let parsed: Vec<BehavioralEvent> = serde_json::from_str(&json).unwrap();
assert_eq!(parsed, c.events().to_vec());
}
#[test]
fn timestamp_extractor_round_trips_ts() {
let e = BehavioralEvent::Scroll {
ts: 1234,
delta_x: 0.0,
delta_y: 100.0,
delta_mode: 0,
};
assert_eq!(e.timestamp(), 1234);
}
}