mmoxi 0.3.1

spectrum scale tools
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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

//! Prometheus metrics.

use std::collections::HashMap;
use std::io::Write;
use std::path::Path;

use anyhow::{anyhow, Result};

use crate::nsd::FsPoolId;
use crate::sysfs;

/// Convert `Data` to Prometheus metrics.
pub trait ToText {
    /// Converts the `Data` to Prometheus' text-based format.
    ///
    /// # Errors
    ///
    /// This function uses [`writeln`] to write to `output`. It can only fail
    /// if any of these [`writeln`] fails.
    fn to_prom(&self, output: &mut impl Write) -> Result<()>;
}

/// Returns block device metrics grouped by pool.
///
/// # Errors
///
/// Returns an error if fetching the NSDs or block device statistics fails.
pub fn pool_block_device_metrics<Cache>(
    device_cache: Cache,
    force: bool,
) -> Result<PoolBlockDeviceMetrics>
where
    Cache: AsRef<Path>,
{
    let pooled_nsds = crate::nsd::local_pooled(device_cache, force)?;

    let stats = sysfs::block::stat_all()?;

    let mut metrics = PoolBlockDeviceMetrics::default();

    for (id, nsds) in pooled_nsds {
        let mut pool_stat_sum = sysfs::block::Stat::default();

        for nsd in nsds {
            let device_name = nsd.device_name()?;

            let stat = stats.get(device_name.as_ref()).ok_or_else(|| {
                anyhow!("no block device stat for device: {}", nsd.device())
            })?;

            pool_stat_sum += *stat;
        }

        metrics.inner.insert(id, pool_stat_sum);
    }

    Ok(metrics)
}

/// Block device metrics grouped by pool.
#[derive(Default)]
pub struct PoolBlockDeviceMetrics {
    inner: HashMap<FsPoolId, sysfs::block::Stat>,
}

impl ToText for PoolBlockDeviceMetrics {
    fn to_prom(&self, output: &mut impl Write) -> Result<()> {
        writeln!(
            output,
            "# HELP gpfs_pool_read_ios GPFS pool processed read I/Os"
        )?;
        writeln!(output, "# TYPE gpfs_pool_read_ios counter")?;

        for (id, stat) in &self.inner {
            writeln!(
                output,
                "gpfs_pool_read_ios{{fs=\"{}\",pool=\"{}\"}} {}",
                id.fs(),
                id.pool(),
                stat.read_ios
            )?;
        }

        writeln!(output, "# HELP gpfs_pool_read_bytes GPFS pool read bytes")?;
        writeln!(output, "# TYPE gpfs_pool_read_bytes counter")?;

        for (id, stat) in &self.inner {
            writeln!(
                output,
                "gpfs_pool_read_bytes{{fs=\"{}\",pool=\"{}\"}} {}",
                id.fs(),
                id.pool(),
                stat.read_bytes()
            )?;
        }

        writeln!(
            output,
            "# HELP gpfs_pool_write_ios GPFS pool processed write I/Os"
        )?;
        writeln!(output, "# TYPE gpfs_pool_write_ios counter")?;

        for (id, stat) in &self.inner {
            writeln!(
                output,
                "gpfs_pool_write_ios{{fs=\"{}\",pool=\"{}\"}} {}",
                id.fs(),
                id.pool(),
                stat.write_ios
            )?;
        }

        writeln!(
            output,
            "# HELP gpfs_pool_write_bytes GPFS pool written bytes"
        )?;
        writeln!(output, "# TYPE gpfs_pool_write_bytes counter")?;

        for (id, stat) in &self.inner {
            writeln!(
                output,
                "gpfs_pool_write_bytes{{fs=\"{}\",pool=\"{}\"}} {}",
                id.fs(),
                id.pool(),
                stat.write_bytes()
            )?;
        }

        Ok(())
    }
}