@oneuptime/common 12.0.31 → 12.0.33

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

@@ -760,3 +760,199 @@ describe("SnmpMonitorCriteria.isMonitorInstanceCriteriaFilterMet", () => {
     });
   });
 });
+
+/*
+ * Ping-first polling. A device with no usable SNMP credentials is only
+ * pinged, and the walk pipeline hands its monitors a response with
+ * `snmpResponse` undefined - never a synthesized failure. Every criterion
+ * that reads the walk must then be NOT EVALUATED (null) rather than
+ * breaching, while reachability keeps reading the top-level isOnline.
+ */
+function buildPingOnlyDataToProcess(input: {
+  isOnline: boolean;
+}): ProbeMonitorResponse {
+  return {
+    projectId: ObjectID.generate(),
+    monitorId: ObjectID.generate(),
+    monitorStepId: ObjectID.generate(),
+    probeId: ObjectID.generate(),
+    failureCause: input.isOnline ? "" : "Request timed out",
+    isOnline: input.isOnline,
+    pingResponse: {
+      packetsSent: 2,
+      packetsReceived: input.isOnline ? 2 : 0,
+      packetLossPercent: input.isOnline ? 0 : 100,
+      avgRoundTripTimeInMs: input.isOnline ? 1.5 : undefined,
+    },
+    monitoredAt: new Date(),
+  };
+}
+
+describe("SnmpMonitorCriteria — ping-first polling", () => {
+  describe("a poll that ran no walk evaluates no walk-dependent criterion", () => {
+    const walkDependentFilters: Array<CriteriaFilter> = [
+      {
+        checkOn: CheckOn.SnmpWalkIsSucceeding,
+        filterType: FilterType.False,
+        value: undefined,
+      },
+      {
+        checkOn: CheckOn.SnmpOidExists,
+        filterType: FilterType.False,
+        value: undefined,
+        snmpMonitorOptions: { oid: PSU_OID },
+      },
+      {
+        checkOn: CheckOn.SnmpOidValue,
+        filterType: FilterType.EqualTo,
+        value: "3",
+        snmpMonitorOptions: { oid: PSU_OID },
+      },
+      {
+        checkOn: CheckOn.SnmpResponseTime,
+        filterType: FilterType.GreaterThan,
+        value: 0,
+      },
+      {
+        checkOn: CheckOn.SnmpInterfaceIsDown,
+        filterType: FilterType.False,
+        value: undefined,
+      },
+      {
+        checkOn: CheckOn.SnmpInterfaceUtilizationPercent,
+        filterType: FilterType.LessThan,
+        value: 100,
+      },
+      {
+        checkOn: CheckOn.SnmpInterfaceErrorsPerSecond,
+        filterType: FilterType.LessThan,
+        value: 100,
+      },
+    ];
+
+    for (const criteriaFilter of walkDependentFilters) {
+      /*
+       * Each of these filters is chosen to MATCH an empty/absent walk if it
+       * were evaluated ("OID Exists is False", "Interface Is Down is
+       * False", "Walk Is Succeeding is False"), which is exactly the
+       * false incident a ping-only device must never raise.
+       */
+      test(`${criteriaFilter.checkOn} is not evaluated (null) on a reachable ping-only poll`, async () => {
+        const result: string | null =
+          await SnmpMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+            dataToProcess: buildPingOnlyDataToProcess({ isOnline: true }),
+            criteriaFilter,
+          });
+
+        expect(result).toBeNull();
+      });
+    }
+  });
+
+  describe("SnmpIsOnline reads device reachability, with or without a walk", () => {
+    test("a reachable ping-only poll satisfies 'Is Online = True'", async () => {
+      const result: string | null =
+        await SnmpMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+          dataToProcess: buildPingOnlyDataToProcess({ isOnline: true }),
+          criteriaFilter: {
+            checkOn: CheckOn.SnmpIsOnline,
+            filterType: FilterType.True,
+            value: undefined,
+          },
+        });
+
+      expect(result).toBeTruthy();
+    });
+
+    test("an unreachable ping-only poll satisfies 'Is Online = False' (the unreachable incident)", async () => {
+      const result: string | null =
+        await SnmpMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+          dataToProcess: buildPingOnlyDataToProcess({ isOnline: false }),
+          criteriaFilter: {
+            checkOn: CheckOn.SnmpIsOnline,
+            filterType: FilterType.False,
+            value: undefined,
+          },
+        });
+
+      expect(result).toBeTruthy();
+    });
+
+    /*
+     * ICMP-filtered SNMP gear: the walk succeeded, so the device is
+     * reachable even though the top-level verdict is what is read - the
+     * pipeline stamps isOnline = ping || walk, and that is what arrives.
+     */
+    test("reads the top-level verdict, not the walk's: a failed walk on a reachable device is still online", async () => {
+      const dataToProcess: ProbeMonitorResponse = buildDataToProcess({
+        oidResponses: [],
+        isOnline: false,
+      });
+      dataToProcess.isOnline = true;
+
+      const result: string | null =
+        await SnmpMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+          dataToProcess,
+          criteriaFilter: {
+            checkOn: CheckOn.SnmpIsOnline,
+            filterType: FilterType.True,
+            value: undefined,
+          },
+        });
+
+      expect(result).toBeTruthy();
+    });
+  });
+
+  describe("SnmpWalkIsSucceeding reads the walk itself", () => {
+    test("a failed walk satisfies 'Walk Is Succeeding = False' (the walk-failing alert)", async () => {
+      const dataToProcess: ProbeMonitorResponse = buildDataToProcess({
+        oidResponses: [],
+        isOnline: false,
+      });
+      // The device still answers ping; only the walk is broken.
+      dataToProcess.isOnline = true;
+
+      const result: string | null =
+        await SnmpMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+          dataToProcess,
+          criteriaFilter: {
+            checkOn: CheckOn.SnmpWalkIsSucceeding,
+            filterType: FilterType.False,
+            value: undefined,
+          },
+        });
+
+      expect(result).toBeTruthy();
+    });
+
+    test("a successful walk satisfies 'Walk Is Succeeding = True' and not 'False'", async () => {
+      const dataToProcess: ProbeMonitorResponse = buildDataToProcess({
+        oidResponses: [],
+        isOnline: true,
+      });
+
+      expect(
+        await SnmpMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+          dataToProcess,
+          criteriaFilter: {
+            checkOn: CheckOn.SnmpWalkIsSucceeding,
+            filterType: FilterType.True,
+            value: undefined,
+          },
+        }),
+      ).toBeTruthy();
+
+      expect(
+        await SnmpMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+          dataToProcess,
+          criteriaFilter: {
+            checkOn: CheckOn.SnmpWalkIsSucceeding,
+            filterType: FilterType.False,
+            value: undefined,
+          },
+        }),
+      ).toBeNull();
+    });
+  });
+});

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

