wip

REFACTORING.md

@@ -0,0 +1,135 @@
+# Refactorisation : Meilleure délégation des responsabilités
+
+## 🎯 Problèmes identifiés
+
+### 1. **Mélange des responsabilités dans `system_monitor`**
+- ❌ Formatage des messages d'alerte dans la crate de monitoring
+- ❌ Messages hardcodés limitant la flexibilité
+- ❌ Couplage fort entre données et présentation
+
+### 2. **Logique d'orchestration insuffisante dans `node_notifier`**
+- ❌ Simple "collage" de crates sans valeur ajoutée
+- ❌ Pas de traitement intelligent des données
+
+## ✅ Solutions apportées
+
+### 1. **Séparation claire des responsabilités**
+
+#### `system_monitor` (Crate de données)
+- ✅ **Responsabilité unique** : Collecte et analyse des métriques système
+- ✅ **Pas de formatage** : Retourne des structures de données pures
+- ✅ **API riche** : `SystemMetrics`, `ThresholdViolation`, `Severity`
+
+#### `node_notifier` (Crate d'orchestration)
+- ✅ **Formatage intelligent** : `AlertFormatter` avec logique métier
+- ✅ **Messages contextuels** : Différents messages selon métrique et gravité
+- ✅ **Orchestration** : Coordination entre monitoring et notifications
+
+#### `discord_client` (Crate de transport)
+- ✅ **Transport pur** : Envoi de messages sans logique métier
+- ✅ **Réutilisable** : Peut être utilisé par d'autres applications
+
+### 2. **Nouvelles structures de données**
+
+```rust
+// Métriques pures sans formatage
+pub struct SystemMetrics {
+    pub cpu_usage: f32,
+    pub memory_usage: f32,
+    pub swap_usage: f32,
+    pub disk_usage: f32,
+}
+
+// Violation avec contexte riche
+pub struct ThresholdViolation {
+    pub metric_name: String,
+    pub current_value: f32,
+    pub threshold: f32,
+    pub severity: Severity, // Warning | Critical
+}
+```
+
+### 3. **Formatage intelligent dans `node_notifier`**
+
+```rust
+struct AlertFormatter;
+
+impl AlertFormatter {
+    fn format_violation(&self, violation: &ThresholdViolation) -> String {
+        // Logique de formatage contextuelle
+        // Emojis, niveaux, messages spécifiques
+    }
+    
+    fn get_message_for_metric(&self, metric: &str, severity: &Severity) -> String {
+        // Messages personnalisés par métrique et gravité
+    }
+}
+```
+
+## 🏗️ Architecture finale
+
+```
+┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
+│  system_monitor │    │  node_notifier   │    │ discord_client  │
+│                 │    │                  │    │                 │
+│ • Collecte      │───▶│ • Orchestration  │───▶│ • Transport     │
+│ • Analyse       │    │ • Formatage      │    │ • Envoi         │
+│ • Seuils        │    │ • Logique métier │    │                 │
+│                 │    │                  │    │                 │
+└─────────────────┘    └──────────────────┘    └─────────────────┘
+      DONNÉES                BUSINESS                TRANSPORT
+```
+
+## 📈 Avantages obtenus
+
+### 1. **Réutilisabilité**
+- `system_monitor` peut être utilisé dans d'autres contextes (CLI, web, etc.)
+- `discord_client` réutilisable pour tout type de notification
+- `node_notifier` concentre la logique spécifique à cette application
+
+### 2. **Maintenabilité**
+- Responsabilités claires et séparées
+- Changement de formatage sans impact sur le monitoring
+- Tests plus simples et ciblés
+
+### 3. **Extensibilité**
+- Facile d'ajouter de nouveaux formats (email, Slack, etc.)
+- Nouveaux types de métriques sans casser l'existant
+- Seuils configurables avec niveaux multiples
+
+### 4. **Qualité du code**
+- Structures de données typées et riches
+- Gestion d'erreurs centralisée
+- API claire et documentée
+
+## 🔄 Migration des exemples
+
+Tous les exemples ont été mis à jour pour utiliser la nouvelle API :
+
+- ✅ `basic_monitoring` : Affichage structuré des métriques
+- ✅ `custom_thresholds` : Seuils avec niveaux critique/warning
+- ✅ `continuous_monitoring` : Formatage riche des alertes
+- ✅ `discord_notifications` : Inchangé (transport pur)
+
+## 🎯 Résultat
+
+### Avant (couplage fort)
+```rust
+// system_monitor retournait des strings formatées
+let alerts = monitor.check_thresholds(); // Vec<String>
+for alert in alerts {
+    notifier.send_notification(&alert); // Pas de contrôle du format
+}
+```
+
+### Après (séparation claire)
+```rust
+// system_monitor retourne des données structurées
+let violations = monitor.check_thresholds(); // Vec<ThresholdViolation>
+for violation in violations {
+    let message = formatter.format_violation(&violation); // Formatage intelligent
+    notifier.send_notification(&message); // Transport pur
+}
+```
+
+Cette refactorisation respecte maintenant parfaitement les principes SOLID et offre une architecture robuste et évolutive ! 🚀