Struct ResourceMonitor 

pub struct ResourceMonitor { /* private fields */ }

Resource monitor for tracking and limiting resource usage.

Implementations

impl ResourceMonitor

pub fn new(limits: ResourceLimits) -> Self

Create a new resource monitor with the given limits.

pub fn can_allocate(&self, resource_type: ResourceType, amount: u64) -> bool

Check if a resource allocation can be made.

pub fn record_allocation(&mut self, resource_type: ResourceType, amount: u64)

Record a resource allocation.

pub fn record_deallocation(&mut self, resource_type: ResourceType, amount: u64)

Record a resource deallocation.

pub fn update_usage(&mut self, resource_type: ResourceType, current: u64)

Update current usage (for absolute measurements like CPU).

pub fn is_throttled(&self, resource_type: ResourceType) -> bool

Check if a resource type is currently throttled.

pub fn get_stats(&self, resource_type: ResourceType) -> Option<ResourceStats>

Get usage statistics for a resource type.

pub fn get_all_stats(&self) -> HashMap<ResourceType, ResourceStats>

Get all resource statistics.

pub fn get_allocation_rate( &self, resource_type: ResourceType, window: Duration, ) -> u64

Calculate recent allocation rate (bytes/sec or percent/sec).

pub fn cleanup_old_records(&mut self, older_than: Duration)

Clean old allocation records (older than specified duration).

pub fn reset_stats(&mut self)

Reset all statistics.

pub fn health_score(&self) -> f64

Get overall system health score (0.0 to 1.0).

pub fn is_over_limit(&self) -> bool

Check if any resource is over limit.

pub fn calculate_degradation_level(&self) -> DegradationLevel

Calculate the appropriate degradation level based on current resource usage.

This method analyzes resource utilization and determines what level of degradation is appropriate to maintain system stability.

pub fn update_degradation_level(&mut self)

Update the degradation level based on current resource usage.

This should be called periodically to adjust system behavior based on resource pressure.

pub fn degradation_level(&self) -> DegradationLevel

Get the current degradation level.

pub fn should_accept_requests(&self) -> bool

Check if the system should accept new requests based on degradation level.

pub fn should_run_background_tasks(&self) -> bool

Check if background tasks should run based on degradation level.

pub fn recommended_cache_size(&self, base_size: usize) -> usize

Get recommended cache size based on degradation level.

pub fn recommended_concurrency(&self, base_concurrency: usize) -> usize

Get recommended concurrency limit based on degradation level.

pub fn sample_cpu_usage(&mut self) -> f32

Sample actual system CPU usage and update statistics.

This method refreshes CPU usage from the operating system and updates the internal statistics. Returns the current CPU usage percentage (0-100). Also updates degradation level based on new resource usage.

pub fn sample_memory_usage(&mut self) -> u64

Sample actual system memory usage and update statistics.

This method refreshes memory usage from the operating system and updates the internal statistics. Returns the current memory usage in bytes. Also updates degradation level based on new resource usage.

pub fn sample_all_system_resources(&mut self) -> (f32, u64)

Sample all system resources (CPU and memory) at once.

This is more efficient than calling individual sample methods separately. Returns a tuple of (cpu_usage_percent, memory_used_bytes). Also updates degradation level based on new resource usage.

pub fn total_system_memory(&self) -> u64

Get total system memory in bytes.

pub fn cpu_count(&self) -> usize

Get number of CPU cores.

pub fn predict_usage( &self, resource_type: ResourceType, window: Duration, forecast_duration: Duration, ) -> Option<u64>

Predict future resource usage based on recent trends.

Uses simple linear regression on recent allocation history to predict usage at a future time.

Arguments

• resource_type - The resource type to predict
• window - Duration of historical data to analyze
• forecast_duration - How far into the future to predict

Returns

Returns predicted usage value, or None if insufficient data.

pub fn should_proactive_throttle( &self, resource_type: ResourceType, prediction_window: Duration, forecast_duration: Duration, ) -> bool

Check if proactive throttling should be enabled based on predictions.

Analyzes predicted resource usage and determines if throttling should be enabled preemptively to avoid hitting limits.

Arguments

• resource_type - The resource type to check
• prediction_window - Duration of historical data for prediction
• forecast_duration - How far ahead to predict

Returns

Returns true if proactive throttling is recommended, false otherwise.

pub fn get_throttle_intensity( &self, resource_type: ResourceType, prediction_window: Duration, forecast_duration: Duration, ) -> f64

Get recommended throttle intensity based on predictions.

Returns a value between 0.0 (no throttling) and 1.0 (maximum throttling) based on predicted resource pressure.

Arguments

• resource_type - The resource type to analyze
• prediction_window - Duration of historical data for prediction
• forecast_duration - How far ahead to predict

Returns

Returns throttle intensity (0.0 to 1.0), where higher values mean more aggressive throttling.

impl ResourceMonitor

pub fn start_monitoring(&self, config: MonitoringConfig) -> MonitoringHandle

Start background monitoring of system resources.

This spawns a background task that periodically samples CPU and memory usage and updates the resource monitor’s statistics. The returned handle can be used to stop the monitoring gracefully.

Arguments

• config - Configuration for the monitoring task

Example

use chie_core::resource_mgmt::{ResourceMonitor, ResourceLimits, MonitoringConfig};
use std::time::Duration;

let limits = ResourceLimits::default();
let monitor = ResourceMonitor::new(limits);

// Start background monitoring
let config = MonitoringConfig {
    sample_interval: Duration::from_secs(10),
    ..Default::default()
};
let handle = monitor.start_monitoring(config);

// Monitor runs in background...

// Stop when done
handle.stop().await.unwrap();