Christoffer Martinsson
83cb43bcf1
Some checks failed
Build and Release / build-and-release (push) Failing after 1m24s
- Rewrite smart collector to match current architecture - Add back to mod.rs exports - Fixes infinite smartctl loop issue - Uses simple health and temperature monitoring
101 lines
3.2 KiB
Rust
101 lines
3.2 KiB
Rust
use async_trait::async_trait;
|
|
use cm_dashboard_shared::{Metric, StatusTracker};
|
|
|
|
|
|
pub mod backup;
|
|
pub mod cpu;
|
|
pub mod disk;
|
|
pub mod error;
|
|
pub mod memory;
|
|
pub mod nixos;
|
|
pub mod smart;
|
|
pub mod systemd;
|
|
|
|
pub use error::CollectorError;
|
|
|
|
|
|
/// Base trait for all collectors with extreme efficiency requirements
|
|
#[async_trait]
|
|
pub trait Collector: Send + Sync {
|
|
/// Collect all metrics this collector provides
|
|
async fn collect(&self, status_tracker: &mut StatusTracker) -> Result<Vec<Metric>, CollectorError>;
|
|
|
|
|
|
}
|
|
|
|
/// CPU efficiency rules for all collectors
|
|
pub mod efficiency {
|
|
//! CRITICAL: All collectors must follow these efficiency rules to minimize system impact
|
|
//!
|
|
//! # FILE READING RULES
|
|
//! - Read entire files in single syscall when possible
|
|
//! - Use BufReader only for very large files (>4KB)
|
|
//! - Never read files character by character
|
|
//! - Cache file descriptors when safe (immutable paths)
|
|
//!
|
|
//! # PARSING RULES
|
|
//! - Use split() instead of regex for simple patterns
|
|
//! - Parse numbers with from_str() not complex parsing
|
|
//! - Avoid string allocations in hot paths
|
|
//! - Use str::trim() before parsing numbers
|
|
//!
|
|
//! # MEMORY ALLOCATION RULES
|
|
//! - Reuse Vec buffers when possible
|
|
//! - Pre-allocate collections with known sizes
|
|
//! - Use str slices instead of String when possible
|
|
//! - Avoid clone() in hot paths
|
|
//!
|
|
//! # SYSTEM CALL RULES
|
|
//! - Minimize syscalls - prefer single reads over multiple
|
|
//! - Use /proc filesystem efficiently
|
|
//! - Avoid spawning processes when /proc data available
|
|
//! - Cache static data (like CPU count)
|
|
//!
|
|
//! # ERROR HANDLING RULES
|
|
//! - Use Result<> but minimize allocation in error paths
|
|
//! - Log errors at debug level only to avoid I/O overhead
|
|
//! - Graceful degradation - missing metrics better than failing
|
|
//! - Never panic in collectors
|
|
//!
|
|
//! # CONCURRENCY RULES
|
|
//! - Collectors must be thread-safe but avoid locks
|
|
//! - Use atomic operations for simple counters
|
|
//! - Avoid shared mutable state between collections
|
|
//! - Each collection should be independent
|
|
}
|
|
|
|
/// Utility functions for efficient system data collection
|
|
pub mod utils {
|
|
use super::CollectorError;
|
|
use std::fs;
|
|
|
|
/// Read entire file content efficiently
|
|
pub fn read_proc_file(path: &str) -> Result<String, CollectorError> {
|
|
fs::read_to_string(path).map_err(|e| CollectorError::SystemRead {
|
|
path: path.to_string(),
|
|
error: e.to_string(),
|
|
})
|
|
}
|
|
|
|
/// Parse float from string slice efficiently
|
|
pub fn parse_f32(s: &str) -> Result<f32, CollectorError> {
|
|
s.trim()
|
|
.parse()
|
|
.map_err(|e: std::num::ParseFloatError| CollectorError::Parse {
|
|
value: s.to_string(),
|
|
error: e.to_string(),
|
|
})
|
|
}
|
|
|
|
/// Parse integer from string slice efficiently
|
|
pub fn parse_u64(s: &str) -> Result<u64, CollectorError> {
|
|
s.trim()
|
|
.parse()
|
|
.map_err(|e: std::num::ParseIntError| CollectorError::Parse {
|
|
value: s.to_string(),
|
|
error: e.to_string(),
|
|
})
|
|
}
|
|
|
|
}
|