node-notifier/system_monitor/README.md

# System Monitor

Une crate Rust pour surveiller les ressources système (CPU, mémoire, swap, disque) avec des seuils configurables.

## 📋 Description

Cette crate fournit une API complète pour surveiller les ressources système et détecter les dépassements de seuils. Elle encapsule la complexité de `sysinfo` dans une interface simple et extensible, parfaite pour des systèmes d'alerte et de monitoring.

## 🚀 Fonctionnalités

- ✅ Surveillance du CPU, mémoire, swap et disque
- ✅ Seuils configurables pour déclencher des alertes
- ✅ API simple et extensible
- ✅ Support pour des fonctions de surveillance personnalisées
- ✅ Gestion automatique des cas d'erreur (division par zéro, etc.)
- ✅ Structure orientée objet avec `SystemMonitor`
- ✅ Surveillance spécifique des points de montage (`/` et `/home`)

## 📦 Installation

Ajoutez cette dépendance à votre `Cargo.toml` :

```toml
[dependencies]
system_monitor = { path = "path/to/system_monitor" }
```

## 🔧 Utilisation

### Utilisation basique

```rust
use system_monitor::SystemMonitor;

// Utilisation avec les seuils par défaut
let mut monitor = SystemMonitor::new();

// Vérifier les seuils et obtenir les alertes
let alerts = monitor.check_thresholds();
for alert in alerts {
    println!("🚨 Alerte: {}", alert);
}

// Obtenir un résumé du système
let summary = monitor.get_system_summary();
println!("📊 État système:\n{}", summary);
```

### Seuils personnalisés

```rust
use system_monitor::{SystemMonitor, ResourceThreshold, get_cpu_usage, get_memory_usage};

// Créer des seuils personnalisés
let custom_thresholds = vec![
    ResourceThreshold::new(
        "CPU".to_string(),
        get_cpu_usage,
        90.0, // Seuil à 90% au lieu de 80%
        "CPU critique ! Intervention requise".to_string(),
    ),
    ResourceThreshold::new(
        "Memory".to_string(),
        get_memory_usage,
        85.0, // Seuil mémoire à 85%
        "Mémoire élevée détectée".to_string(),
    ),
];

let mut monitor = SystemMonitor::new_with_thresholds(custom_thresholds);
```

### Surveillance continue

```rust
use system_monitor::SystemMonitor;
use std::time::Duration;
use std::thread;

let mut monitor = SystemMonitor::new();

loop {
    // Actualiser les données système
    monitor.refresh();
    
    // Vérifier les seuils
    let alerts = monitor.check_thresholds();
    
    if !alerts.is_empty() {
        for alert in alerts {
            println!("🚨 {}", alert);
            // Ici vous pourriez envoyer une notification
        }
    } else {
        println!("✅ Système OK");
    }
    
    // Attendre 30 secondes avant la prochaine vérification
    thread::sleep(Duration::from_secs(30));
}
```

## 📊 Métriques surveillées

### Seuils par défaut

- **CPU**: 80% - Utilisation globale du processeur
- **Mémoire**: 80% - RAM utilisée vs totale
- **Swap**: 80% - Espace swap utilisé vs total
- **Disque**: 80% - Espace utilisé sur les points de montage `/` et `/home`

### Détails des métriques

#### CPU
- Mesure l'utilisation globale du CPU en pourcentage
- Basé sur la moyenne de tous les cœurs
- Actualisé à chaque appel de `refresh()`

#### Mémoire
- Calcule le pourcentage de RAM utilisée
- Inclut les buffers et cache système
- Formule : `(mémoire_utilisée / mémoire_totale) * 100`

#### Swap
- Surveille l'utilisation de l'espace swap
- Important pour détecter la saturation mémoire
- Retourne 0% si aucun swap n'est configuré

#### Disque
- Surveille spécifiquement `/` (racine) et `/home`
- Calcule l'espace utilisé combiné
- Formule : `((total - disponible) / total) * 100`

## 🎛️ API Reference

### `SystemMonitor`

#### Constructeurs

```rust
// Avec seuils par défaut
pub fn new() -> Self

// Avec seuils personnalisés
pub fn new_with_thresholds(thresholds: Vec<ResourceThreshold>) -> Self
```

#### Méthodes

```rust
// Actualise les données système
pub fn refresh(&mut self)

// Vérifie les seuils et retourne les alertes
pub fn check_thresholds(&mut self) -> Vec<String>

// Retourne un résumé des ressources système
pub fn get_system_summary(&self) -> String
```

### `ResourceThreshold`

