m1ngsama/tracker
1
0
Fork 0
mirror of https://github.com/m1ngsama/tracker.git synced 2025-12-24 10:51:43 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

style: apply cargo fmt

Browse source 
Formatted Rust code to pass CI style checks.
This commit is contained in:
m1ngsama 2025-12-18 13:18:54 +08:00
parent 0e9c5a33c3
commit 22cbc1d019
6 changed files with 60 additions and 31 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
src/alert.rs
View file

@ -17,7 +17,10 @@ impl AlertSystem {
pub fn check_cpu_alert(&mut self, cpu_percent: f32) -> bool {
let threshold = self.config.alert_thresholds.cpu_percent;
if cpu_percent > threshold {
let message = format!("CPU usage is {:.2}% (threshold: {:.2}%)", cpu_percent, threshold);
let message = format!(
"CPU usage is {:.2}% (threshold: {:.2}%)",
cpu_percent, threshold
);
self.trigger_alert("CPU", &message);
return true;
}
@ -27,7 +30,10 @@ impl AlertSystem {
pub fn check_memory_alert(&mut self, memory_percent: f32) -> bool {
let threshold = self.config.alert_thresholds.memory_percent;
if memory_percent > threshold {
let message = format!("Memory usage is {:.2}% (threshold: {:.2}%)", memory_percent, threshold);
let message = format!(
"Memory usage is {:.2}% (threshold: {:.2}%)",
memory_percent, threshold
);
self.trigger_alert("Memory", &message);
return true;
}
@ -37,7 +43,10 @@ impl AlertSystem {
pub fn check_disk_alert(&mut self, disk_percent: f32) -> bool {
let threshold = self.config.alert_thresholds.disk_percent;
if disk_percent > threshold {
let message = format!("Disk usage is {:.2}% (threshold: {:.2}%)", disk_percent, threshold);
let message = format!(
"Disk usage is {:.2}% (threshold: {:.2}%)",
disk_percent, threshold
);
self.trigger_alert("Disk", &message);
return true;
}
@ -45,7 +54,8 @@ impl AlertSystem {
}
fn trigger_alert(&mut self, alert_type: &str, message: &str) {
self.logger.log_alert(&format!("{}: {}", alert_type, message));
self.logger
.log_alert(&format!("{}: {}", alert_type, message));
println!("\n⚠️ ALERT: {}", message);
}
}
}

2
src/config.rs
View file

@ -1,7 +1,7 @@
use anyhow::Result;
use serde::{Deserialize, Serialize};
use std::fs;
use std::path::Path;
use anyhow::Result;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Config {

2
src/logger.rs
View file

@ -49,4 +49,4 @@ impl Default for TrackerLogger {
fn default() -> Self {
Self::new("logs")
}
}
}

9
src/main.rs
View file

@ -2,12 +2,12 @@ use clap::Parser;
use std::thread;
use std::time::Duration;
mod alert;
mod config;
mod logger;
mod monitor;
mod process;
mod temperature;
mod alert;
mod logger;
use config::Config;
use monitor::SystemMonitor;
@ -41,7 +41,10 @@ fn main() {
let mut monitor = SystemMonitor::new(config);
if args.continuous {
log::info!("Starting continuous monitoring mode with {}s interval", args.interval);
log::info!(
"Starting continuous monitoring mode with {}s interval",
args.interval
);
loop {
monitor.display_stats();
thread::sleep(Duration::from_secs(args.interval));

46
src/monitor.rs
View file

@ -1,10 +1,10 @@
use crate::alert::AlertSystem;
use crate::config::Config;
use crate::logger::TrackerLogger;
use crate::process::ProcessMonitor;
use crate::temperature::TemperatureMonitor;
use crate::alert::AlertSystem;
use crate::logger::TrackerLogger;
use sysinfo::{System, Disks, Networks};
use chrono::Local;
use sysinfo::{Disks, Networks, System};
pub struct SystemMonitor {
config: Config,
@ -57,15 +57,15 @@ impl SystemMonitor {
pub fn get_disk_usage(&mut self) -> DiskInfo {
self.disks.refresh();
let mut total: u64 = 0;
let mut available: u64 = 0;
for disk in &self.disks {
total += disk.total_space();
available += disk.available_space();
}
let used = total.saturating_sub(available);
let percent = if total > 0 {
(used as f32 / total as f32) * 100.0
@ -82,10 +82,10 @@ impl SystemMonitor {
pub fn get_network_stats(&mut self) -> NetworkStats {
self.networks.refresh();
let mut bytes_sent = 0;
let mut bytes_recv = 0;
for (_, network) in &self.networks {
bytes_sent += network.total_transmitted();
bytes_recv += network.total_received();
@ -99,7 +99,10 @@ impl SystemMonitor {
pub fn display_stats(&mut self) {
println!("\n{}", "=".repeat(50));
println!("System Tracker - {}", Local::now().format("%Y-%m-%d %H:%M:%S"));
println!(
"System Tracker - {}",
Local::now().format("%Y-%m-%d %H:%M:%S")
);
println!("{}\n", "=".repeat(50));
if self.config.display.show_cpu {
@ -111,37 +114,46 @@ impl SystemMonitor {
if self.config.display.show_memory {
let mem = self.get_memory_info();
println!("Memory: {:.2}% ({:.2}GB / {:.2}GB)",
println!(
"Memory: {:.2}% ({:.2}GB / {:.2}GB)",
mem.percent,
mem.used as f64 / (1024_f64.powi(3)),
mem.total as f64 / (1024_f64.powi(3))
);
self.logger.log_stats("Memory", &format!("{:.2}%", mem.percent));
self.logger
.log_stats("Memory", &format!("{:.2}%", mem.percent));
self.alert_system.check_memory_alert(mem.percent);
}
if self.config.display.show_disk {
let disk = self.get_disk_usage();
println!("Disk: {:.2}% ({:.2}GB / {:.2}GB)",
println!(
"Disk: {:.2}% ({:.2}GB / {:.2}GB)",
disk.percent,
disk.used as f64 / (1024_f64.powi(3)),
disk.total as f64 / (1024_f64.powi(3))
);
self.logger.log_stats("Disk", &format!("{:.2}%", disk.percent));
self.logger
.log_stats("Disk", &format!("{:.2}%", disk.percent));
self.alert_system.check_disk_alert(disk.percent);
}
if self.config.display.show_network {
let net = self.get_network_stats();
println!("Network: Sent {:.2}MB | Recv {:.2}MB",
println!(
"Network: Sent {:.2}MB | Recv {:.2}MB",
net.bytes_sent as f64 / (1024_f64.powi(2)),
net.bytes_recv as f64 / (1024_f64.powi(2))
);
self.logger.log_stats("Network", &format!("Sent: {} Recv: {}", net.bytes_sent, net.bytes_recv));
self.logger.log_stats(
"Network",
&format!("Sent: {} Recv: {}", net.bytes_sent, net.bytes_recv),
);
}
if self.config.display.show_processes {
self.process_monitor.display_processes(self.config.process_limit);
self.process_monitor
.display_processes(self.config.process_limit);
}
if self.config.display.show_temperatures {
@ -168,4 +180,4 @@ pub struct DiskInfo {
pub struct NetworkStats {
pub bytes_sent: u64,
pub bytes_recv: u64,
}
}

12
src/process.rs
View file

@ -21,8 +21,10 @@ impl ProcessMonitor {
pub fn get_top_processes(&mut self, limit: usize) -> Vec<ProcessInfo> {
self.sys.refresh_all();
let mut processes: Vec<ProcessInfo> = self.sys.processes()
let mut processes: Vec<ProcessInfo> = self
.sys
.processes()
.iter()
.map(|(pid, process)| {
let total_memory = self.sys.total_memory() as f32;
@ -57,8 +59,10 @@ impl ProcessMonitor {
println!("{}", "-".repeat(60));
for proc in self.get_top_processes(limit) {
println!("{:<10}{:<30}{:<10.2}{:<10.2}",
proc.pid, proc.name, proc.cpu_percent, proc.memory_percent);
println!(
"{:<10}{:<30}{:<10.2}{:<10.2}",
proc.pid, proc.name, proc.cpu_percent, proc.memory_percent
);
}
println!("\nTotal Processes: {}", self.get_process_count());