wip

examples/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "node_notifier_examples"
+version = "0.1.0"
+edition = "2021"
+
+[[example]]
+name = "basic_monitoring"
+path = "basic_monitoring.rs"
+
+[[example]]
+name = "custom_thresholds"
+path = "custom_thresholds.rs"
+
+[[example]]
+name = "discord_notifications"
+path = "discord_notifications.rs"
+
+[[example]]
+name = "continuous_monitoring" 
+path = "continuous_monitoring.rs"
+
+[dependencies]
+discord_client = { path = "../discord_client" }
+system_monitor = { path = "../system_monitor" }
+chrono = { version = "0.4", features = ["serde"] }

examples/README.md

@@ -0,0 +1,166 @@
+# Exemples d'utilisation
+
+Ce dossier contient des exemples pratiques d'utilisation des différentes crates du projet Node Notifier.
+
+## 📁 Structure
+
+- `basic_monitoring.rs` - Exemple basique de surveillance système
+- `custom_thresholds.rs` - Configuration de seuils personnalisés
+- `discord_notifications.rs` - Test du client Discord
+- `continuous_monitoring.rs` - Surveillance continue avec boucle
+
+## 🚀 Exécution des exemples
+
+Depuis le répertoire `node_notifier` :
+
+### 1. Surveillance basique
+```bash
+cargo run --example basic_monitoring
+```
+Démontre l'utilisation basique de `SystemMonitor` avec les seuils par défaut.
+
+**Sortie exemple :**
+```
+🖥️  Surveillance système basique
+
+✅ Aucune alerte - Système OK
+
+📊 Résumé des ressources:
+CPU usage: 14.72%
+Memory usage: 23.10%
+Swap usage: 0.00%
+Disk usage: 79.17%
+```
+
+### 2. Seuils personnalisés
+```bash
+cargo run --example custom_thresholds
+```
+Montre comment configurer des seuils personnalisés et créer des messages d'alerte sur mesure.
+
+**Fonctionnalités :**
+- Seuils CPU, mémoire et disque personnalisés
+- Messages d'alerte personnalisés
+- Configuration flexible
+
+### 3. Test Discord
+```bash
+DISCORD_WEBHOOK="your-webhook-url" cargo run --example discord_notifications
+```
+Teste la fonctionnalité de notification Discord avec différents types de messages.
+
+**Prérequis :**
+- Variable d'environnement `DISCORD_WEBHOOK` configurée
+- Webhook Discord valide
+
+**Messages testés :**
+- Message de test de connexion
+- Alerte simulée avec formatage
+- Rapport système formaté
+
+### 4. Surveillance continue
+```bash
+DISCORD_WEBHOOK="your-webhook-url" cargo run --example continuous_monitoring
+```
+Démontre une surveillance continue avec notifications automatiques.
+
+**Fonctionnalités :**
+- Vérifications toutes les 30 secondes
+- Alertes instantanées en cas de dépassement
+- Rapport périodique toutes les 5 minutes
+- Gestion des timestamps
+
+## 🔧 Configuration
+
+### Variables d'environnement
+
+Pour les exemples Discord, définissez votre webhook :
+
+```bash
+export DISCORD_WEBHOOK="https://discord.com/api/webhooks/your/webhook/url"
+```
+
+Ou créez un fichier `.env` dans le répertoire racine :
+
+```env
+DISCORD_WEBHOOK=https://discord.com/api/webhooks/your/webhook/url
+```
+
+### Configuration Discord
+
+1. **Créer un webhook :**
+   - Accédez à votre serveur Discord
+   - Paramètres du canal → Intégrations → Webhooks
+   - Créez un nouveau webhook
+   - Copiez l'URL
+
+2. **Permissions requises :**
+   - Envoyer des messages
+   - Intégrer des liens
+   - Utiliser des emojis externes
+
+## 📊 Cas d'usage
+
+### Surveillance ponctuelle
+Utilisez `basic_monitoring` ou `custom_thresholds` pour une vérification unique des ressources système.
+
+### Monitoring de production
+Utilisez `continuous_monitoring` comme base pour un système de surveillance permanent.
+
+### Tests d'intégration
+Utilisez `discord_notifications` pour valider votre configuration Discord.
+
+## 🛠️ Personnalisation
+
+### Modifier les seuils
+Dans `custom_thresholds.rs`, adaptez les valeurs selon vos besoins :
+
+```rust
+ResourceThreshold::new(
+    "CPU".to_string(),
+    get_cpu_usage,
+    95.0, // Seuil critique à 95%
+    "🔥 CPU en surchauffe !".to_string(),
+),
+```
+
+### Ajouter des métriques
+Créez vos propres fonctions de surveillance :
+
+```rust
+fn get_custom_metric(sys: &System, disks: &Disks) -> f32 {
+    // Votre logique personnalisée
+    42.0
+}
+```
+
+### Personnaliser les messages Discord
+Modifiez le formatage des messages dans `continuous_monitoring.rs` :
+
+```rust
+let message = format!(
+    "🚨 **ALERTE CRITIQUE**\n\n{}\n\n⏰ {}", 
+    alert, 
+    chrono::Utc::now().format("%H:%M:%S")
+);
+```
+
+## 🔍 Debugging
+
+### Activer les logs
+```bash
+RUST_LOG=debug cargo run --example basic_monitoring
+```
+
+### Tester sans Discord
+Les exemples `basic_monitoring` et `custom_thresholds` fonctionnent sans configuration Discord.
+
+### Vérifier les métriques
+Consultez les valeurs retournées pour identifier les problèmes de seuils.
+
+## 💡 Conseils
+
+- **Production** : Adaptez `continuous_monitoring` pour vos besoins spécifiques
+- **Seuils** : Commencez avec des valeurs conservatrices et ajustez progressivement
+- **Rate limiting** : Attention aux limites Discord (30 req/min par webhook)
+- **Monitoring** : Surveillez aussi les performances de votre système de monitoring

