Merge branch 'master' into feature/wss-selfsigned

socktop_agent/src/metrics.rs

@@ -4,8 +4,11 @@ use crate::gpu::collect_all_gpus;
 use crate::state::AppState;
 use crate::types::{DiskInfo, Metrics, NetworkInfo, ProcessInfo, ProcessesPayload};
 use once_cell::sync::OnceCell;
+#[cfg(target_os = "linux")]
 use std::collections::HashMap;
+#[cfg(target_os = "linux")]
 use std::fs;
+#[cfg(target_os = "linux")]
 use std::io;
 use std::sync::Mutex;
 use std::time::{Duration, Instant};
@@ -198,6 +201,8 @@ pub async fn collect_disks(state: &AppState) -> Vec<DiskInfo> {
         .collect()
 }
 
+// Linux-only helpers and implementation using /proc deltas for accurate CPU%.
+#[cfg(target_os = "linux")]
 #[inline]
 fn read_total_jiffies() -> io::Result<u64> {
     // /proc/stat first line: "cpu  user nice system idle iowait irq softirq steal ..."
@@ -216,6 +221,7 @@ fn read_total_jiffies() -> io::Result<u64> {
     Err(io::Error::other("no cpu line"))
 }
 
+#[cfg(target_os = "linux")]
 #[inline]
 fn read_proc_jiffies(pid: u32) -> Option<u64> {
     let path = format!("/proc/{pid}/stat");
@@ -230,11 +236,10 @@ fn read_proc_jiffies(pid: u32) -> Option<u64> {
     Some(utime.saturating_add(stime))
 }
 
-// Replace the body of collect_processes_top_k to use /proc deltas.
-// This makes CPU% = (delta_proc / delta_total) * 100 over the 2s interval.
+/// Collect top processes (Linux variant): compute CPU% via /proc jiffies delta.
+#[cfg(target_os = "linux")]
 pub async fn collect_processes_top_k(state: &AppState, k: usize) -> ProcessesPayload {
     // Fresh view to avoid lingering entries and select "no tasks" (no per-thread rows).
-    // Only processes, no per-thread entries.
     let mut sys = System::new();
     sys.refresh_processes_specifics(
         ProcessesToUpdate::All,
@@ -256,12 +261,20 @@ pub async fn collect_processes_top_k(state: &AppState, k: usize) -> ProcessesPay
 
     // Compute deltas vs last sample
     let (last_total, mut last_map) = {
-        let mut t = state.proc_cpu.lock().await;
-        let lt = t.last_total;
-        let lm = std::mem::take(&mut t.last_per_pid);
-        t.last_total = total_now;
-        t.last_per_pid = current.clone();
-        (lt, lm)
+        #[cfg(target_os = "linux")]
+        {
+            let mut t = state.proc_cpu.lock().await;
+            let lt = t.last_total;
+            let lm = std::mem::take(&mut t.last_per_pid);
+            t.last_total = total_now;
+            t.last_per_pid = current.clone();
+            (lt, lm)
+        }
+        #[cfg(not(target_os = "linux"))]
+        {
+            let _: u64 = total_now; // silence unused warning
+            (0u64, HashMap::new())
+        }
     };
 
     // On first run or if total delta is tiny, report zeros
@@ -308,6 +321,47 @@ pub async fn collect_processes_top_k(state: &AppState, k: usize) -> ProcessesPay
     }
 }
 
+/// Collect top processes (non-Linux): use sysinfo's internal CPU% by doing a double refresh.
+#[cfg(not(target_os = "linux"))]
+pub async fn collect_processes_top_k(state: &AppState, k: usize) -> ProcessesPayload {
+    use tokio::time::sleep;
+
+    let mut sys = state.sys.lock().await;
+
+    // First refresh to set baseline
+    sys.refresh_processes_specifics(
+        ProcessesToUpdate::All,
+        false,
+        ProcessRefreshKind::everything().without_tasks(),
+    );
+    // Small delay so sysinfo can compute CPU deltas on next refresh
+    sleep(Duration::from_millis(250)).await;
+    sys.refresh_processes_specifics(
+        ProcessesToUpdate::All,
+        false,
+        ProcessRefreshKind::everything().without_tasks(),
+    );
+
+    let total_count = sys.processes().len();
+
+    let mut procs: Vec<ProcessInfo> = sys
+        .processes()
+        .values()
+        .map(|p| ProcessInfo {
+            pid: p.pid().as_u32(),
+            name: p.name().to_string_lossy().into_owned(),
+            cpu_usage: p.cpu_usage(),
+            mem_bytes: p.memory(),
+        })
+        .collect();
+
+    procs = top_k_sorted(procs, k);
+    ProcessesPayload {
+        process_count: total_count,
+        top_processes: procs,
+    }
+}
+
 // Small helper to select and sort top-k by cpu
 fn top_k_sorted(mut v: Vec<ProcessInfo>, k: usize) -> Vec<ProcessInfo> {
     if v.len() > k {

socktop_agent/src/state.rs

@@ -1,5 +1,6 @@
 //! Shared agent state: sysinfo handles and hot JSON cache.
 
+#[cfg(target_os = "linux")]
 use std::collections::HashMap;
 use std::sync::atomic::AtomicUsize;
 use std::sync::Arc;
@@ -11,6 +12,7 @@ pub type SharedComponents = Arc<Mutex<Components>>;
 pub type SharedDisks = Arc<Mutex<Disks>>;
 pub type SharedNetworks = Arc<Mutex<Networks>>;
 
+#[cfg(target_os = "linux")]
 #[derive(Default)]
 pub struct ProcCpuTracker {
     pub last_total: u64,
@@ -24,7 +26,8 @@ pub struct AppState {
     pub disks: SharedDisks,
     pub networks: SharedNetworks,
 
-    // For correct per-process CPU% using /proc deltas
+    // For correct per-process CPU% using /proc deltas (Linux only path uses this tracker)
+    #[cfg(target_os = "linux")]
     pub proc_cpu: Arc<Mutex<ProcCpuTracker>>,
 
     // Connection tracking (to allow future idle sleeps if desired)
@@ -45,6 +48,7 @@ impl AppState {
             components: Arc::new(Mutex::new(components)),
             disks: Arc::new(Mutex::new(disks)),
             networks: Arc::new(Mutex::new(networks)),
+            #[cfg(target_os = "linux")]
             proc_cpu: Arc::new(Mutex::new(ProcCpuTracker::default())),
             client_count: Arc::new(AtomicUsize::new(0)),
             auth_token: std::env::var("SOCKTOP_TOKEN")