rusty_bin/monitor/

health.rs

//! Health checking implementation
//!
//! This module provides the actual implementation of health monitoring.

use crate::monitor::config::MonitorConfig;
use crate::monitor::utils::time;
use parking_lot::RwLock;
use rusty_common::collections::FxHashMap;
use serde::{Deserialize, Serialize};
use std::sync::Arc;
use std::time::Duration;
use tokio::time::interval;

/// Health status enum
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum HealthStatus {
    /// System is healthy
    Healthy,
    /// System has warnings
    Warning,
    /// System is in critical state
    Critical,
    /// Health status is unknown
    Unknown,
}

/// Health check structure
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HealthCheck {
    /// Name of the health check
    pub name: String,
    /// Current health status
    pub status: HealthStatus,
    /// Status message
    pub message: String,
    /// Timestamp in nanoseconds
    pub timestamp: u64,
    /// Additional details about the health check
    pub details: FxHashMap<String, String>,
}

/// Health checker implementation
#[derive(Debug, Clone)]
pub struct HealthChecker {
    /// Monitor configuration
    config: MonitorConfig,
    /// Cached health checks
    checks: Arc<RwLock<Vec<HealthCheck>>>,
}

impl HealthChecker {
    /// Create a new health checker
    #[must_use]
    pub fn new(config: MonitorConfig) -> Self {
        Self {
            config,
            checks: Arc::new(RwLock::new(Vec::new())),
        }
    }

    /// Start health monitoring
    pub async fn start_monitoring(&self) {
        log::info!("Starting health monitoring");

        let mut interval = interval(Duration::from_secs(
            self.config.monitoring.health_check_interval_seconds,
        ));
        let checks = self.checks.clone();
        let config = self.config.clone();

        loop {
            interval.tick().await;

            let health_checks = Self::perform_health_checks_static(&config).await;

            // Update stored checks
            {
                let mut stored_checks = checks.write();
                *stored_checks = health_checks;
            }
        }
    }

    /// Perform all health checks
    pub async fn perform_health_checks(&self) -> Vec<HealthCheck> {
        Self::perform_health_checks_static(&self.config).await
    }

    /// Perform health checks (static version)
    async fn perform_health_checks_static(config: &MonitorConfig) -> Vec<HealthCheck> {
        let mut checks = Vec::new();

        // Check disk space
        checks.push(Self::check_disk_space_static(config).await);

        // Check memory usage
        checks.push(Self::check_memory_usage_static().await);

        // Check data directories
        checks.push(Self::check_data_directories_static(config).await);

        // Check file permissions
        checks.push(Self::check_file_permissions_static(config).await);

        checks
    }

    /// Check disk space (static version)
    async fn check_disk_space_static(_config: &MonitorConfig) -> HealthCheck {
        use sysinfo::Disks;

        let disks = Disks::new_with_refreshed_list();

        let mut status = HealthStatus::Healthy;
        let mut message = "Disk space is adequate".to_string();
        let mut details = FxHashMap::default();

        for disk in &disks {
            let total = disk.total_space();
            let available = disk.available_space();
            let usage_percent = ((total - available) as f64 / total as f64) * 100.0;

            let mount_point = disk.mount_point().to_string_lossy().to_string();
            details.insert(
                format!("disk_{}", mount_point.replace('/', "_")),
                format!("{usage_percent:.1}% used"),
            );

            if usage_percent > 90.0 {
                status = HealthStatus::Critical;
                message = format!("Disk space critical: {mount_point} is {usage_percent:.1}% full");
            } else if usage_percent > 80.0 && status == HealthStatus::Healthy {
                status = HealthStatus::Warning;
                message = format!("Disk space warning: {mount_point} is {usage_percent:.1}% full");
            }
        }

        HealthCheck {
            name: "disk_space".to_string(),
            status,
            message,
            timestamp: time::now_nanos(),
            details,
        }
    }

    /// Check memory usage (static version)
    async fn check_memory_usage_static() -> HealthCheck {
        use sysinfo::System;

        let mut system = System::new_all();
        system.refresh_memory();

        let memory_total = system.total_memory();
        let memory_used = system.used_memory();
        let usage_percent = (memory_used as f64 / memory_total as f64) * 100.0;

        let (status, message) = if usage_percent > 90.0 {
            (
                HealthStatus::Critical,
                format!("Memory usage critical: {usage_percent:.1}%"),
            )
        } else if usage_percent > 80.0 {
            (
                HealthStatus::Warning,
                format!("Memory usage high: {usage_percent:.1}%"),
            )
        } else {
            (
                HealthStatus::Healthy,
                format!("Memory usage normal: {usage_percent:.1}%"),
            )
        };

        let mut details = FxHashMap::default();
        details.insert("usage_percent".to_string(), format!("{usage_percent:.1}%"));
        details.insert(
            "used_mb".to_string(),
            format!("{}", memory_used / 1024 / 1024),
        );
        details.insert(
            "total_mb".to_string(),
            format!("{}", memory_total / 1024 / 1024),
        );

        HealthCheck {
            name: "memory_usage".to_string(),
            status,
            message,
            timestamp: time::now_nanos(),
            details,
        }
    }

    /// Check data directories (static version)
    async fn check_data_directories_static(config: &MonitorConfig) -> HealthCheck {
        let directories = [&config.storage.market_data_path];

        let mut status = HealthStatus::Healthy;
        let mut message = "All data directories accessible".to_string();
        let mut details = FxHashMap::default();

        for (i, dir) in directories.iter().enumerate() {
            let dir_name = format!("directory_{i}");

            if !dir.exists() {
                status = HealthStatus::Critical;
                message = format!("Data directory missing: {}", dir.display());
                details.insert(dir_name, "missing".to_string());
            } else if !dir.is_dir() {
                status = HealthStatus::Critical;
                message = format!("Data path is not a directory: {}", dir.display());
                details.insert(dir_name, "not_directory".to_string());
            } else {
                details.insert(dir_name, "ok".to_string());
            }
        }

        HealthCheck {
            name: "data_directories".to_string(),
            status,
            message,
            timestamp: time::now_nanos(),
            details,
        }
    }

    /// Check file permissions (static version)
    async fn check_file_permissions_static(config: &MonitorConfig) -> HealthCheck {
        use std::fs::OpenOptions;

        let test_file = config.storage.market_data_path.join(".permission_test");

        let (status, message) = match OpenOptions::new()
            .create(true)
            .write(true)
            .truncate(true)
            .open(&test_file)
        {
            Ok(_) => {
                // Clean up test file
                let _ = std::fs::remove_file(&test_file);
                (
                    HealthStatus::Healthy,
                    "File permissions are adequate".to_string(),
                )
            }
            Err(e) => (
                HealthStatus::Critical,
                format!("Cannot write to data directory: {e}"),
            ),
        };

        HealthCheck {
            name: "file_permissions".to_string(),
            status,
            message,
            timestamp: time::now_nanos(),
            details: FxHashMap::default(),
        }
    }

    /// Get current health status
    pub fn get_health_status(&self) -> Vec<HealthCheck> {
        self.checks.read().clone()
    }

    /// Get overall health status
    pub fn get_overall_status(&self) -> HealthStatus {
        let checks = self.checks.read();

        if checks
            .iter()
            .any(|c| matches!(c.status, HealthStatus::Critical))
        {
            HealthStatus::Critical
        } else if checks
            .iter()
            .any(|c| matches!(c.status, HealthStatus::Warning))
        {
            HealthStatus::Warning
        } else if checks.is_empty() {
            HealthStatus::Unknown
        } else {
            HealthStatus::Healthy
        }
    }
}