Fix physical drive name and health status display

- Display actual drive name (e.g., nvme0n1) instead of mount point for physical drives
- Fix health status parsing for physical drives to show proper status icons
- Update pool name extraction to handle disk_{drive}_health metrics correctly
- Improve storage widget rendering for physical drive identification

Cargo.lock

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

agent/Cargo.toml

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

agent/src/collectors/disk.rs

@@ -210,7 +210,7 @@ impl DiskCollector {
                     .collect();
                 
                 // Convert numeric references to actual mount points if needed
-                let member_paths = if raw_paths.iter().any(|path| !path.starts_with('/')) {
+                let mut member_paths = if raw_paths.iter().any(|path| !path.starts_with('/')) {
                     // Handle numeric format like "1:2" by finding corresponding /mnt/disk* paths
                     self.resolve_numeric_mergerfs_paths(&raw_paths)?
                 } else {
@@ -218,6 +218,10 @@ impl DiskCollector {
                     raw_paths
                 };
                 
+                // For SnapRAID setups, include parity drives that are related to this pool's data drives
+                let related_parity_paths = self.discover_related_parity_drives(&member_paths)?;
+                member_paths.extend(related_parity_paths);
+                
                 // Categorize as data vs parity drives
                 let (data_drives, parity_drives) = match self.categorize_pool_drives(&member_paths) {
                     Ok(drives) => drives,
@@ -240,6 +244,38 @@ impl DiskCollector {
         Ok(pools)
     }
 
+    /// Discover parity drives that are related to the given data drives
+    fn discover_related_parity_drives(&self, data_drives: &[String]) -> Result<Vec<String>> {
+        let mount_devices = self.get_mount_devices()?;
+        let mut related_parity = Vec::new();
+        
+        // Find parity drives that share the same parent directory as the data drives
+        for data_path in data_drives {
+            if let Some(parent_dir) = self.get_parent_directory(data_path) {
+                // Look for parity drives in the same parent directory
+                for (mount_point, _device) in &mount_devices {
+                    if mount_point.contains("parity") && mount_point.starts_with(&parent_dir) {
+                        if !related_parity.contains(mount_point) {
+                            related_parity.push(mount_point.clone());
+                        }
+                    }
+                }
+            }
+        }
+        
+        Ok(related_parity)
+    }
+    
+    /// Get parent directory of a mount path (e.g., "/mnt/disk1" -> "/mnt")
+    fn get_parent_directory(&self, path: &str) -> Option<String> {
+        if let Some(last_slash) = path.rfind('/') {
+            if last_slash > 0 {
+                return Some(path[..last_slash].to_string());
+            }
+        }
+        None
+    }
+
     /// Categorize pool member drives as data vs parity
     fn categorize_pool_drives(&self, member_paths: &[String]) -> Result<(Vec<DriveInfo>, Vec<DriveInfo>)> {
         let mut data_drives = Vec::new();
@@ -891,12 +927,12 @@ impl DiskCollector {
         });
 
         // Individual drive metrics
-        for (i, drive) in pool.data_drives.iter().enumerate() {
-            self.generate_pool_drive_metrics(metrics, &pool_name, &format!("data_{}", i), drive, timestamp, status_tracker);
+        for drive in &pool.data_drives {
+            self.generate_pool_drive_metrics(metrics, &pool_name, &drive.device, drive, timestamp, status_tracker);
         }
 
-        for (i, drive) in pool.parity_drives.iter().enumerate() {
-            self.generate_pool_drive_metrics(metrics, &pool_name, &format!("parity_{}", i), drive, timestamp, status_tracker);
+        for drive in &pool.parity_drives {
+            self.generate_pool_drive_metrics(metrics, &pool_name, &drive.device, drive, timestamp, status_tracker);
         }
     }
 

dashboard/Cargo.toml

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

dashboard/src/ui/widgets/system.rs

@@ -146,14 +146,14 @@ impl SystemWidget {
         self.agent_hash.as_ref()
     }
 
-    /// Get mount point for a pool name
+    /// Get default mount point for a pool name (fallback only - should use actual mount_point metrics)
     fn get_mount_point_for_pool(&self, pool_name: &str) -> String {
-        match pool_name {
-            "root" => "/".to_string(),
-            "steampool" => "/mnt/steampool".to_string(),
-            "steampool_1" => "/steampool_1".to_string(),
-            "steampool_2" => "/steampool_2".to_string(),
-            _ => format!("/{}", pool_name), // Default fallback
+        // For device names, use the device name directly as display name
+        if pool_name.starts_with("nvme") || pool_name.starts_with("sd") || pool_name.starts_with("hd") {
+            pool_name.to_string()
+        } else {
+            // For other pools, use the pool name as-is (will be overridden by mount_point metric)
+            pool_name.to_string()
         }
     }
 
@@ -208,6 +208,13 @@ impl SystemWidget {
                             pool.pool_health = Some(health.clone());
                             pool.health_status = metric.status.clone();
                         }
+                    } else if metric.name.contains("_health") && !metric.name.contains("_pool_health") {
+                        // Handle physical drive health metrics (disk_{drive}_health)
+                        if let MetricValue::String(health) = &metric.value {
+                            // For physical drives, use the drive health as pool health
+                            pool.pool_health = Some(health.clone());
+                            pool.health_status = metric.status.clone();
+                        }
                     } else if metric.name.contains("_temperature") {
                         if let Some(drive_name) = self.extract_drive_name(&metric.name) {
                             // Find existing drive or create new one
@@ -349,52 +356,45 @@ impl SystemWidget {
         // Pattern: disk_{pool_name}_{various suffixes}
         // Since pool_name can contain underscores, work backwards from known metric suffixes
         if metric_name.starts_with("disk_") {
-            // Handle filesystem metrics: disk_{pool}_fs_{filesystem}_{metric}
+            // Handle filesystem metrics: disk_{pool}_fs_{filesystem}_{metric} 
             if metric_name.contains("_fs_") {
                 if let Some(fs_pos) = metric_name.find("_fs_") {
                     return Some(metric_name[5..fs_pos].to_string()); // Skip "disk_", extract pool name before "_fs_"
                 }
             }
+            
             // Handle pool-level metrics (usage_percent, used_gb, total_gb, mount_point, pool_type, pool_health)
-            else if let Some(suffix_pos) = metric_name.rfind("_usage_percent")
-                .or_else(|| metric_name.rfind("_used_gb"))
-                .or_else(|| metric_name.rfind("_total_gb"))
-                .or_else(|| metric_name.rfind("_available_gb"))
-                .or_else(|| metric_name.rfind("_mount_point"))
-                .or_else(|| metric_name.rfind("_pool_type"))
-                .or_else(|| metric_name.rfind("_pool_health")) {
-                return Some(metric_name[5..suffix_pos].to_string()); // Skip "disk_"
-            }
-            // Handle drive-specific metrics: disk_{pool}_{drive_role}_{metric} (for mergerfs) or disk_{pool}_{drive}_{metric} (for physical drives)
-            else if let Some(suffix_pos) = metric_name.rfind("_temperature")
-                .or_else(|| metric_name.rfind("_wear_percent"))
-                .or_else(|| metric_name.rfind("_health")) {
-                // For mergerfs pools, metrics look like: disk_srv_media_data_0_temperature or disk_srv_media_parity_0_temperature
-                // We need to extract just "srv_media" as the pool name
-                let before_suffix = &metric_name[..suffix_pos];
-                
-                // Check if this looks like a mergerfs drive metric (contains data_ or parity_)
-                if before_suffix.contains("_data_") {
-                    if let Some(data_pos) = before_suffix.find("_data_") {
-                        return Some(metric_name[5..data_pos].to_string()); // Extract pool name before "_data_"
-                    }
-                } else if before_suffix.contains("_parity_") {
-                    if let Some(parity_pos) = before_suffix.find("_parity_") {
-                        return Some(metric_name[5..parity_pos].to_string()); // Extract pool name before "_parity_"
-                    }
+            // Use rfind to get the last occurrence of these suffixes
+            let pool_suffixes = ["_usage_percent", "_used_gb", "_total_gb", "_available_gb", "_mount_point", "_pool_type", "_pool_health"];
+            for suffix in pool_suffixes {
+                if let Some(suffix_pos) = metric_name.rfind(suffix) {
+                    return Some(metric_name[5..suffix_pos].to_string()); // Skip "disk_"
                 }
-                
-                // Fallback for physical drive metrics: find the second-to-last underscore
-                if let Some(drive_start) = before_suffix.rfind('_') {
-                    if drive_start > 5 {
-                        return Some(metric_name[5..drive_start].to_string()); // Skip "disk_"
+            }
+            
+            // Handle physical drive health metrics: disk_{drive}_health
+            if metric_name.ends_with("_health") && !metric_name.contains("_pool_health") {
+                // Count underscores to distinguish physical drive health (disk_{drive}_health) 
+                // from pool drive health (disk_{pool}_{drive}_health)
+                let underscore_count = metric_name.matches('_').count();
+                if underscore_count == 2 { // disk_{drive}_health
+                    if let Some(suffix_pos) = metric_name.rfind("_health") {
+                        return Some(metric_name[5..suffix_pos].to_string()); // Skip "disk_"
                     }
                 }
             }
-            // Fallback: extract first component after disk_ prefix
-            else if let Some(captures) = metric_name.strip_prefix("disk_") {
-                if let Some(pos) = captures.find('_') {
-                    return Some(captures[..pos].to_string());
+            
+            // Handle drive-specific metrics: disk_{pool}_{drive}_{metric}
+            let drive_suffixes = ["_temperature", "_wear_percent", "_health"];
+            for suffix in drive_suffixes {
+                if let Some(suffix_pos) = metric_name.rfind(suffix) {
+                    // Extract pool name by finding the second-to-last underscore
+                    let before_suffix = &metric_name[..suffix_pos];
+                    if let Some(drive_start) = before_suffix.rfind('_') {
+                        if drive_start > 5 {
+                            return Some(metric_name[5..drive_start].to_string()); // Skip "disk_"
+                        }
+                    }
                 }
             }
         }
@@ -429,7 +429,7 @@ impl SystemWidget {
     /// Extract drive name from disk metric name  
     fn extract_drive_name(&self, metric_name: &str) -> Option<String> {
         // Pattern: disk_{pool_name}_{drive_name}_{metric_type}
-        // For mergerfs: disk_{pool_name}_{data|parity}_{index}_{metric_type}
+        // Now using actual device names like: disk_srv_media_sdb_temperature
         // Since pool_name can contain underscores, work backwards from known metric suffixes
         if metric_name.starts_with("disk_") {
             if let Some(suffix_pos) = metric_name.rfind("_temperature")
@@ -437,14 +437,7 @@ impl SystemWidget {
                 .or_else(|| metric_name.rfind("_health")) {
                 let before_suffix = &metric_name[..suffix_pos];
                 
-                // For mergerfs drive metrics: extract the role_index part (e.g., "data_0", "parity_1")
-                if before_suffix.contains("_data_") || before_suffix.contains("_parity_") {
-                    if let Some(role_start) = before_suffix.rfind("_data_").or_else(|| before_suffix.rfind("_parity_")) {
-                        return Some(before_suffix[role_start + 1..].to_string()); // e.g., "data_0" or "parity_1"
-                    }
-                }
-                
-                // Fallback for physical drive metrics: get the last component
+                // Extract the last component as drive name (e.g., "sdb", "sdc", "nvme0n1")
                 if let Some(drive_start) = before_suffix.rfind('_') {
                     return Some(before_suffix[drive_start + 1..].to_string());
                 }
@@ -459,7 +452,10 @@ impl SystemWidget {
 
         for pool in &self.storage_pools {
             // Pool header line with type and health
-            let pool_label = if pool.pool_type == "single" {
+            let pool_label = if pool.pool_type.starts_with("drive (") {
+                // For physical drives, show the drive name instead of mount point
+                format!("{} ({}):", pool.name, pool.pool_type)
+            } else if pool.pool_type == "single" {
                 format!("{}:", pool.mount_point)
             } else {
                 format!("{} ({}):", pool.mount_point, pool.pool_type)
@@ -470,26 +466,7 @@ impl SystemWidget {
             );
             lines.push(Line::from(pool_spans));
 
-            // Pool health line (for multi-disk pools)
-            if pool.pool_type != "single" {
-                if let Some(health) = &pool.pool_health {
-                    let health_text = match health.as_str() {
-                        "healthy" => format!("Pool Status: {} Healthy", 
-                            if pool.drives.len() > 1 { format!("({} drives)", pool.drives.len()) } else { String::new() }),
-                        "degraded" => "Pool Status: ⚠ Degraded".to_string(),
-                        "critical" => "Pool Status: ✗ Critical".to_string(), 
-                        "rebuilding" => "Pool Status: ⟳ Rebuilding".to_string(),
-                        _ => format!("Pool Status: ? {}", health),
-                    };
-                    
-                    let mut health_spans = vec![
-                        Span::raw("  "),
-                        Span::styled("├─ ", Typography::tree()),
-                    ];
-                    health_spans.extend(StatusIcons::create_status_spans(pool.health_status.clone(), &health_text));
-                    lines.push(Line::from(health_spans));
-                }
-            }
+            // Skip pool health line as discussed - removed
 
             // Total usage line (always show for pools)
             let usage_text = match (pool.usage_percent, pool.used_gb, pool.total_gb) {
@@ -512,7 +489,7 @@ impl SystemWidget {
             lines.push(Line::from(usage_spans));
 
             // Drive lines with enhanced grouping
-            if pool.pool_type != "single" && pool.drives.len() > 1 {
+            if pool.pool_type.contains("mergerfs") && pool.drives.len() > 1 {
                 // Group drives by type for mergerfs pools
                 let (data_drives, parity_drives): (Vec<_>, Vec<_>) = pool.drives.iter().enumerate()
                     .partition(|(_, drive)| {
@@ -521,7 +498,7 @@ impl SystemWidget {
                     });
 
                 // Show data drives
-                if !data_drives.is_empty() && pool.pool_type.contains("mergerfs") {
+                if !data_drives.is_empty() {
                     lines.push(Line::from(vec![
                         Span::raw("  "),
                         Span::styled("├─ ", Typography::tree()),
@@ -539,7 +516,7 @@ impl SystemWidget {
                 }
 
                 // Show parity drives
-                if !parity_drives.is_empty() && pool.pool_type.contains("mergerfs") {
+                if !parity_drives.is_empty() {
                     lines.push(Line::from(vec![
                         Span::raw("  "),
                         Span::styled("└─ ", Typography::tree()),
@@ -554,13 +531,13 @@ impl SystemWidget {
                             self.render_drive_line(&mut lines, drive, "   ├─");
                         }
                     }
-                } else {
-                    // Regular drive listing for non-mergerfs pools
-                    for (i, drive) in pool.drives.iter().enumerate() {
-                        let is_last = i == pool.drives.len() - 1;
-                        let tree_symbol = if is_last { "└─" } else { "├─" };
-                        self.render_drive_line(&mut lines, drive, tree_symbol);
-                    }
+                }
+            } else if pool.pool_type != "single" && pool.drives.len() > 1 {
+                // Regular drive listing for non-mergerfs multi-drive pools
+                for (i, drive) in pool.drives.iter().enumerate() {
+                    let is_last = i == pool.drives.len() - 1;
+                    let tree_symbol = if is_last { "└─" } else { "├─" };
+                    self.render_drive_line(&mut lines, drive, tree_symbol);
                 }
             } else if pool.pool_type.starts_with("drive (") {
                 // Physical drive pools: show drive info + filesystem children
@@ -641,10 +618,12 @@ impl SystemWidget {
         if let Some(wear) = drive.wear_percent {
             drive_info.push(format!("W: {:.0}%", wear));
         }
+        
+        // Always show drive name with info, or just name if no info available
         let drive_text = if drive_info.is_empty() {
             drive.name.clone()
         } else {
-            format!("{} {}", drive.name, drive_info.join(" • "))
+            format!("{} {}", drive.name, drive_info.join(" "))
         };
 
         let mut drive_spans = vec![

shared/Cargo.toml

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