Mountain/IPC/Enhanced/PerformanceDashboard/

Dashboard.rs

#![allow(non_snake_case)]

//! `PerformanceDashboard` aggregator + 25-method impl. Holds
//! the metric ring-buffer, trace store, alert ring, statistics
//! cell, and the `is_running` lifecycle flag. Method bodies
//! tightly couple with the sibling DTOs so the impl stays a
//! single file (per the "tightly-coupled cluster" exception).

use std::{
	collections::{HashMap, VecDeque},
	sync::Arc,
	time::{Duration, SystemTime},
};

use tokio::{
	sync::{Mutex as AsyncMutex, RwLock},
	time::interval,
};

use crate::{
	IPC::Enhanced::PerformanceDashboard::{
		AlertSeverity::Enum as AlertSeverity,
		DashboardConfig::Struct as DashboardConfig,
		DashboardStatistics::Struct as DashboardStatistics,
		LogLevel::Enum as LogLevel,
		MetricType::Enum as MetricType,
		PerformanceAlert::Struct as PerformanceAlert,
		PerformanceMetric::Struct as PerformanceMetric,
		TraceLog::Struct as TraceLog,
		TraceSpan::Struct as TraceSpan,
	},
	dev_log,
};

pub struct Struct {
	pub(super) config:DashboardConfig,
	pub(super) metrics:Arc<RwLock<VecDeque<PerformanceMetric>>>,
	pub(super) traces:Arc<RwLock<HashMap<String, TraceSpan>>>,
	pub(super) alerts:Arc<RwLock<VecDeque<PerformanceAlert>>>,
	pub(super) statistics:Arc<RwLock<DashboardStatistics>>,
	pub(super) is_running:Arc<AsyncMutex<bool>>,
}

impl Struct {
	pub fn new(config:DashboardConfig) -> Self {
		let config_clone = config.clone();
		let dashboard = Self {
			config,
			metrics:Arc::new(RwLock::new(VecDeque::new())),
			traces:Arc::new(RwLock::new(HashMap::new())),
			alerts:Arc::new(RwLock::new(VecDeque::new())),
			statistics:Arc::new(RwLock::new(DashboardStatistics {
				total_metrics_collected:0,
				total_traces_collected:0,
				total_alerts_triggered:0,
				average_processing_time_ms:0.0,
				peak_processing_time_ms:0,
				error_rate_percentage:0.0,
				throughput_messages_per_second:0.0,
				memory_usage_mb:0.0,
				last_update:SystemTime::now()
					.duration_since(SystemTime::UNIX_EPOCH)
					.unwrap_or_default()
					.as_secs(),
			})),
			is_running:Arc::new(AsyncMutex::new(false)),
		};

		dev_log!(
			"ipc",
			"[PerformanceDashboard] Created dashboard with {}ms update interval",
			config_clone.update_interval_ms
		);

		dashboard
	}

	pub async fn start(&self) -> Result<(), String> {
		{
			let mut running = self.is_running.lock().await;
			if *running {
				return Ok(());
			}
			*running = true;
		}

		self.start_metrics_collection().await;
		self.start_alert_monitoring().await;
		self.start_data_cleanup().await;

		dev_log!("ipc", "[PerformanceDashboard] Performance dashboard started");
		Ok(())
	}

	pub async fn stop(&self) -> Result<(), String> {
		{
			let mut running = self.is_running.lock().await;
			if !*running {
				return Ok(());
			}
			*running = false;
		}

		{
			let mut metrics = self.metrics.write().await;
			metrics.clear();
		}

		{
			let mut traces = self.traces.write().await;
			traces.clear();
		}

		{
			let mut alerts = self.alerts.write().await;
			alerts.clear();
		}

		dev_log!("ipc", "[PerformanceDashboard] Performance dashboard stopped");
		Ok(())
	}

	pub async fn record_metric(&self, metric:PerformanceMetric) {
		let mut metrics = self.metrics.write().await;
		metrics.push_back(metric.clone());

		drop(metrics);

		self.update_statistics().await;
		self.check_alerts(&metric).await;

		dev_log!("ipc", "[PerformanceDashboard] Recorded metric: {:?}", metric.metric_type);
	}

