@oneuptime/common 14.0.2 → 14.0.5

package/Tests/App/Dashboard/EventOverlayScope.test.ts

@@ -66,6 +66,8 @@ const ID_RELATIONS: Array<[string, string]> = [
   ["dockerSwarmClusterIds", "dockerSwarmClusters"],
   ["iotFleetId", "iotFleets"],
   ["iotFleetIds", "iotFleets"],
+  ["databaseServerId", "databaseServers"],
+  ["databaseServerIds", "databaseServers"],
   ["serviceId", "services"],
   ["serviceIds", "services"],
   ["services", "services"],
@@ -87,6 +89,7 @@ const NAME_RELATIONS: Array<[string, string, string]> = [
   ["ceph.cluster.name", "cephClusters", "name"],
   ["docker.swarm.cluster.name", "dockerSwarmClusters", "name"],
   ["iot.fleet.name", "iotFleets", "name"],
+  // Not oneuptime.database.server.name: see "database overlays match by id".
   ["service.name", "services", "name"],
   ["oneuptime.service.name", "services", "name"],
 ];
@@ -155,6 +158,7 @@ describe("event overlay resource scope", () => {
       ["oneuptime.docker.host.id", "dockerHosts"],
       ["oneuptime.podman.host.id", "podmanHosts"],
       ["oneuptime.kubernetes.cluster.id", "kubernetesClusters"],
+      ["oneuptime.database.server.id", "databaseServers"],
       ["oneuptime.service.id", "services"],
     ])(`uses stamped ${prefix}%s ids`, (key: string, relation: string) => {
       expect(
@@ -242,6 +246,7 @@ describe("event overlay resource scope", () => {
     [ServiceType.CephCluster, "cephClusters"],
     [ServiceType.DockerSwarmCluster, "dockerSwarmClusters"],
     [ServiceType.IoTDevice, "iotFleets"],
+    [ServiceType.DatabaseServer, "databaseServers"],
     [ServiceType.OpenTelemetry, "services"],
   ])(
     "scopes polymorphic primaryEntityId of type %s",
@@ -843,3 +848,145 @@ describe("event overlay resource scope", () => {
     expect(membership.values).toEqual([RESOURCE_B, RESOURCE_A]);
   });
 });
+
+/*
+ * Ingest stamps `oneuptime.database.server.name` from the batch ("PostgreSQL
+ * orders-db.internal:5432", or "Database" for a batch linked by id alone),
+ * never from the row: a database created or renamed by hand ("Orders DB")
+ * or detected as a workload has another name, and names are not unique. So
+ * database overlays match by id only.
+ */
+describe("database overlays match by id, never by the stamped display name", () => {
+  const STAMPED_NAME: string = "PostgreSQL orders-db.internal:5432";
+
+  test.each(["", "resource."])(
+    "a %soneuptime.database.server.name filter alone overlays no incident or alert",
+    (prefix: string) => {
+      const result: EventOverlayScope = scope({
+        [`${prefix}oneuptime.database.server.name`]: STAMPED_NAME,
+      });
+
+      // Never matched against DatabaseServer.name…
+      expect(JSON.stringify(result.incidentQueries)).not.toContain(
+        "databaseServers",
+      );
+      // …and never widened to every incident in the project.
+      expectSuppressed(result);
+      // Change events carry attributes, so they still match the exact value.
+      expect(result.changeEventQueries).toEqual([
+        {
+          attributes: {
+            [`${prefix}oneuptime.database.server.name`]: STAMPED_NAME,
+          },
+        },
+      ]);
+    },
+  );
+
+  test("the literal fallback name 'Database' never selects a row named 'Database'", () => {
+    const result: EventOverlayScope = scope({
+      "oneuptime.database.server.name": "Database",
+    });
+
+    expectSuppressed(result);
+  });
+
+  test.each([
+    ["oneuptime.database.server.id"],
+    ["resource.oneuptime.database.server.id"],
+    ["databaseServerId"],
+  ])(
+    "with %s next to it, the id alone scopes — a name that differs from the row's cannot drop the overlays",
+    (idKey: string) => {
+      const result: EventOverlayScope = scope({
+        [idKey]: RESOURCE_A,
+        "oneuptime.database.server.name": STAMPED_NAME,
+      });
+
+      expect(result.incidentQueries).toEqual([
+        { databaseServers: { _id: RESOURCE_A } },
+      ]);
+      expect(result.alertQueries).toEqual([
+        { databaseServers: { _id: RESOURCE_A } },
+      ]);
+      expect(result.changeEventQueries).toEqual([
+        { attributes: { [idKey]: RESOURCE_A } },
+      ]);
+    },
+  );
+
+  test("a polymorphic DatabaseServer primary entity scopes by id; the name is ignored", () => {
+    const result: EventOverlayScope = getEventOverlayScope([
+      {
+        metricQueryData: {
+          filterData: {
+            metricName: "postgresql.backends",
+            primaryEntityType: ServiceType.DatabaseServer,
+            primaryEntityId: RESOURCE_A,
+            attributes: {
+              "resource.oneuptime.database.server.name": STAMPED_NAME,
+            },
+          },
+        },
+      } as unknown as MetricQueryConfigData,
+    ]);
+
+    expect(result.incidentQueries).toEqual([
+      { databaseServers: { _id: RESOURCE_A } },
+    ]);
+    expect(result.alertQueries).toEqual([
+      { databaseServers: { _id: RESOURCE_A } },
+    ]);
+  });
+
+  test("a primary entity of ANOTHER type does not excuse a database name", () => {
+    const result: EventOverlayScope = getEventOverlayScope([
+      {
+        metricQueryData: {
+          filterData: {
+            metricName: "postgresql.backends",
+            primaryEntityType: ServiceType.Host,
+            primaryEntityId: RESOURCE_A,
+            attributes: { "oneuptime.database.server.name": STAMPED_NAME },
+          },
+        },
+      } as unknown as MetricQueryConfigData,
+    ]);
+
+    expectSuppressed(result);
+  });
+
+  test("an event scope naming only the database's display name overlays nothing", () => {
+    const query: MetricQueryConfigData = config();
+    query.eventScope = { "oneuptime.database.server.name": STAMPED_NAME };
+
+    const result: EventOverlayScope = getEventOverlayScope([query]);
+
+    expectSuppressed(result);
+  });
+
+  test("an event scope with the database's id and name is scoped by the id", () => {
+    const query: MetricQueryConfigData = config();
+    query.eventScope = {
+      "oneuptime.database.server.id": RESOURCE_A,
+      "oneuptime.database.server.name": STAMPED_NAME,
+    };
+
+    const result: EventOverlayScope = getEventOverlayScope([query]);
+
+    expect(result.incidentQueries).toEqual([
+      { databaseServers: { _id: RESOURCE_A } },
+    ]);
+  });
+
+  test("a membership of display names is refused like a single one", () => {
+    expectSuppressed(
+      scope({
+        "oneuptime.database.server.name": new Includes([
+          STAMPED_NAME,
+          "Redis cache.internal:6379",
+        ]),
+      }),
+    );
+  });
+});

package/Tests/App/Dashboard/EventOverlayScopeHook.test.tsx

@@ -331,6 +331,7 @@ describe("resource-scoped event overlay requests", (): void => {
     ["cephClusterId", "cephClusters"],
     ["dockerSwarmClusterId", "dockerSwarmClusters"],
     ["iotFleetId", "iotFleets"],
+    ["databaseServerId", "databaseServers"],
     ["serviceId", "services"],
   ])(
     "carries %s into every event source's request",

package/Tests/App/Dashboard/ExceptionMonitorEnvironmentFilter.test.tsx

@@ -5,11 +5,11 @@
  */
 import "@testing-library/jest-dom";
 import {
+  act,
   cleanup,
   fireEvent,
   render,
   screen,
-  waitFor,
 } from "@testing-library/react";
 import React, { ReactElement } from "react";
 import {
@@ -119,13 +119,33 @@ function latestPreviewQuery(): JSONObject {
   return previewQueries[previewQueries.length - 1]!;
 }
 
+// ExceptionMonitorStepForm's preview debounce.
+const PREVIEW_DEBOUNCE_MS: number = 500;
+
+/*
+ * Runs the preview debounce out on jest's clock, inside act() so the render
+ * it triggers has committed when this returns. This used to be a real-time
+ * waitFor with a 3s budget, which was not enough on a loaded CI runner: when
+ * the worker's event loop stalled past 3s (a major GC is enough), the
+ * debounce and waitFor's timeout were both overdue and fired in the same
+ * timers phase - the debounce only scheduling React's render, the timeout
+ * rejecting before that render ran.
+ */
+function runPreviewDebounce(): void {
+  act(() => {
+    jest.advanceTimersByTime(PREVIEW_DEBOUNCE_MS);
+  });
+}
+
 describe("Exceptions monitor form — environment filter", () => {
   beforeEach(() => {
     previewQueries = [];
+    jest.useFakeTimers();
   });
 
   afterEach(() => {
     cleanup();
+    jest.useRealTimers();
   });
 
   test("offers an Environments field without opening the advanced options", () => {
@@ -143,7 +163,7 @@ describe("Exceptions monitor form — environment filter", () => {
     expect(latestPreviewQuery()["environment"]).toBeUndefined();
   });
 
-  test("typing environments saves them and narrows the preview", async () => {
+  test("typing environments saves them and narrows the preview", () => {
     const recorder: Recorder = renderForm({ exceptionTypes: ["TypeError"] });
 
     fireEvent.change(environmentsInput(), {
@@ -155,15 +175,14 @@ describe("Exceptions monitor form — environment filter", () => {
     expect(recorder.latest?.exceptionTypes).toEqual(["TypeError"]);
 
     // The preview is debounced so typing does not refetch per keystroke.
-    await waitFor(
-      () => {
-        expect(latestPreviewQuery()["environment"]).toEqual({
-          _type: "Includes",
-          value: ["production", "staging"],
-        });
-      },
-      { timeout: 3000 },
-    );
+    expect(latestPreviewQuery()["environment"]).toBeUndefined();
+
+    runPreviewDebounce();
+
+    expect(latestPreviewQuery()["environment"]).toEqual({
+      _type: "Includes",
+      value: ["production", "staging"],
+    });
     expect(latestPreviewQuery()["exceptionType"]).toEqual({
       _type: "Includes",
       value: ["TypeError"],
@@ -201,18 +220,19 @@ describe("Exceptions monitor form — environment filter", () => {
     });
   });
 
-  test("clearing the field goes back to every environment", async () => {
+  test("clearing the field goes back to every environment", () => {
     const recorder: Recorder = renderForm({ environments: ["production"] });
 
     fireEvent.change(environmentsInput(), { target: { value: "" } });
 
     expect(recorder.latest?.environments).toEqual([]);
+    expect(latestPreviewQuery()["environment"]).toEqual({
+      _type: "Includes",
+      value: ["production"],
+    });
 
-    await waitFor(
-      () => {
-        expect(latestPreviewQuery()["environment"]).toBeUndefined();
-      },
-      { timeout: 3000 },
-    );
+    runPreviewDebounce();
+
+    expect(latestPreviewQuery()["environment"]).toBeUndefined();
   });
 });