rtopm 0.1.0

A modern TUI system resource monitor with Docker and disk I/O tracking
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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

use std::collections::VecDeque;

const MAX_SAMPLES: usize = 3600; // 1 hora a 1 muestra/seg

#[derive(Clone)]
pub struct MetricSample {
    pub cpu_pct: f64,
    pub mem_pct: f64,
    #[allow(dead_code)]
    pub load1: f64,
    pub net_recv_bps: f64,
    pub net_sent_bps: f64,
    pub disk_read_bps: f64,
    pub disk_write_bps: f64,
}

#[derive(Clone)]
#[allow(dead_code)]
pub struct ProcessHistorySample {
    pub cpu_pct: f64,
    pub mem_pct: f64,
    pub memory_bytes: u64,
    pub disk_read_bps: f64,
    pub disk_write_bps: f64,
}

#[derive(Clone)]
#[allow(dead_code)]
pub struct ContainerHistorySample {
    pub cpu_pct: f64,
    pub mem_pct: f64,
    pub memory_bytes: u64,
    pub net_recv_bps: f64,
    pub net_sent_bps: f64,
    pub disk_read_bps: f64,
    pub disk_write_bps: f64,
}

pub struct MetricsHistory {
    pub samples: VecDeque<MetricSample>,
}

impl MetricsHistory {
    pub fn new() -> Self {
        Self {
            samples: VecDeque::with_capacity(MAX_SAMPLES),
        }
    }

    pub fn push(&mut self, sample: MetricSample) {
        if self.samples.len() >= MAX_SAMPLES {
            self.samples.pop_front();
        }
        self.samples.push_back(sample);
    }

    pub fn tail_n(&self, n: usize) -> Vec<&MetricSample> {
        let skip = self.samples.len().saturating_sub(n);
        self.samples.iter().skip(skip).collect()
    }
}

#[derive(Clone, Copy, PartialEq)]
pub enum HistoryRange {
    OneMin,
    FiveMin,
    FifteenMin,
    OneHour,
}

impl HistoryRange {
    pub fn samples(self) -> usize {
        match self {
            Self::OneMin => 60,
            Self::FiveMin => 300,
            Self::FifteenMin => 900,
            Self::OneHour => 3600,
        }
    }

    pub fn label(self) -> &'static str {
        match self {
            Self::OneMin => "1 min",
            Self::FiveMin => "5 min",
            Self::FifteenMin => "15 min",
            Self::OneHour => "1 hora",
        }
    }

    pub fn next(self) -> Self {
        match self {
            Self::OneMin => Self::FiveMin,
            Self::FiveMin => Self::FifteenMin,
            Self::FifteenMin => Self::OneHour,
            Self::OneHour => Self::OneMin,
        }
    }
}