Collect Juniper dom threshold values

python/nav/ipdevpoll/plugins/statsensors.py

@@ -25,12 +25,16 @@
 from nav.ipdevpoll import db
 from nav.ipdevpoll.db import run_in_thread
 from nav.metrics.carbon import send_metrics
-from nav.metrics.templates import metric_path_for_sensor
+from nav.metrics.templates import metric_path_for_sensor, metric_path_for_threshold
 from nav.models.manage import Sensor
+from nav.mibs.juniper_dom_mib import JuniperDomMib
+from nav.enterprise.ids import VENDOR_ID_JUNIPER_NETWORKS_INC
 
 # Ask for no more than this number of values in a single SNMP GET operation
 MAX_SENSORS_PER_REQUEST = 5
 
+THRESHOLD_MIBS = {VENDOR_ID_JUNIPER_NETWORKS_INC: [JuniperDomMib]}
+
 
 class StatSensors(Plugin):
     """Collects measurement values from registered sensors and pushes to
@@ -59,6 +63,11 @@ def handle(self):
             defer.returnValue(None)
         netboxes = yield db.run_in_thread(self._get_netbox_list)
         sensors = yield run_in_thread(self._get_sensors)
+        yield self._handle_sensor_stats(sensors, netboxes)
+        yield self._handle_thresholds(sensors, netboxes)
+
+    @defer.inlineCallbacks
+    def _handle_sensor_stats(self, sensors, netboxes):
         self._logger.debug("retrieving data from %d sensors", len(sensors))
         oids = list(sensors.keys())
         requests = [
@@ -73,6 +82,8 @@ def handle(self):
 
     def _get_sensors(self):
         sensors = Sensor.objects.filter(netbox=self.netbox.id).values()
+        for sensor in sensors:
+            self._logger.info(f"Internal names: {sensor.get('internal_name', None)}")
         return dict((row['oid'], row) for row in sensors)
 
     def _response_to_metrics(self, result, sensors, netboxes):
@@ -98,6 +109,52 @@ def _response_to_metrics(self, result, sensors, netboxes):
         send_metrics(metrics)
         return metrics
 
+    @defer.inlineCallbacks
+    def _handle_thresholds(self, sensors, netboxes):
+        metrics = yield self._collect_thresholds(netboxes, sensors)
+        self._logger.info(f"Metrics: {metrics}")
+        if metrics:
+            send_metrics(metrics)
+
+    @defer.inlineCallbacks
+    def _collect_thresholds(self, netboxes, sensors):
+        for mib in self._mibs_for_me(THRESHOLD_MIBS):
+            try:
+                metrics = yield self._collect_thresholds_from_mib(
+                    mib, netboxes, sensors
+                )
+            except (TimeoutError, defer.TimeoutError):
+                self._logger.debug(
+                    "collect_thresholds: ignoring timeout in %s", mib.mib['moduleName']
+                )
+            else:
+                if metrics:
+                    defer.returnValue(metrics)
+        defer.returnValue([])
+
+    @defer.inlineCallbacks
+    def _collect_thresholds_from_mib(self, mib, netboxes, sensors):
+        metrics = []
+        timestamp = time.time()
+        thresholds = yield mib.get_all_thresholds()
+        self._logger.debug(f"Threshold: {thresholds}")
+        for threshold in thresholds:
+            sensor = sensors[threshold['sensor_oid']]
+            value = self.convert_to_precision(threshold['value'], sensor)
+            for netbox in netboxes:
+                path = metric_path_for_threshold(
+                    netbox, sensor['internal_name'], threshold['name']
+                )
+                # thresholds will have the same precision etc. as its related sensor
+                metrics.append((path, (timestamp, value)))
+            return metrics
+
+    def _mibs_for_me(self, mib_class_dict):
+        vendor = self.netbox.type.get_enterprise_id() if self.netbox.type else None
+        mib_classes = mib_class_dict.get(vendor, None) or mib_class_dict.get(None, [])
+        for mib_class in mib_classes:
+            yield mib_class(self.agent)
+
 
 def convert_to_precision(value, sensor):
     """Moves the decimal point of a value according to the precision defined

python/nav/metrics/templates.py

@@ -100,6 +100,20 @@ def metric_path_for_sensor(sysname, sensor):
     )
 
 
+def metric_prefix_for_thresholds(sysname):
+    tmpl = "{prefix}.thresholds"
+    return tmpl.format(prefix=metric_prefix_for_sensors(sysname))
+
+
+def metric_path_for_threshold(sysname, sensor, threshold):
+    tmpl = "{prefix}.{sensor}.{threshold}"
+    return tmpl.format(
+        prefix=metric_prefix_for_thresholds(sysname),
+        sensor=escape_metric_name(sensor),
+        threshold=escape_metric_name(threshold),
+    )
+
+
 def metric_path_for_service_availability(sysname, handler, service_id):
     tmpl = "{service}.availability"
     return tmpl.format(service=metric_prefix_for_service(sysname, handler, service_id))

