@oneuptime/common 14.0.3 → 14.0.6

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/LogsResourceFacetChips.test.tsx

@@ -95,6 +95,7 @@ const MODEL_NAME_BY_FACET_KEY: Record<string, string> = {
   cloudResourceId: "CloudResource",
   rumApplicationId: "RumApplication",
   iotFleetId: "IoTFleet",
+  databaseServerId: "DatabaseServer",
 };
 
 const CASES: Array<CatalogCase> = RESOURCE_FACET_CATALOG.map(

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

@@ -0,0 +1,310 @@
+import "@testing-library/jest-dom";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+import {
+  act,
+  cleanup,
+  fireEvent,
+  render,
+  screen,
+} from "@testing-library/react";
+import * as React from "react";
+import getJestMockFunction, { MockFunction } from "../../MockType";
+
+/*
+ * A metric row opens the explorer (METRIC_VIEW) carrying the list's
+ * attribute scope — but the explorer charts by attributes only, so a list
+ * scoped by entity keys alone (a Database page: its endpoints' and members'
+ * keys) would open a project-wide chart of the metric. Such a host either
+ * takes the click itself (`onMetricClick`) or turns the drill-down off
+ * (`disableMetricDrillDown`). Pinned here: the real MetricsViewer's row
+ * wiring with the data loading replaced, and the real MetricRow's two forms.
+ */
+
+const rowProps: Array<{ onClick?: (() => void) | undefined }> = [];
+
+jest.mock("../../../UI/Components/TelemetryViewer/TelemetryViewer", () => {
+  return {
+    __esModule: true,
+    default: (props: {
+      renderRow: (metric: { name: string }) => React.ReactElement;
+    }) => {
+      return props.renderRow({ name: "db.client.operation.duration" });
+    },
+  };
+});
+
+jest.mock(
+  "../../../../App/FeatureSet/Dashboard/src/Components/Metrics/MetricRow",
+  () => {
+    return {
+      __esModule: true,
+      default: (props: { onClick?: (() => void) | undefined }) => {
+        rowProps.push(props);
+        return props.onClick ? (
+          <button onClick={props.onClick}>Open metric</button>
+        ) : (
+          <div>Plain metric</div>
+        );
+      },
+    };
+  },
+);
+
+jest.mock("../../../UI/Utils/ModelAPI/ModelAPI", () => {
+  return {
+    __esModule: true,
+    default: {
+      getList: () => {
+        return Promise.resolve({ data: [], count: 0 });
+      },
+      getCommonHeaders: () => {
+        return {};
+      },
+    },
+  };
+});
+
+jest.mock("../../../UI/Utils/AnalyticsModelAPI/AnalyticsModelAPI", () => {
+  return {
+    __esModule: true,
+    default: {
+      getList: () => {
+        return Promise.resolve({ data: [] });
+      },
+      aggregate: () => {
+        return Promise.resolve({ data: [] });
+      },
+    },
+  };
+});
+
+jest.mock("../../../UI/Utils/API/API", () => {
+  return {
+    __esModule: true,
+    default: {
+      post: () => {
+        return Promise.resolve({ data: { facets: {} } });
+      },
+    },
+  };
+});
+
+jest.mock(
+  "../../../../App/FeatureSet/Dashboard/src/Components/Metrics/Utils/Metrics",
+  () => {
+    return {
+      __esModule: true,
+      default: {
+        getTelemetryAttributes: () => {
+          return Promise.resolve([]);
+        },
+        fetchSparklineAggregates: () => {
+          return Promise.resolve(new Map());
+        },
+      },
+    };
+  },
+);
+
+jest.mock("../../../UI/Utils/Telemetry/UseTelemetryEntityNames", () => {
+  return {
+    __esModule: true,
+    default: () => {
+      return {};
+    },
+  };
+});
+
+import MetricsViewer, {
+  getMetricRowClickHandler,
+} from "../../../../App/FeatureSet/Dashboard/src/Components/Metrics/MetricsViewer";
+import { MetricRowProps } from "../../../../App/FeatureSet/Dashboard/src/Components/Metrics/MetricRow";
+import MetricType from "../../../Models/DatabaseModels/MetricType";
+import ObjectID from "../../../Types/ObjectID";
+import Navigation from "../../../UI/Utils/Navigation";
+import ProjectUtil from "../../../UI/Utils/Project";
+
+const PROJECT_ID: ObjectID = new ObjectID(
+  "11111111-0000-4000-8000-000000000001",
+);
+const DATABASE_KEYS: Array<string> = ["0a1b2c3d4e5f6071", "8a9b0c1d2e3f4051"];
+
+// The module is mocked for the viewer tests above; the row tests need the real one.
+const MetricRow: React.FunctionComponent<MetricRowProps> = (
+  jest.requireActual(
+    "../../../../App/FeatureSet/Dashboard/src/Components/Metrics/MetricRow",
+  ) as { default: React.FunctionComponent<MetricRowProps> }
+).default;
+
+let navigateSpy: ReturnType<typeof jest.spyOn>;
+
+type ViewerProps = React.ComponentProps<typeof MetricsViewer>;
+
+async function renderViewer(props: ViewerProps): Promise<void> {
+  await act(async () => {
+    render(<MetricsViewer {...props} disableUrlSync={true} />);
+  });
+}
+
+beforeEach(() => {
+  rowProps.length = 0;
+  jest.spyOn(ProjectUtil, "getCurrentProjectId").mockReturnValue(PROJECT_ID);
+  navigateSpy = jest.spyOn(Navigation, "navigate").mockImplementation(() => {
+    return undefined;
+  });
+});
+
+afterEach(() => {
+  cleanup();
+  jest.restoreAllMocks();
+});
+
+describe("getMetricRowClickHandler", () => {
+  const METRIC: MetricType = {
+    name: "db.client.connection.count",
+  } as MetricType;
+
+  test("by default a click navigates with the metric", () => {
+    const navigate: MockFunction = getJestMockFunction();
+    const handler: (() => void) | undefined = getMetricRowClickHandler({
+      metric: METRIC,
+      navigate,
+    });
+
+    expect(handler).toBeDefined();
+    handler!();
+    expect(navigate).toHaveBeenCalledWith(METRIC);
+  });
+
+  test("a disabled drill-down has no handler at all", () => {
+    const navigate: MockFunction = getJestMockFunction();
+
+    expect(
+      getMetricRowClickHandler({
+        metric: METRIC,
+        disableMetricDrillDown: true,
+        navigate,
+      }),
+    ).toBeUndefined();
+    expect(navigate).not.toHaveBeenCalled();
+  });
+
+  test("an explicit false keeps the default navigation", () => {
+    const navigate: MockFunction = getJestMockFunction();
+    getMetricRowClickHandler({
+      metric: METRIC,
+      disableMetricDrillDown: false,
+      navigate,
+    })!();
+
+    expect(navigate).toHaveBeenCalledTimes(1);
+  });
+
+  test("the host's handler replaces navigation", () => {
+    const navigate: MockFunction = getJestMockFunction();
+    const onMetricClick: MockFunction = getJestMockFunction();
+
+    getMetricRowClickHandler({
+      metric: METRIC,
+      onMetricClick,
+      navigate,
+    })!();
+
+    expect(onMetricClick).toHaveBeenCalledWith(METRIC);
+    expect(navigate).not.toHaveBeenCalled();
+  });
+
+  test("the host's handler wins over a disabled drill-down", () => {
+    const navigate: MockFunction = getJestMockFunction();
+    const onMetricClick: MockFunction = getJestMockFunction();
+
+    getMetricRowClickHandler({
+      metric: METRIC,
+      onMetricClick,
+      disableMetricDrillDown: true,
+      navigate,
+    })!();
+
+    expect(onMetricClick).toHaveBeenCalledWith(METRIC);
+    expect(navigate).not.toHaveBeenCalled();
+  });
+});
+
+describe("MetricsViewer row drill-down", () => {
+  test("without either prop a row still opens the explorer (unchanged default)", async () => {
+    await renderViewer({ entityKeysFilter: DATABASE_KEYS });
+
+    fireEvent.click(screen.getByRole("button", { name: "Open metric" }));
+
+    expect(navigateSpy).toHaveBeenCalledTimes(1);
+  });
+
+  test("disableMetricDrillDown renders plain rows that never navigate", async () => {
+    await renderViewer({
+      entityKeysFilter: DATABASE_KEYS,
+      disableMetricDrillDown: true,
+    });
+
+    expect(screen.getByText("Plain metric")).toBeInTheDocument();
+    expect(
+      screen.queryByRole("button", { name: "Open metric" }),
+    ).not.toBeInTheDocument();
+    expect(rowProps.length).toBeGreaterThan(0);
+    for (const props of rowProps) {
+      expect(props.onClick).toBeUndefined();
+    }
+    expect(navigateSpy).not.toHaveBeenCalled();
+  });
+
+  test("onMetricClick receives the clicked metric and the explorer is not opened", async () => {
+    const onMetricClick: MockFunction = getJestMockFunction();
+
+    await renderViewer({ entityKeysFilter: DATABASE_KEYS, onMetricClick });
+
+    fireEvent.click(screen.getByRole("button", { name: "Open metric" }));
+
+    expect(onMetricClick).toHaveBeenCalledTimes(1);
+    expect((onMetricClick.mock.calls[0]![0] as MetricType).name).toBe(
+      "db.client.operation.duration",
+    );
+    expect(navigateSpy).not.toHaveBeenCalled();
+  });
+});
+
+describe("MetricRow", () => {
+  const METRIC: MetricType = {
+    name: "postgresql.backends",
+    description: "Number of backends",
+  } as MetricType;
+
+  test("with a handler it is a button offering Explore", () => {
+    const onClick: MockFunction = getJestMockFunction();
+    render(<MetricRow metric={METRIC} onClick={onClick} />);
+
+    const row: HTMLElement = screen.getByTestId("metric-row");
+    expect(row.tagName).toBe("BUTTON");
+    expect(screen.getByText("Explore")).toBeInTheDocument();
+
+    fireEvent.click(row);
+    expect(onClick).toHaveBeenCalledTimes(1);
+  });
+
+  test("without a handler it is a plain entry: no button, no Explore affordance", () => {
+    render(<MetricRow metric={METRIC} />);
+
+    const row: HTMLElement = screen.getByTestId("metric-row");
+    expect(row.tagName).toBe("DIV");
+    expect(screen.queryByRole("button")).not.toBeInTheDocument();
+    expect(screen.queryByText("Explore")).not.toBeInTheDocument();
+    // The metric itself still reads the same.
+    expect(screen.getByText("postgresql.backends")).toBeInTheDocument();
+    expect(screen.getByText("Number of backends")).toBeInTheDocument();
+  });
+});