memfaultd 1.26.1

Memfault daemon for embedded Linux systems. Observability, logging, crash reporting, and updating all in one service. Learn more at https://docs.memfault.com/
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
132
133
134
135

//
// Copyright (c) Memfault, Inc.
// See License.txt for details
use std::{collections::HashSet, time::Duration};

use serde::{Deserialize, Serialize};

use crate::util::serialization::seconds_to_duration;

use super::{DiskSpaceMetricsConfig, DiskstatsMetricsConfig, ProcessMetricsConfig};
#[derive(Clone, Serialize, Deserialize, Debug)]
pub struct SystemMetricConfig {
    pub enable: bool,
    #[serde(with = "seconds_to_duration")]
    pub poll_interval_seconds: Duration,
    pub processes: Option<HashSet<String>>,
    pub disk_space: Option<HashSet<String>>,
    pub diskstats: Option<HashSet<String>>,
    pub network_interfaces: Option<HashSet<String>>,
    pub cpu: Option<CpuMetricsConfig>,
    pub memory: Option<MemoryMetricsConfig>,
    pub thermal: Option<ThermalMetricsConfig>,
    pub oui: Option<OuiMetricsConfig>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct CpuMetricsConfig {
    pub enable: bool,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct MemoryMetricsConfig {
    pub enable: bool,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ThermalMetricsConfig {
    pub enable: bool,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct OuiMetricsConfig {
    pub enable: bool,
}

impl SystemMetricConfig {
    pub fn cpu_metrics_enabled(&self) -> bool {
        match self.cpu {
            None => true,
            Some(CpuMetricsConfig { enable }) => enable,
        }
    }

    pub fn memory_metrics_enabled(&self) -> bool {
        match self.memory {
            None => true,
            Some(MemoryMetricsConfig { enable }) => enable,
        }
    }

    pub fn thermal_metrics_enabled(&self) -> bool {
        match self.thermal {
            None => true,
            Some(ThermalMetricsConfig { enable }) => enable,
        }
    }

    pub fn oui_metrics_enabled(&self) -> bool {
        match self.oui {
            None => true,
            Some(OuiMetricsConfig { enable }) => enable,
        }
    }

    pub fn diskstats_metrics_enabled(&self) -> bool {
        !self
            .diskstats
            .as_ref()
            .is_some_and(|disks| disks.is_empty())
    }

    pub fn disk_space_metrics_enabled(&self) -> bool {
        !self
            .disk_space
            .as_ref()
            .is_some_and(|disks| disks.is_empty())
    }

    pub fn process_metrics_enabled(&self) -> bool {
        !self
            .processes
            .as_ref()
            .is_some_and(|processes| processes.is_empty())
    }

    pub fn network_metrics_enabled(&self) -> bool {
        !self
            .network_interfaces
            .as_ref()
            .is_some_and(|interfaces| interfaces.is_empty())
    }

    pub fn poll_interval(&self) -> Duration {
        self.poll_interval_seconds
    }

    pub fn monitored_processes(&self) -> ProcessMetricsConfig {
        match self.processes.as_ref() {
            Some(processes) => {
                let mut processes = processes.clone();
                processes.insert("memfaultd".to_string());
                ProcessMetricsConfig::Processes(processes)
            }
            None => ProcessMetricsConfig::Auto,
        }
    }

    pub fn disk_space_config(&self) -> DiskSpaceMetricsConfig {
        match self.disk_space.as_ref() {
            Some(mounts) => DiskSpaceMetricsConfig::Disks(mounts.clone()),
            None => DiskSpaceMetricsConfig::Auto,
        }
    }

    pub fn diskstats_config(&self) -> DiskstatsMetricsConfig {
        match self.diskstats.as_ref() {
            Some(devices) => DiskstatsMetricsConfig::Devices(devices.clone()),
            None => DiskstatsMetricsConfig::Auto,
        }
    }

    pub fn network_interfaces_config(&self) -> Option<&HashSet<String>> {
        self.network_interfaces.as_ref()
    }
}