Include uptime, read and write I/O

src/resources/operations.rs

@@ -1,38 +1,54 @@
 use serde::{Deserialize, Serialize};
 use crate::squire;
-use sysinfo::{Pid, System};
+use sysinfo::{Pid, ProcessesToUpdate, System};
 
 #[derive(Serialize, Deserialize, Debug)]
 pub struct Usage {
     name: String,
     pid: u32,
     cpu: String,
     memory: String,
+    uptime: String,
+    read_io: String,
+    write_io: String
 }
 
-pub fn process_monitor(system: &System, process_names: &Vec<String>) -> Vec<Usage> {
+pub fn process_monitor(system: &mut System, process_names: &Vec<String>) -> Vec<Usage> {
     let mut usages: Vec<Usage> = Vec::new();
+    system.refresh_processes(ProcessesToUpdate::All);
     for (pid, process) in system.processes() {
         let process_name = process.name().to_str().unwrap().to_string();
         if process_names.iter().any(|given_name| process_name.contains(given_name)) {
             let cpu_usage = process.cpu_usage();
             let memory_usage = process.memory();
-            let cpu = format!("{}", cpu_usage);
+            let cpu = format!("{:.2}%", cpu_usage);
             let memory = squire::util::size_converter(memory_usage);
             let pid_32 = pid.as_u32();
+
+            let uptime = squire::util::convert_seconds(process.run_time() as i64);
+            let disk_usage = process.disk_usage();
+            let written = squire::util::size_converter(disk_usage.total_written_bytes);
+            let written_since = squire::util::size_converter(disk_usage.written_bytes);
+            let read = squire::util::size_converter(disk_usage.total_read_bytes);
+            let read_since = squire::util::size_converter(disk_usage.read_bytes);
+
             usages.push(Usage {
                 name: process_name,
                 pid: pid_32,
                 cpu,
                 memory,
+                uptime,
+                read_io: format!("{}/{}", read_since, read),
+                write_io: format!("{}/{}", written_since, written)
             });
         }
     }
     usages
 }
 
-pub fn service_monitor(system: &System, service_names: &Vec<String>) -> Vec<Usage> {
+pub fn service_monitor(system: &mut System, service_names: &Vec<String>) -> Vec<Usage> {
     let mut usages: Vec<Usage> = Vec::new();
+    system.refresh_processes(ProcessesToUpdate::All);
     for service_name in service_names {
         match service_monitor_fn(system, &service_name) {
             Ok(usage) => usages.push(usage),
@@ -43,6 +59,9 @@ pub fn service_monitor(system: &System, service_names: &Vec<String>) -> Vec<Usag
                     pid: 0000,
                     memory: "N/A".to_string(),
                     cpu: "N/A".to_string(),
+                    uptime: "N/A".to_string(),
+                    read_io: "N/A".to_string(),
+                    write_io: "N/A".to_string()
                 });
             }
         };
@@ -59,14 +78,25 @@ fn service_monitor_fn(system: &System, service_name: &String) -> Result<Usage, S
     if let Some(process) = system.process(sys_pid) {
         let cpu_usage = process.cpu_usage();
         let memory_usage = process.memory();
-        let cpu = format!("{}", cpu_usage);
+        let cpu = format!("{:.2}%", cpu_usage);
         let memory = squire::util::size_converter(memory_usage);
         let pid_32 = sys_pid.as_u32();
+
+        let uptime = squire::util::convert_seconds(process.run_time() as i64);
+        let disk_usage = process.disk_usage();
+        let written = squire::util::size_converter(disk_usage.total_written_bytes);
+        let written_since = squire::util::size_converter(disk_usage.written_bytes);
+        let read = squire::util::size_converter(disk_usage.total_read_bytes);
+        let read_since = squire::util::size_converter(disk_usage.read_bytes);
+
         Ok(Usage {
             name: service_name.to_string(),
             pid: pid_32,
             cpu,
             memory,
+            uptime,
+            read_io: format!("{}/{}", read_since, read),
+            write_io: format!("{}/{}", written_since, written)
         })
     } else {
         Err(format!("Process with PID {} not found", pid))

src/resources/stream.rs

@@ -63,18 +63,18 @@ fn get_docker_stats() -> Result<Vec<serde_json::Value>, Box<dyn std::error::Erro
 }
 
 fn get_service_stats(
-    system: &System,
+    system: &mut System,
     config: &squire::settings::Config
 ) -> Vec<serde_json::Value> {
-    let usages = resources::operations::service_monitor(&system, &config.services);
+    let usages = resources::operations::service_monitor(system, &config.services);
     usages.into_iter().map(|usage| serde_json::to_value(usage).unwrap()).collect()
 }
 
 fn get_process_stats(
-    system: &System,
+    system: &mut System,
     config: &squire::settings::Config
 ) -> Vec<serde_json::Value> {
-    let usages = resources::operations::process_monitor(&system, &config.processes);
+    let usages = resources::operations::process_monitor(system, &config.processes);
     usages.into_iter().map(|usage| serde_json::to_value(usage).unwrap()).collect()
 }
 
@@ -151,11 +151,11 @@ pub fn system_resources(config: &squire::settings::Config) -> HashMap<String, se
     system_metrics.insert("cpu_usage".to_string(), serde_json::json!(cpu_percent));
     system_metrics.insert("docker_stats".to_string(), serde_json::json!(docker_stats));
     if !config.services.is_empty() {
-        let service_stats = get_service_stats(&system, &config);
+        let service_stats = get_service_stats(&mut system, &config);
         system_metrics.insert("service_stats".to_string(), serde_json::json!(service_stats));
     }
     if !config.processes.is_empty() {
-        let process_stats = get_process_stats(&system, &config);
+        let process_stats = get_process_stats(&mut system, &config);
         system_metrics.insert("process_stats".to_string(), serde_json::json!(process_stats));
     }
     system_metrics

src/templates/monitor.rs

@@ -344,6 +344,9 @@ pub fn get_content() -> String {
                 <th>Service Name</th>
                 <th>CPU %</th>
                 <th>Memory Usage</th>
+                <th>Uptime</th>
+                <th>Read I/O</th>
+                <th>Write I/O</th>
             </tr>
         </thead>
         <tbody>
@@ -359,6 +362,9 @@ pub fn get_content() -> String {
                 <th>Process Name</th>
                 <th>CPU %</th>
                 <th>Memory Usage</th>
+                <th>Uptime</th>
+                <th>Read I/O</th>
+                <th>Write I/O</th>
             </tr>
         </thead>
         <tbody>
@@ -451,6 +457,9 @@ pub fn get_content() -> String {
                         <td>${service.name}</td>
                         <td>${service.cpu}</td>
                         <td>${service.memory}</td>
+                        <td>${service.uptime}</td>
+                        <td>${service.read_io}</td>
+                        <td>${service.write_io}</td>
                     `;
                     tableBody.appendChild(row);
                 });
@@ -481,6 +490,9 @@ pub fn get_content() -> String {
                         <td>${process.name}</td>
                         <td>${process.cpu}</td>
                         <td>${process.memory}</td>
+                        <td>${process.uptime}</td>
+                        <td>${process.read_io}</td>
+                        <td>${process.write_io}</td>
                     `;
                     tableBody.appendChild(row);
                 });