@@ -0,0 +1,367 @@
+import { MetricPointType } from "../../../../Models/AnalyticsModels/Metric";
+import MetricType from "../../../../Models/DatabaseModels/MetricType";
+import GlobalConfigService from "../../../../Server/Services/GlobalConfigService";
+import MetricService from "../../../../Server/Services/MetricService";
+import MonitorMetricUtil from "../../../../Server/Utils/Monitor/MonitorMetricUtil";
+import TelemetryUtil from "../../../../Server/Utils/Telemetry/Telemetry";
+import Dictionary from "../../../../Types/Dictionary";
+import { JSONObject } from "../../../../Types/JSON";
+import {
+  DatabaseMetricDefinition,
+  DatabaseMetricGroup,
+  getAllDatabaseMetrics,
+  getDatabaseMetricsByGroup,
+} from "../../../../Types/Monitor/DatabaseMetricCatalog";
+import DatabaseMonitorResponse, {
+  DatabaseMetricGroupStatus,
+  DatabaseMetricGroupUnavailableReason,
+} from "../../../../Types/Monitor/DatabaseMonitor/DatabaseMonitorResponse";
+import MonitorMetricType from "../../../../Types/Monitor/MonitorMetricType";
+import ObjectID from "../../../../Types/ObjectID";
+import ProbeMonitorResponse from "../../../../Types/Probe/ProbeMonitorResponse";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+
+const PROJECT_ID: ObjectID = new ObjectID(
+  "44444444-4444-4444-8444-444444444444",
+);
+const MONITOR_ID: ObjectID = new ObjectID(
+  "55555555-5555-4555-8555-555555555555",
+);
+const PROBE_ID: ObjectID = new ObjectID("66666666-6666-4666-8666-666666666666");
+
+function buildDatabaseResponse(input: {
+  metrics?: Partial<Record<MonitorMetricType, number>>;
+  isOnline?: boolean;
+  unavailableGroups?: Array<DatabaseMetricGroupStatus>;
+  collectedGroups?: Array<DatabaseMetricGroup>;
+}): DatabaseMonitorResponse {
+  return {
+    isOnline: input.isOnline ?? true,
+    responseTimeInMs: 12,
+    failureCause: "",
+    metrics: input.metrics ?? {},
+    collectedGroups: input.collectedGroups ?? [],
+    unavailableGroups: input.unavailableGroups ?? [],
+    connectionError: null,
+    engineVersion: "PostgreSQL 15.18",
+  };
+}
+
+function buildProbeResponse(
+  databaseMonitorResponse: DatabaseMonitorResponse,
+): ProbeMonitorResponse {
+  return {
+    projectId: PROJECT_ID,
+    monitorId: MONITOR_ID,
+    monitorStepId: ObjectID.generate(),
+    probeId: PROBE_ID,
+    failureCause: databaseMonitorResponse.failureCause,
+    monitoredAt: new Date("2026-09-02T10:00:00.000Z"),
+    isOnline: databaseMonitorResponse.isOnline,
+    responseTimeInMs: databaseMonitorResponse.responseTimeInMs,
+    databaseMonitorResponse: databaseMonitorResponse,
+  };
+}
+
+describe("MonitorMetricUtil Database Health metric write path", () => {
+  let insertedRows: Array<JSONObject>;
+  let indexedMaps: Array<Dictionary<MetricType>>;
+
+  beforeEach(() => {
+    insertedRows = [];
+    indexedMaps = [];
+
+    jest
+      .spyOn(GlobalConfigService, "findOneBy")
+      .mockResolvedValue(null as never);
+    jest
+      .spyOn(MetricService, "insertJsonRows")
+      .mockImplementation(async (rows: Array<JSONObject>): Promise<void> => {
+        insertedRows.push(...rows);
+      });
+    jest
+      .spyOn(TelemetryUtil, "indexMetricNameServiceNameMap")
+      .mockImplementation(
+        async (data: {
+          projectId: ObjectID;
+          metricNameServiceNameMap: Dictionary<MetricType>;
+        }): Promise<void> => {
+          indexedMaps.push(data.metricNameServiceNameMap);
+        },
+      );
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  async function save(response: ProbeMonitorResponse): Promise<void> {
+    await MonitorMetricUtil.saveMonitorMetrics({
+      monitorId: MONITOR_ID,
+      projectId: PROJECT_ID,
+      dataToProcess: response,
+      monitorName: "Orders Primary",
+      probeName: "Frankfurt Probe",
+    });
+  }
+
+  function rowsByName(name: MonitorMetricType): Array<JSONObject> {
+    return insertedRows.filter((row: JSONObject) => {
+      return row["name"] === name;
+    });
+  }
+
+  function databaseRows(): Array<JSONObject> {
+    const databaseMetricNames: Set<string> = new Set<string>(
+      getAllDatabaseMetrics().map((definition: DatabaseMetricDefinition) => {
+        return definition.metricType.toString();
+      }),
+    );
+
+    return insertedRows.filter((row: JSONObject) => {
+      return databaseMetricNames.has(String(row["name"]));
+    });
+  }
+
+  test("writes one row per collected metric, keyed by its own metric type", async () => {
+    await save(
+      buildProbeResponse(
+        buildDatabaseResponse({
+          metrics: {
+            [MonitorMetricType.DatabaseConnectionsTotal]: 42,
+            [MonitorMetricType.DatabaseConnectionsUsedPercent]: 21,
+          },
+          collectedGroups: [DatabaseMetricGroup.Connections],
+        }),
+      ),
+    );
+
+    expect(databaseRows()).toHaveLength(2);
+    expect(rowsByName(MonitorMetricType.DatabaseConnectionsTotal)).toHaveLength(
+      1,
+    );
+    expect(
+      rowsByName(MonitorMetricType.DatabaseConnectionsTotal)[0]?.["value"],
+    ).toBe(42);
+    expect(
+      rowsByName(MonitorMetricType.DatabaseConnectionsUsedPercent)[0]?.[
+        "value"
+      ],
+    ).toBe(21);
+  });
+
+  test("carries only monitor, project and probe identity on database rows", async () => {
+    await save(
+      buildProbeResponse(
+        buildDatabaseResponse({
+          metrics: { [MonitorMetricType.DatabaseCacheHitPercent]: 99 },
+        }),
+      ),
+    );
+
+    const row: JSONObject | undefined = rowsByName(
+      MonitorMetricType.DatabaseCacheHitPercent,
+    )[0];
+
+    expect(row?.["primaryEntityId"]).toBe(MONITOR_ID.toString());
+    expect(row?.["metricPointType"]).toBe(MetricPointType.Sum);
+    expect(row?.["attributes"]).toEqual({
+      monitorId: MONITOR_ID.toString(),
+      projectId: PROJECT_ID.toString(),
+      probeId: PROBE_ID.toString(),
+      monitorName: "Orders Primary",
+      probeName: "Frankfurt Probe",
+    });
+  });
+
+  test("writes no row for a metric the check did not collect", async () => {
+    await save(
+      buildProbeResponse(
+        buildDatabaseResponse({
+          metrics: { [MonitorMetricType.DatabaseConnectionsTotal]: 7 },
+        }),
+      ),
+    );
+
+    for (const definition of getAllDatabaseMetrics()) {
+      if (
+        definition.metricType === MonitorMetricType.DatabaseConnectionsTotal
+      ) {
+        continue;
+      }
+
+      expect(rowsByName(definition.metricType)).toEqual([]);
+    }
+  });
+
+  /*
+   * The degradation contract: a group the monitoring login cannot read must
+   * leave its series with no datapoint at all. A zero here would read as a
+   * healthy measurement and silently resolve whatever it was meant to catch.
+   */
+  test("writes nothing - not zero - for the metrics of an unavailable group", async () => {
+    const lockMetrics: Array<DatabaseMetricDefinition> =
+      getDatabaseMetricsByGroup(DatabaseMetricGroup.Locks);
+
+    expect(lockMetrics.length).toBeGreaterThan(0);
+
+    await save(
+      buildProbeResponse(
+        buildDatabaseResponse({
+          metrics: { [MonitorMetricType.DatabaseConnectionsTotal]: 15 },
+          collectedGroups: [DatabaseMetricGroup.Connections],
+          unavailableGroups: [
+            {
+              group: DatabaseMetricGroup.Locks,
+              reason: DatabaseMetricGroupUnavailableReason.MissingPermission,
+              message: "The monitoring login cannot read lock statistics.",
+              remediation: "GRANT pg_monitor TO monitoring_user;",
+            },
+          ],
+        }),
+      ),
+    );
+
+    for (const definition of lockMetrics) {
+      expect(rowsByName(definition.metricType)).toEqual([]);
+    }
+
+    expect(
+      rowsByName(MonitorMetricType.DatabaseConnectionsTotal)[0]?.["value"],
+    ).toBe(15);
+  });
+
+  test("keeps a measured zero, which is a real value for every catalog metric", async () => {
+    await save(
+      buildProbeResponse(
+        buildDatabaseResponse({
+          metrics: {
+            [MonitorMetricType.DatabaseReplicationLagSeconds]: 0,
+            [MonitorMetricType.DatabaseMetricGroupsFailed]: 0,
+          },
+        }),
+      ),
+    );
+
+    expect(
+      rowsByName(MonitorMetricType.DatabaseReplicationLagSeconds)[0]?.["value"],
+    ).toBe(0);
+    expect(
+      rowsByName(MonitorMetricType.DatabaseMetricGroupsFailed)[0]?.["value"],
+    ).toBe(0);
+  });
+
+  test("still records availability and response time when no metric was collected", async () => {
+    await save(buildProbeResponse(buildDatabaseResponse({ metrics: {} })));
+
+    expect(databaseRows()).toEqual([]);
+    expect(rowsByName(MonitorMetricType.IsOnline)[0]?.["value"]).toBe(1);
+    expect(rowsByName(MonitorMetricType.ResponseTime)[0]?.["value"]).toBe(12);
+  });
+
+  test("records the outage when the connection itself failed", async () => {
+    const offline: DatabaseMonitorResponse = buildDatabaseResponse({
+      isOnline: false,
+      metrics: {},
+    });
+    offline.connectionError = "Connection refused.";
+    offline.failureCause = "Connection refused.";
+
+    const probeResponse: ProbeMonitorResponse = buildProbeResponse(offline);
+
+    await save(probeResponse);
+
+    expect(databaseRows()).toEqual([]);
+    expect(rowsByName(MonitorMetricType.IsOnline)[0]?.["value"]).toBe(0);
+  });
+
+  test("writes every catalog series on a fully collected check", async () => {
+    const metrics: Partial<Record<MonitorMetricType, number>> = {};
+    let nextValue: number = 1;
+
+    for (const definition of getAllDatabaseMetrics()) {
+      metrics[definition.metricType] = nextValue;
+      nextValue = nextValue + 1;
+    }
+
+    await save(buildProbeResponse(buildDatabaseResponse({ metrics: metrics })));
+
+    expect(databaseRows()).toHaveLength(getAllDatabaseMetrics().length);
+
+    for (const definition of getAllDatabaseMetrics()) {
+      expect(rowsByName(definition.metricType)).toHaveLength(1);
+    }
+  });
+
+  test("registers each series with the catalog's own description and unit", async () => {
+    const percentMetric: DatabaseMetricDefinition | undefined =
+      getAllDatabaseMetrics().find((definition: DatabaseMetricDefinition) => {
+        return (
+          definition.metricType ===
+          MonitorMetricType.DatabaseConnectionsUsedPercent
+        );
+      });
+
+    expect(percentMetric).toBeDefined();
+
+    await save(
+      buildProbeResponse(
+        buildDatabaseResponse({
+          metrics: {
+            [MonitorMetricType.DatabaseConnectionsUsedPercent]: 55,
+          },
+        }),
+      ),
+    );
+
+    expect(indexedMaps).toHaveLength(1);
+    const metricMap: Dictionary<MetricType> = indexedMaps[0]!;
+    const registered: MetricType | undefined =
+      metricMap[MonitorMetricType.DatabaseConnectionsUsedPercent];
+
+    expect(registered?.unit).toBe(percentMetric!.unit);
+    expect(registered?.description).toBe(percentMetric!.description);
+  });
+
+  test("skips a non-finite value rather than writing a bogus datapoint", async () => {
+    await save(
+      buildProbeResponse(
+        buildDatabaseResponse({
+          metrics: {
+            [MonitorMetricType.DatabaseSizeBytes]: Number.NaN,
+            [MonitorMetricType.DatabaseDeadTuples]: Number.POSITIVE_INFINITY,
+            [MonitorMetricType.DatabaseQueriesTotal]: 900,
+          },
+        }),
+      ),
+    );
+
+    expect(databaseRows()).toHaveLength(1);
+    expect(
+      rowsByName(MonitorMetricType.DatabaseQueriesTotal)[0]?.["value"],
+    ).toBe(900);
+  });
+
+  test("leaves database series untouched for a check that carries no database payload", async () => {
+    await save({
+      projectId: PROJECT_ID,
+      monitorId: MONITOR_ID,
+      monitorStepId: ObjectID.generate(),
+      probeId: PROBE_ID,
+      failureCause: "",
+      monitoredAt: new Date("2026-09-02T10:00:00.000Z"),
+      isOnline: true,
+      responseTimeInMs: 80,
+    });
+
+    expect(databaseRows()).toEqual([]);
+    expect(rowsByName(MonitorMetricType.ResponseTime)[0]?.["value"]).toBe(80);
+  });
+});

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

@@ -16,6 +16,8 @@ import MetricsViewConfig from "../../../../Types/Metrics/MetricsViewConfig";
 import MetricMonitorResponse from "../../../../Types/Monitor/MetricMonitor/MetricMonitorResponse";
 import MonitorStep from "../../../../Types/Monitor/MonitorStep";
 import RollingTime from "../../../../Types/RollingTime/RollingTime";
+import SnmpMonitorResponse from "../../../../Types/Monitor/SnmpMonitor/SnmpMonitorResponse";
+import ProbeMonitorResponse from "../../../../Types/Probe/ProbeMonitorResponse";
 import ObjectID from "../../../../Types/ObjectID";
 
 /*
@@ -819,3 +821,101 @@ describe("MonitorCriteriaObservationBuilder.getMetricValueDisplayUnit", () => {
     expect(unit).toBeUndefined();
   });
 });
+
+/*
+ * Network Device observations under ping-first polling. "Is Online" is the
+ * device's reachability (ping OR walk, the top-level isOnline the walk
+ * pipeline stamps); "Walk Is Succeeding" is the walk itself, and a poll that
+ * ran no walk is a distinct, non-failure state.
+ */
+describe("MonitorCriteriaObservationBuilder.describeFilterObservation — network device polls", () => {
+  function buildProbeInputs(input: {
+    checkOn: CheckOn;
+    isOnline?: boolean | undefined;
+    failureCause?: string | undefined;
+    snmpResponse?: SnmpMonitorResponse | undefined;
+  }): {
+    monitor: Monitor;
+    criteriaFilter: CriteriaFilter;
+    monitorStep: MonitorStep;
+    dataToProcess: ProbeMonitorResponse;
+  } {
+    return {
+      monitor: new Monitor(),
+      monitorStep: new MonitorStep(),
+      criteriaFilter: {
+        checkOn: input.checkOn,
+        filterType: FilterType.False,
+        value: undefined,
+      },
+      dataToProcess: {
+        projectId: ObjectID.generate(),
+        monitorId: ObjectID.generate(),
+        monitorStepId: ObjectID.generate(),
+        probeId: ObjectID.generate(),
+        failureCause: input.failureCause ?? "",
+        isOnline: input.isOnline,
+        snmpResponse: input.snmpResponse,
+        monitoredAt: new Date(),
+      },
+    };
+  }
+
+  test("Is Online describes device reachability from the top-level verdict, even with no walk", () => {
+    expect(
+      MonitorCriteriaObservationBuilder.describeFilterObservation(
+        buildProbeInputs({ checkOn: CheckOn.SnmpIsOnline, isOnline: true }),
+      ),
+    ).toBe("Device is reachable (answered ping or SNMP).");
+
+    expect(
+      MonitorCriteriaObservationBuilder.describeFilterObservation(
+        buildProbeInputs({
+          checkOn: CheckOn.SnmpIsOnline,
+          isOnline: false,
+          failureCause: "Request timed out",
+        }),
+      ),
+    ).toBe("Device is unreachable by ping and SNMP: Request timed out");
+  });
+
+  test("Walk Is Succeeding names the no-walk state rather than calling it a failure", () => {
+    expect(
+      MonitorCriteriaObservationBuilder.describeFilterObservation(
+        buildProbeInputs({
+          checkOn: CheckOn.SnmpWalkIsSucceeding,
+          isOnline: true,
+        }),
+      ),
+    ).toBe("No SNMP walk ran on this poll (the device is only pinged).");
+  });
+
+  test("Walk Is Succeeding reports the walk's own verdict and failure cause", () => {
+    const failedWalk: SnmpMonitorResponse = {
+      isOnline: false,
+      responseTimeInMs: 0,
+      failureCause: "SNMP timed out after 3 attempts",
+      oidResponses: [],
+    };
+
+    expect(
+      MonitorCriteriaObservationBuilder.describeFilterObservation(
+        buildProbeInputs({
+          checkOn: CheckOn.SnmpWalkIsSucceeding,
+          isOnline: true,
+          snmpResponse: failedWalk,
+        }),
+      ),
+    ).toBe("SNMP walk failed: SNMP timed out after 3 attempts");
+
+    expect(
+      MonitorCriteriaObservationBuilder.describeFilterObservation(
+        buildProbeInputs({
+          checkOn: CheckOn.SnmpWalkIsSucceeding,
+          isOnline: true,
+          snmpResponse: { ...failedWalk, isOnline: true, failureCause: "" },
+        }),
+      ),
+    ).toBe("SNMP walk succeeded.");
+  });
+});

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

@@ -372,6 +372,11 @@ describe("MonitorStepResourceIdentity — monitor types with no resource identit
     MonitorType.Domain,
     MonitorType.DNS,
     MonitorType.SQLQuery,
+    /*
+     * A database health step names a host:port, which is not one of the
+     * buckets SeriesResourceRefs carries.
+     */
+    MonitorType.Database,
     MonitorType.SyntheticMonitor,
     MonitorType.CustomJavaScriptCode,
     MonitorType.IncomingRequest,