Ensure metric names start with smartmon

Author: technowhizz

etc/kayobe/ansible/scripts/smartmon.py

@@ -118,18 +118,18 @@ def parse_device_info(device):
     metric_labels = f'disk="{device.name}",serial_number="{serial_number}",type="{device.interface}"'
 
     metrics = [
-        f'device_info{{{label_str}}} 1.0',
-        f'device_smart_available{{{metric_labels}}} {float(1) if device.smart_capable else float(0)}',
+        f'smartmon_device_info{{{label_str}}} 1.0',
+        f'smartmon_device_smart_available{{{metric_labels}}} {float(1) if device.smart_capable else float(0)}',
     ]
 
     if device.smart_capable:
         metrics.append(
-            f'device_smart_enabled{{{metric_labels}}} {float(1) if device.smart_enabled else float(0)}'
+            f'smartmon_device_smart_enabled{{{metric_labels}}} {float(1) if device.smart_enabled else float(0)}'
         )
         if device.assessment:
             is_healthy = 1 if device.assessment.upper() == "PASS" else 0
             metrics.append(
-                f'device_smart_healthy{{{metric_labels}}} {float(is_healthy)}'
+                f'smartmon_device_smart_healthy{{{metric_labels}}} {float(is_healthy)}'
             )
 
     return metrics
@@ -166,7 +166,7 @@ def parse_if_attributes(device):
         snake_name = camel_to_snake(attr_name)
 
         if snake_name in SMARTMON_ATTRS and isinstance(val, (int, float)):
-            metrics.append(f"{snake_name}{{{labels}}} {float(val)}")
+            metrics.append(f"smartmon_{snake_name}{{{labels}}} {float(val)}")
 
     return metrics
 
@@ -219,7 +219,7 @@ def main(output_path=None):
             version_num = "unknown"
     except Exception:
         version_num = "unknown"
-    all_metrics.append(f'smartctl_version{{version="{version_num}"}} 1')
+    all_metrics.append(f'smartmon_smartctl_version{{version="{version_num}"}} 1')
 
     dev_list = DeviceList()
 
@@ -229,7 +229,7 @@ def main(output_path=None):
         serial_number = (dev.serial or "").lower()
 
         run_timestamp = int(datetime.datetime.now(datetime.timezone.utc).timestamp())
-        all_metrics.append(f'smartctl_run{{disk="{disk_name}",type="{disk_type}"}} {run_timestamp}')
+        all_metrics.append(f'smartmon_smartctl_run{{disk="{disk_name}",type="{disk_type}"}} {run_timestamp}')
 
         active = 1
         try:
@@ -243,7 +243,7 @@ def main(output_path=None):
             active = 0
 
         all_metrics.append(
-            f'device_active{{disk="{disk_name}",type="{disk_type}",serial_number="{serial_number}"}} {active}'
+            f'smartmon_device_active{{disk="{disk_name}",type="{disk_type}",serial_number="{serial_number}"}} {active}'
         )
         if active == 0:
             continue

etc/kayobe/ansible/scripts/test_smartmon.py

