refactor(module_reload): remove stats and history tracking

Author: skiniks

crates/rari/src/runtime/module_reload/config.rs

@@ -5,8 +5,6 @@ pub struct ReloadConfig {
     pub reload_timeout_ms: u64,
     pub parallel_reloads: bool,
     pub debounce_delay_ms: u64,
-    pub max_history_size: usize,
-    pub enable_memory_monitoring: bool,
 }
 
 impl Default for ReloadConfig {
@@ -17,8 +15,6 @@ impl Default for ReloadConfig {
             reload_timeout_ms: 5000,
             parallel_reloads: true,
             debounce_delay_ms: 150,
-            max_history_size: 100,
-            enable_memory_monitoring: true,
         }
     }
 }
@@ -31,8 +27,6 @@ impl ReloadConfig {
             reload_timeout_ms: 3000,
             parallel_reloads: true,
             debounce_delay_ms: 200,
-            max_history_size: 50,
-            enable_memory_monitoring: false,
         }
     }
 
@@ -43,8 +37,6 @@ impl ReloadConfig {
             reload_timeout_ms: 10000,
             parallel_reloads: true,
             debounce_delay_ms: 100,
-            max_history_size: 200,
-            enable_memory_monitoring: true,
         }
     }
 

crates/rari/src/runtime/module_reload/manager.rs

@@ -1,38 +1,32 @@
 use crate::error::{ModuleReloadError, RariError};
 use crate::rsc::components::ComponentRegistry;
 use crate::runtime::JsExecutionRuntime;
-use crate::runtime::module_reload::{
-    DebounceManager, ModuleReloadRequest, ReloadConfig, ReloadHistoryEntry, ReloadStats,
-};
+use crate::runtime::module_reload::{DebounceManager, ModuleReloadRequest, ReloadConfig};
 use crate::runtime::utils::DistPathResolver;
 use std::collections::VecDeque;
 use std::path::Path;
 use std::sync::Arc;
