procsys 0.7.0

Rust library to retrieve system, kernel, and process metrics from the pseudo-filesystems /proc and /sys
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

use std::path::Path;

use serde::Serialize;

use crate::{
    error::{CollectResult, MetricError},
    utils,
};

/// LoadAvg represents an entry in /proc/loadavg
#[derive(Debug, Serialize, Clone, Default)]
pub struct LoadAvg {
    pub load1: f64,
    pub load5: f64,
    pub load15: f64,
}

impl LoadAvg {
    fn new() -> Self {
        Default::default()
    }
}

/// collects the load average information
/// # Example
/// ```
/// use procsys::loadavg;
///
/// let sysload = loadavg::collect().expect("load average");
///
/// println!("load average 1 : {}", sysload.load1);
/// println!("load average 5 : {}", sysload.load5);
/// println!("load average 15: {}", sysload.load15);
/// ```
pub fn collect() -> CollectResult<LoadAvg> {
    collect_from("loadavg", Path::new("/proc"))
}

fn collect_from(filename: &str, base_path: &Path) -> CollectResult<LoadAvg> {
    let mut sysload = LoadAvg::new();

    match utils::collect_info_string(filename, Path::new(base_path))? {
        Some(content) => {
            let avgfields: Vec<&str> = content
                .trim()
                .split(' ')
                .filter(|s| !s.is_empty())
                .collect();

            if avgfields.len() < 3 {
                return Err(MetricError::InvalidFieldNumberError(
                    "load avegrage".to_string(),
                    avgfields.len(),
                    content,
                ));
            }

            sysload.load1 = avgfields[0].parse::<f64>().unwrap_or_default();
            sysload.load5 = avgfields[1].parse::<f64>().unwrap_or_default();
            sysload.load15 = avgfields[2].parse::<f64>().unwrap_or_default();
        }
        None => return Ok(sysload),
    }

    Ok(sysload)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn sys_loadavg() {
        let sysload = collect_from("loadavg", Path::new("test_data/fixtures/proc"))
            .expect("collecting system load average");

        assert_eq!(sysload.load1, 0.02);
        assert_eq!(sysload.load5, 0.04);
        assert_eq!(sysload.load15, 0.05);
    }
}