node-notifier/system_monitor

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 :

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

🔧 Utilisation

Utilisation basique

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

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

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

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

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

Méthodes

// 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 :

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

// 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

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

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

# 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

#[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

// 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.