use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::{Arc, Mutex, MutexGuard};
use std::thread::{self, JoinHandle};
use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
use arc_swap::ArcSwap;
use serde::{Deserialize, Serialize};
use crate::connections::{ConnectionInfo, ConnectionMonitor};
use crate::core::cpu::CpuStats;
use crate::core::memory::MemoryStats;
use crate::gpu::{GpuCollection, GpuDynamicInfo, GpuStaticInfo};
use crate::network_monitor::NetworkMonitor;
use crate::process_monitor::{ProcessMonitor, ProcessMonitorInfo};
use crate::system_stats::SystemStats;
pub const DEFAULT_TICK: Duration = Duration::from_millis(1000);
pub const DEFAULT_HISTORY: usize = 120;
#[cfg(target_os = "windows")]
pub fn com_guard() -> Option<wmi::COMLibrary> {
wmi::COMLibrary::new().ok()
}
#[cfg(not(target_os = "windows"))]
pub fn com_guard() -> Option<()> {
None
}
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DiskSnapshot {
pub name: String,
pub mount_point: String,
pub total: Option<u64>,
pub used: Option<u64>,
pub filesystem: String,
pub read_rate: Option<f64>,
pub write_rate: Option<f64>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct DiskIoSnapshot {
pub device: String,
pub read_bytes: Option<u64>,
pub write_bytes: Option<u64>,
}
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct NetSnapshot {
pub name: String,
pub is_up: Option<bool>,
pub rx_bytes: u64,
pub tx_bytes: u64,
pub rx_rate: Option<f64>,
pub tx_rate: Option<f64>,
pub speed_mbps: Option<u32>,
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct StageTimings {
pub cpu_us: u64,
pub memory_us: u64,
pub gpu_us: u64,
pub process_us: u64,
pub network_us: u64,
pub connection_us: u64,
pub disk_us: u64,
pub system_us: u64,
}
impl StageTimings {
pub fn critical_path_us(&self) -> u64 {
[
self.cpu_us,
self.memory_us,
self.gpu_us,
self.process_us,
self.network_us,
self.connection_us,
self.disk_us,
self.system_us,
]
.into_iter()
.max()
.unwrap_or(0)
}
pub fn serial_us(&self) -> u64 {
self.cpu_us
+ self.memory_us
+ self.gpu_us
+ self.process_us
+ self.network_us
+ self.connection_us
+ self.disk_us
+ self.system_us
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct Histories {
pub cpu: Vec<f32>,
pub memory: Vec<f32>,
pub gpu_util: Vec<Vec<f32>>,
pub gpu_memory: Vec<Vec<f32>>,
pub gpu_temp: Vec<Vec<f32>>,
pub net_rx: Vec<f32>,
pub net_tx: Vec<f32>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct Snapshot {
pub generation: u64,
pub collected_at: Option<u64>,
pub collect_us: u64,
pub timings: StageTimings,
#[serde(default)]
pub process_sampled: bool,
#[serde(default)]
pub connections_sampled: bool,
#[serde(default)]
pub connection_errors: Option<Vec<String>>,
pub cpu: Option<CpuStats>,
pub memory: Option<MemoryStats>,
pub warmup: bool,
pub gpu_static: Vec<GpuStaticInfo>,
pub gpu_dynamic: Vec<Option<GpuDynamicInfo>>,
pub processes: Vec<ProcessMonitorInfo>,
pub connections: Vec<ConnectionInfo>,
pub disks: Vec<DiskSnapshot>,
pub disk_io: Vec<DiskIoSnapshot>,
pub cpu_temperatures: Vec<crate::hwmon::HwSensor>,
pub network: Vec<NetSnapshot>,
pub system_stats: Option<SystemStats>,
pub histories: Histories,
}
impl Snapshot {
pub fn cpu_utilization(&self) -> Option<f32> {
self.cpu.as_ref().map(|c| 100.0 - c.total.idle)
}
pub fn memory_utilization(&self) -> Option<f32> {
self.memory.as_ref().and_then(|m| m.ram_usage_percent())
}
pub fn total_rx_rate(&self) -> Option<f64> {
self.sum_rates(|n| n.rx_rate)
}
pub fn total_tx_rate(&self) -> Option<f64> {
self.sum_rates(|n| n.tx_rate)
}
fn sum_rates(&self, rate: impl Fn(&NetSnapshot) -> Option<f64>) -> Option<f64> {
if self.network.is_empty() {
return None;
}
self.network.iter().map(rate).sum::<Option<f64>>()
}
}
#[derive(Clone)]
pub struct SnapshotHandle {
slot: Arc<ArcSwap<Snapshot>>,
stop: Arc<AtomicBool>,
interval_ms: Arc<AtomicU64>,
}
impl SnapshotHandle {
pub fn latest(&self) -> Arc<Snapshot> {
self.slot.load_full()
}
pub fn generation(&self) -> u64 {
self.slot.load().generation
}
pub fn set_interval(&self, interval: Duration) {
self.interval_ms
.store(interval.as_millis() as u64, Ordering::Relaxed);
}
pub fn interval(&self) -> Duration {
Duration::from_millis(self.interval_ms.load(Ordering::Relaxed))
}
pub fn request_stop(&self) {
self.stop.store(true, Ordering::Relaxed);
}
pub fn is_stopping(&self) -> bool {
self.stop.load(Ordering::Relaxed)
}
}
pub type PublishHook = Arc<dyn Fn() + Send + Sync>;
#[derive(Clone)]
pub struct CollectorConfig {
pub interval: Duration,
pub history_size: usize,
pub collect_processes: bool,
pub collect_connections: bool,
pub disk_every_n_ticks: u64,
pub process_every_n_ticks: u64,
pub connection_every_n_ticks: u64,
pub max_duty_cycle: f32,
pub on_publish: Option<PublishHook>,
}
impl std::fmt::Debug for CollectorConfig {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("CollectorConfig")
.field("interval", &self.interval)
.field("history_size", &self.history_size)
.field("collect_processes", &self.collect_processes)
.field("collect_connections", &self.collect_connections)
.field("disk_every_n_ticks", &self.disk_every_n_ticks)
.field("process_every_n_ticks", &self.process_every_n_ticks)
.field("connection_every_n_ticks", &self.connection_every_n_ticks)
.field("max_duty_cycle", &self.max_duty_cycle)
.field("on_publish", &self.on_publish.is_some())
.finish()
}
}
impl Default for CollectorConfig {
fn default() -> Self {
Self {
interval: DEFAULT_TICK,
history_size: DEFAULT_HISTORY,
collect_processes: true,
collect_connections: true,
disk_every_n_ticks: 10,
process_every_n_ticks: 1,
connection_every_n_ticks: 1,
max_duty_cycle: 0.5,
on_publish: None,
}
}
}
pub struct Collector {
handle: SnapshotHandle,
join: Option<JoinHandle<()>>,
}
impl Collector {
pub fn spawn(config: CollectorConfig) -> Self {
let slot = Arc::new(ArcSwap::from_pointee(Snapshot::default()));
let stop = Arc::new(AtomicBool::new(false));
let interval_ms = Arc::new(AtomicU64::new(config.interval.as_millis() as u64));
let handle = SnapshotHandle {
slot: Arc::clone(&slot),
stop: Arc::clone(&stop),
interval_ms: Arc::clone(&interval_ms),
};
let join = thread::Builder::new()
.name("ironmon-collector".into())
.spawn(move || collector_loop(config, slot, stop, interval_ms))
.ok();
Self { handle, join }
}
pub fn handle(&self) -> SnapshotHandle {
self.handle.clone()
}
}
impl Drop for Collector {
fn drop(&mut self) {
self.handle.request_stop();
if let Some(join) = self.join.take() {
let _ = join.join();
}
}
}
struct Sources {
gpu: Option<GpuCollection>,
processes: Option<ProcessMonitor>,
network: Option<NetworkMonitor>,
connections: Option<ConnectionMonitor>,
}
fn push_capped(series: &mut Vec<f32>, value: f32, cap: usize) {
if series.len() >= cap {
let overflow = series.len() + 1 - cap;
series.drain(..overflow);
}
series.push(value);
}
fn collector_loop(
config: CollectorConfig,
slot: Arc<ArcSwap<Snapshot>>,
stop: Arc<AtomicBool>,
interval_ms: Arc<AtomicU64>,
) {
com_guard();
let mut histories = Histories::default();
let mut generation: u64 = 0;
let mut cached_disks: Vec<DiskSnapshot> = Vec::new();
let mut cached_disk_io: Vec<DiskIoSnapshot> = Vec::new();
let mut cached_processes: Vec<ProcessMonitorInfo> = Vec::new();
let mut cached_connections: Vec<ConnectionInfo> = Vec::new();
let mut warmup_sources = Sources {
gpu: None,
processes: None,
network: None,
connections: None,
};
generation += 1;
let mut warmup = collect_once(
&mut warmup_sources,
&config,
&mut histories,
&mut cached_disks,
&mut cached_disk_io,
&mut cached_processes,
&mut cached_connections,
&[],
generation,
);
warmup.warmup = true;
slot.store(Arc::new(warmup));
if let Some(ref hook) = config.on_publish {
hook();
}
if stop.load(Ordering::Relaxed) {
return;
}
let mut sources = Sources {
gpu: GpuCollection::auto_detect().ok(),
processes: if config.collect_processes {
ProcessMonitor::new().ok()
} else {
None
},
network: NetworkMonitor::new().ok(),
connections: if config.collect_connections {
ConnectionMonitor::new().ok()
} else {
None
},
};
let gpu_static: Vec<GpuStaticInfo> = sources
.gpu
.as_ref()
.and_then(|g| {
g.gpus()
.iter()
.map(|gpu| gpu.static_info())
.collect::<Result<Vec<_>, _>>()
.ok()
})
.unwrap_or_default();
histories.gpu_util = vec![Vec::new(); gpu_static.len()];
histories.gpu_memory = vec![Vec::new(); gpu_static.len()];
histories.gpu_temp = vec![Vec::new(); gpu_static.len()];
while !stop.load(Ordering::Relaxed) {
let tick_start = Instant::now();
generation += 1;
let snapshot = collect_once(
&mut sources,
&config,
&mut histories,
&mut cached_disks,
&mut cached_disk_io,
&mut cached_processes,
&mut cached_connections,
&gpu_static,
generation,
);
slot.store(Arc::new(snapshot));
if let Some(ref hook) = config.on_publish {
hook();
}
let interval = Duration::from_millis(interval_ms.load(Ordering::Relaxed).max(50));
let elapsed = tick_start.elapsed();
let min_period = elapsed.div_f32(config.max_duty_cycle.clamp(0.05, 1.0));
let period = interval.max(min_period);
let mut remaining = period.saturating_sub(elapsed);
while remaining > Duration::ZERO && !stop.load(Ordering::Relaxed) {
let slice = remaining.min(Duration::from_millis(50));
thread::sleep(slice);
remaining = remaining.saturating_sub(slice);
}
}
}
static READER_PASS: Mutex<()> = Mutex::new(());
pub(crate) fn reader_pass() -> MutexGuard<'static, ()> {
READER_PASS
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner())
}
#[allow(clippy::too_many_arguments)]
fn collect_once(
sources: &mut Sources,
config: &CollectorConfig,
histories: &mut Histories,
cached_disks: &mut Vec<DiskSnapshot>,
cached_disk_io: &mut Vec<DiskIoSnapshot>,
cached_processes: &mut Vec<ProcessMonitorInfo>,
cached_connections: &mut Vec<ConnectionInfo>,
gpu_static: &[GpuStaticInfo],
generation: u64,
) -> Snapshot {
let _pass = reader_pass();
let started = Instant::now();
let Sources {
gpu,
processes,
network,
connections,
} = sources;
let due = |every: u64| generation == 1 || generation.is_multiple_of(every.max(1));
let refresh_disks = due(config.disk_every_n_ticks);
let refresh_processes = due(config.process_every_n_ticks);
let refresh_connections = due(config.connection_every_n_ticks);
#[allow(clippy::type_complexity)]
let (cpu, memory, gpu_dynamic, process_list, net_list, conn_list, disk_list, sys_stats, temps) =
thread::scope(|scope| {
let cpu_h = scope.spawn(timed(collect_cpu));
let temp_h = scope.spawn(timed(crate::hwmon::read_cpu_temperatures));
let mem_h = scope.spawn(timed(collect_memory));
let sys_h = scope.spawn(timed(collect_system_stats));
let gpu_h = scope.spawn(timed(move || collect_gpu(gpu.as_ref())));
let proc_h = scope.spawn(timed(move || {
refresh_processes
.then(|| collect_processes(processes.as_mut()))
.flatten()
}));
let net_h = scope.spawn(timed(move || collect_network(network.as_mut())));
let conn_h = scope.spawn(timed(move || {
refresh_connections.then(|| collect_connections(connections.as_mut()))
}));
let disk_h = scope.spawn(timed(move || {
if refresh_disks {
Some((collect_disks(), collect_disk_io()))
} else {
None
}
}));
(
join_or_default(cpu_h),
join_or_default(mem_h),
join_or_default(gpu_h),
join_or_default(proc_h),
join_or_default(net_h),
join_or_default(conn_h),
join_or_default(disk_h),
join_or_default(sys_h),
join_or_default(temp_h),
)
});
let timings = StageTimings {
cpu_us: cpu.1,
memory_us: memory.1,
gpu_us: gpu_dynamic.1,
process_us: process_list.1,
network_us: net_list.1,
connection_us: conn_list.1,
disk_us: disk_list.1,
system_us: sys_stats.1,
};
let process_sampled = process_list.0.is_some();
let connections_sampled = conn_list.0.is_some();
let (cpu, memory) = (cpu.0, memory.0);
let gpu_dynamic = gpu_dynamic.0;
let network = net_list.0;
let system_stats = sys_stats.0;
if let Some((fresh_disks, fresh_io)) = disk_list.0 {
*cached_disks = fresh_disks;
*cached_disk_io = fresh_io;
}
if let Some(fresh) = process_list.0 {
*cached_processes = fresh;
}
let mut connection_errors = None;
if let Some((fresh, errors)) = conn_list.0 {
*cached_connections = fresh;
connection_errors = Some(errors);
}
let processes = cached_processes.clone();
let connections = cached_connections.clone();
let cap = config.history_size.max(1);
if let Some(ref c) = cpu {
push_capped(&mut histories.cpu, 100.0 - c.total.idle, cap);
}
if let Some(ref m) = memory {
if let Some(pct) = m.ram_usage_percent() {
push_capped(&mut histories.memory, pct, cap);
}
}
for (i, info) in gpu_dynamic.iter().enumerate() {
let Some(info) = info.as_ref() else { continue };
if i < histories.gpu_util.len() {
if let Some(util) = info.utilization {
push_capped(&mut histories.gpu_util[i], util as f32, cap);
}
if let Some(mem_util) = info.memory.utilization {
push_capped(&mut histories.gpu_memory[i], mem_util as f32, cap);
}
if let Some(temp) = info.thermal.temperature {
push_capped(&mut histories.gpu_temp[i], temp as f32, cap);
}
}
}
let rx_rates: Vec<f64> = network.iter().filter_map(|n| n.rx_rate).collect();
let tx_rates: Vec<f64> = network.iter().filter_map(|n| n.tx_rate).collect();
if !rx_rates.is_empty() {
push_capped(
&mut histories.net_rx,
rx_rates.iter().sum::<f64>() as f32,
cap,
);
}
if !tx_rates.is_empty() {
push_capped(
&mut histories.net_tx,
tx_rates.iter().sum::<f64>() as f32,
cap,
);
}
Snapshot {
generation,
warmup: false,
collected_at: SystemTime::now()
.duration_since(UNIX_EPOCH)
.ok()
.map(|d| d.as_secs()),
collect_us: started.elapsed().as_micros() as u64,
timings,
process_sampled,
connections_sampled,
connection_errors,
cpu,
memory,
gpu_static: gpu_static.to_vec(),
gpu_dynamic,
processes,
connections,
disks: cached_disks.clone(),
disk_io: cached_disk_io.clone(),
cpu_temperatures: temps.0,
network,
system_stats,
histories: histories.clone(),
}
}
fn timed<T, F>(f: F) -> impl FnOnce() -> (T, u64) + Send
where
F: FnOnce() -> T + Send,
T: Send,
{
move || {
com_guard();
let start = Instant::now();
let value = f();
(value, start.elapsed().as_micros() as u64)
}
}
fn join_or_default<T: Default>(handle: thread::ScopedJoinHandle<'_, (T, u64)>) -> (T, u64) {
handle.join().unwrap_or_else(|_| (T::default(), 0))
}
fn collect_cpu() -> Option<CpuStats> {
#[cfg(target_os = "windows")]
{
crate::platform::windows::read_cpu_stats().ok()
}
#[cfg(target_os = "linux")]
{
crate::platform::linux::read_cpu_stats().ok()
}
#[cfg(target_os = "macos")]
{
crate::platform::macos::read_cpu_stats().ok()
}
#[cfg(not(any(target_os = "windows", target_os = "linux", target_os = "macos")))]
{
None
}
}
fn collect_memory() -> Option<MemoryStats> {
#[cfg(target_os = "windows")]
{
crate::platform::windows::read_memory_stats().ok()
}
#[cfg(target_os = "linux")]
{
crate::platform::linux::read_memory_stats().ok()
}
#[cfg(target_os = "macos")]
{
crate::platform::macos::read_memory_stats().ok()
}
#[cfg(not(any(target_os = "windows", target_os = "linux", target_os = "macos")))]
{
None
}
}
fn collect_system_stats() -> Option<SystemStats> {
SystemStats::new().ok()
}
fn collect_gpu(gpu: Option<&GpuCollection>) -> Vec<Option<GpuDynamicInfo>> {
let Some(collection) = gpu else {
return Vec::new();
};
collection
.snapshot_all_partial()
.into_iter()
.map(|result| result.ok().map(|info| info.dynamic_info))
.collect()
}
fn collect_processes(monitor: Option<&mut ProcessMonitor>) -> Option<Vec<ProcessMonitorInfo>> {
monitor?.processes().ok()
}
fn collect_connections(
monitor: Option<&mut ConnectionMonitor>,
) -> (Vec<ConnectionInfo>, Vec<String>) {
monitor
.map(|m| m.all_connections_checked())
.unwrap_or_else(|| (Vec::new(), vec!["Connection collector unavailable".into()]))
}
fn collect_network(monitor: Option<&mut NetworkMonitor>) -> Vec<NetSnapshot> {
let Some(monitor) = monitor else {
return Vec::new();
};
let Ok(interfaces) = monitor.interfaces() else {
return Vec::new();
};
let is_virtual = |name: &str| {
name.starts_with("lo")
|| name.contains("Loopback")
|| name.starts_with("vEthernet")
|| name.starts_with("Local Area Connection*")
|| name.starts_with("VMware")
|| name.starts_with("VirtualBox")
};
let mut out: Vec<NetSnapshot> = interfaces
.iter()
.filter(|i| !is_virtual(&i.name) && i.is_active())
.map(|i| {
let rate = monitor.bandwidth_rate(&i.name, i);
NetSnapshot {
name: i.name.clone(),
is_up: i.is_up,
rx_bytes: i.rx_bytes,
tx_bytes: i.tx_bytes,
rx_rate: rate.map(|(rx, _)| rx),
tx_rate: rate.map(|(_, tx)| tx),
speed_mbps: i.speed_mbps,
}
})
.collect();
if out.is_empty() {
out = interfaces
.iter()
.filter(|i| !i.name.starts_with("lo") && !i.name.contains("Loopback") && i.is_active())
.map(|i| {
let rate = monitor.bandwidth_rate(&i.name, i);
NetSnapshot {
name: i.name.clone(),
is_up: i.is_up,
rx_bytes: i.rx_bytes,
tx_bytes: i.tx_bytes,
rx_rate: rate.map(|(rx, _)| rx),
tx_rate: rate.map(|(_, tx)| tx),
speed_mbps: i.speed_mbps,
}
})
.collect();
}
out
}
fn collect_disk_io() -> Vec<DiskIoSnapshot> {
let mut out: Vec<DiskIoSnapshot> = crate::disk::all_io_counters()
.into_iter()
.map(|(device, io)| DiskIoSnapshot {
device,
read_bytes: io.read_bytes,
write_bytes: io.write_bytes,
})
.collect();
out.sort_by(|a, b| a.device.cmp(&b.device));
out
}
#[cfg(target_os = "windows")]
fn collect_disks() -> Vec<DiskSnapshot> {
crate::platform::windows::logical_drives()
.map(|drives| {
drives
.into_iter()
.map(|d| DiskSnapshot {
name: d.name.clone(),
mount_point: d.name,
total: Some(d.total),
used: Some(d.used),
filesystem: d.filesystem,
read_rate: None,
write_rate: None,
})
.collect()
})
.unwrap_or_default()
}
#[cfg(not(target_os = "windows"))]
fn collect_disks() -> Vec<DiskSnapshot> {
let Ok(disks) = crate::disk::enumerate_disks() else {
return Vec::new();
};
disks
.iter()
.filter_map(|disk| {
let info = disk.info().ok()?;
let (mount_point, filesystem, used, total) = disk
.filesystem_info()
.ok()
.and_then(|fs_infos| fs_infos.first().cloned())
.map(|fs| {
(
fs.mount_point.to_string_lossy().to_string(),
fs.fs_type.clone(),
fs.used_size,
fs.total_size,
)
})
.unwrap_or_else(|| ("N/A".to_string(), "N/A".to_string(), None, info.capacity));
let (read_rate, write_rate) = disk
.io_stats()
.ok()
.map(|io| {
(
io.read_throughput.map(|v| v as f64),
io.write_throughput.map(|v| v as f64),
)
})
.unwrap_or((None, None));
Some(DiskSnapshot {
name: info.model.unwrap_or_else(|| disk.name().to_string()),
mount_point,
total,
used,
filesystem,
read_rate,
write_rate,
})
})
.collect()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn collect_processes_without_a_monitor_reports_no_table() {
assert!(collect_processes(None).is_none());
}
#[cfg(target_os = "macos")]
#[test]
fn macos_gui_pipeline_reads_real_cpu_and_memory() {
let cpu = collect_cpu().expect("macOS GUI pipeline CPU reader");
assert!(!cpu.cores.is_empty());
let memory = collect_memory().expect("macOS GUI pipeline memory reader");
assert!(memory.ram.total > 0);
}
#[test]
fn tick_period_bounds_collection_duty_cycle() {
let period = |elapsed_ms: u64, interval_ms: u64, duty: f32| -> Duration {
let elapsed = Duration::from_millis(elapsed_ms);
let interval = Duration::from_millis(interval_ms);
interval.max(elapsed.div_f32(duty.clamp(0.05, 1.0)))
};
let ms = |d: Duration| d.as_millis() as u64;
assert_eq!(ms(period(20, 1000, 0.5)), 1000);
assert_eq!(ms(period(500, 1000, 0.5)), 1000);
assert_eq!(ms(period(1500, 1000, 0.5)), 3000);
assert_eq!(ms(period(1000, 1000, 0.25)), 4000);
for elapsed_ms in [1u64, 50, 500, 1500, 5000] {
for duty in [0.1f32, 0.25, 0.5, 1.0] {
let p = period(elapsed_ms, 1000, duty).as_secs_f64();
let ratio = Duration::from_millis(elapsed_ms).as_secs_f64() / p;
assert!(
ratio <= duty as f64 + 1e-6,
"elapsed {elapsed_ms}ms over period {p}s gives duty {ratio}, over budget {duty}"
);
}
}
}
#[test]
fn push_capped_keeps_newest_samples() {
let mut series = Vec::new();
for i in 0..10 {
push_capped(&mut series, i as f32, 4);
}
assert_eq!(series.len(), 4, "series must be bounded by cap");
assert_eq!(series, vec![6.0, 7.0, 8.0, 9.0], "oldest samples evicted");
}
#[test]
fn push_capped_handles_cap_of_one() {
let mut series = Vec::new();
push_capped(&mut series, 1.0, 1);
push_capped(&mut series, 2.0, 1);
assert_eq!(series, vec![2.0]);
}
#[test]
fn critical_path_is_max_not_sum() {
let t = StageTimings {
cpu_us: 100,
memory_us: 50,
gpu_us: 900,
process_us: 400,
..Default::default()
};
assert_eq!(
t.critical_path_us(),
900,
"critical path is the slowest stage"
);
assert_eq!(t.serial_us(), 1450, "serial cost is the sum");
assert!(
t.critical_path_us() < t.serial_us(),
"concurrent collection must beat serial"
);
}
#[test]
fn default_snapshot_is_generation_zero() {
let snap = Snapshot::default();
assert_eq!(snap.generation, 0, "readers treat gen 0 as not-ready");
assert_eq!(snap.cpu_utilization(), None);
assert_eq!(snap.memory_utilization(), None);
}
#[test]
fn snapshot_aggregates_network_rates() {
let snap = Snapshot {
network: vec![
NetSnapshot {
rx_rate: Some(1.5),
tx_rate: Some(0.5),
..Default::default()
},
NetSnapshot {
rx_rate: Some(2.5),
tx_rate: Some(1.5),
..Default::default()
},
],
..Default::default()
};
assert_eq!(snap.total_rx_rate(), Some(4.0));
assert_eq!(snap.total_tx_rate(), Some(2.0));
}
#[test]
fn snapshot_totals_need_every_interface_to_have_a_rate() {
let partial = Snapshot {
network: vec![
NetSnapshot {
rx_rate: Some(3.0),
tx_rate: None,
..Default::default()
},
NetSnapshot {
rx_rate: None,
tx_rate: None,
..Default::default()
},
],
..Default::default()
};
assert_eq!(
partial.total_rx_rate(),
None,
"one interface has no rate yet"
);
assert_eq!(partial.total_tx_rate(), None);
let none_yet = Snapshot {
network: vec![NetSnapshot::default()],
..Default::default()
};
assert_eq!(none_yet.total_rx_rate(), None);
let no_interfaces = Snapshot::default();
assert_eq!(no_interfaces.total_rx_rate(), None);
assert_eq!(no_interfaces.total_tx_rate(), None);
}
#[test]
fn handle_is_lock_free_readable_and_stoppable() {
let slot = Arc::new(ArcSwap::from_pointee(Snapshot::default()));
let handle = SnapshotHandle {
slot: Arc::clone(&slot),
stop: Arc::new(AtomicBool::new(false)),
interval_ms: Arc::new(AtomicU64::new(1000)),
};
assert_eq!(handle.generation(), 0);
slot.store(Arc::new(Snapshot {
generation: 7,
..Default::default()
}));
assert_eq!(handle.generation(), 7, "readers see the newest publish");
assert_eq!(handle.latest().generation, 7);
handle.set_interval(Duration::from_millis(250));
assert_eq!(handle.interval(), Duration::from_millis(250));
assert!(!handle.is_stopping());
handle.request_stop();
assert!(handle.is_stopping());
}
#[test]
fn first_publish_does_not_wait_for_driver_enumeration() {
let collector = Collector::spawn(CollectorConfig {
interval: Duration::from_millis(200),
..Default::default()
});
let handle = collector.handle();
let start = Instant::now();
while handle.generation() == 0 && start.elapsed() < Duration::from_secs(60) {
thread::sleep(Duration::from_millis(1));
}
let first = handle.latest();
assert!(
first.generation > 0,
"collector published nothing within 60s"
);
assert!(
first.cpu.is_some() || first.memory.is_some(),
"the first snapshot carried no CPU or memory sample, so the warm-up \
publish is not doing its job — consumers would render an empty UI \
until driver enumeration completed"
);
}
#[test]
fn snapshot_is_send_and_sync() {
fn assert_send_sync<T: Send + Sync>() {}
assert_send_sync::<Snapshot>();
assert_send_sync::<SnapshotHandle>();
}
}