@oneuptime/common 11.4.1 → 11.5.0

package/Tests/Server/Utils/Monitor/Criteria/SnmpMonitorCriteria.test.ts

@@ -207,6 +207,65 @@ describe("SnmpMonitorCriteria.isMonitorInstanceCriteriaFilterMet", () => {
       expect(result).toBeTruthy();
       expect(result).toContain("equal to OK");
     });
+
+    test("empty OctetString is NOT coerced to numeric 0 for an 'equal to 0' filter", async () => {
+      /*
+       * Regression: Number("") === 0, so an empty value used to spuriously
+       * satisfy a numeric "== 0" criterion. It must fall through to a string
+       * comparison ("" !== "0") and not match.
+       */
+      const criteriaFilter: CriteriaFilter = {
+        checkOn: CheckOn.SnmpOidValue,
+        filterType: FilterType.EqualTo,
+        value: "0",
+        snmpMonitorOptions: { oid: PSU_OID },
+      };
+
+      const dataToProcess: ProbeMonitorResponse = buildDataToProcess({
+        oidResponses: [
+          {
+            oid: PSU_OID,
+            value: "",
+            type: SnmpDataType.OctetString,
+          },
+        ],
+      });
+
+      const result: string | null =
+        await SnmpMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+          dataToProcess,
+          criteriaFilter,
+        });
+
+      expect(result).toBeNull();
+    });
+
+    test("whitespace-only OctetString is NOT coerced to numeric 0", async () => {
+      const criteriaFilter: CriteriaFilter = {
+        checkOn: CheckOn.SnmpOidValue,
+        filterType: FilterType.EqualTo,
+        value: "0",
+        snmpMonitorOptions: { oid: PSU_OID },
+      };
+
+      const dataToProcess: ProbeMonitorResponse = buildDataToProcess({
+        oidResponses: [
+          {
+            oid: PSU_OID,
+            value: "   ",
+            type: SnmpDataType.OctetString,
+          },
+        ],
+      });
+
+      const result: string | null =
+        await SnmpMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+          dataToProcess,
+          criteriaFilter,
+        });
+
+      expect(result).toBeNull();
+    });
   });
 
   describe("SnmpOidValue guards", () => {

package/Tests/Server/Utils/Monitor/IoTDeviceAbsenceSeries.test.ts

@@ -0,0 +1,113 @@
+import {
+  IOT_DEVICE_ID_ATTRIBUTE_KEY,
+  buildAbsentIoTDeviceSeries,
+  getIoTDeviceAbsenceGroupByKey,
+} from "../../../../Server/Utils/Monitor/IoTDeviceAbsenceSeries";
+import MetricSeriesResult from "../../../../Types/Monitor/MetricMonitor/MetricSeriesResult";
+import MetricSeriesFingerprint from "../../../../Utils/Metrics/MetricSeriesFingerprint";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * The absence-series helpers are what turn a silent registered device
+ * into a per-device offline incident — pin down the gating and the
+ * synthetic-series shape (which must match what the device's real
+ * series would carry so incidents dedupe and auto-resolve).
+ */
+
+function presentSeries(deviceIds: Array<string>): Array<MetricSeriesResult> {
+  return deviceIds.map((id: string) => {
+    return {
+      fingerprint: MetricSeriesFingerprint.computeFingerprint({
+        [IOT_DEVICE_ID_ATTRIBUTE_KEY]: id,
+      }),
+      labels: { [IOT_DEVICE_ID_ATTRIBUTE_KEY]: id },
+      // present series carry samples; the builder only reads labels.
+      aggregatedResults: [],
+    };
+  });
+}
+
+describe("getIoTDeviceAbsenceGroupByKey", () => {
+  test("returns the key only for a pure device.id group-by", () => {
+    expect(getIoTDeviceAbsenceGroupByKey(["device.id"])).toBe("device.id");
+  });
+
+  test.each([
+    [[]],
+    [["iot.device.type"]],
+    [["device.id", "iot.device.type"]],
+    [["resource.iot.fleet.name"]],
+  ])("returns null for %j", (keys: Array<string>) => {
+    expect(getIoTDeviceAbsenceGroupByKey(keys)).toBeNull();
+  });
+});
+
+describe("buildAbsentIoTDeviceSeries", () => {
+  test("emits one empty series per registered-but-absent device", () => {
+    const absent: Array<MetricSeriesResult> = buildAbsentIoTDeviceSeries({
+      presentSeries: presentSeries(["sensor-1"]),
+      expectedDeviceExternalIds: ["sensor-1", "sensor-2", "sensor-3"],
+      deviceKey: IOT_DEVICE_ID_ATTRIBUTE_KEY,
+      slotCount: 2,
+    });
+
+    expect(absent).toHaveLength(2);
+    const ids: Array<string> = absent.map((s: MetricSeriesResult) => {
+      return String(s.labels["device.id"]);
+    });
+    expect(ids.sort()).toEqual(["sensor-2", "sensor-3"]);
+
+    for (const series of absent) {
+      // One empty slot per query+formula so criteria alias resolution lines up.
+      expect(series.aggregatedResults).toHaveLength(2);
+      for (const slot of series.aggregatedResults) {
+        expect(slot.data).toEqual([]);
+      }
+      // Fingerprint must match what the device's REAL series would carry.
+      expect(series.fingerprint).toBe(
+        MetricSeriesFingerprint.computeFingerprint(series.labels),
+      );
+    }
+  });
+
+  test("device ids are compared byte-exact — no canonicalization", () => {
+    /*
+     * device.id labels are stored verbatim (unlike host.name). A
+     * registered id differing only in case is a DIFFERENT device and
+     * must be treated as absent; lowercasing would fork the
+     * fingerprint from the real series and break dedupe.
+     */
+    const absent: Array<MetricSeriesResult> = buildAbsentIoTDeviceSeries({
+      presentSeries: presentSeries(["Sensor-A"]),
+      expectedDeviceExternalIds: ["Sensor-A", "sensor-a"],
+      deviceKey: IOT_DEVICE_ID_ATTRIBUTE_KEY,
+      slotCount: 1,
+    });
+
+    expect(absent).toHaveLength(1);
+    expect(absent[0]?.labels["device.id"]).toBe("sensor-a");
+  });
+
+  test("dedupes duplicate registered ids and skips empties", () => {
+    const absent: Array<MetricSeriesResult> = buildAbsentIoTDeviceSeries({
+      presentSeries: [],
+      expectedDeviceExternalIds: ["sensor-1", "sensor-1", ""],
+      deviceKey: IOT_DEVICE_ID_ATTRIBUTE_KEY,
+      slotCount: 0, // clamps to 1
+    });
+
+    expect(absent).toHaveLength(1);
+    expect(absent[0]?.aggregatedResults).toHaveLength(1);
+  });
+
+  test("returns nothing when every registered device is present", () => {
+    const absent: Array<MetricSeriesResult> = buildAbsentIoTDeviceSeries({
+      presentSeries: presentSeries(["a", "b"]),
+      expectedDeviceExternalIds: ["a", "b"],
+      deviceKey: IOT_DEVICE_ID_ATTRIBUTE_KEY,
+      slotCount: 1,
+    });
+
+    expect(absent).toHaveLength(0);
+  });
+});

package/Tests/Server/Utils/Monitor/PerSeriesRecoveryResolution.test.ts

@@ -0,0 +1,198 @@
+import MonitorIncident from "../../../../Server/Utils/Monitor/MonitorIncident";
+import MonitorAlert from "../../../../Server/Utils/Monitor/MonitorAlert";
+import Incident from "../../../../Models/DatabaseModels/Incident";
+import Alert from "../../../../Models/DatabaseModels/Alert";
+import MonitorCriteriaInstance from "../../../../Types/Monitor/MonitorCriteriaInstance";
+import Dictionary from "../../../../Types/Dictionary";
+import { describe, expect, it } from "@jest/globals";
+
+/*
+ * Regression tests for per-series offline/online auto-resolve.
+ *
+ * Per-series offline monitors (Host / Proxmox / Ceph / IoTDevice) pair
+ * an OFFLINE criteria that creates incidents (e.g. Min(device_up) < 1)
+ * with a RECOVERY criteria that does not (Min(device_up) >= 1), grouped
+ * by a device/host key. Exactly one criteria wins per evaluation tick,
+ * and the breaching-series set handed to shouldClose{Incident,Alert} is
+ * that winning criteria's per-series matches.
+ *
+ * On the recovery tick the RECOVERY criteria wins, so its matches are
+ * the healthy series — NOT breaches. The bug: membership in that set was
+ * treated as "still breaching", so the open offline incident's own
+ * fingerprint kept it pinned open forever once no other series was down.
+ * The fix only counts membership when the matched criteria actually
+ * creates incidents/alerts.
+ */
+
+const CREATED_CRITERIA_ID: string = "offline-criteria";
+const TEMPLATE_ID: string = "template-1";
+const DEVICE_FP: string = "fp-device-1";
+
+const INCIDENT_AUTO_RESOLVE: Dictionary<Array<string>> = {
+  [CREATED_CRITERIA_ID]: [TEMPLATE_ID],
+};
+const ALERT_AUTO_RESOLVE: Dictionary<Array<string>> = {
+  [CREATED_CRITERIA_ID]: [TEMPLATE_ID],
+};
+
+function incident(fingerprint: string): Incident {
+  const i: Incident = new Incident();
+  i.createdCriteriaId = CREATED_CRITERIA_ID;
+  i.createdIncidentTemplateId = TEMPLATE_ID;
+  i.seriesFingerprint = fingerprint;
+  return i;
+}
+
+function alert(fingerprint: string): Alert {
+  const a: Alert = new Alert();
+  a.createdCriteriaId = CREATED_CRITERIA_ID;
+  a.seriesFingerprint = fingerprint;
+  return a;
+}
+
+function criteria(id: string, creates: boolean): MonitorCriteriaInstance {
+  const c: MonitorCriteriaInstance = new MonitorCriteriaInstance();
+  c.data!.id = id;
+  // Same flag drives both — the templates set createIncidents/createAlerts together.
+  c.data!.createIncidents = creates;
+  c.data!.createAlerts = creates;
+  return c;
+}
+
+function shouldCloseIncident(input: Record<string, unknown>): boolean {
+  return (
+    MonitorIncident as unknown as {
+      shouldCloseIncident: (i: Record<string, unknown>) => boolean;
+    }
+  ).shouldCloseIncident(input);
+}
+function shouldCloseAlert(input: Record<string, unknown>): boolean {
+  return (
+    MonitorAlert as unknown as {
+      shouldCloseAlert: (i: Record<string, unknown>) => boolean;
+    }
+  ).shouldCloseAlert(input);
+}
+
+describe("Per-series offline/online auto-resolve", () => {
+  describe("MonitorIncident.shouldCloseIncident", () => {
+    it("RESOLVES on the recovery tick even though the recovered series is in the matched (recovery) criteria's set", () => {
+      /*
+       * The device is back up: the RECOVERY criteria won, its match set
+       * contains the now-healthy device. It must NOT keep the incident open.
+       */
+      expect(
+        shouldCloseIncident({
+          openIncident: incident(DEVICE_FP),
+          autoResolveCriteriaInstanceIdIncidentIdsDictionary:
+            INCIDENT_AUTO_RESOLVE,
+          criteriaInstance: criteria("recovery-criteria", false),
+          breachingSeriesFingerprints: new Set<string>([DEVICE_FP]),
+          disableSeriesAbsenceResolution: false,
+        }),
+      ).toBe(true);
+    });
+
+    it("keeps the incident open while the device is still down (offline criteria won, series still breaching)", () => {
+      expect(
+        shouldCloseIncident({
+          openIncident: incident(DEVICE_FP),
+          autoResolveCriteriaInstanceIdIncidentIdsDictionary:
+            INCIDENT_AUTO_RESOLVE,
+          criteriaInstance: criteria(CREATED_CRITERIA_ID, true),
+          breachingSeriesFingerprints: new Set<string>([DEVICE_FP]),
+          disableSeriesAbsenceResolution: false,
+        }),
+      ).toBe(false);
+    });
+
+    it("resolves when this device recovered but another device is still down (offline criteria won, fp absent)", () => {
+      expect(
+        shouldCloseIncident({
+          openIncident: incident(DEVICE_FP),
+          autoResolveCriteriaInstanceIdIncidentIdsDictionary:
+            INCIDENT_AUTO_RESOLVE,
+          criteriaInstance: criteria(CREATED_CRITERIA_ID, true),
+          // Only some OTHER device is still breaching the offline criteria.
+          breachingSeriesFingerprints: new Set<string>(["fp-device-2"]),
+          disableSeriesAbsenceResolution: false,
+        }),
+      ).toBe(true);
+    });
+
+    it("does not resolve on recovery when the creating criteria did not opt into auto-resolve", () => {
+      expect(
+        shouldCloseIncident({
+          openIncident: incident(DEVICE_FP),
+          autoResolveCriteriaInstanceIdIncidentIdsDictionary: {}, // not configured
+          criteriaInstance: criteria("recovery-criteria", false),
+          breachingSeriesFingerprints: new Set<string>([DEVICE_FP]),
+          disableSeriesAbsenceResolution: false,
+        }),
+      ).toBe(false);
+    });
+
+    it("still respects the event-driven guard (incoming-request) over recovery resolution", () => {
+      expect(
+        shouldCloseIncident({
+          openIncident: incident(DEVICE_FP),
+          autoResolveCriteriaInstanceIdIncidentIdsDictionary:
+            INCIDENT_AUTO_RESOLVE,
+          criteriaInstance: criteria("recovery-criteria", false),
+          breachingSeriesFingerprints: new Set<string>([DEVICE_FP]),
+          disableSeriesAbsenceResolution: true,
+        }),
+      ).toBe(false);
+    });
+  });
+
+  describe("MonitorAlert.shouldCloseAlert", () => {
+    it("RESOLVES on the recovery tick even though the recovered series is in the matched (recovery) criteria's set", () => {
+      expect(
+        shouldCloseAlert({
+          openAlert: alert(DEVICE_FP),
+          autoResolveCriteriaInstanceIdAlertIdsDictionary: ALERT_AUTO_RESOLVE,
+          criteriaInstance: criteria("recovery-criteria", false),
+          breachingSeriesFingerprints: new Set<string>([DEVICE_FP]),
+          disableSeriesAbsenceResolution: false,
+        }),
+      ).toBe(true);
+    });
+
+    it("keeps the alert open while the device is still down", () => {
+      expect(
+        shouldCloseAlert({
+          openAlert: alert(DEVICE_FP),
+          autoResolveCriteriaInstanceIdAlertIdsDictionary: ALERT_AUTO_RESOLVE,
+          criteriaInstance: criteria(CREATED_CRITERIA_ID, true),
+          breachingSeriesFingerprints: new Set<string>([DEVICE_FP]),
+          disableSeriesAbsenceResolution: false,
+        }),
+      ).toBe(false);
+    });
+
+    it("resolves when this device recovered but another is still down", () => {
+      expect(
+        shouldCloseAlert({
+          openAlert: alert(DEVICE_FP),
+          autoResolveCriteriaInstanceIdAlertIdsDictionary: ALERT_AUTO_RESOLVE,
+          criteriaInstance: criteria(CREATED_CRITERIA_ID, true),
+          breachingSeriesFingerprints: new Set<string>(["fp-device-2"]),
+          disableSeriesAbsenceResolution: false,
+        }),
+      ).toBe(true);
+    });
+
+    it("still respects the event-driven guard over recovery resolution", () => {
+      expect(
+        shouldCloseAlert({
+          openAlert: alert(DEVICE_FP),
+          autoResolveCriteriaInstanceIdAlertIdsDictionary: ALERT_AUTO_RESOLVE,
+          criteriaInstance: criteria("recovery-criteria", false),
+          breachingSeriesFingerprints: new Set<string>([DEVICE_FP]),
+          disableSeriesAbsenceResolution: true,
+        }),
+      ).toBe(false);
+    });
+  });
+});

package/Tests/Types/Monitor/MonitorType.test.ts

@@ -120,7 +120,7 @@ describe("MonitorTypeHelper", () => {
       MonitorType.SSLCertificate,
       MonitorType.SyntheticMonitor,
       MonitorType.CustomJavaScriptCode,
-      MonitorType.SNMP,
+      MonitorType.NetworkDevice,
       MonitorType.DNS,
       MonitorType.DNSSEC,
       MonitorType.Domain,

package/Tests/Utils/Monitor/LatencyMatrixUtil.test.ts

@@ -0,0 +1,111 @@
+import LatencyMatrixUtil from "../../../Utils/Monitor/LatencyMatrixUtil";
+import LatencyMatrix, {
+  LatencyMatrixCell,
+} from "../../../Types/Monitor/LatencyMatrix";
+
+describe("LatencyMatrixUtil.buildMatrix", () => {
+  const now: Date = new Date("2026-07-11T12:00:00Z");
+
+  it("builds a dense grid seeded with no-data cells", () => {
+    const matrix: LatencyMatrix = LatencyMatrixUtil.buildMatrix({
+      monitors: [{ id: "m1", name: "Ping A" }],
+      probes: [
+        { id: "p1", name: "US East" },
+        { id: "p2", name: "EU West" },
+      ],
+      results: [],
+      now,
+    });
+
+    expect(matrix.monitors).toHaveLength(1);
+    expect(matrix.probes).toHaveLength(2);
+    expect(matrix.cells["m1"]!["p1"]!.hasData).toBe(false);
+    expect(matrix.cells["m1"]!["p2"]!.hasData).toBe(false);
+  });
+
+  it("fills latency, online state, and age from the latest step", () => {
+    const matrix: LatencyMatrix = LatencyMatrixUtil.buildMatrix({
+      monitors: [{ id: "m1", name: "Ping A" }],
+      probes: [{ id: "p1", name: "US East" }],
+      results: [
+        {
+          monitorId: "m1",
+          probeId: "p1",
+          lastMonitoringLog: {
+            step1: {
+              responseTimeInMs: 42,
+              isOnline: true,
+              monitoredAt: "2026-07-11T11:59:00Z",
+            },
+          },
+        },
+      ],
+      now,
+    });
+
+    const cell: LatencyMatrixCell = matrix.cells["m1"]!["p1"]!;
+    expect(cell.hasData).toBe(true);
+    expect(cell.latencyInMs).toBe(42);
+    expect(cell.isOnline).toBe(true);
+    expect(cell.ageInSeconds).toBe(60);
+  });
+
+  it("picks the most recently monitored step across multiple steps", () => {
+    const matrix: LatencyMatrix = LatencyMatrixUtil.buildMatrix({
+      monitors: [{ id: "m1", name: "Ping A" }],
+      probes: [{ id: "p1", name: "US East" }],
+      results: [
+        {
+          monitorId: "m1",
+          probeId: "p1",
+          lastMonitoringLog: {
+            older: {
+              responseTimeInMs: 100,
+              isOnline: true,
+              monitoredAt: "2026-07-11T10:00:00Z",
+            },
+            newer: {
+              responseTimeInMs: 25,
+              isOnline: true,
+              monitoredAt: "2026-07-11T11:59:30Z",
+            },
+          },
+        },
+      ],
+      now,
+    });
+
+    expect(matrix.cells["m1"]!["p1"]!.latencyInMs).toBe(25);
+  });
+
+  it("ignores results for unknown monitor/probe pairs", () => {
+    const matrix: LatencyMatrix = LatencyMatrixUtil.buildMatrix({
+      monitors: [{ id: "m1", name: "Ping A" }],
+      probes: [{ id: "p1", name: "US East" }],
+      results: [
+        {
+          monitorId: "ghost",
+          probeId: "p1",
+          lastMonitoringLog: {
+            step1: { responseTimeInMs: 5, monitoredAt: now.toISOString() },
+          },
+        },
+      ],
+      now,
+    });
+
+    expect(matrix.cells["m1"]!["p1"]!.hasData).toBe(false);
+    expect(matrix.cells["ghost"]).toBeUndefined();
+  });
+
+  it("treats an empty log as no data", () => {
+    const matrix: LatencyMatrix = LatencyMatrixUtil.buildMatrix({
+      monitors: [{ id: "m1", name: "Ping A" }],
+      probes: [{ id: "p1", name: "US East" }],
+      results: [{ monitorId: "m1", probeId: "p1", lastMonitoringLog: {} }],
+      now,
+    });
+
+    expect(matrix.cells["m1"]!["p1"]!.hasData).toBe(false);
+  });
+});

package/Types/AI/AIRunStatus.ts

@@ -1,4 +1,13 @@
 enum AIRunStatus {
+  /*
+   * Durable intent: the run has been recorded but no worker has claimed it
+   * yet. Queued runs survive pod restarts — the enqueueing pod tries to
+   * process immediately, and the queue poller picks up whatever is left
+   * (claims are CAS-guarded, so double-processing is impossible). Not
+   * terminal, not consuming compute; the queue's own TTL expires runs that
+   * sit here too long to still be useful.
+   */
+  Queued = "Queued",
   Running = "Running",
   /*
    * The run paused mid-turn to wait for the user to approve pending tool

package/Types/Dashboard/DashboardComponents/ComponentArgument.ts

@@ -27,7 +27,6 @@ export enum EntityFilterModelType {
   AlertState = "AlertState",
   MonitorStatus = "MonitorStatus",
   Monitor = "Monitor",
-  Service = "Service",
   Label = "Label",
   KubernetesCluster = "KubernetesCluster",
   DockerHost = "DockerHost",

package/Types/Dashboard/DashboardComponents/DashboardLogChartComponent.ts

@@ -1,5 +1,6 @@
 import ObjectID from "../../ObjectID";
 import DashboardComponentType from "../DashboardComponentType";
+import DashboardChartType from "../Chart/ChartType";
 import BaseComponent from "./DashboardBaseComponent";
 
 export default interface DashboardLogChartComponent extends BaseComponent {
@@ -7,12 +8,16 @@ export default interface DashboardLogChartComponent extends BaseComponent {
   componentId: ObjectID;
   arguments: {
     title?: string | undefined;
-    serviceIds?: Array<string> | undefined;
+    chartType?: DashboardChartType | undefined;
     severityFilters?: Array<string> | undefined;
     bodyContains?: string | undefined;
     /*
-     * Exact attribute matches in the log-search syntax used by Log Stream,
-     * for example: @service.name:checkout @deployment.environment:production.
+     * Exact attribute matches stored by the structured key/value editor.
+     */
+    attributeFilters?: Record<string, string | number | boolean> | undefined;
+    /*
+     * Legacy log-search syntax retained as a read-only fallback for widgets
+     * saved before the structured attribute editor was introduced.
      */
     attributeFilterQuery?: string | undefined;
   };

package/Types/LlmLogStatus.ts

@@ -2,6 +2,7 @@ enum LlmLogStatus {
   Success = "Success",
   Error = "Error",
   InsufficientBalance = "Insufficient Balance",
+  BudgetExceeded = "Budget Exceeded",
 }
 
 export default LlmLogStatus;

package/Types/Monitor/CriteriaFilter.ts

@@ -71,6 +71,10 @@ export enum CheckOn {
   SnmpOidExists = "SNMP OID Exists",
   SnmpResponseTime = "SNMP Response Time (in ms)",
   SnmpIsOnline = "SNMP Device Is Online",
+  SnmpInterfaceIsDown = "SNMP Interface Is Down",
+  SnmpTrapReceived = "SNMP Trap Received (Trap OID)",
+  SnmpInterfaceUtilizationPercent = "SNMP Interface Utilization (in %)",
+  SnmpInterfaceErrorsPerSecond = "SNMP Interface Errors (per second)",
 
   // DNS monitors.
   DnsResponseTime = "DNS Response Time (in ms)",
@@ -287,6 +291,7 @@ export class CriteriaFilterUtil {
     if (
       checkOn === CheckOn.IsOnline ||
       checkOn === CheckOn.SnmpIsOnline ||
+      checkOn === CheckOn.SnmpInterfaceIsDown ||
       checkOn === CheckOn.DnsIsOnline ||
       checkOn === CheckOn.DomainIsExpired ||
       checkOn === CheckOn.DnssecChainValid ||

package/Types/Monitor/IotAlertTemplates.ts

@@ -3,7 +3,12 @@ import MonitorStep from "./MonitorStep";
 import MonitorCriteria from "./MonitorCriteria";
 import MonitorCriteriaInstance from "./MonitorCriteriaInstance";
 import FilterCondition from "../Filter/FilterCondition";
-import { CheckOn, FilterType, EvaluateOverTimeType } from "./CriteriaFilter";
+import {
+  CheckOn,
+  FilterType,
+  EvaluateOverTimeType,
+  NoDataPolicy,
+} from "./CriteriaFilter";
 import MonitorStepIoTMonitor from "./MonitorStepIoTMonitor";
 import RollingTime from "../RollingTime/RollingTime";
 import MetricsAggregationType from "../Metrics/MetricsAggregationType";
@@ -102,6 +107,16 @@ export function buildIoTOfflineCriteriaInstance(args: {
   incidentDescription?: string;
   criteriaName?: string;
   criteriaDescription?: string;
+  /*
+   * Evaluate an empty (no data) series as 0 instead of skipping it.
+   * This is what lets REGISTERED devices that go completely silent
+   * trip the criteria: monitor evaluation injects an empty synthetic
+   * series per registered-but-silent device, TreatAsZero folds it to
+   * 0, and e.g. Min(iot_device_up) < 1 fires. Only the Device Offline
+   * template opts in — treating no-data as zero on a battery or
+   * temperature threshold would false-alarm for silent devices.
+   */
+  treatNoDataAsZero?: boolean;
 }): MonitorCriteriaInstance {
   const instance: MonitorCriteriaInstance = new MonitorCriteriaInstance();
 
@@ -122,6 +137,9 @@ export function buildIoTOfflineCriteriaInstance(args: {
         metricMonitorOptions: {
           metricAggregationType: EvaluateOverTimeType.AnyValue,
           metricAlias: args.metricAlias,
+          ...(args.treatNoDataAsZero
+            ? { onNoDataPolicy: NoDataPolicy.TreatAsZero }
+            : {}),
         },
         value: args.value,
       },
@@ -356,10 +374,11 @@ const deviceOfflineTemplate: IoTAlertTemplate = {
         filterType: FilterType.LessThan,
         value: 1,
         incidentTitle: `[IoT] Device Offline - ${args.monitorName}`,
-        incidentDescription: `An IoT device is reporting as down (iot_device_up = 0). The device is unreachable, powered off, or has lost connectivity to its gateway. Check the root cause for the affected device id, verify the device's power and network state, and confirm its gateway is forwarding telemetry.`,
+        incidentDescription: `An IoT device is reporting as down (iot_device_up = 0) or has stopped reporting entirely. The device is unreachable, powered off, or has lost connectivity to its gateway. Check the root cause for the affected device id, verify the device's power and network state, and confirm its gateway is forwarding telemetry.`,
         criteriaName: "Device Offline - iot_device_up < 1",
         criteriaDescription:
-          "Triggers when any device reports iot_device_up below 1 over the monitoring window.",
+          "Triggers when any device reports iot_device_up below 1 over the monitoring window, or when a registered device goes silent.",
+        treatNoDataAsZero: true,
       }),
       onlineCriteriaInstance: buildIoTOnlineCriteriaInstance({
         onlineMonitorStatusId: args.onlineMonitorStatusId,

package/Types/Monitor/LatencyMatrix.ts

@@ -0,0 +1,27 @@
+/*
+ * A probes × targets latency grid. Each cell is the latest response time a
+ * probe measured for a monitor, so operators can see at a glance which
+ * probe locations are slow to which targets. Built from each monitor's
+ * per-probe last-check snapshot; no new data collection.
+ */
+export interface LatencyMatrixAxisItem {
+  id: string;
+  name: string;
+}
+
+export interface LatencyMatrixCell {
+  monitorId: string;
+  probeId: string;
+  hasData: boolean;
+  latencyInMs?: number | undefined;
+  isOnline?: boolean | undefined;
+  // Age of the measurement in seconds, so the UI can dim stale cells.
+  ageInSeconds?: number | undefined;
+}
+
+export default interface LatencyMatrix {
+  monitors: Array<LatencyMatrixAxisItem>;
+  probes: Array<LatencyMatrixAxisItem>;
+  // Keyed cells[monitorId][probeId].
+  cells: Record<string, Record<string, LatencyMatrixCell>>;
+}

package/Types/Monitor/MonitorCriteriaInstance.ts

@@ -415,7 +415,7 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
       return monitorCriteriaInstance;
     }
 
-    if (arg.monitorType === MonitorType.SNMP) {
+    if (arg.monitorType === MonitorType.NetworkDevice) {
       const monitorCriteriaInstance: MonitorCriteriaInstance =
         new MonitorCriteriaInstance();
 
@@ -616,7 +616,7 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
       };
     }
 
-    if (arg.monitorType === MonitorType.SNMP) {
+    if (arg.monitorType === MonitorType.NetworkDevice) {
       monitorCriteriaInstance.data = {
         id: ObjectID.generate().toString(),
         monitorStatusId: arg.monitorStatusId,