@@ -78,42 +78,42 @@ def _test_parse_device_info(self, fixture_name):
 
         # The device_info line should exist for every device
         device_info_found = any(
-            line.startswith("device_info{") and
+            line.startswith("smartmon_device_info{") and
             f'disk="{dev_name}"' in line and
             f'type="{dev_iface}"' in line and
             f'serial_number="{dev_serial}"' in line
             for line in metrics
         )
         self.assertTrue(
             device_info_found,
-            f"Expected a device_info metric line for {dev_name} but didn't find it."
+            f"Expected a smartmon_device_info metric line for {dev_name} but didn't find it."
         )
 
         # If smart_capable is true, we expect device_smart_available = 1
         if device_info.get("smart_capable"):
             smart_available_found = any(
-                line.startswith("device_smart_available{") and
+                line.startswith("smartmon_device_smart_available{") and
                 f'disk="{dev_name}"' in line and
                 f'serial_number="{dev_serial}"' in line and
                 line.endswith(" 1.0")
                 for line in metrics
             )
             self.assertTrue(
                 smart_available_found,
-                f"Expected device_smart_available=1.0 for {dev_name}, not found."
+                f"Expected smartmon_device_smart_available=1.0 for {dev_name}, not found."
             )
 
         # If smart_enabled is true, we expect device_smart_enabled = 1
         if device_info.get("smart_enabled"):
             smart_enabled_found = any(
-                line.startswith("device_smart_enabled{") and
+                line.startswith("smartmon_device_smart_enabled{") and
                 f'disk="{dev_name}"' in line and
                 line.endswith(" 1.0")
                 for line in metrics
             )
             self.assertTrue(
                 smart_enabled_found,
-                f"Expected device_smart_enabled=1.0 for {dev_name}, not found."
+                f"Expected smartmon_device_smart_enabled=1.0 for {dev_name}, not found."
             )
 
         # device_smart_healthy if assessment in [PASS, WARN, FAIL]
@@ -122,14 +122,14 @@ def _test_parse_device_info(self, fixture_name):
         if assessment in ["PASS", "WARN", "FAIL"]:
             expected_val = float(1) if assessment == "PASS" else float(0)
             smart_healthy_found = any(
-                line.startswith("device_smart_healthy{") and
+                line.startswith("smartmon_device_smart_healthy{") and
                 f'disk="{dev_name}"' in line and
                 line.endswith(f" {expected_val}")
                 for line in metrics
             )
             self.assertTrue(
                 smart_healthy_found,
-                f"Expected device_smart_healthy={expected_val} for {dev_name}, not found."
+                f"Expected smartmon_device_smart_healthy={expected_val} for {dev_name}, not found."
             )
 
     def test_parse_device_info(self):
@@ -164,7 +164,7 @@ def _test_parse_if_attributes(self, fixture_name):
 
             if isinstance(attr_val, (int, float)) and snake_key in SMARTMON_ATTRS:
                 expected_line = (
-                    f"{snake_key}{{disk=\"{dev_name}\",serial_number=\"{dev_serial}\",type=\"{dev_iface}\"}} {float(attr_val)}"
+                    f"smartmon_{snake_key}{{disk=\"{dev_name}\",serial_number=\"{dev_serial}\",type=\"{dev_iface}\"}} {float(attr_val)}"
                 )
                 self.assertIn(
                     expected_line,
@@ -175,7 +175,7 @@ def _test_parse_if_attributes(self, fixture_name):
                 # If it's not in SMARTMON_ATTRS or not numeric,
                 # we do NOT expect a line with that name+value
                 unexpected_line = (
-                    f"{snake_key}{{disk=\"{dev_name}\",serial_number=\"{dev_serial}\",type=\"{dev_iface}\"}} {float(attr_val)}"
+                    f"smartmon_{snake_key}{{disk=\"{dev_name}\",serial_number=\"{dev_serial}\",type=\"{dev_iface}\"}} {float(attr_val)}"
                 )
                 self.assertNotIn(
                     unexpected_line,
@@ -268,8 +268,8 @@ def run_command_side_effect(cmd, parse_json=False):
                     self.assertTrue(found, f"Expected metric '{expected}' not found")
 
                 # Check that smartctl_version metric is present
-                version_found = any(line.startswith("smartctl_version{") for line in metrics_lines)
-                self.assertTrue(version_found, "Expected 'smartctl_version' metric not found in output file.")
+                version_found = any(line.startswith("smartmon_smartctl_version{") for line in metrics_lines)
+                self.assertTrue(version_found, "Expected 'smartmon_smartctl_version' metric not found in output file.")
 
                 # Check that the output file is not empty
                 self.assertTrue(metrics_lines, "Metrics output file is empty.")