diff --git a/src/alert.rs b/src/alert.rs
index fba1240..c599fe8 100644
--- a/src/alert.rs
+++ b/src/alert.rs
@@ -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);
     }
-}
\ No newline at end of file
+}
diff --git a/src/config.rs b/src/config.rs
index 5eac9b5..393d3bc 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -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 {
diff --git a/src/logger.rs b/src/logger.rs
index 801b665..ef701e3 100644
--- a/src/logger.rs
+++ b/src/logger.rs
@@ -49,4 +49,4 @@ impl Default for TrackerLogger {
     fn default() -> Self {
         Self::new("logs")
     }
-}
\ No newline at end of file
+}
diff --git a/src/main.rs b/src/main.rs
index 4507f3c..8a8c9f0 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -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));
diff --git a/src/monitor.rs b/src/monitor.rs
index 6ebd2c3..065f809 100644
--- a/src/monitor.rs
+++ b/src/monitor.rs
@@ -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,
-}
\ No newline at end of file
+}
diff --git a/src/process.rs b/src/process.rs
index 1be1c20..2fec83b 100644
--- a/src/process.rs
+++ b/src/process.rs
@@ -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());