examples/basic_monitoring.rs

@@ -0,0 +1,32 @@
+// Exemple basique d'utilisation de system_monitor
+use system_monitor::SystemMonitor;
+
+fn main() {
+    println!("🖥️  Surveillance système basique\n");
+
+    // Créer un moniteur avec les seuils par défaut
+    let mut monitor = SystemMonitor::new();
+
+    // Vérifier les seuils
+    let violations = monitor.check_thresholds();
+
+    if violations.is_empty() {
+        println!("✅ Aucune alerte - Système OK");
+    } else {
+        println!("🚨 Alertes détectées:");
+        for violation in violations {
+            println!("   - {} : {:.2}% (seuil: {:.2}%)", 
+                violation.metric_name, 
+                violation.current_value, 
+                violation.threshold);
+        }
+    }
+
+    // Afficher les métriques système
+    let metrics = monitor.get_metrics();
+    println!("\n📊 Métriques système:");
+    println!("   CPU:     {:.1}%", metrics.cpu_usage);
+    println!("   Mémoire: {:.1}%", metrics.memory_usage);
+    println!("   Swap:    {:.1}%", metrics.swap_usage);
+    println!("   Disque:  {:.1}%", metrics.disk_usage);
+}

examples/continuous_monitoring.rs

@@ -0,0 +1,98 @@
+// Exemple de surveillance continue
+use discord_client::DiscordNotifier;
+use system_monitor::{SystemMonitor, Severity};
+use std::time::Duration;
+use std::thread;
+
+fn format_violation_message(violation: &system_monitor::ThresholdViolation, check_count: u32) -> String {
+    let emoji = match violation.severity {
+        Severity::Warning => "⚠️",
+        Severity::Critical => "🚨",
+    };
+    
+    let level = match violation.severity {
+        Severity::Warning => "ALERTE",
+        Severity::Critical => "CRITIQUE",
+    };
+
+    format!(
+        "{} **{}** - {}\n\n**Valeur:** {:.2}%\n**Seuil:** {:.2}%\n\n*Vérification #{} à {}*",
+        emoji,
+        level,
+        violation.metric_name,
+        violation.current_value,
+        violation.threshold,
+        check_count,
+        chrono::Utc::now().format("%Y-%m-%d %H:%M:%S UTC")
+    )
+}
+
+fn format_report_message(metrics: &system_monitor::SystemMetrics, check_count: u32) -> String {
+    format!(
+        "📊 **Rapport système** (Vérification #{})\n\n```\nCPU:     {:.1}%\nMémoire: {:.1}%\nSwap:    {:.1}%\nDisque:  {:.1}%\n```\n\n*Système OK - Surveillance continue*",
+        check_count,
+        metrics.cpu_usage,
+        metrics.memory_usage,
+        metrics.swap_usage,
+        metrics.disk_usage
+    )
+}
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    println!("🔄 Surveillance continue démarrée\n");
+
+    // Configuration
+    let webhook_url = std::env::var("DISCORD_WEBHOOK")
+        .expect("DISCORD_WEBHOOK environment variable not set");
+    
+    let check_interval = Duration::from_secs(30); // Vérification toutes les 30 secondes
+    let report_interval = 10; // Rapport complet toutes les 10 vérifications (5 minutes)
+
+    // Initialisation
+    let notifier = DiscordNotifier::new(
+        webhook_url,
+        "🔍 System Monitor".to_string(),
+        "https://cdn.shopify.com/s/files/1/0262/1423/6212/files/Lord_of_the_Rings_eye_of_Sauron_-_Ghtic.com_-_Blog.png?v=1579680018".to_string(),
+    );
+
+    let mut monitor = SystemMonitor::new();
+    let mut check_count = 0;
+
+    // Message de démarrage
+    notifier.send_notification("🟢 **Surveillance système démarrée**\n\nMonitoring actif avec vérifications toutes les 30 secondes.")?;
+
+    println!("✅ Surveillance démarrée - Appuyez sur Ctrl+C pour arrêter");
+
+    // Boucle de surveillance
+    loop {
+        check_count += 1;
+        
+        // Actualiser les données système
+        monitor.refresh();
+        
+        // Vérifier les seuils
+        let violations = monitor.check_thresholds();
+        
+        // Envoyer les alertes s'il y en a
+        for violation in violations {
+            let message = format_violation_message(&violation, check_count);
+            
+            println!("🚨 Alerte envoyée: {} {:.2}%", violation.metric_name, violation.current_value);
+            notifier.send_notification(&message)?;
+        }
+
+        // Rapport périodique complet
+        if check_count % report_interval == 0 {
+            let metrics = monitor.get_metrics();
+            let report = format_report_message(&metrics, check_count);
+            
+            println!("📊 Envoi du rapport périodique (vérification #{})", check_count);
+            notifier.send_notification(&report)?;
+        } else {
+            println!("✅ Vérification #{} - Système OK", check_count);
+        }
+
+        // Attendre avant la prochaine vérification
+        thread::sleep(check_interval);
+    }
+}

