@oneuptime/common 14.0.2 → 14.0.5

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

@@ -285,6 +285,7 @@ describe.each(ENTITY_KINDS)(
           cephClusterIds: [],
           dockerSwarmClusterIds: [],
           iotFleetIds: [],
+          databaseServerIds: [],
         });
       jest.spyOn(HostService, "findBy").mockResolvedValue([]);
       jest

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

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

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

@@ -14,6 +14,7 @@ import Incident from "../../../../Models/DatabaseModels/Incident";
 import Monitor from "../../../../Models/DatabaseModels/Monitor";
 import AlertService from "../../../../Server/Services/AlertService";
 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";
@@ -152,6 +153,7 @@ function emptyResourceContext(): SeriesResolvedResourceIds {
     cephClusterIds: [],
     dockerSwarmClusterIds: [],
     iotFleetIds: [],
+    databaseServerIds: [],
   };
 }
 
@@ -173,6 +175,7 @@ describe("Alerts 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;
 
@@ -190,6 +193,7 @@ describe("Alerts link the resources their series identifies", () => {
     cephClusterRows = [];
     dockerSwarmClusterRows = [];
     iotFleetRows = [];
+    databaseServerRows = [];
 
     resourceContext = emptyResourceContext();
 
@@ -250,6 +254,9 @@ describe("Alerts 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(AlertService, "create")
@@ -336,6 +343,7 @@ describe("Alerts 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 MonitorAlert.criteriaMetCreateAlertsAndUpdateMonitorStatus({
       criteriaInstance: criteriaInstance(),
@@ -356,6 +364,8 @@ describe("Alerts 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",
         ),
@@ -375,6 +385,115 @@ describe("Alerts link the resources their series identifies", () => {
     expect(idsOn(alert.cephClusters)).toEqual(["ceph-1"]);
     expect(idsOn(alert.dockerSwarmClusters)).toEqual(["swarm-1"]);
     expect(idsOn(alert.iotFleets)).toEqual(["fleet-1"]);
+    expect(idsOn(alert.databaseServers)).toEqual([
+      "d0000000-0000-4000-8000-000000000001",
+    ]);
+  });
+
+  it("links the database when the series is grouped by oneuptime.database.server.id", async () => {
+    /*
+     * A metric monitor over a database's own engine metrics (collector /
+     * Database Agent), grouped by the stamp ingest puts on every such row.
+     */
+    databaseServerRows = [{ _id: "d0000000-0000-4000-8000-000000000001" }];
+
+    await MonitorAlert.criteriaMetCreateAlertsAndUpdateMonitorStatus({
+      criteriaInstance: criteriaInstance(),
+      monitor: monitor(),
+      dataToProcess: dataToProcess,
+      rootCause: "Connections are above 90% of max_connections",
+      autoResolveCriteriaInstanceIdAlertIdsDictionary: NO_AUTO_RESOLVE,
+      matchesPerSeries: [
+        series(
+          {
+            "oneuptime.database.server.id":
+              "d0000000-0000-4000-8000-000000000001",
+            "oneuptime.database.server.name": "PostgreSQL db.prod:5432",
+          },
+          "fp-1",
+        ),
+      ],
+      props: {},
+    });
+
+    expect(createdAlerts).toHaveLength(1);
+    expect(idsOn(createdAlerts[0]!.databaseServers)).toEqual([
+      "d0000000-0000-4000-8000-000000000001",
+    ]);
+    // A database batch names no host; nothing else may be linked.
+    expect(createdAlerts[0]!.hosts).toBeUndefined();
+    expect(createdAlerts[0]!.services).toBeUndefined();
+  });
+
+  it("gives each database series its own database", async () => {
+    jest.spyOn(DatabaseServerService, "findBy").mockImplementation((async (
+      args: unknown,
+    ): Promise<Array<{ _id: string | undefined }>> => {
+      const query: JSONObject = (args as { query: JSONObject }).query;
+      const includes: { values?: Array<string> } = query["_id"] as {
+        values?: Array<string>;
+      };
+      return [{ _id: String((includes.values || [])[0]) }];
+    }) as never);
+
+    await MonitorAlert.criteriaMetCreateAlertsAndUpdateMonitorStatus({
+      criteriaInstance: criteriaInstance(),
+      monitor: monitor(),
+      dataToProcess: dataToProcess,
+      rootCause: "Replication lag is above 30s",
+      autoResolveCriteriaInstanceIdAlertIdsDictionary: NO_AUTO_RESOLVE,
+      matchesPerSeries: [
+        series(
+          {
+            "oneuptime.database.server.id":
+              "d0000000-0000-4000-8000-00000000000a",
+          },
+          "fp-1",
+        ),
+        series(
+          {
+            "oneuptime.database.server.id":
+              "d0000000-0000-4000-8000-00000000000b",
+          },
+          "fp-2",
+        ),
+      ],
+      props: {},
+    });
+
+    expect(createdAlerts).toHaveLength(2);
+    expect(idsOn(createdAlerts[0]!.databaseServers)).toEqual([
+      "d0000000-0000-4000-8000-00000000000a",
+    ]);
+    expect(idsOn(createdAlerts[1]!.databaseServers)).toEqual([
+      "d0000000-0000-4000-8000-00000000000b",
+    ]);
+  });
+
+  it("still attaches the step-config database to an ungrouped alert", async () => {
+    /*
+     * An ungrouped metric monitor scoped by the attribute filter
+     * `oneuptime.database.server.id = …` names the database only through
+     * its step config (MonitorStepResourceIdentity → MonitorResourceContext).
+     */
+    resourceContext = {
+      ...emptyResourceContext(),
+      databaseServerIds: ["d0000000-0000-4000-8000-000000000001"],
+    };
+
+    await MonitorAlert.criteriaMetCreateAlertsAndUpdateMonitorStatus({
+      criteriaInstance: criteriaInstance(),
+      monitor: monitor(),
+      dataToProcess: dataToProcess,
+      rootCause: "Deadlocks detected",
+      autoResolveCriteriaInstanceIdAlertIdsDictionary: NO_AUTO_RESOLVE,
+      props: {},
+    });
+
+    expect(idsOn(createdAlerts[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/MonitorCriteriaEvaluator.test.ts

@@ -1427,10 +1427,8 @@ describe("MonitorCriteriaEvaluator - Kubernetes affected-resources breach predic
   });
 
   test("an `= 0` RECOVERY criteria does NOT turn the all-clear into a list of zeroes", async () => {
-    const replicaStep: MonitorStep = kubernetesStep(
-      "k8s-deployment-replica-mismatch",
-    );
-    const criteria: MonitorCriteriaInstance = recoveryCriteria(replicaStep);
+    const jobStep: MonitorStep = kubernetesStep("k8s-job-failures");
+    const criteria: MonitorCriteriaInstance = recoveryCriteria(jobStep);
 
     // Fixture guard: the real recovery is a non-incident `= 0`.
     expect(criteria.data?.filters[0]!.filterType).toBe(FilterType.EqualTo);
@@ -1439,12 +1437,12 @@ describe("MonitorCriteriaEvaluator - Kubernetes affected-resources breach predic
     expect(criteria.data?.createAlerts).toBe(false);
 
     const context: string | null = await kubernetesContext({
-      metricName: "k8s.deployment.unavailable_replicas",
-      monitorStep: replicaStep,
+      metricName: "k8s.job.failed_pods",
+      monitorStep: jobStep,
       criteriaInstance: criteria,
       affectedResources: [
-        { workloadType: "Deployment", workloadName: "web", metricValue: 0 },
-        { workloadType: "Deployment", workloadName: "api", metricValue: 0 },
+        { workloadType: "Job", workloadName: "web", metricValue: 0 },
+        { workloadType: "Job", workloadName: "api", metricValue: 0 },
       ],
     });
 
@@ -1454,32 +1452,27 @@ describe("MonitorCriteriaEvaluator - Kubernetes affected-resources breach predic
   });
 
   test("a `> 0` criteria renders exactly as the hardcoded filter did, on the highest sample", async () => {
-    const replicaStep: MonitorStep = kubernetesStep(
-      "k8s-deployment-replica-mismatch",
-    );
+    const jobStep: MonitorStep = kubernetesStep("k8s-job-failures");
 
     const context: string | null = await kubernetesContext({
-      metricName: "k8s.deployment.unavailable_replicas",
-      monitorStep: replicaStep,
-      criteriaInstance: firingCriteria(replicaStep),
+      metricName: "k8s.job.failed_pods",
+      monitorStep: jobStep,
+      criteriaInstance: firingCriteria(jobStep),
       affectedResources: [
         {
-          workloadType: "Deployment",
+          workloadType: "Job",
           workloadName: "web",
           metricValue: 3,
           lowestMetricValue: 0,
         },
-        { workloadType: "Deployment", workloadName: "api", metricValue: 5 },
-        { workloadType: "Deployment", workloadName: "ok", metricValue: 0 },
+        { workloadType: "Job", workloadName: "api", metricValue: 5 },
+        { workloadType: "Job", workloadName: "ok", metricValue: 0 },
       ],
     });
 
     expect(context).toContain("**Affected Resources** (2 total)");
     expect(context).toContain(
-      [
-        "1. **Deployment** `api` — **5**",
-        "2. **Deployment** `web` — **3**",
-      ].join("\n"),
+      ["1. **Job** `api` — **5**", "2. **Job** `web` — **3**"].join("\n"),
     );
     expect(context).not.toContain("`ok`");
 
@@ -1488,9 +1481,51 @@ describe("MonitorCriteriaEvaluator - Kubernetes affected-resources breach predic
     const webIndex: number = context!.indexOf("`web`");
     expect(apiIndex).toBeGreaterThan(-1);
     expect(webIndex).toBeGreaterThan(apiIndex);
-    expect(context).toContain(
-      "Deployment `api` has **5** unavailable replica(s).",
+    expect(context).toContain("Job `api` has **5** failed pod(s).");
+  });
+
+  /*
+   * REGRESSION: the breakdown is the RAW rows of the monitor's last query.
+   * k8s-deployment-replica-mismatch compares `desired - available`, so
+   * those rows are `k8s.deployment.available` — and ranking them against
+   * the criteria's "> 0" listed every HEALTHY deployment, with its
+   * available count, as having that many unavailable replicas.
+   */
+  test("a criteria on a formula names the formula and lists no raw operand values", async () => {
+    const replicaStep: MonitorStep = kubernetesStep(
+      "k8s-deployment-replica-mismatch",
     );
+
+    for (const criteria of [
+      firingCriteria(replicaStep),
+      recoveryCriteria(replicaStep),
+    ]) {
+      const context: string | null = await kubernetesContext({
+        metricName: "k8s.deployment.available",
+        monitorStep: replicaStep,
+        criteriaInstance: criteria,
+        affectedResources: [
+          { workloadType: "Deployment", workloadName: "web", metricValue: 3 },
+          { workloadType: "Deployment", workloadName: "api", metricValue: 5 },
+        ],
+      });
+
+      expect(context).toContain("**Kubernetes Cluster Details**");
+      expect(context).toContain("- Metric: Deployment Replica Shortfall");
+      expect(context).toContain(
+        "- Formula: `desired_replicas - available_replicas`",
+      );
+      /*
+       * The operands are NAMED (so an engineer knows what to query), but
+       * none of the raw scan's values is shown as the shortfall.
+       */
+      expect(context).toContain("`available_replicas` = ");
+      expect(context).not.toContain("**3**");
+      expect(context).not.toContain("**5**");
+      expect(context).not.toContain("**Affected Resources**");
+      expect(context).not.toContain("**Root Cause Analysis**");
+      expect(context).not.toContain("`web`");
+    }
   });
 
   test("a `<` criteria keeps the breaching rows and sorts worst (lowest) first", async () => {
@@ -1773,7 +1808,7 @@ describe("MonitorCriteriaEvaluator - Kubernetes root cause analysis scoping", ()
 
     test("unavailable replicas stay a bare count", () => {
       const analysis: string | null = analyse({
-        metricName: "k8s.deployment.unavailable_replicas",
+        metricName: "kube_deployment_status_replicas_unavailable",
         topResource: {
           workloadType: "Deployment",
           workloadName: "web",
@@ -2009,7 +2044,7 @@ describe("MonitorCriteriaEvaluator - Kubernetes affected resources list", () =>
 
   test("a workload-level series is titled by its workload type and does not repeat it", async () => {
     const context: string | null = await kubernetesContext({
-      metricName: "k8s.deployment.unavailable_replicas",
+      metricName: "k8s.statefulset.ready_pods",
       affectedResources: [
         {
           namespace: "payments",