init

agent/src/collector.rs

@@ -0,0 +1,109 @@
+use common::metrics::{CPU, Disk, Memory, Metrics, Network, SystemInfo};
+use sysinfo::{Disks, Networks, System};
+
+pub struct Collector {
+    sys: System,
+    disks: Disks,
+    networks: Networks,
+}
+
+impl Collector {
+    pub fn new() -> Self {
+        Collector {
+            sys: System::new_all(),
+            disks: Disks::new_with_refreshed_list(),
+            networks: Networks::new_with_refreshed_list(),
+        }
+    }
+
+    pub fn collect_all(&mut self) -> Metrics {
+        let system_info = self.collect_sysinfo();
+
+        self.sys.refresh_cpu_usage();
+        self.sys.refresh_memory();
+        self.networks.refresh(true);
+
+        let cpu = self.collect_cpu();
+        let disk = self.collect_disk();
+        let memory = self.collect_memory();
+        let network = self.collect_network();
+
+        let metrics = Metrics {
+            system_info,
+            cpu,
+            disk,
+            memory,
+            network,
+        };
+
+        metrics
+    }
+
+    fn collect_sysinfo(&self) -> SystemInfo {
+        let system_info = SystemInfo {
+            uptime: System::uptime(),
+            host: System::host_name(),
+            name: System::name(),
+            kernel: System::kernel_version(),
+            os_version: System::os_version(),
+        };
+
+        system_info
+    }
+
+    fn collect_cpu(&self) -> CPU {
+        let cpus = self.sys.cpus();
+
+        let threads = cpus.len();
+        let usage = self.sys.global_cpu_usage();
+
+        CPU {
+            brand: String::from(cpus[0].brand()),
+            usage,
+            threads,
+        }
+    }
+
+    fn collect_disk(&self) -> Disk {
+        let disk = self
+            .disks
+            .iter()
+            .max_by_key(|disk| disk.total_space())
+            .unwrap();
+
+        let total = disk.total_space();
+        let free = disk.available_space();
+
+        Disk {
+            used: total - free,
+            free,
+            total
+        }
+    }
+
+    fn collect_memory(&self) -> Memory {
+        let memory_metrics = Memory {
+            used: self.sys.used_memory(),
+            total: self.sys.total_memory(),
+            swap_used: self.sys.used_swap(),
+            swap_total: self.sys.total_swap(),
+        };
+
+        memory_metrics
+    }
+
+    fn collect_network(&self) -> Network {
+        let (down, up): (u64, u64) = self.networks
+            .values()
+            .map(|data| (data.received(), data.transmitted()))
+            .fold((0, 0), |(acc_down, acc_up), (down, up)| {
+                (acc_down + down, acc_up + up)
+            });
+
+        Network {
+            down,
+            up,
+        }
+    }
+
+}