python/nav/mibs/juniper_dom_mib.py

@@ -23,7 +23,7 @@
 from nav.mibs.mibretriever import MibRetriever
 from nav.models.manage import Sensor
 
-COLUMNS = {
+SENSOR_COLUMNS = {
     "jnxDomCurrentRxLaserPower": {
         "unit_of_measurement": Sensor.UNIT_DBM,
         "precision": 2,
@@ -51,6 +51,33 @@
     },
 }
 
+THRESHOLD_COLUMNS = {
+    "jnxDomCurrentRxLaserPower": {
+        "high_alarm_threshold": "jnxDomCurrentRxLaserPowerHighAlarmThreshold",
+        "low_alarm_threshold": "jnxDomCurrentRxLaserPowerLowAlarmThreshold",
+        "high_warning_threshold": "jnxDomCurrentRxLaserPowerHighWarningThreshold",
+        "low_warning_threshold": "jnxDomCurrentRxLaserPowerLowWarningThreshold",
+    },
+    "jnxDomCurrentTxLaserBiasCurrent": {
+        "high_alarm_threshold": "jnxDomCurrentTxLaserBiasCurrentHighAlarmThreshold",
+        "low_alarm_threshold": "jnxDomCurrentTxLaserBiasCurrentLowAlarmThreshold",
+        "high_warning_threshold": "jnxDomCurrentTxLaserBiasCurrentHighWarningThreshold",
+        "low_warning_threshold": "jnxDomCurrentTxLaserBiasCurrentLowWarningThreshold",
+    },
+    "jnxDomCurrentTxLaserOutputPower": {
+        "high_alarm_threshold": "jnxDomCurrentTxLaserOutputPowerHighAlarmThreshold",
+        "low_alarm_threshold": "jnxDomCurrentTxLaserOutputPowerLowAlarmThreshold",
+        "high_warning_threshold": "jnxDomCurrentTxLaserOutputPowerHighWarningThreshold",
+        "low_warning_threshold": "jnxDomCurrentTxLaserOutputPowerLowWarningThreshold",
+    },
+    "jnxDomCurrentModuleTemperature": {
+        "high_alarm_threshold": "jnxDomCurrentModuleTemperatureHighAlarmThreshold",
+        "low_alarm_threshold": "jnxDomCurrentModuleTemperatureLowAlarmThreshold",
+        "high_warning_threshold": "jnxDomCurrentModuleTemperatureHighWarningThreshold",
+        "low_warning_threshold": "jnxDomCurrentModuleTemperatureLowWarningThreshold",
+    },
+}
+
 
 class JuniperDomMib(MibRetriever):
     """MibRetriever for Juniper DOM Sensors"""
@@ -63,12 +90,12 @@ def get_all_sensors(self):
         device.
         """
         sensors = []
-        for column, config in COLUMNS.items():
-            sensors += yield self.handle_column(column, config)
+        for column, config in SENSOR_COLUMNS.items():
+            sensors += yield self.handle_sensor_column(column, config)
         returnValue(sensors)
 
     @defer.inlineCallbacks
-    def handle_column(self, column, config):
+    def handle_sensor_column(self, column, config):
         """Returns the sensors of the given type"""
         result = []
         value_oid = self.nodes[column].oid
@@ -84,3 +111,31 @@ def handle_column(self, column, config):
             sensor.update(config)
             result.append(sensor)
         returnValue(result)
+
+    @defer.inlineCallbacks
+    def get_all_thresholds(self):
+        thresholds = []
+        for sensor_column, thresholds in THRESHOLD_COLUMNS.items():
+            sensor_oid = self.nodes[sensor_column].oid
+            for threshold_name, threshold_column in thresholds.items():
+                thresholds += yield self.handle_threshold_column(
+                    threshold_column, threshold_name, sensor_oid
+                )
+        returnValue(thresholds)
+
+    @defer.inlineCallbacks
+    def handle_threshold_column(self, column, name, sensor_oid):
+        """Returns the sensor thresholds of the given type"""
+        result = []
+        value_oid = self.nodes[column].oid
+        rows = yield self.retrieve_column(column)
+        for row, value in rows.items():
+            threshold = dict(
+                oid=str(value_oid + row),
+                mib=self.get_module_name(),
+                name=name,
+                value=value,
+                sensor_oid=str(sensor_oid + row),
+            )
+            result.append(threshold)
+        returnValue(result)