	pub async fn start_trace_span(&self, operation_name:String) -> TraceSpan {
		let trace_id = Self::generate_trace_id();
		let span_id = Self::generate_span_id();

		let span = TraceSpan {
			trace_id:trace_id.clone(),
			span_id:span_id.clone(),
			parent_span_id:None,
			operation_name,
			start_time:SystemTime::now()
				.duration_since(SystemTime::UNIX_EPOCH)
				.unwrap_or_default()
				.as_millis() as u64,
			end_time:None,
			duration_ms:None,
			tags:HashMap::new(),
			logs:Vec::new(),
		};

		{
			let mut traces = self.traces.write().await;
			traces.insert(span_id.clone(), span.clone());
		}

		{
			let mut stats = self.statistics.write().await;
			stats.total_traces_collected += 1;
		}

		span
	}

	pub async fn end_trace_span(&self, span_id:&str) -> Result<(), String> {
		let mut traces = self.traces.write().await;

		if let Some(span) = traces.get_mut(span_id) {
			let end_time = SystemTime::now()
				.duration_since(SystemTime::UNIX_EPOCH)
				.unwrap_or_default()
				.as_millis() as u64;

			span.end_time = Some(end_time);
			span.duration_ms = Some(end_time.saturating_sub(span.start_time));

			dev_log!(
				"ipc",
				"[PerformanceDashboard] Ended trace span: {} (duration: {}ms)",
				span.operation_name,
				span.duration_ms.unwrap_or(0)
			);

			Ok(())
		} else {
			Err(format!("Trace span not found: {}", span_id))
		}
	}

	pub async fn add_trace_log(&self, span_id:&str, log:TraceLog) -> Result<(), String> {
		let mut traces = self.traces.write().await;

		if let Some(span) = traces.get_mut(span_id) {
			span.logs.push(log);
			Ok(())
		} else {
			Err(format!("Trace span not found: {}", span_id))
		}
	}

	async fn start_metrics_collection(&self) {
		let dashboard = Arc::new(self.clone());

		tokio::spawn(async move {
			let mut interval = interval(Duration::from_millis(dashboard.config.update_interval_ms));

			while *dashboard.is_running.lock().await {
				interval.tick().await;
				dashboard.collect_system_metrics().await;
				dashboard.update_statistics().await;
			}
		});
	}

	async fn start_alert_monitoring(&self) {
		let dashboard = Arc::new(self.clone());

		tokio::spawn(async move {
			let mut interval = interval(Duration::from_secs(10));

			while *dashboard.is_running.lock().await {
				interval.tick().await;
				dashboard.check_performance_alerts().await;
			}
		});
	}

	async fn start_data_cleanup(&self) {
		let dashboard = Arc::new(self.clone());

		tokio::spawn(async move {
			let mut interval = interval(Duration::from_secs(3600));

			while *dashboard.is_running.lock().await {
				interval.tick().await;
				dashboard.cleanup_old_data().await;
			}
		});
	}

	async fn collect_system_metrics(&self) {
		if let Ok(memory_usage) = Self::get_memory_usage() {
			let metric = PerformanceMetric {
				metric_type:MetricType::MemoryUsage,
				value:memory_usage,
				timestamp:SystemTime::now()
					.duration_since(SystemTime::UNIX_EPOCH)
					.unwrap_or_default()
					.as_millis() as u64,
				channel:None,
				tags:HashMap::new(),
			};
			self.record_metric(metric).await;
		}

		if let Ok(cpu_usage) = Self::get_cpu_usage() {
			let metric = PerformanceMetric {
				metric_type:MetricType::CpuUsage,
				value:cpu_usage,
				timestamp:SystemTime::now()
					.duration_since(SystemTime::UNIX_EPOCH)
					.unwrap_or_default()
					.as_millis() as u64,
				channel:None,
				tags:HashMap::new(),
			};
			self.record_metric(metric).await;
		}
	}