-use std::time::{Duration, Instant};
-use tokio::sync::{Mutex, RwLock};
+use std::time::Duration;
+use tokio::sync::Mutex;
 use tracing::error;
 
 pub struct ModuleReloadManager {
     reload_queue: Arc<Mutex<VecDeque<ModuleReloadRequest>>>,
-    reload_stats: Arc<RwLock<ReloadStats>>,
     config: ReloadConfig,
     runtime: Option<Arc<JsExecutionRuntime>>,
     component_registry: Option<Arc<parking_lot::Mutex<ComponentRegistry>>>,
     debounce_manager: DebounceManager,
-    reload_history: Arc<Mutex<VecDeque<ReloadHistoryEntry>>>,
     dist_path_resolver: Option<Arc<DistPathResolver>>,
 }
 
 impl Clone for ModuleReloadManager {
     fn clone(&self) -> Self {
         Self {
             reload_queue: Arc::clone(&self.reload_queue),
-            reload_stats: Arc::clone(&self.reload_stats),
             config: self.config.clone(),
             runtime: self.runtime.clone(),
             component_registry: self.component_registry.clone(),
             debounce_manager: self.debounce_manager.clone(),
-            reload_history: Arc::clone(&self.reload_history),
             dist_path_resolver: self.dist_path_resolver.clone(),
         }
     }
@@ -42,25 +36,21 @@ impl ModuleReloadManager {
     pub fn new(config: ReloadConfig) -> Self {
         Self {
             reload_queue: Arc::new(Mutex::new(VecDeque::new())),
-            reload_stats: Arc::new(RwLock::new(ReloadStats::default())),
             config,
             runtime: None,
             component_registry: None,
             debounce_manager: DebounceManager::new(),
-            reload_history: Arc::new(Mutex::new(VecDeque::new())),
             dist_path_resolver: None,
         }
     }
 
     pub fn with_runtime(config: ReloadConfig, runtime: Arc<JsExecutionRuntime>) -> Self {
         Self {
             reload_queue: Arc::new(Mutex::new(VecDeque::new())),
-            reload_stats: Arc::new(RwLock::new(ReloadStats::default())),
             config,
             runtime: Some(runtime),
             component_registry: None,
             debounce_manager: DebounceManager::new(),
-            reload_history: Arc::new(Mutex::new(VecDeque::new())),
             dist_path_resolver: None,
         }
     }
@@ -89,10 +79,6 @@ impl ModuleReloadManager {
         self.config.enabled
     }
 
-    pub async fn get_stats(&self) -> ReloadStats {
-        self.reload_stats.read().await.clone()
-    }
-
     pub async fn enqueue_reload(&self, request: ModuleReloadRequest) {
         let mut queue = self.reload_queue.lock().await;
         queue.push_back(request);
@@ -116,37 +102,6 @@ impl ModuleReloadManager {
     fn clone_for_task(&self) -> Self {
         self.clone()
     }
-
-    async fn record_reload_stats(&self, success: bool, duration_ms: u64) {
-        let mut stats = self.reload_stats.write().await;
-        stats.record_reload(success, duration_ms);
-    }
-
-    async fn add_to_history(&self, component_id: String, success: bool, duration_ms: u64) {
-        let mut history = self.reload_history.lock().await;
-
-        let entry = ReloadHistoryEntry::new(component_id, success, duration_ms);
-        history.push_back(entry);
-
-        while history.len() > self.config.max_history_size {
-            history.pop_front();
-        }
-    }
-
-    pub async fn get_reload_history(&self) -> Vec<ReloadHistoryEntry> {
-        let history = self.reload_history.lock().await;
-        history.iter().cloned().collect()
-    }
-
-    pub async fn clear_history(&self) {
-        let mut history = self.reload_history.lock().await;
-        history.clear();
-    }
-
-    pub async fn get_memory_usage(&self) -> u64 {
-        let stats = self.reload_stats.read().await;
-        stats.estimated_memory_bytes
-    }
 }
 
 impl ModuleReloadManager {
@@ -192,15 +147,8 @@ impl ModuleReloadManager {
             return Ok(());
         }
 
-        let start = Instant::now();
-
         let result = self.reload_with_retry(component_id, file_path).await;
 
-        let duration_ms = start.elapsed().as_millis() as u64;
-
-        self.record_reload_stats(result.is_ok(), duration_ms).await;
-        self.add_to_history(component_id.to_string(), result.is_ok(), duration_ms).await;
-
         match &result {
             Ok(_) => {}
             Err(e) => {

crates/rari/src/runtime/module_reload/mod.rs

@@ -2,12 +2,10 @@ pub mod config;
 pub mod debounce;
 pub mod manager;
 pub mod request;
-pub mod stats;
 pub mod verification;
 
 pub use config::ReloadConfig;
 pub use debounce::{DebounceManager, DebouncePendingMap};
 pub use manager::ModuleReloadManager;
 pub use request::ModuleReloadRequest;
-pub use stats::{ReloadHistoryEntry, ReloadStats};
 pub use verification::{JsComponentVerification, JsModuleCacheInfo, JsReloadResult};

crates/rari/src/runtime/module_reload/stats.rs

@@ -303,8 +303,6 @@ pub struct RscConfig {
     pub hmr_reload_timeout_ms: u64,
     pub hmr_parallel_reloads: bool,
     pub hmr_debounce_delay_ms: u64,
-    pub hmr_max_history_size: usize,
-    pub hmr_enable_memory_monitoring: bool,
 }
 
 impl Default for RscConfig {
@@ -321,8 +319,6 @@ impl Default for RscConfig {
             hmr_reload_timeout_ms: 5000,
             hmr_parallel_reloads: true,
             hmr_debounce_delay_ms: 150,
-            hmr_max_history_size: 100,
-            hmr_enable_memory_monitoring: true,
         }
     }
 }
@@ -463,19 +459,6 @@ impl Config {
                 .map_err(|_| ConfigError::Config("RARI_HMR_DEBOUNCE_DELAY_MS".to_string()))?;
         }
 
-        if let Ok(history_size_str) = std::env::var("RARI_HMR_MAX_HISTORY_SIZE") {
-            config.rsc.hmr_max_history_size = history_size_str
-                .parse()
-                .map_err(|_| ConfigError::Config("RARI_HMR_MAX_HISTORY_SIZE".to_string()))?;
-        }
-
-        if let Ok(memory_monitoring_str) = std::env::var("RARI_HMR_ENABLE_MEMORY_MONITORING") {
-            config.rsc.hmr_enable_memory_monitoring = memory_monitoring_str.cow_to_lowercase()
-                == "true"
-                || memory_monitoring_str == "1"
-                || memory_monitoring_str.cow_to_lowercase() == "yes";
-        }
-
         if let Ok(rsc_html_enabled_str) = std::env::var("RARI_RSC_HTML_ENABLED") {
             config.rsc_html.enabled = rsc_html_enabled_str.cow_to_lowercase() == "true"
                 || rsc_html_enabled_str == "1"

crates/rari/src/server/config/mod.rs

@@ -129,8 +129,6 @@ impl Server {
             reload_timeout_ms: config.rsc.hmr_reload_timeout_ms,
             parallel_reloads: config.rsc.hmr_parallel_reloads,
             debounce_delay_ms: config.rsc.hmr_debounce_delay_ms,
-            max_history_size: config.rsc.hmr_max_history_size,
-            enable_memory_monitoring: config.rsc.hmr_enable_memory_monitoring,
         };
         let mut module_reload_manager =
             crate::runtime::module_reload::ModuleReloadManager::new(reload_config);