Structure pour définir des seuils personnalisés :

```rust
pub struct ResourceThreshold {
    pub name: String,                                    // Nom de la ressource
    pub get_usage_fn: fn(&System, &Disks) -> f32,      // Fonction de mesure
    pub threshold: f32,                                  // Seuil (en %)
    pub value: f32,                                      // Valeur actuelle
    pub message: String,                                 // Message d'alerte
}

impl ResourceThreshold {
    pub fn new(name: String, get_usage_fn: fn(&System, &Disks) -> f32, threshold: f32, message: String) -> Self
    pub fn check(&mut self, sys: &System, disks: &Disks) -> Option<String>
}
```

### Fonctions de surveillance

```rust
// Utilisation du CPU (%)
pub fn get_cpu_usage(sys: &System, _: &Disks) -> f32

// Utilisation de la mémoire (%)
pub fn get_memory_usage(sys: &System, _: &Disks) -> f32

// Utilisation du swap (%)
pub fn get_swap_usage(sys: &System, _: &Disks) -> f32

// Utilisation du disque (%)
pub fn get_disk_usage(_: &System, disks: &Disks) -> f32

// Seuils par défaut
pub fn get_default_resource_thresholds() -> Vec<ResourceThreshold>
```

## 🔧 Surveillance personnalisée

### Créer une fonction de surveillance custom

```rust
use system_monitor::{ResourceThreshold, SystemMonitor};
use sysinfo::{System, Disks};

// Fonction personnalisée pour surveiller la température CPU (exemple)
fn get_cpu_temperature(sys: &System, _: &Disks) -> f32 {
    // Implémentation exemple (nécessite une crate additionnelle)
    // Retourne la température en degrés Celsius
    65.0 // Valeur d'exemple
}

// Utilisation
let custom_threshold = ResourceThreshold::new(
    "CPU Temperature".to_string(),
    get_cpu_temperature,
    80.0, // Alerte si > 80°C
    "Température CPU élevée !".to_string(),
);

let monitor = SystemMonitor::new_with_thresholds(vec![custom_threshold]);
```

### Surveiller des processus spécifiques

```rust
use sysinfo::{System, ProcessExt, Pid};

fn get_process_memory_usage(sys: &System, _: &Disks) -> f32 {
    if let Some(process) = sys.process(Pid::from(1234)) { // PID du processus
        let process_memory = process.memory() as f32;
        let total_memory = sys.total_memory() as f32;
        (process_memory / total_memory) * 100.0
    } else {
        0.0
    }
}
```

## 🧪 Tests

```bash
# Exécuter tous les tests
cargo test

# Tests avec logs détaillés
RUST_LOG=debug cargo test

# Tests de performance
cargo test --release
```

### Exemple de test

```rust
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_cpu_usage() {
        let sys = System::new_all();
        let disks = Disks::new();
        
        let usage = get_cpu_usage(&sys, &disks);
        assert!(usage >= 0.0 && usage <= 100.0);
    }

    #[test]
    fn test_threshold_check() {
        let mut threshold = ResourceThreshold::new(
            "Test".to_string(),
            |_, _| 85.0, // Fonction qui retourne toujours 85%
            80.0,        // Seuil à 80%
            "Test alert".to_string(),
        );

        let sys = System::new();
        let disks = Disks::new();
        
        // Devrait déclencher une alerte
        assert!(threshold.check(&sys, &disks).is_some());
    }
}
```

## 🔧 Dépannage

### Problèmes courants

**Valeurs de métrique à 0**
- Sur certains systèmes, l'initialisation peut prendre du temps
- Appelez `refresh()` et attendez quelques secondes

**Permissions insuffisantes**
- Certaines métriques peuvent nécessiter des privilèges élevés
- Exécutez avec `sudo` si nécessaire

**Pas de disque détecté**
- Vérifiez que `/` et `/home` sont montés
- Adaptez la fonction `get_disk_usage()` pour vos points de montage

### Debug

```rust
// Activer les logs sysinfo
RUST_LOG=sysinfo=debug cargo run

// Inspecter les valeurs
let monitor = SystemMonitor::new();
println!("Disques détectés:");
for disk in &monitor.disks {
    println!("- {}: {} bytes", disk.mount_point().display(), disk.total_space());
}
```

## 🚀 Extensions possibles

- Surveillance réseau (bande passante, latence)
- Surveillance de la température
- Métriques de processus spécifiques
- Historique des valeurs
- Export vers des formats standards (Prometheus, etc.)
- Surveillance de services système

## 📄 Licence

Cette crate est sous licence MIT.