	async fn update_statistics(&self) {
		let metrics = self.metrics.read().await;
		let mut stats = self.statistics.write().await;

		let processing_metrics:Vec<&PerformanceMetric> = metrics
			.iter()
			.filter(|m| matches!(m.metric_type, MetricType::MessageProcessingTime))
			.collect();

		if !processing_metrics.is_empty() {
			let total_time:f64 = processing_metrics.iter().map(|m| m.value).sum();
			stats.average_processing_time_ms = total_time / processing_metrics.len() as f64;
			stats.peak_processing_time_ms = processing_metrics.iter().map(|m| m.value as u64).max().unwrap_or(0);
		}

		let error_metrics:Vec<&PerformanceMetric> = metrics
			.iter()
			.filter(|m| matches!(m.metric_type, MetricType::ErrorRate))
			.collect();

		if !error_metrics.is_empty() {
			let total_errors:f64 = error_metrics.iter().map(|m| m.value).sum();
			stats.error_rate_percentage = total_errors / error_metrics.len() as f64;
		}

		let throughput_metrics:Vec<&PerformanceMetric> = metrics
			.iter()
			.filter(|m| matches!(m.metric_type, MetricType::NetworkThroughput))
			.collect();

		if !throughput_metrics.is_empty() {
			let total_throughput:f64 = throughput_metrics.iter().map(|m| m.value).sum();
			stats.throughput_messages_per_second = total_throughput / throughput_metrics.len() as f64;
		}

		let memory_metrics:Vec<&PerformanceMetric> = metrics
			.iter()
			.filter(|m| matches!(m.metric_type, MetricType::MemoryUsage))
			.collect();

		if !memory_metrics.is_empty() {
			let total_memory:f64 = memory_metrics.iter().map(|m| m.value).sum();
			stats.memory_usage_mb = total_memory / memory_metrics.len() as f64;
		}

		stats.last_update = SystemTime::now()
			.duration_since(SystemTime::UNIX_EPOCH)
			.unwrap_or_default()
			.as_secs();
	}

	async fn check_alerts(&self, metric:&PerformanceMetric) {
		let threshold = match metric.metric_type {
			MetricType::MessageProcessingTime => self.config.alert_threshold_ms as f64,
			MetricType::ErrorRate => 5.0,
			MetricType::MemoryUsage => 1024.0,
			MetricType::CpuUsage => 90.0,
			_ => return,
		};

		if metric.value > threshold {
			let severity = match metric.value / threshold {
				ratio if ratio > 5.0 => AlertSeverity::Critical,
				ratio if ratio > 3.0 => AlertSeverity::High,
				ratio if ratio > 2.0 => AlertSeverity::Medium,
				_ => AlertSeverity::Low,
			};

			let alert = PerformanceAlert {
				alert_id:Self::generate_alert_id(),
				metric_type:metric.metric_type.clone(),
				threshold,
				current_value:metric.value,
				timestamp:metric.timestamp,
				channel:metric.channel.clone(),
				severity,
				message:format!(
					"{} exceeded threshold: {} > {}",
					Self::metric_type_name(&metric.metric_type),
					metric.value,
					threshold
				),
			};

			{
				let mut alerts = self.alerts.write().await;
				alerts.push_back(alert.clone());
			}

			{
				let mut stats = self.statistics.write().await;
				stats.total_alerts_triggered += 1;
			}

			dev_log!("ipc", "warn: [PerformanceDashboard] Alert triggered: {}", alert.message);
		}
	}

	async fn check_performance_alerts(&self) {
		dev_log!("ipc", "[PerformanceDashboard] Checking performance alerts");
	}

	async fn cleanup_old_data(&self) {
		let retention_threshold = SystemTime::now()
			.duration_since(SystemTime::UNIX_EPOCH)
			.unwrap_or_default()
			.as_secs()
			- (self.config.metrics_retention_hours * 3600);

		{
			let mut metrics = self.metrics.write().await;
			metrics.retain(|m| m.timestamp >= retention_threshold);
		}

		{
			let mut traces = self.traces.write().await;
			traces.retain(|_, span| span.start_time >= retention_threshold);

			if traces.len() > self.config.max_traces_stored {
				let excess = traces.len() - self.config.max_traces_stored;
				let keys_to_remove:Vec<String> = traces.keys().take(excess).cloned().collect();

				for key in keys_to_remove {
					traces.remove(&key);
				}
			}
		}

		{
			let mut alerts = self.alerts.write().await;
			alerts.retain(|a| a.timestamp >= retention_threshold);
		}

		dev_log!("ipc", "[PerformanceDashboard] Cleaned up old data");
	}

