rust_observer 0.2.2

Express telemetry rust SDK
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

use smallvec::SmallVec;
use sysinfo::{System, Disks};
use std::sync::Arc;
use parking_lot::Mutex;

#[derive(Debug, Clone)]
pub struct SystemMetrics {
    pub cpu_usage: f32,
    pub cpu_cores_usage: SmallVec<[f32; 16]>,
    pub memory_total: u64,
    pub memory_used: u64,
    pub swap_total: u64,
    pub swap_used: u64,
    pub disk_total_space: u64,
    pub disk_available_space: u64,
}

pub struct SystemMetricsCollector {
    sys: Arc<Mutex<System>>,
    disks: Arc<Mutex<Disks>>,
}

impl SystemMetricsCollector {
    pub fn new() -> Self {
        let mut sys = System::new_all();
        sys.refresh_all();
        let disks = Disks::new_with_refreshed_list();

        SystemMetricsCollector {
            sys: Arc::new(Mutex::new(sys)),
            disks: Arc::new(Mutex::new(disks)),
        }
    }

    pub fn collect(&self) -> SystemMetrics {
        let mut sys = self.sys.lock();
        sys.refresh_all();

        let cpu_usage = sys.global_cpu_usage();
        let cpu_cores_usage = sys.cpus().iter().map(|cpu| cpu.cpu_usage()).collect();
        let memory_total = sys.total_memory();
        let memory_used = sys.used_memory();
        let swap_total = sys.total_swap();
        let swap_used = sys.used_swap();

        let mut disks = self.disks.lock();
        disks.refresh_list();
        let disk_total_space = disks.iter().map(|disk| disk.total_space()).sum();
        let disk_available_space = disks.iter().map(|disk| disk.available_space()).sum();

        SystemMetrics {
            cpu_usage,
            cpu_cores_usage,
            memory_total,
            memory_used,
            swap_total,
            swap_used,
            disk_total_space,
            disk_available_space,
        }
    }
}