refactor: refactored system_info.rs

Signed-off-by: Jan Zachmann <50990105+JanZachmann@users.noreply.github.com>

Author: JanZachmann

Cargo.lock

@@ -8,7 +8,7 @@ license = "MIT OR Apache-2.0"
 name = "omnect-device-service"
 readme = "README.md"
 repository = "https://github.com/omnect/omnect-device-service.git"
-version = "0.41.9"
+version = "0.41.10"
 
 [dependencies]
 actix-server = { version = "2.6", default-features = false }

Cargo.toml

@@ -9,9 +9,14 @@ use azure_iot_sdk::client::{IotHubClient, IotMessage};
 use inotify::WatchMask;
 use lazy_static::lazy_static;
 use log::{info, warn};
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Serialize, Serializer, ser::Error};
 use serde_json::json;
-use std::{env, path::Path, time::Duration};
+use std::{
+    env,
+    path::Path,
+    sync::{LazyLock, RwLock},
+    time::Duration,
+};
 use sysinfo;
 use time::format_description::well_known::Rfc3339;
 use tokio::sync::mpsc;
@@ -29,45 +34,103 @@ lazy_static! {
     };
 }
 
-#[derive(Serialize)]
+#[derive(Default, Serialize)]
 struct Label {
-    device_id: String,
-    module_name: String,
+    #[serde(serialize_with = "device_id")]
+    device_id: (),
+    #[serde(serialize_with = "module_name")]
+    module_name: (),
     #[serde(skip_serializing_if = "Option::is_none")]
     sensor: Option<String>,
 }
 
+fn device_id<S>(_: &(), s: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    let Some(hostname) = sysinfo::System::host_name() else {
+        return Err(Error::custom("failed to get hostname"));
+    };
+
+    s.serialize_str(&hostname)
+}
+
+fn module_name<S>(_: &(), s: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    s.serialize_str("omnect-device-service")
+}
+
 #[derive(Serialize)]
