qualia_client_core/
system_telemetry.rs1use 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
60pub fn subscribe_system_telemetry(tx: SyncSender<SystemTelemetryEvent>) {
62 bus().subscribe(tx);
63}
64
65pub 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
109pub fn stop_activation_telemetry() {
111 TICKER_STOP.store(true, Ordering::Release);
112}
113
114pub 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
138pub 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}