Skip to main content

qualia_client_core/
system_telemetry.rs

1//! Structured system telemetry events for Flutter HUD (100 ms during activation).
2
3use std::sync::atomic::{AtomicBool, Ordering};
4use std::sync::mpsc::{SyncSender, TrySendError};
5use std::sync::{Mutex, OnceLock};
6use std::thread;
7use std::time::Duration;
8
9use serde::{Deserialize, Serialize};
10
11#[derive(Debug, Clone, Serialize, Deserialize)]
12pub struct SystemTelemetryEvent {
13    pub ram_used_mb: u32,
14    pub ram_total_mb: u32,
15    pub vram_used_mb: u32,
16    pub vram_total_mb: u32,
17    pub llm_memory_mb: u32,
18    pub kv_cache_mb: u32,
19    pub lifecycle: String,
20    pub status: String,
21    pub activation_in_progress: bool,
22}
23
24struct TelemetryBus {
25    senders: Mutex<Vec<SyncSender<SystemTelemetryEvent>>>,
26}
27
28impl TelemetryBus {
29    fn new() -> Self {
30        Self {
31            senders: Mutex::new(Vec::new()),
32        }
33    }
34
35    fn subscribe(&self, tx: SyncSender<SystemTelemetryEvent>) {
36        if let Ok(mut senders) = self.senders.lock() {
37            senders.push(tx);
38        }
39    }
40
41    fn publish(&self, event: SystemTelemetryEvent) {
42        if let Ok(mut senders) = self.senders.lock() {
43            senders.retain(|tx| match tx.try_send(event.clone()) {
44                Ok(_) => true,
45                Err(TrySendError::Full(_)) => true,
46                Err(TrySendError::Disconnected(_)) => false,
47            });
48        }
49    }
50}
51
52fn bus() -> &'static TelemetryBus {
53    static BUS: OnceLock<TelemetryBus> = OnceLock::new();
54    BUS.get_or_init(TelemetryBus::new)
55}
56
57static ACTIVATION_TICKER: AtomicBool = AtomicBool::new(false);
58static TICKER_STOP: AtomicBool = AtomicBool::new(false);
59
60/// Subscribes to system telemetry.
61pub fn subscribe_system_telemetry(tx: SyncSender<SystemTelemetryEvent>) {
62    bus().subscribe(tx);
63}
64
65/// Publishes system telemetry.
66pub fn publish_system_telemetry(event: SystemTelemetryEvent) {
67    bus().publish(event);
68}
69
70fn probe_vram_usage_mb() -> (u32, u32) {
71    #[cfg(target_os = "windows")]
72    {
73        if let Ok(memory) = qualia_core_db::directml_bridge::probe_best_adapter_memory() {
74            let used = memory.local_usage_bytes / (1024 * 1024);
75            let total = memory.local_budget_bytes / (1024 * 1024);
76            return (used as u32, total as u32);
77        }
78    }
79    (0, 0)
80}
81
82fn sample_event(status: &str, activation_in_progress: bool) -> SystemTelemetryEvent {
83    use sysinfo::System;
84
85    let mut sys = System::new_all();
86    sys.refresh_memory();
87    let (vram_used_mb, vram_total_mb) = probe_vram_usage_mb();
88    let ram_total_mb = (sys.total_memory() / (1024 * 1024)).min(u32::MAX as u64) as u32;
89    let ram_used_mb = (sys.used_memory() / (1024 * 1024)).min(u32::MAX as u64) as u32;
90    let llm_memory_mb = (crate::model_lifecycle::get_llm_memory_bytes() / (1024 * 1024))
91        .min(u32::MAX as u64) as u32;
92
93    SystemTelemetryEvent {
94        ram_used_mb,
95        ram_total_mb,
96        vram_used_mb,
97        vram_total_mb,
98        llm_memory_mb,
99        kv_cache_mb: crate::model_lifecycle::get_kv_cache_used_mb(),
100        lifecycle: crate::model_lifecycle::lifecycle_label(
101            crate::model_lifecycle::get_model_lifecycle_state(),
102        )
103        .to_string(),
104        status: status.to_string(),
105        activation_in_progress,
106    }
107}
108
109/// Stops activation telemetry.
110pub fn stop_activation_telemetry() {
111    TICKER_STOP.store(true, Ordering::Release);
112}
113
114/// Push telemetry every 100 ms while model activation runs.
115pub fn start_activation_telemetry(status: impl Into<String>) {
116    if ACTIVATION_TICKER
117        .compare_exchange(false, true, Ordering::AcqRel, Ordering::Relaxed)
118        .is_err()
119    {
120        return;
121    }
122    TICKER_STOP.store(false, Ordering::Release);
123    let status = status.into();
124    thread::Builder::new()
125        .name("qualia-telemetry-ticker".into())
126        .spawn(move || {
127            bus().publish(sample_event(&status, true));
128            while !TICKER_STOP.load(Ordering::Acquire) {
129                bus().publish(sample_event(&status, true));
130                thread::sleep(Duration::from_millis(100));
131            }
132            bus().publish(sample_event("Model activation complete", false));
133            ACTIVATION_TICKER.store(false, Ordering::Release);
134        })
135        .ok();
136}
137
138/// Publishes idle telemetry.
139pub fn publish_idle_telemetry() {
140    bus().publish(sample_event("Idle", false));
141}
142
143#[cfg(test)]
144mod tests {
145    use super::*;
146
147    #[test]
148    fn sample_event_has_nonzero_ram_total_on_host() {
149        let event = sample_event("test", false);
150        assert!(event.ram_total_mb > 0);
151    }
152}