Christoffer Martinsson
2b2cb2da3e
All checks were successful
Build and Release / build-and-release (push) Successful in 1m7s
Implements clean structured data collection eliminating all string metric parsing bugs. Collectors now populate AgentData directly with type-safe field access. Key improvements: - Mount points preserved correctly (/ and /boot instead of root/boot) - Tmpfs discovery added to memory collector - Temperature data flows as typed f32 fields - Zero string parsing overhead - Complete removal of MetricCollectionManager bridge - Direct ZMQ transmission of structured JSON All functionality maintained: service tracking, notifications, status evaluation, and multi-host monitoring.
98 lines
3.2 KiB
Rust
98 lines
3.2 KiB
Rust
use async_trait::async_trait;
|
|
use cm_dashboard_shared::{AgentData};
|
|
|
|
|
|
pub mod backup;
|
|
pub mod cpu;
|
|
pub mod disk;
|
|
pub mod error;
|
|
pub mod memory;
|
|
pub mod nixos;
|
|
pub mod systemd;
|
|
|
|
pub use error::CollectorError;
|
|
|
|
|
|
/// Base trait for all collectors with direct structured data output
|
|
#[async_trait]
|
|
pub trait Collector: Send + Sync {
|
|
/// Collect data and populate AgentData directly with status evaluation
|
|
async fn collect_structured(&self, agent_data: &mut AgentData) -> Result<(), 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(),
|
|
})
|
|
}
|
|
|
|
}
|