examples/custom_thresholds.rs

@@ -0,0 +1,64 @@
+// Exemple avec seuils personnalisés
+use system_monitor::{SystemMonitor, ResourceThreshold, get_cpu_usage, get_memory_usage, get_disk_usage};
+
+fn main() {
+    println!("🎛️  Surveillance avec seuils personnalisés\n");
+
+    // Définir des seuils personnalisés
+    let custom_thresholds = vec![
+        ResourceThreshold::new(
+            "CPU".to_string(),
+            get_cpu_usage,
+            90.0, // Seuil CPU plus élevé
+        ).with_critical_threshold(98.0),
+        ResourceThreshold::new(
+            "Memory".to_string(),
+            get_memory_usage,
+            75.0, // Seuil mémoire plus bas
+        ).with_critical_threshold(90.0),
+        ResourceThreshold::new(
+            "Disk".to_string(),
+            get_disk_usage,
+            85.0, // Seuil disque personnalisé
+        ).with_critical_threshold(95.0),
+    ];
+
+    // Créer le moniteur avec les seuils personnalisés
+    let mut monitor = SystemMonitor::new_with_thresholds(custom_thresholds);
+
+    // Afficher la configuration
+    println!("Configuration des seuils:");
+    for threshold in &monitor.thresholds {
+        let critical_info = threshold.critical_threshold
+            .map(|c| format!(" (critique: {}%)", c))
+            .unwrap_or_default();
+        println!("  {} : {}%{}", threshold.name, threshold.threshold, critical_info);
+    }
+    println!();
+
+    // Vérifier les seuils
+    let violations = monitor.check_thresholds();
+
+    if violations.is_empty() {
+        println!("✅ Toutes les métriques sont dans les seuils acceptables");
+    } else {
+        println!("🚨 Violations avec seuils personnalisés:");
+        for violation in violations {
+            let severity_icon = match violation.severity {
+                system_monitor::Severity::Warning => "⚠️",
+                system_monitor::Severity::Critical => "🚨",
+            };
+            println!("   {} {} : {:.2}% (seuil: {:.2}%)", 
+                severity_icon,
+                violation.metric_name, 
+                violation.current_value, 
+                violation.threshold);
+        }
+    }
+
+    println!("\n📊 État détaillé:");
+    let metrics = monitor.get_metrics();
+    println!("   CPU:     {:.1}%", metrics.cpu_usage);
+    println!("   Mémoire: {:.1}%", metrics.memory_usage);
+    println!("   Disque:  {:.1}%", metrics.disk_usage);
+}

