@oneuptime/common 14.0.2 → 14.0.5

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

@@ -224,6 +224,7 @@ describe("Dependency-suppression skip block in the alert / incident creators", (
         cephClusterIds: [],
         dockerSwarmClusterIds: [],
         iotFleetIds: [],
+        databaseServerIds: [],
       }) as unknown as SpyLike;
 
     jest

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

@@ -210,6 +210,7 @@ describe("MonitorIncident drops criteria references the project cannot use", ()
         cephClusterIds: [],
         dockerSwarmClusterIds: [],
         iotFleetIds: [],
+        databaseServerIds: [],
       });
 
     jest

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

@@ -114,6 +114,7 @@ function emptyResourceContext(): SeriesResolvedResourceIds {
     cephClusterIds: [],
     dockerSwarmClusterIds: [],
     iotFleetIds: [],
+    databaseServerIds: [],
   };
 }
 

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

@@ -12,6 +12,7 @@ jest.mock("isolated-vm", () => {
 import Incident from "../../../../Models/DatabaseModels/Incident";
 import Monitor from "../../../../Models/DatabaseModels/Monitor";
 import CephClusterService from "../../../../Server/Services/CephClusterService";
+import DatabaseServerService from "../../../../Server/Services/DatabaseServerService";
 import DockerHostService from "../../../../Server/Services/DockerHostService";
 import DockerSwarmClusterService from "../../../../Server/Services/DockerSwarmClusterService";
 import HostService from "../../../../Server/Services/HostService";
@@ -144,6 +145,7 @@ function emptyResourceContext(): SeriesResolvedResourceIds {
     cephClusterIds: [],
     dockerSwarmClusterIds: [],
     iotFleetIds: [],
+    databaseServerIds: [],
   };
 }
 
@@ -160,6 +162,7 @@ describe("Incidents link the resources their series identifies", () => {
   let cephClusterRows: Array<{ _id: string }> = [];
   let dockerSwarmClusterRows: Array<{ _id: string }> = [];
   let iotFleetRows: Array<{ _id: string }> = [];
+  let databaseServerRows: Array<{ _id: string }> = [];
 
   let resourceContext: SeriesResolvedResourceIds;
 
@@ -176,6 +179,7 @@ describe("Incidents link the resources their series identifies", () => {
     cephClusterRows = [];
     dockerSwarmClusterRows = [];
     iotFleetRows = [];
+    databaseServerRows = [];
 
     resourceContext = emptyResourceContext();
 
@@ -230,6 +234,9 @@ describe("Incidents link the resources their series identifies", () => {
     jest.spyOn(IoTFleetService, "findBy").mockImplementation(async () => {
       return iotFleetRows as never;
     });
+    jest.spyOn(DatabaseServerService, "findBy").mockImplementation(async () => {
+      return databaseServerRows as never;
+    });
 
     jest
       .spyOn(IncidentService, "create")
@@ -366,6 +373,7 @@ describe("Incidents link the resources their series identifies", () => {
     cephClusterRows = [{ _id: "ceph-1" }];
     dockerSwarmClusterRows = [{ _id: "swarm-1" }];
     iotFleetRows = [{ _id: "fleet-1" }];
+    databaseServerRows = [{ _id: "d0000000-0000-4000-8000-000000000001" }];
 
     await MonitorIncident.criteriaMetCreateIncidentsAndUpdateMonitorStatus({
       criteriaInstance: criteriaInstance(),
@@ -386,6 +394,8 @@ describe("Incidents link the resources their series identifies", () => {
             "ceph.cluster.name": "ceph",
             "docker.swarm.cluster.name": "swarm",
             "iot.fleet.name": "fleet",
+            "oneuptime.database.server.id":
+              "d0000000-0000-4000-8000-000000000001",
           },
           "fp-1",
         ),
@@ -405,6 +415,84 @@ describe("Incidents link the resources their series identifies", () => {
     expect(idsOn(incident.cephClusters)).toEqual(["ceph-1"]);
     expect(idsOn(incident.dockerSwarmClusters)).toEqual(["swarm-1"]);
     expect(idsOn(incident.iotFleets)).toEqual(["fleet-1"]);
+    expect(idsOn(incident.databaseServers)).toEqual([
+      "d0000000-0000-4000-8000-000000000001",
+    ]);
+  });
+
+  it.each([
+    ["oneuptime.database.server.id"],
+    ["resource.oneuptime.database.server.id"],
+  ])("links the database from the %s spelling", async (key: string) => {
+    databaseServerRows = [{ _id: "d0000000-0000-4000-8000-000000000001" }];
+
+    await MonitorIncident.criteriaMetCreateIncidentsAndUpdateMonitorStatus({
+      criteriaInstance: criteriaInstance(),
+      monitor: monitor(),
+      dataToProcess: dataToProcess,
+      rootCause: "Connections are above 90% of max_connections",
+      autoResolveCriteriaInstanceIdIncidentIdsDictionary: NO_AUTO_RESOLVE,
+      matchesPerSeries: [
+        series({ [key]: "d0000000-0000-4000-8000-000000000001" }, "fp-1"),
+      ],
+      props: {},
+    });
+
+    expect(idsOn(createdIncidents[0]!.databaseServers)).toEqual([
+      "d0000000-0000-4000-8000-000000000001",
+    ]);
+
+    const call: { query: JSONObject } = (
+      DatabaseServerService.findBy as unknown as {
+        mock: { calls: Array<Array<{ query: JSONObject }>> };
+      }
+    ).mock.calls[0]![0]!;
+    expect(call.query["projectId"]).toBe(PROJECT_ID);
+  });
+
+  it("links no database from the display-name stamp alone", async () => {
+    // The name is not an identity (not unique, renameable) — id stamp only.
+    databaseServerRows = [{ _id: "d0000000-0000-4000-8000-000000000001" }];
+
+    await MonitorIncident.criteriaMetCreateIncidentsAndUpdateMonitorStatus({
+      criteriaInstance: criteriaInstance(),
+      monitor: monitor(),
+      dataToProcess: dataToProcess,
+      rootCause: "Connections are above 90% of max_connections",
+      autoResolveCriteriaInstanceIdIncidentIdsDictionary: NO_AUTO_RESOLVE,
+      matchesPerSeries: [
+        series(
+          { "oneuptime.database.server.name": "PostgreSQL db.prod:5432" },
+          "fp-1",
+        ),
+      ],
+      props: {},
+    });
+
+    expect(createdIncidents).toHaveLength(1);
+    expect(createdIncidents[0]!.databaseServers).toBeUndefined();
+    expect(DatabaseServerService.findBy).not.toHaveBeenCalled();
+  });
+
+  it("still attaches the step-config database to an ungrouped incident", async () => {
+    resourceContext = {
+      ...emptyResourceContext(),
+      databaseServerIds: ["d0000000-0000-4000-8000-000000000001"],
+    };
+
+    await MonitorIncident.criteriaMetCreateIncidentsAndUpdateMonitorStatus({
+      criteriaInstance: criteriaInstance(),
+      monitor: monitor(),
+      dataToProcess: dataToProcess,
+      rootCause: "Replication lag is above 30s",
+      autoResolveCriteriaInstanceIdIncidentIdsDictionary: NO_AUTO_RESOLVE,
+      props: {},
+    });
+
+    expect(idsOn(createdIncidents[0]!.databaseServers)).toEqual([
+      "d0000000-0000-4000-8000-000000000001",
+    ]);
+    expect(DatabaseServerService.findBy).not.toHaveBeenCalled();
   });
 
   it("gives each series its own resource, with no cross-contamination", async () => {

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

@@ -1,3 +1,6 @@
+import DatabaseServer from "../../../../Models/DatabaseModels/DatabaseServer";
+import ScheduledMaintenance from "../../../../Models/DatabaseModels/ScheduledMaintenance";
+import ScheduledMaintenanceService from "../../../../Server/Services/ScheduledMaintenanceService";
 import MonitorMaintenanceSuppression, {
   MaintainedResourceKeys,
 } from "../../../../Server/Utils/Monitor/MonitorMaintenanceSuppression";
@@ -5,6 +8,7 @@ import SeriesResourceLabels, {
   SeriesResourceRefs,
 } from "../../../../Server/Utils/Monitor/SeriesResourceLabels";
 import { JSONObject } from "../../../../Types/JSON";
+import ObjectID from "../../../../Types/ObjectID";
 import { PerSeriesCriteriaMatch } from "../../../../Types/Probe/ProbeApiIngestResponse";
 
 function emptyMaintained(): MaintainedResourceKeys {
@@ -19,6 +23,7 @@ function emptyMaintained(): MaintainedResourceKeys {
     dockerSwarmClusters: { ids: new Set<string>(), names: new Set<string>() },
     iotFleets: { ids: new Set<string>(), names: new Set<string>() },
     services: { ids: new Set<string>(), names: new Set<string>() },
+    databaseServers: { ids: new Set<string>(), names: new Set<string>() },
   };
 }
 
@@ -154,6 +159,40 @@ describe("SeriesResourceLabels", () => {
         });
       expect(refsUnprefixed.iotFleetNames).toEqual(["fleet-2"]);
     });
+
+    it("maps database server id keys (prefixed and unprefixed)", () => {
+      const refs: SeriesResourceRefs = SeriesResourceLabels.extractResourceRefs(
+        {
+          "resource.oneuptime.database.server.id":
+            "d0000000-0000-4000-8000-000000000001",
+          "oneuptime.database.server.id":
+            "d0000000-0000-4000-8000-000000000002",
+        },
+      );
+      expect(refs.databaseServerIds.sort()).toEqual([
+        "d0000000-0000-4000-8000-000000000001",
+        "d0000000-0000-4000-8000-000000000002",
+      ]);
+      // A database stamp names no host, service or cluster.
+      expect(refs.hostIds).toEqual([]);
+      expect(refs.hostNames).toEqual([]);
+      expect(refs.serviceNames).toEqual([]);
+    });
+
+    it("never reads the database display-name stamp as an identity", () => {
+      const refs: SeriesResourceRefs = SeriesResourceLabels.extractResourceRefs(
+        {
+          "oneuptime.database.server.name": "PostgreSQL db.prod:5432",
+          "resource.oneuptime.database.server.name": "PostgreSQL db.prod:5432",
+        },
+      );
+      expect(refs.databaseServerIds).toEqual([]);
+      expect(
+        Object.values(refs).every((values: Array<string>): boolean => {
+          return values.length === 0;
+        }),
+      ).toBe(true);
+    });
   });
 });
 
@@ -297,6 +336,77 @@ describe("MonitorMaintenanceSuppression.getSuppressedFingerprintsForMaintainedRe
     expect(Array.from(result)).toEqual(["fpVCenter"]);
   });
 
+  it("suppresses only the series whose database is under maintenance", () => {
+    const maintained: MaintainedResourceKeys = emptyMaintained();
+    maintained.databaseServers.ids.add("d0000000-0000-4000-8000-000000000001");
+
+    const result: Set<string> =
+      MonitorMaintenanceSuppression.getSuppressedFingerprintsForMaintainedResources(
+        {
+          matchesPerSeries: [
+            series("fpDb", {
+              "oneuptime.database.server.id":
+                "d0000000-0000-4000-8000-000000000001",
+            }),
+            series("fpDbPrefixed", {
+              "resource.oneuptime.database.server.id":
+                "d0000000-0000-4000-8000-000000000001",
+            }),
+            series("fpOther", {
+              "oneuptime.database.server.id":
+                "d0000000-0000-4000-8000-000000000002",
+            }),
+          ],
+          maintained,
+        },
+      );
+
+    expect(Array.from(result).sort()).toEqual(["fpDb", "fpDbPrefixed"]);
+  });
+
+  it("does not suppress a database series that carries only the display name", () => {
+    /*
+     * The name set is never filled for databases, and a name label is
+     * never read — the display name is not unique across clusters.
+     */
+    const maintained: MaintainedResourceKeys = emptyMaintained();
+    maintained.databaseServers.ids.add("d0000000-0000-4000-8000-000000000001");
+    maintained.databaseServers.names.add("PostgreSQL db.prod:5432");
+
+    const result: Set<string> =
+      MonitorMaintenanceSuppression.getSuppressedFingerprintsForMaintainedResources(
+        {
+          matchesPerSeries: [
+            series("fpName", {
+              "oneuptime.database.server.name": "PostgreSQL db.prod:5432",
+            }),
+          ],
+          maintained,
+        },
+      );
+
+    expect(result.size).toBe(0);
+  });
+
+  it("does not let a database id match a host with the same id string", () => {
+    const maintained: MaintainedResourceKeys = emptyMaintained();
+    maintained.databaseServers.ids.add("5a000000-0000-4000-8000-000000000001");
+
+    const result: Set<string> =
+      MonitorMaintenanceSuppression.getSuppressedFingerprintsForMaintainedResources(
+        {
+          matchesPerSeries: [
+            series("fpHost", {
+              "oneuptime.host.id": "5a000000-0000-4000-8000-000000000001",
+            }),
+          ],
+          maintained,
+        },
+      );
+
+    expect(result.size).toBe(0);
+  });
+
   it("does not cross-match resource types that happen to share a name", () => {
     /*
      * A service named the same string as the breaching host must not
@@ -349,3 +459,98 @@ describe("MonitorMaintenanceSuppression.getSuppressedFingerprintsForMaintainedRe
     expect(result.size).toBe(0);
   });
 });
+
+describe("MonitorMaintenanceSuppression.getSuppressedSeriesFingerprints — databases", () => {
+  const PROJECT_ID: ObjectID = new ObjectID(
+    "11111111-1111-4111-8111-111111111111",
+  );
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  function ongoingEventWithDatabases(ids: Array<string>): ScheduledMaintenance {
+    const event: ScheduledMaintenance = new ScheduledMaintenance();
+    event._id = "event-1";
+    event.databaseServers = ids.map((id: string): DatabaseServer => {
+      const databaseServer: DatabaseServer = new DatabaseServer();
+      databaseServer._id = id;
+      databaseServer.name = `PostgreSQL ${id}:5432`;
+      return databaseServer;
+    });
+    return event;
+  }
+
+  it("selects the databases of ongoing events and suppresses their series", async () => {
+    const findBy: jest.SpyInstance = jest
+      .spyOn(ScheduledMaintenanceService, "findBy")
+      .mockResolvedValue([
+        ongoingEventWithDatabases(["d0000000-0000-4000-8000-000000000001"]),
+      ]);
+
+    const result: Set<string> =
+      await MonitorMaintenanceSuppression.getSuppressedSeriesFingerprints({
+        projectId: PROJECT_ID,
+        matchesPerSeries: [
+          series("fpDb", {
+            "oneuptime.database.server.id":
+              "d0000000-0000-4000-8000-000000000001",
+          }),
+          series("fpOther", {
+            "oneuptime.database.server.id":
+              "d0000000-0000-4000-8000-000000000002",
+          }),
+        ],
+      });
+
+    expect(Array.from(result)).toEqual(["fpDb"]);
+
+    const args: {
+      query: { projectId: ObjectID };
+      select: { databaseServers?: unknown };
+    } = findBy.mock.calls[0]![0] as {
+      query: { projectId: ObjectID };
+      select: { databaseServers?: unknown };
+    };
+    expect(args.query.projectId).toBe(PROJECT_ID);
+    // Only the id is read — the display name is never an identity.
+    expect(args.select.databaseServers).toEqual({ _id: true });
+  });
+
+  it("does not suppress by the database name even when the event holds one", async () => {
+    jest
+      .spyOn(ScheduledMaintenanceService, "findBy")
+      .mockResolvedValue([
+        ongoingEventWithDatabases(["d0000000-0000-4000-8000-000000000001"]),
+      ]);
+
+    const result: Set<string> =
+      await MonitorMaintenanceSuppression.getSuppressedSeriesFingerprints({
+        projectId: PROJECT_ID,
+        matchesPerSeries: [
+          series("fpName", {
+            "oneuptime.database.server.name":
+              "PostgreSQL d0000000-0000-4000-8000-000000000001:5432",
+          }),
+        ],
+      });
+
+    expect(result.size).toBe(0);
+  });
+
+  it("skips the maintenance query entirely when there are no per-series matches", async () => {
+    const findBy: jest.SpyInstance = jest.spyOn(
+      ScheduledMaintenanceService,
+      "findBy",
+    );
+
+    const result: Set<string> =
+      await MonitorMaintenanceSuppression.getSuppressedSeriesFingerprints({
+        projectId: PROJECT_ID,
+        matchesPerSeries: [],
+      });
+
+    expect(result.size).toBe(0);
+    expect(findBy).not.toHaveBeenCalled();
+  });
+});

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

@@ -19,6 +19,7 @@ jest.mock("../../../../Server/Utils/PasswordHash", () => {
 });
 
 import Monitor from "../../../../Models/DatabaseModels/Monitor";
+import DatabaseServerService from "../../../../Server/Services/DatabaseServerService";
 import HostService from "../../../../Server/Services/HostService";
 import KubernetesClusterService from "../../../../Server/Services/KubernetesClusterService";
 import ServiceService from "../../../../Server/Services/ServiceService";
@@ -136,6 +137,7 @@ describe("MonitorResourceContext", () => {
     stubService("dockerHost", DockerHostService, []);
     stubService("kubernetesCluster", KubernetesClusterService, []);
     stubService("service", ServiceService, []);
+    stubService("databaseServer", DatabaseServerService, []);
   });
 
   afterEach(() => {
@@ -346,4 +348,64 @@ describe("MonitorResourceContext", () => {
     expect(resolved.hostIds).toEqual([]);
     expect(HostService.findBy).not.toHaveBeenCalled();
   });
+
+  test("resolves the database a metric monitor's id filter names, by primary key", async () => {
+    stubService("databaseServer", DatabaseServerService, [
+      { _id: "d0000000-0000-4000-8000-000000000001" },
+    ]);
+
+    const resolved: SeriesResolvedResourceIds =
+      await MonitorResourceContextUtil.resolveResourceContextForMonitor({
+        monitor: monitorWith(MonitorType.Metrics, {
+          metricMonitor: {
+            metricViewConfig: metricViewConfigWith({
+              "oneuptime.database.server.id":
+                "d0000000-0000-4000-8000-000000000001",
+            }),
+          },
+        }),
+      });
+
+    expect(resolved).toEqual({
+      ...MonitorResourceContextUtil.emptyContext(),
+      databaseServerIds: ["d0000000-0000-4000-8000-000000000001"],
+    });
+
+    const databaseQueries: Array<JSONObject> = capturedQueries
+      .filter((entry: { service: string }): boolean => {
+        return entry.service === "databaseServer";
+      })
+      .map((entry: { query: JSONObject }): JSONObject => {
+        return entry.query;
+      });
+
+    expect(databaseQueries).toHaveLength(1);
+    expect(String(databaseQueries[0]!["projectId"])).toBe(
+      PROJECT_ID.toString(),
+    );
+    expect(databaseQueries[0]!["_id"]).toBeDefined();
+    expect(databaseQueries[0]!["name"]).toBeUndefined();
+  });
+
+  test("a database display-name filter costs zero round-trips", async () => {
+    const resolved: SeriesResolvedResourceIds =
+      await MonitorResourceContextUtil.resolveResourceContextForMonitor({
+        monitor: monitorWith(MonitorType.Metrics, {
+          metricMonitor: {
+            metricViewConfig: metricViewConfigWith({
+              "oneuptime.database.server.name": "PostgreSQL db.prod:5432",
+            }),
+          },
+        }),
+      });
+
+    expect(resolved).toEqual(MonitorResourceContextUtil.emptyContext());
+    expect(capturedQueries).toHaveLength(0);
+  });
+
+  test("the empty context carries an empty database list", () => {
+    expect(MonitorResourceContextUtil.emptyContext().databaseServerIds).toEqual(
+      [],
+    );
+  });
 });