Initial Meterbox commit with boot disk usage metric.

Co-authored-by: Cursor <cursoragent@cursor.com>

backend/src/metrics.rs

@@ -0,0 +1,203 @@
+use serde::Serialize;
+use sysinfo::{Networks, System};
+
+#[derive(Debug, Clone, Serialize)]
+pub struct Sample {
+    pub ts: i64,
+    pub cpu_pct: f32,
+    pub mem_used_bytes: u64,
+    pub mem_total_bytes: u64,
+    pub mem_pct: f32,
+    pub disk_used_bytes: u64,
+    pub disk_total_bytes: u64,
+    pub disk_pct: f32,
+    pub net_rx_bps: f64,
+    pub net_tx_bps: f64,
+    pub load1: f64,
+    pub load5: f64,
+    pub load15: f64,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct HostInfo {
+    pub hostname: String,
+    pub os: String,
+    pub kernel: String,
+    pub cpus: usize,
+    pub mem_total_bytes: u64,
+    pub disk_used_bytes: u64,
+    pub disk_total_bytes: u64,
+    pub disk_pct: f32,
+    pub uptime_secs: u64,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct DiskUsage {
+    pub used_bytes: u64,
+    pub total_bytes: u64,
+    pub pct: f32,
+}
+
+/// Boot / root filesystem usage via `statvfs("/")`.
+pub fn boot_disk_usage() -> DiskUsage {
+    #[cfg(target_os = "linux")]
+    {
+        use std::ffi::CString;
+        let Ok(path) = CString::new("/") else {
+            return DiskUsage {
+                used_bytes: 0,
+                total_bytes: 0,
+                pct: 0.0,
+            };
+        };
+        let mut buf: libc::statvfs = unsafe { std::mem::zeroed() };
+        let rc = unsafe { libc::statvfs(path.as_ptr(), &mut buf) };
+        if rc != 0 {
+            return DiskUsage {
+                used_bytes: 0,
+                total_bytes: 0,
+                pct: 0.0,
+            };
+        }
+        let frsize = buf.f_frsize as u64;
+        let total = buf.f_blocks as u64 * frsize;
+        let available = buf.f_bavail as u64 * frsize;
+        let used = total.saturating_sub(available);
+        let pct = if total > 0 {
+            (used as f64 / total as f64 * 100.0) as f32
+        } else {
+            0.0
+        };
+        return DiskUsage {
+            used_bytes: used,
+            total_bytes: total,
+            pct,
+        };
+    }
+    #[cfg(not(target_os = "linux"))]
+    {
+        DiskUsage {
+            used_bytes: 0,
+            total_bytes: 0,
+            pct: 0.0,
+        }
+    }
+}
+
+pub struct Sampler {
+    sys: System,
+    networks: Networks,
+    last_rx: u64,
+    last_tx: u64,
+    last_ts: Option<i64>,
+    primed: bool,
+}
+
+impl Sampler {
+    pub fn new() -> Self {
+        let mut sys = System::new();
+        sys.refresh_memory();
+        sys.refresh_cpu_all();
+        let networks = Networks::new_with_refreshed_list();
+        Self {
+            sys,
+            networks,
+            last_rx: 0,
+            last_tx: 0,
+            last_ts: None,
+            primed: false,
+        }
+    }
+
+    pub fn host_info(&mut self) -> HostInfo {
+        self.sys.refresh_memory();
+        let disk = boot_disk_usage();
+        HostInfo {
+            hostname: hostname::get()
+                .ok()
+                .and_then(|h| h.into_string().ok())
+                .unwrap_or_else(|| "unknown".into()),
+            os: System::long_os_version().unwrap_or_else(|| "unknown".into()),
+            kernel: System::kernel_version().unwrap_or_else(|| "unknown".into()),
+            cpus: self
+                .sys
+                .physical_core_count()
+                .unwrap_or_else(|| self.sys.cpus().len())
+                .max(1),
+            mem_total_bytes: self.sys.total_memory(),
+            disk_used_bytes: disk.used_bytes,
+            disk_total_bytes: disk.total_bytes,
+            disk_pct: disk.pct,
+            uptime_secs: System::uptime(),
+        }
+    }
+
+    pub fn sample(&mut self) -> Sample {
+        self.sys.refresh_cpu_all();
+        self.sys.refresh_memory();
+        self.networks.refresh(true);
+
+        let now = chrono::Utc::now().timestamp();
+        let cpu_pct = self.sys.global_cpu_usage();
+        let mem_total = self.sys.total_memory();
+        let mem_used = self.sys.used_memory();
+        let mem_pct = if mem_total > 0 {
+            (mem_used as f64 / mem_total as f64 * 100.0) as f32
+        } else {
+            0.0
+        };
+        let disk = boot_disk_usage();
+
+        let (rx, tx) = aggregate_networks(&self.networks);
+        let (rx_bps, tx_bps) = if let Some(prev) = self.last_ts {
+            let dt = (now - prev).max(1) as f64;
+            if self.primed && rx >= self.last_rx && tx >= self.last_tx {
+                (
+                    (rx - self.last_rx) as f64 / dt,
+                    (tx - self.last_tx) as f64 / dt,
+                )
+            } else {
+                (0.0, 0.0)
+            }
+        } else {
+            (0.0, 0.0)
+        };
+
+        self.last_rx = rx;
+        self.last_tx = tx;
+        self.last_ts = Some(now);
+        self.primed = true;
+
+        let load = System::load_average();
+
+        Sample {
+            ts: now,
+            cpu_pct,
+            mem_used_bytes: mem_used,
+            mem_total_bytes: mem_total,
+            mem_pct,
+            disk_used_bytes: disk.used_bytes,
+            disk_total_bytes: disk.total_bytes,
+            disk_pct: disk.pct,
+            net_rx_bps: rx_bps,
+            net_tx_bps: tx_bps,
+            load1: load.one,
+            load5: load.five,
+            load15: load.fifteen,
+        }
+    }
+}
+
+fn aggregate_networks(networks: &Networks) -> (u64, u64) {
+    let mut rx = 0u64;
+    let mut tx = 0u64;
+    for (name, data) in networks.iter() {
+        let n = name.to_lowercase();
+        if n == "lo" || n.starts_with("docker") || n.starts_with("br-") || n.starts_with("veth") {
+            continue;
+        }
+        rx = rx.saturating_add(data.total_received());
+        tx = tx.saturating_add(data.total_transmitted());
+    }
+    (rx, tx)
+}