fix(smart v0.1.14): filtre NVMe correct + SmartStatus défensif

- Filtre nvme : n[4..].contains('n') au lieu de n.contains('n')
  pour distinguer nvme0n1 (namespace) de nvme0 (contrôleur)
- SmartStatus.passed : #[serde(default)] pour éviter crash si absent

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

agent/Cargo.lock

@@ -248,7 +248,7 @@ dependencies = [
 
 [[package]]
 name = "nanometrics-agent"
-version = "0.1.10"
+version = "0.1.14"
 dependencies = [
  "libc",
  "rumqttc",

agent/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nanometrics-agent"
-version = "0.1.11"
+version = "0.1.14"
 edition = "2021"
 
 [lib]

agent/src/metrics/smart.rs

@@ -9,10 +9,16 @@ struct SmartJson {
 }
 
 #[derive(Deserialize)]
-struct SmartStatus { passed: bool }
+struct SmartStatus {
+    #[serde(default)]
+    passed: bool,
+}
 
 #[derive(Deserialize)]
-struct SmartTemp { current: i64 }
+struct SmartTemp {
+    #[serde(default)]
+    current: Option<i64>,
+}
 
 #[derive(Deserialize)]
 struct SmartAttrs { table: Vec<SmartAttr> }
@@ -44,7 +50,7 @@ pub fn is_available() -> bool {
 pub fn parse_json(json: &str) -> Result<crate::payload::SmartMetrics, serde_json::Error> {
     let s: SmartJson = serde_json::from_str(json)?;
 
-    let temperature = s.temperature.as_ref().map(|t| t.current)
+    let temperature = s.temperature.as_ref().and_then(|t| t.current)
         .or_else(|| s.nvme_smart_health_information_log.as_ref()?.temperature);
 
     let mut reallocated = None;
@@ -82,6 +88,7 @@ pub fn parse_json(json: &str) -> Result<crate::payload::SmartMetrics, serde_json
 
 pub fn collect() -> Option<Vec<crate::payload::SmartMetrics>> {
     if !is_available() {
+        eprintln!("[smart] smartctl introuvable dans PATH");
         return None;
     }
     let mut devs: Vec<String> = std::fs::read_dir("/sys/block")
@@ -91,11 +98,9 @@ pub fn collect() -> Option<Vec<crate::payload::SmartMetrics>> {
         .map(|e| e.file_name().into_string().unwrap_or_default())
         .filter_map(|n| {
             if n.starts_with("sd") {
-                // /dev/sda, /dev/sdb — block device, groupe disk OK
                 Some(format!("/dev/{}", n))
-            } else if n.starts_with("nvme") && n.contains('n') {
-                // /dev/nvme0n1 — block device (brw-rw---- root disk), groupe disk OK
-                // NE PAS utiliser /dev/nvme0 (contrôleur crw------- root root, root only)
+            } else if n.starts_with("nvme") && n[4..].contains('n') {
+                // nvme0n1, nvme1n1 — namespace block device ; "nvme0" (contrôleur) ne passerait pas
                 Some(format!("/dev/{}", n))
             } else {
                 None
@@ -105,18 +110,32 @@ pub fn collect() -> Option<Vec<crate::payload::SmartMetrics>> {
         .into_iter()
         .collect();
     devs.sort();
+    eprintln!("[smart] disques détectés: {:?}", devs);
 
     let mut results = Vec::new();
     for dev in &devs {
-        let Ok(output) = std::process::Command::new("smartctl")
+        let output = match std::process::Command::new("smartctl")
             .args(["-a", "-j", dev])
-            .output() else { continue };
+            .output()
+        {
+            Ok(o) => o,
+            Err(e) => { eprintln!("[smart] erreur exec smartctl {}: {}", dev, e); continue }
+        };
+        eprintln!("[smart] smartctl {} → exit={}, stdout={} octets, stderr={} octets",
+            dev, output.status, output.stdout.len(), output.stderr.len());
         let json = String::from_utf8_lossy(&output.stdout);
-        if let Ok(metrics) = parse_json(&json) {
-            results.push(crate::payload::SmartMetrics {
-                device: dev.trim_start_matches("/dev/").to_string(),
-                ..metrics
-            });
+        match parse_json(&json) {
+            Ok(metrics) => {
+                eprintln!("[smart] {} parsé OK (passed={})", dev, metrics.passed);
+                results.push(crate::payload::SmartMetrics {
+                    device: dev.trim_start_matches("/dev/").to_string(),
+                    ..metrics
+                });
+            }
+            Err(e) => {
+                eprintln!("[smart] {} parse JSON échoué: {}", dev, e);
+                eprintln!("[smart] premiers 200 octets stdout: {:?}", &json.chars().take(200).collect::<String>());
+            }
         }
     }
     if results.is_empty() { None } else { Some(results) }

server/transport/udp.go

@@ -2,7 +2,6 @@ package transport
 
 import (
 	"encoding/json"
-	"fmt"
 	"log"
 	"net"
 
@@ -34,19 +33,21 @@ func StartUDP(addr string, handler func(*models.AgentMetrics)) error {
 func processUDP(data []byte, src string, handler func(*models.AgentMetrics)) {
 	var m models.AgentMetrics
 	if err := json.Unmarshal(data, &m); err != nil {
-		preview := ""
-		if len(data) > 0 {
-			end := len(data)
-			if end > 32 {
-				end = 32
-			}
-			preview = fmt.Sprintf(" | src=%s | premiers octets: %x | texte: %q", src, data[:end], data[:end])
+		end := 32
+		if len(data) < end {
+			end = len(data)
 		}
-		log.Printf("[udp] JSON invalide: %v%s", err, preview)
+		log.Printf("[udp] JSON invalide: %v | src=%s | octets: %x", err, src, data[:end])
 		return
 	}
 	if m.Hostname == "" {
 		return
 	}
+	// DEBUG SMART — logguer le payload ASUS complet
+	if m.Smart != nil {
+		log.Printf("[udp] SMART reçu de %s: %d disque(s)", m.Hostname, len(m.Smart))
+	} else {
+		log.Printf("[udp] payload de %s (v%s): smart=nil hdd=%v", m.Hostname, m.Version, m.HDDTotal)
+	}
 	handler(&m)
 }