Add info-level logging for SMART data collection debugging

Agent changes:
- Changed docker ps and docker images commands to run without sudo
- cm-agent user is already in docker group, so sudo is not needed
- Fixes "unable to change to root gid: Operation not permitted" error
- Systemd security restrictions were blocking sudo gid changes

This fixes Docker container and image collection on systems with
systemd security hardening enabled.

Updated to version 0.1.178

Cargo.lock

@@ -279,7 +279,7 @@ checksum = "a1d728cc89cf3aee9ff92b05e62b19ee65a02b5702cff7d5a377e32c6ae29d8d"
 
 [[package]]
 name = "cm-dashboard"
-version = "0.1.170"
+version = "0.1.179"
 dependencies = [
  "anyhow",
  "chrono",
@@ -301,7 +301,7 @@ dependencies = [
 
 [[package]]
 name = "cm-dashboard-agent"
-version = "0.1.170"
+version = "0.1.179"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -324,7 +324,7 @@ dependencies = [
 
 [[package]]
 name = "cm-dashboard-shared"
-version = "0.1.170"
+version = "0.1.179"
 dependencies = [
  "chrono",
  "serde",

agent/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cm-dashboard-agent"
-version = "0.1.170"
+version = "0.1.180"
 edition = "2021"
 
 [dependencies]

agent/src/collectors/disk.rs

@@ -385,8 +385,9 @@ impl DiskCollector {
 
     /// Get SMART data for drives
     async fn get_smart_data_for_drives(&self, physical_drives: &[PhysicalDrive], mergerfs_pools: &[MergerfsPool]) -> HashMap<String, SmartData> {
+        use tracing::info;
         let mut smart_data = HashMap::new();
-        
+
         // Collect all drive names
         let mut all_drives = std::collections::HashSet::new();
         for drive in physical_drives {
@@ -401,18 +402,30 @@ impl DiskCollector {
             }
         }
 
+        info!("Collecting SMART data for {} drives", all_drives.len());
+
         // Get SMART data for each drive
-        for drive_name in all_drives {
-            if let Ok(data) = self.get_smart_data(&drive_name).await {
-                smart_data.insert(drive_name, data);
+        for drive_name in &all_drives {
+            match self.get_smart_data(drive_name).await {
+                Ok(data) => {
+                    info!("SMART data collected for {}: serial={:?}, temp={:?}, health={}",
+                        drive_name, data.serial_number, data.temperature_celsius, data.health);
+                    smart_data.insert(drive_name.clone(), data);
+                }
+                Err(e) => {
+                    info!("Failed to get SMART data for {}: {:?}", drive_name, e);
+                }
             }
         }
 
+        info!("SMART data collection complete: {}/{} drives successful", smart_data.len(), all_drives.len());
         smart_data
     }
 
     /// Get SMART data for a single drive
     async fn get_smart_data(&self, drive_name: &str) -> Result<SmartData, CollectorError> {
+        use tracing::info;
+
         let output = Command::new("sudo")
             .args(&["smartctl", "-a", &format!("/dev/{}", drive_name)])
             .output()
@@ -423,13 +436,13 @@ impl DiskCollector {
 
         let output_str = String::from_utf8_lossy(&output.stdout);
         let error_str = String::from_utf8_lossy(&output.stderr);
-        
+
         // Debug logging for SMART command results
-        debug!("SMART output for {}: status={}, stdout_len={}, stderr={}", 
+        debug!("SMART output for {}: status={}, stdout_len={}, stderr={}",
             drive_name, output.status, output_str.len(), error_str);
-        
+
         if !output.status.success() {
-            debug!("SMART command failed for {}: {}", drive_name, error_str);
+            info!("SMART command failed for {}, status={}, stderr={}", drive_name, output.status, error_str);
             // Return unknown data rather than failing completely
             return Ok(SmartData {
                 health: "UNKNOWN".to_string(),

agent/src/collectors/systemd.rs

@@ -123,13 +123,30 @@ impl SystemdCollector {
                             // For now, docker containers have no additional metrics
                             // Future: could add memory_mb, cpu_percent, restart_count, etc.
                             let metrics = Vec::new();
-                            
+
                             sub_services.push(SubServiceData {
                                 name: container_name.clone(),
                                 service_status: self.calculate_service_status(&container_name, &container_status),
                                 metrics,
                             });
                         }
+
+                        // Add Docker images
+                        let docker_images = self.get_docker_images();
+                        for (image_name, image_status, image_size) in docker_images {
+                            let mut metrics = Vec::new();
+                            metrics.push(SubServiceMetric {
+                                label: "size".to_string(),
+                                value: 0.0, // Size as string in name instead
+                                unit: None,
+                            });
+
+                            sub_services.push(SubServiceData {
+                                name: format!("{} ({})", image_name, image_size),
+                                service_status: self.calculate_service_status(&image_name, &image_status),
+                                metrics,
+                            });
+                        }
                     }
 
                     // Create complete service data
@@ -151,7 +168,7 @@ impl SystemdCollector {
                 }
             }
         }
-        
+
         // Update cached state
         {
             let mut state = self.state.write().unwrap();
@@ -756,9 +773,10 @@ impl SystemdCollector {
     fn get_docker_containers(&self) -> Vec<(String, String)> {
         let mut containers = Vec::new();
 
-        // Check if docker is available (use sudo for permissions)
-        let output = Command::new("sudo")
-            .args(&["docker", "ps", "--format", "{{.Names}},{{.Status}}"])
+        // Check if docker is available (cm-agent user is in docker group)
+        // Use -a to show ALL containers (running and stopped)
+        let output = Command::new("docker")
+            .args(&["ps", "-a", "--format", "{{.Names}},{{.Status}}"])
             .output();
 
         let output = match output {
@@ -783,10 +801,10 @@ impl SystemdCollector {
 
                 let container_status = if status_str.contains("Up") {
                     "active"
-                } else if status_str.contains("Exited") {
-                    "warning" // Match original: Exited → Warning, not inactive
+                } else if status_str.contains("Exited") || status_str.contains("Created") {
+                    "inactive" // Stopped/created containers are inactive
                 } else {
-                    "failed" // Other states → failed
+                    "failed" // Other states (restarting, paused, dead) → failed
                 };
                 
                 containers.push((format!("docker_{}", container_name), container_status.to_string()));
@@ -795,6 +813,55 @@ impl SystemdCollector {
 
         containers
     }
+
+    /// Get docker images as sub-services
+    fn get_docker_images(&self) -> Vec<(String, String, String)> {
+        let mut images = Vec::new();
+        // Check if docker is available (cm-agent user is in docker group)
+        let output = Command::new("docker")
+            .args(&["images", "--format", "{{.Repository}}:{{.Tag}},{{.Size}}"])
+            .output();
+
+        let output = match output {
+            Ok(out) if out.status.success() => out,
+            Ok(_) => {
+                return images;
+            }
+            Err(_) => {
+                return images;
+            }
+        };
+
+        let output_str = match String::from_utf8(output.stdout) {
+            Ok(s) => s,
+            Err(_) => return images,
+        };
+
+        for line in output_str.lines() {
+            if line.trim().is_empty() {
+                continue;
+            }
+
+            let parts: Vec<&str> = line.split(',').collect();
+            if parts.len() >= 2 {
+                let image_name = parts[0].trim();
+                let size = parts[1].trim();
+
+                // Skip <none>:<none> images (dangling images)
+                if image_name.contains("<none>") {
+                    continue;
+                }
+
+                images.push((
+                    format!("image_{}", image_name),
+                    "active".to_string(), // Images are always "active" (present)
+                    size.to_string()
+                ));
+            }
+        }
+
+        images
+    }
 }
 
 #[async_trait]

dashboard/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cm-dashboard"
-version = "0.1.170"
+version = "0.1.180"
 edition = "2021"
 
 [dependencies]

dashboard/src/ui/widgets/system.rs

@@ -629,10 +629,20 @@ impl SystemWidget {
         let virtual_interfaces: Vec<_> = self.network_interfaces.iter().filter(|i| !i.is_physical).collect();
 
         // Find standalone virtual interfaces (those without a parent)
-        let standalone_virtual: Vec<_> = virtual_interfaces.iter()
+        let mut standalone_virtual: Vec<_> = virtual_interfaces.iter()
             .filter(|i| i.parent_interface.is_none())
             .collect();
 
+        // Sort standalone virtual: VLANs first (by VLAN ID), then others alphabetically
+        standalone_virtual.sort_by(|a, b| {
+            match (a.vlan_id, b.vlan_id) {
+                (Some(vlan_a), Some(vlan_b)) => vlan_a.cmp(&vlan_b),
+                (Some(_), None) => std::cmp::Ordering::Less,
+                (None, Some(_)) => std::cmp::Ordering::Greater,
+                (None, None) => a.name.cmp(&b.name),
+            }
+        });
+
         // Render physical interfaces with their children
         for (phy_idx, interface) in physical.iter().enumerate() {
             let is_last_physical = phy_idx == physical.len() - 1 && standalone_virtual.is_empty();
@@ -646,7 +656,7 @@ impl SystemWidget {
             lines.push(Line::from(header_spans));
 
             // Find child interfaces for this physical interface
-            let children: Vec<_> = virtual_interfaces.iter()
+            let mut children: Vec<_> = virtual_interfaces.iter()
                 .filter(|vi| {
                     if let Some(parent) = &vi.parent_interface {
                         parent == &interface.name
@@ -656,6 +666,16 @@ impl SystemWidget {
                 })
                 .collect();
 
+            // Sort children: VLANs first (by VLAN ID), then others alphabetically
+            children.sort_by(|a, b| {
+                match (a.vlan_id, b.vlan_id) {
+                    (Some(vlan_a), Some(vlan_b)) => vlan_a.cmp(&vlan_b),
+                    (Some(_), None) => std::cmp::Ordering::Less,
+                    (None, Some(_)) => std::cmp::Ordering::Greater,
+                    (None, None) => a.name.cmp(&b.name),
+                }
+            });
+
             // Count total items under this physical interface (IPs + children)
             let ip_count = interface.ipv4_addresses.len() + interface.ipv6_addresses.len();
             let total_children = ip_count + children.len();

shared/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cm-dashboard-shared"
-version = "0.1.170"
+version = "0.1.180"
 edition = "2021"
 
 [dependencies]