-struct Metric {
-    time_generated_utc: String,
-    name: String,
-    value: f64,
-    labels: Label,
+enum MetricValue {
+    CpuUsage(f64),
+    MemoryUsed(f64),
+    MemoryTotal(f64),
+    DiskUsed(f64),
+    DiskTotal(f64),
+    Temp(f64, String),
 }
 
-impl Metric {
-    // ToDo new not needed
-    fn new(
-        time: String,
-        name: String,
-        value: f64,
-        device: String,
-        sensor: Option<String>,
-    ) -> Metric {
+impl MetricValue {
+    fn to_metric(self) -> Metric {
+        let (name, value, labels) = match self {
+            MetricValue::CpuUsage(value) => ("cpu_usage".to_owned(), value, Label::default()),
+            MetricValue::MemoryUsed(value) => ("memory_used".to_owned(), value, Label::default()),
+            MetricValue::MemoryTotal(value) => ("memory_total".to_owned(), value, Label::default()),
+            MetricValue::DiskUsed(value) => ("disk_used".to_owned(), value, Label::default()),
+            MetricValue::DiskTotal(value) => ("disk_total".to_owned(), value, Label::default()),
+            MetricValue::Temp(value, sensor) => (
+                "temp".to_owned(),
+                value,
+                Label {
+                    sensor: Some(sensor),
+                    ..Default::default()
+                },
+            ),
+        };
+
         Metric {
-            time_generated_utc: time,
-            name,
-            value,
-            labels: Label {
-                device_id: device,
-                module_name: "omnect-device-service".to_string(),
-                sensor,
+            metric: InnerMetric {
+                name,
+                value,
+                labels,
             },
+            ..Default::default()
         }
     }
 }
 
-// ToDo rm lazy_static
+#[derive(Default, Serialize)]
+struct InnerMetric {
+    name: String,
+    value: f64,
+    labels: Label,
+}
+
+#[derive(Default, Serialize)]
+struct Metric {
+    #[serde(serialize_with = "time_stamp")]
+    time_generated_utc: (),
+    #[serde(flatten)]
+    metric: InnerMetric,
+}
+
+static TIME_STAMP: LazyLock<RwLock<String>> =
+    LazyLock::new(|| RwLock::new(time::OffsetDateTime::now_utc().format(&Rfc3339).unwrap()));
+
+fn time_stamp<S>(_: &(), s: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    let Ok(time_stamp) = TIME_STAMP.read() else {
+        return Err(Error::custom("failed to get timestamp"));
+    };
+
+    s.serialize_str(&time_stamp)
+}
+
+// ToDo rm lazy_staticw
 lazy_static! {
     static ref TIMESYNC_FILE: &'static Path = if cfg!(feature = "mock") {
         Path::new("/tmp/synchronized")
@@ -100,7 +163,6 @@ struct HardwareInfo {
     components: sysinfo::Components,
     disk: sysinfo::Disks,
     system: sysinfo::System,
-    hostname: String,
 }
 
 #[derive(Default, Serialize)]
@@ -191,10 +253,6 @@ impl SystemInfo {
             RootPartition::current()?.as_str()
         );
 
-        let Some(hostname) = sysinfo::System::host_name() else {
-            bail!("metrics: hostname could not be read")
-        };
-
         feature::add_watch::<Self>(&TIMESYNC_FILE, WatchMask::CREATE | WatchMask::ONESHOT)?;
 
         if 0 < *REFRESH_SYSTEM_INFO_INTERVAL_SECS {
@@ -220,8 +278,6 @@ impl SystemInfo {
                         .with_cpu(sysinfo::CpuRefreshKind::everything())
                         .with_memory(sysinfo::MemoryRefreshKind::everything()),
                 ),
-
-                hostname,
             },
             reboot_reason: reboot_reason::current_reboot_reason(),
             fleet_id: None,
@@ -270,106 +326,50 @@ impl SystemInfo {
             .context("boot_time: format uptime")
     }
 
-    fn cpu_usage(&self, time: String) -> Metric {
-        Metric::new(
-            time,
-            "cpu_usage".to_string(),
-            self.hardware_info.system.global_cpu_usage() as f64,
-            self.hardware_info.hostname.clone(),
-            None,
-        )
-    }
-
-    fn memory_used(&self, time: String) -> Metric {
-        Metric::new(
-            time,
-            "memory_used".to_string(),
-            self.hardware_info.system.used_memory() as f64,
-            self.hardware_info.hostname.clone(),
-            None,
-        )
-    }
-
-    fn memory_total(&self, time: String) -> Metric {
-        Metric::new(
-            time,
-            "memory_total".to_string(),
-            self.hardware_info.system.total_memory() as f64,
-            self.hardware_info.hostname.clone(),
-            None,
-        )
-    }
-
-    fn disk_used(&self, time: String, value: f64) -> Metric {
-        Metric::new(
-            time,
-            "disk_used".to_string(),
-            value,
-            self.hardware_info.hostname.clone(),
-            None,
-        )
-    }
-
-    fn disk_total(&self, time: String, value: f64) -> Metric {
-        Metric::new(
-            time,
-            "disk_total".to_string(),
-            value,
-            self.hardware_info.hostname.clone(),
-            None,
-        )
-    }
-
-    fn temp(&self, time: String, value: f64, sensor: String) -> Metric {
-        Metric::new(
-            time,
-            "temp".to_string(),
-            value,
-            self.hardware_info.hostname.clone(),
-            Some(sensor),
-        )
-    }
-
     async fn metrics(&mut self) -> Result<()> {
         let Some(tx) = &self.tx_outgoing_message else {
             warn!("metrics: skip since tx_outgoing_message is None");
             return Ok(());
         };
 
-        let Ok(time) = time::OffsetDateTime::now_utc().format(&Rfc3339) else {
-            bail!("metrics: timestamp could not be generated")
+        let Ok(mut time_stamp) = TIME_STAMP.write() else {
+            bail!("metrics: failed to lock TIME_STAMP")
         };
+        *time_stamp = time::OffsetDateTime::now_utc()
+            .format(&Rfc3339)
+            .context("metrics: failed to get and format timestamp")?;
 
         self.hardware_info.components.refresh(true);
         self.hardware_info.system.refresh_cpu_usage();
         self.hardware_info.system.refresh_memory();
         self.hardware_info.disk.refresh(true);
 
-        let mut disk_total = 0;
-        let mut disk_used = 0;
-        for disk in self.hardware_info.disk.list() {
-            if disk.name().to_str() == Some("/dev/omnect/data") {
-                disk_total = disk.total_space();
-                disk_used = disk.total_space() - disk.available_space();
-                break;
-            }
-        }
-
-        let mut metric_list = vec![
-            self.cpu_usage(time.clone()),
-            self.memory_used(time.clone()),
-            self.memory_total(time.clone()),
-            self.disk_used(time.clone(), disk_used as f64),
-            self.disk_total(time.clone(), disk_total as f64),
+        let (disk_total, disk_used) = self
+            .hardware_info
+            .disk
+            .into_iter()
+            .filter_map(|disk| match (disk.name().to_str(), disk.total_space()) {
+                (Some("/dev/omnect/data"), space) => Some((space, space - disk.available_space())),
+                _ => None,
+            })
+            .next()
+            .unwrap_or((0, 0));
+
+        let mut metrics = vec![
+            MetricValue::CpuUsage(self.hardware_info.system.global_cpu_usage() as f64).to_metric(),
+            MetricValue::MemoryUsed(self.hardware_info.system.used_memory() as f64).to_metric(),
+            MetricValue::MemoryTotal(self.hardware_info.system.total_memory() as f64).to_metric(),
+            MetricValue::DiskUsed(disk_used as f64).to_metric(),
+            MetricValue::DiskTotal(disk_total as f64).to_metric(),
         ];
 
         self.hardware_info.components.iter().for_each(|c| {
             if let Some(t) = c.temperature() {
-                metric_list.push(self.temp(time.clone(), t.into(), c.label().to_string()))
+                metrics.push(MetricValue::Temp(t.into(), c.label().to_string()).to_metric())
             };
         });
 
-        let json = serde_json::to_vec(&metric_list)
+        let json = serde_json::to_vec(&metrics)
             .context("metrics list could not be converted to vector:")?;
 
         let msg = IotMessage::builder()

src/twin/system_info.rs

@@ -112,6 +112,7 @@ impl WebService {
         info!("WebService is enabled");
 
         if matches!(Path::new(&publish_endpoints_path!()).try_exists(), Ok(true)) {
+            debug!("restore publish endpoints");
             *PUBLISH_ENDPOINTS.lock().await = from_json_file(publish_endpoints_path!())?;
         }