examples/discord_notifications.rs

@@ -0,0 +1,52 @@
+// Exemple d'utilisation du client Discord
+use discord_client::DiscordNotifier;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    println!("📢 Test du client Discord\n");
+
+    // Note: Remplacez par votre vraie URL de webhook pour tester
+    let webhook_url = std::env::var("DISCORD_WEBHOOK")
+        .unwrap_or_else(|_| "https://discord.com/api/webhooks/EXAMPLE/URL".to_string());
+
+    if webhook_url.contains("EXAMPLE") {
+        println!("⚠️  Webhook d'exemple détecté - aucune notification ne sera envoyée");
+        println!("   Définissez DISCORD_WEBHOOK pour tester réellement");
+        return Ok(());
+    }
+
+    // Créer le notifier
+    let notifier = DiscordNotifier::new(
+        webhook_url,
+        "🤖 System Monitor Bot".to_string(),
+        "https://cdn.shopify.com/s/files/1/0262/1423/6212/files/Lord_of_the_Rings_eye_of_Sauron_-_Ghtic.com_-_Blog.png?v=1579680018".to_string(),
+    );
+
+    // Messages d'exemple
+    let messages = vec![
+        "✅ **Test de connexion**\n\nLe système de notification fonctionne correctement !",
+        "🚨 **Alerte simulée**\n\n**CPU:** 95% - Utilisation critique\n**Mémoire:** 87% - Niveau élevé",
+        "📊 **Rapport système**\n\n```\nCPU: 45%\nMémoire: 62%\nSwap: 12%\nDisque: 38%\n```\n\n*Surveillance automatique*",
+    ];
+
+    // Envoyer les messages de test
+    for (i, message) in messages.iter().enumerate() {
+        println!("Envoi du message {} de {}...", i + 1, messages.len());
+        
+        match notifier.send_notification(message) {
+            Ok(_) => println!("✅ Message {} envoyé avec succès", i + 1),
+            Err(e) => {
+                println!("❌ Erreur lors de l'envoi du message {} : {}", i + 1, e);
+                return Err(e);
+            }
+        }
+
+        // Pause entre les messages pour éviter le rate limiting
+        if i < messages.len() - 1 {
+            println!("   Pause de 2 secondes...\n");
+            std::thread::sleep(std::time::Duration::from_secs(2));
+        }
+    }
+
+    println!("\n🎉 Tous les messages de test ont été envoyés !");
+    Ok(())
+}