Implement real-time process monitoring and fix UI hardcoded data

This commit addresses several key issues identified during development: Major Changes: - Replace hardcoded top CPU/RAM process display with real system data - Add intelligent process monitoring to CpuCollector using ps command - Fix disk metrics permission issues in systemd collector - Optimize service collection to focus on status, memory, and disk only - Update dashboard widgets to display live process information Process Monitoring Implementation: - Added collect_top_cpu_process() and collect_top_ram_process() methods - Implemented ps-based monitoring with accurate CPU percentages - Added filtering to prevent self-monitoring artifacts (ps commands) - Enhanced error handling and validation for process data - Dashboard now shows realistic values like "claude (PID 2974) 11.0%" Service Collection Optimization: - Removed CPU monitoring from systemd collector for efficiency - Enhanced service directory permission error logging - Simplified services widget to show essential metrics only - Fixed service-to-directory mapping accuracy UI and Dashboard Improvements: - Reorganized dashboard layout with btop-inspired multi-panel design - Updated system panel to include real top CPU/RAM process display - Enhanced widget formatting and data presentation - Removed placeholder/hardcoded data throughout the interface Technical Details: - Updated agent/src/collectors/cpu.rs with process monitoring - Modified dashboard/src/ui/mod.rs for real-time process display - Enhanced systemd collector error handling and disk metrics - Updated CLAUDE.md documentation with implementation details
2025-10-16 23:55:05 +02:00
parent 7a664ef0fb
commit 8a36472a3d
81 changed files with 7702 additions and 9608 deletions
--- a/dashboard/src/ui/widgets/cpu.rs
+++ b/dashboard/src/ui/widgets/cpu.rs
@@ -0,0 +1,196 @@
+use cm_dashboard_shared::{Metric, MetricValue, Status};
+use ratatui::{
+    layout::{Constraint, Direction, Layout, Rect},
+    style::{Color, Style},
+    widgets::{Block, Borders, Gauge, Paragraph},
+    text::{Line, Span},
+    Frame,
+};
+use tracing::debug;
+
+use super::Widget;
+use crate::ui::theme::Theme;
+
+/// CPU widget displaying load, temperature, and frequency
+pub struct CpuWidget {
+    /// CPU load averages (1, 5, 15 minutes)
+    load_1min: Option<f32>,
+    load_5min: Option<f32>,
+    load_15min: Option<f32>,
+    /// CPU temperature in Celsius
+    temperature: Option<f32>,
+    /// CPU frequency in MHz
+    frequency: Option<f32>,
+    /// Aggregated status
+    status: Status,
+    /// Last update indicator
+    has_data: bool,
+}
+
+impl CpuWidget {
+    pub fn new() -> Self {
+        Self {
+            load_1min: None,
+            load_5min: None,
+            load_15min: None,
+            temperature: None,
+            frequency: None,
+            status: Status::Unknown,
+            has_data: false,
+        }
+    }
+    
+    /// Get status color for display (btop-style)
+    fn get_status_color(&self) -> Color {
+        Theme::status_color(self.status)
+    }
+    
+    /// Format load average for display
+    fn format_load(&self) -> String {
+        match (self.load_1min, self.load_5min, self.load_15min) {
+            (Some(l1), Some(l5), Some(l15)) => {
+                format!("{:.2} {:.2} {:.2}", l1, l5, l15)
+            }
+            _ => "— — —".to_string(),
+        }
+    }
+    
+    /// Format temperature for display
+    fn format_temperature(&self) -> String {
+        match self.temperature {
+            Some(temp) => format!("{:.1}°C", temp),
+            None => "—°C".to_string(),
+        }
+    }
+    
+    /// Format frequency for display
+    fn format_frequency(&self) -> String {
+        match self.frequency {
+            Some(freq) => format!("{:.1} MHz", freq),
+            None => "— MHz".to_string(),
+        }
+    }
+    
+    /// Get load percentage for gauge (based on load_1min)
+    fn get_load_percentage(&self) -> u16 {
+        match self.load_1min {
+            Some(load) => {
+                // Assume 8-core system, so 100% = load of 8.0
+                let percentage = (load / 8.0 * 100.0).min(100.0).max(0.0);
+                percentage as u16
+            }
+            None => 0,
+        }
+    }
+    
+    /// Create btop-style dotted bar pattern (like real btop)
+    fn create_btop_dotted_bar(&self, percentage: u16, width: usize) -> String {
+        let filled = (width * percentage as usize) / 100;
+        let empty = width.saturating_sub(filled);
+        
+        // Real btop uses these patterns:
+        // High usage: ████████ (solid blocks)
+        // Medium usage: :::::::: (colons)  
+        // Low usage: ........ (dots)
+        // Empty: (spaces)
+        
+        let pattern = if percentage >= 75 {
+            "█"  // High usage - solid blocks
+        } else if percentage >= 25 {
+            ":"  // Medium usage - colons like btop
+        } else if percentage > 0 {
+            "."  // Low usage - dots like btop
+        } else {
+            " "  // No usage - spaces
+        };
+        
+        let filled_chars = pattern.repeat(filled);
+        let empty_chars = " ".repeat(empty);
+        
+        filled_chars + &empty_chars
+    }
+}
+
+impl Widget for CpuWidget {
+    fn update_from_metrics(&mut self, metrics: &[&Metric]) {
+        debug!("CPU widget updating with {} metrics", metrics.len());
+        
+        // Reset status aggregation
+        let mut statuses = Vec::new();
+        
+        for metric in metrics {
+            match metric.name.as_str() {
+                "cpu_load_1min" => {
+                    if let Some(value) = metric.value.as_f32() {
+                        self.load_1min = Some(value);
+                        statuses.push(metric.status);
+                    }
+                }
+                "cpu_load_5min" => {
+                    if let Some(value) = metric.value.as_f32() {
+                        self.load_5min = Some(value);
+                        statuses.push(metric.status);
+                    }
+                }
+                "cpu_load_15min" => {
+                    if let Some(value) = metric.value.as_f32() {
+                        self.load_15min = Some(value);
+                        statuses.push(metric.status);
+                    }
+                }
+                "cpu_temperature_celsius" => {
+                    if let Some(value) = metric.value.as_f32() {
+                        self.temperature = Some(value);
+                        statuses.push(metric.status);
+                    }
+                }
+                "cpu_frequency_mhz" => {
+                    if let Some(value) = metric.value.as_f32() {
+                        self.frequency = Some(value);
+                        statuses.push(metric.status);
+                    }
+                }
+                _ => {}
+            }
+        }
+        
+        // Aggregate status
+        self.status = if statuses.is_empty() {
+            Status::Unknown
+        } else {
+            Status::aggregate(&statuses)
+        };
+        
+        self.has_data = !metrics.is_empty();
+        
+        debug!("CPU widget updated: load={:?}, temp={:?}, freq={:?}, status={:?}",
+               self.load_1min, self.temperature, self.frequency, self.status);
+    }
+    
+    fn render(&mut self, frame: &mut Frame, area: Rect) {
+        let content_chunks = Layout::default().direction(Direction::Vertical).constraints([Constraint::Length(1), Constraint::Length(1), Constraint::Length(1)]).split(area);
+        let cpu_title = Paragraph::new("CPU:").style(Style::default().fg(Theme::primary_text()).bg(Theme::background()));
+        frame.render_widget(cpu_title, content_chunks[0]);
+        let overall_usage = self.get_load_percentage();
+        let cpu_usage_text = format!("Usage: {} {:>3}%", self.create_btop_dotted_bar(overall_usage, 20), overall_usage);
+        let cpu_usage_para = Paragraph::new(cpu_usage_text).style(Style::default().fg(Theme::cpu_color(overall_usage)).bg(Theme::background()));
+        frame.render_widget(cpu_usage_para, content_chunks[1]);
+        let load_freq_text = format!("Load: {} • {}", self.format_load(), self.format_frequency());
+        let load_freq_para = Paragraph::new(load_freq_text).style(Style::default().fg(Theme::secondary_text()).bg(Theme::background()));
+        frame.render_widget(load_freq_para, content_chunks[2]);
+    }
+    
+    fn get_name(&self) -> &str {
+        "CPU"
+    }
+    
+    fn has_data(&self) -> bool {
+        self.has_data
+    }
+}
+
+impl Default for CpuWidget {
+    fn default() -> Self {
+        Self::new()
+    }
+}