	fn get_memory_usage() -> Result<f64, String> { Ok(100.0) }

	fn get_cpu_usage() -> Result<f64, String> { Ok(25.0) }

	fn generate_trace_id() -> String { uuid::Uuid::new_v4().to_string() }

	fn generate_span_id() -> String { uuid::Uuid::new_v4().to_string() }

	fn generate_alert_id() -> String { uuid::Uuid::new_v4().to_string() }

	fn metric_type_name(metric_type:&MetricType) -> &'static str {
		match metric_type {
			MetricType::MessageProcessingTime => "Message Processing Time",
			MetricType::ConnectionLatency => "Connection Latency",
			MetricType::MemoryUsage => "Memory Usage",
			MetricType::CpuUsage => "CPU Usage",
			MetricType::NetworkThroughput => "Network Throughput",
			MetricType::ErrorRate => "Error Rate",
			MetricType::QueueSize => "Queue Size",
		}
	}

	pub async fn get_statistics(&self) -> DashboardStatistics { self.statistics.read().await.clone() }

	pub async fn get_recent_metrics(&self, limit:usize) -> Vec<PerformanceMetric> {
		let metrics = self.metrics.read().await;
		metrics.iter().rev().take(limit).cloned().collect()
	}

	pub async fn get_active_alerts(&self) -> Vec<PerformanceAlert> {
		let alerts = self.alerts.read().await;
		alerts.iter().rev().cloned().collect()
	}

	pub async fn get_trace(&self, trace_id:&str) -> Option<TraceSpan> {
		let traces = self.traces.read().await;
		traces.values().find(|span| span.trace_id == trace_id).cloned()
	}

	pub fn default_dashboard() -> Self { Self::new(DashboardConfig::default()) }

	pub fn high_frequency_dashboard() -> Self {
		Self::new(DashboardConfig {
			update_interval_ms:1000,
			metrics_retention_hours:1,
			alert_threshold_ms:500,
			trace_sampling_rate:1.0,
			max_traces_stored:5000,
		})
	}

	pub fn create_metric(
		metric_type:MetricType,
		value:f64,
		channel:Option<String>,
		tags:HashMap<String, String>,
	) -> PerformanceMetric {
		PerformanceMetric {
			metric_type,
			value,
			timestamp:SystemTime::now()
				.duration_since(SystemTime::UNIX_EPOCH)
				.unwrap_or_default()
				.as_millis() as u64,
			channel,
			tags,
		}
	}

	pub fn create_trace_log(message:String, level:LogLevel, fields:HashMap<String, String>) -> TraceLog {
		TraceLog {
			timestamp:SystemTime::now()
				.duration_since(SystemTime::UNIX_EPOCH)
				.unwrap_or_default()
				.as_millis() as u64,
			message,
			level,
			fields,
		}
	}

	pub fn calculate_performance_score(average_processing_time:f64, error_rate:f64, throughput:f64) -> f64 {
		let time_score = 100.0 / (1.0 + average_processing_time / 100.0);
		let error_score = 100.0 * (1.0 - error_rate / 100.0);
		let throughput_score = throughput / 1000.0;

		(time_score * 0.4 + error_score * 0.4 + throughput_score * 0.2)
			.max(0.0)
			.min(100.0)
	}

	pub fn format_metric_value(metric_type:&MetricType, value:f64) -> String {
		match metric_type {
			MetricType::MessageProcessingTime => format!("{:.2}ms", value),
			MetricType::ConnectionLatency => format!("{:.2}ms", value),
			MetricType::MemoryUsage => format!("{:.2}MB", value),
			MetricType::CpuUsage => format!("{:.2}%", value),
			MetricType::NetworkThroughput => format!("{:.2} msg/s", value),
			MetricType::ErrorRate => format!("{:.2}%", value),
			MetricType::QueueSize => format!("{:.0}", value),
		}
	}
}

impl Clone for Struct {
	fn clone(&self) -> Self {
		Self {
			config:self.config.clone(),
			metrics:self.metrics.clone(),
			traces:self.traces.clone(),
			alerts:self.alerts.clone(),
			statistics:self.statistics.clone(),
			is_running:Arc::new(AsyncMutex::new(false)),
		}
	}
}