@oneuptime/common 13.0.6 → 13.0.8

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

@@ -1,5 +1,12 @@
 import "@testing-library/jest-dom";
-import { afterEach, describe, expect, jest, test } from "@jest/globals";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
 import {
   cleanup,
   fireEvent,
@@ -93,6 +100,25 @@ jest.mock("react-i18next", () => {
   };
 });
 
+/*
+ * axios is a pass-through spy: every call still goes to the real axios, so
+ * nothing else in this file behaves differently. Only the lapsed-session
+ * regression below scripts it, to drive the REAL browser client (not the mock
+ * above) through a 401, a refresh and a replay.
+ */
+jest.mock("axios", () => {
+  const actualAxios: (...args: Array<unknown>) => unknown = jest.requireActual(
+    "axios",
+  ) as (...args: Array<unknown>) => unknown;
+
+  return Object.assign(
+    jest.fn((...args: Array<unknown>): unknown => {
+      return actualAxios(...args);
+    }),
+    actualAxios,
+  );
+});
+
 import EscalationRules from "../../../../App/FeatureSet/Dashboard/src/Components/OnCallPolicy/EscalationRule/EscalationRules";
 import {
   ResponderGroupRef,
@@ -125,9 +151,24 @@ import {
   parseReadinessSummary,
 } from "../../../../App/FeatureSet/Dashboard/src/Components/OnCallPolicy/Readiness/ReadinessTypes";
 import HTTPErrorResponse from "../../../Types/API/HTTPErrorResponse";
+import HTTPMethod from "../../../Types/API/HTTPMethod";
 import HTTPResponse from "../../../Types/API/HTTPResponse";
+import Route from "../../../Types/API/Route";
+import URL from "../../../Types/API/URL";
 import { JSONObject } from "../../../Types/JSON";
 import ObjectID from "../../../Types/ObjectID";
+import { APP_API_URL, IDENTITY_URL } from "../../../UI/Config";
+import type RealBaseAPI from "../../../UI/Utils/API/API";
+import Navigation from "../../../UI/Utils/Navigation";
+import User from "../../../UI/Utils/User";
+import FakeAxiosServer, {
+  FakeTransport,
+  SentRequest,
+} from "../../UI/Utils/API/FakeAxiosServer";
+import axios from "axios";
+import fs from "fs";
+import type { SpyInstance } from "jest-mock";
+import path from "path";
 
 const USER_ALEX: string = "aaaaaaaa-1111-4111-8111-111111111111";
 const USER_SAM: string = "bbbbbbbb-2222-4222-8222-222222222222";
@@ -1624,6 +1665,240 @@ describe("Sending the reminder", () => {
   });
 });
 
+/*
+ * ---------------------------------------------------------------------------
+ * THE REMINDER AFTER THE SESSION LAPSED
+ * ---------------------------------------------------------------------------
+ *
+ * The customer's report, reproduced. The Dashboard was left open for more than
+ * fifteen minutes, so the browser had already dropped the access-token cookie
+ * (its maxAge is the JWT's lifetime) when "Send setup reminder" was pressed.
+ * The request reached the server with no credentials, and the reminder came
+ * back "You are not authorized to access this project's data." - a 422, which
+ * the browser client has no reason to treat as a lapsed session, so it never
+ * refreshed and the reminder was reported as failed.
+ *
+ * The server now answers a request with no credentials 401, and the client
+ * refreshes on a 401 and replays. These cases run requestSetupReminders
+ * through the REAL browser client rather than the API mock the rest of this
+ * file uses: the mock's post is pointed at the actual BaseAPI.post, and axios
+ * underneath it is scripted like a server.
+ */
+describe("Sending the reminder after the session lapsed", () => {
+  const SEND_URL: string = URL.fromString(APP_API_URL.toString())
+    .addRoute("/on-call-readiness/send-setup-reminder")
+    .toString();
+
+  const REFRESH_URL: string = URL.fromString(IDENTITY_URL.toString())
+    .addRoute("/refresh-token")
+    .toString();
+
+  const NO_CREDENTIALS_BODY: JSONObject = {
+    message: "Authentication required. Please log in to access this resource.",
+  };
+
+  const realBaseAPI: typeof RealBaseAPI = (
+    jest.requireActual("../../../UI/Utils/API/API") as {
+      default: typeof RealBaseAPI;
+    }
+  ).default;
+
+  const mockedAxios: FakeTransport = axios as unknown as FakeTransport;
+
+  let server: FakeAxiosServer;
+  let logoutSpy: SpyInstance<typeof User.logout>;
+  let navigateSpy: SpyInstance<typeof Navigation.navigate>;
+  let currentRouteSpy: SpyInstance<typeof Navigation.getCurrentRoute>;
+
+  beforeEach(() => {
+    server = new FakeAxiosServer(mockedAxios);
+
+    getCommonHeadersMock.mockReturnValue({ tenantid: PROJECT_ID.toString() });
+
+    postMock.mockImplementation((...args: Array<any>): Promise<unknown> => {
+      return realBaseAPI.post(args[0]);
+    });
+
+    logoutSpy = jest.spyOn(User, "logout").mockImplementation((): void => {});
+
+    navigateSpy = jest
+      .spyOn(Navigation, "navigate")
+      .mockImplementation((): void => {});
+
+    currentRouteSpy = jest
+      .spyOn(Navigation, "getCurrentRoute")
+      .mockReturnValue(
+        new Route(`/dashboard/${PROJECT_ID.toString()}/on-call-duty`),
+      );
+  });
+
+  afterEach(() => {
+    logoutSpy.mockRestore();
+    navigateSpy.mockRestore();
+    currentRouteSpy.mockRestore();
+
+    // Back to the pass-through the rest of this file runs on.
+    const actualAxios: (...args: Array<unknown>) => unknown =
+      jest.requireActual("axios") as (...args: Array<unknown>) => unknown;
+
+    mockedAxios.mockImplementation(((...args: Array<unknown>): unknown => {
+      return actualAxios(...args);
+    }) as never);
+  });
+
+  type SentFunction = () => Array<string>;
+
+  const sentOnTheWire: SentFunction = (): Array<string> => {
+    return server.sent.map((request: SentRequest): string => {
+      return `${request.method.toUpperCase()} ${request.url}`;
+    });
+  };
+
+  test("a reminder refused 401 is refreshed, replayed, and reported as SENT", async () => {
+    server
+      .on(HTTPMethod.POST, SEND_URL, [
+        { status: 401, data: NO_CREDENTIALS_BODY },
+        {
+          status: 200,
+          data: {
+            sentCount: 1,
+            results: [
+              { userId: USER_ALEX, outcome: "Sent", message: "Emailed." },
+            ],
+          },
+        },
+      ])
+      .on(HTTPMethod.POST, REFRESH_URL, [{ status: 200 }]);
+
+    const statuses: SetupReminderStatuses = await requestSetupReminders([
+      USER_ALEX,
+    ]);
+
+    // Not the "failed" / "not authorized" state from the customer's screenshot.
+    expect(statuses).toEqual({
+      [USER_ALEX]: { state: "sent", message: "Emailed." },
+    });
+
+    expect(sentOnTheWire()).toEqual([
+      `POST ${SEND_URL}`,
+      `POST ${REFRESH_URL}`,
+      `POST ${SEND_URL}`,
+    ]);
+
+    // The replay is the same reminder, for the same project, sent once more.
+    const replay: SentRequest = server.sent[2]!;
+
+    expect(replay.data).toEqual({ userIds: [USER_ALEX] });
+    expect(replay.data).toEqual(server.sent[0]!.data);
+    expect(replay.headers["tenantid"]).toBe(PROJECT_ID.toString());
+
+    // The lapse is invisible: nobody is logged out, nothing navigates.
+    expect(logoutSpy).not.toHaveBeenCalled();
+    expect(navigateSpy).not.toHaveBeenCalled();
+  });
+
+  test("a batch refused 401 is replayed as one batch, and each person is reported", async () => {
+    server
+      .on(HTTPMethod.POST, SEND_URL, [
+        { status: 401, data: NO_CREDENTIALS_BODY },
+        {
+          status: 200,
+          data: {
+            sentCount: 1,
+            results: [
+              { userId: USER_ALEX, outcome: "Sent", message: "Emailed." },
+              {
+                userId: USER_SAM,
+                outcome: "SkippedThrottled",
+                message: "Already reminded in the last 24 hours.",
+              },
+            ],
+          },
+        },
+      ])
+      .on(HTTPMethod.POST, REFRESH_URL, [{ status: 200 }]);
+
+    const statuses: SetupReminderStatuses = await requestSetupReminders([
+      USER_ALEX,
+      USER_SAM,
+    ]);
+
+    expect(statuses[USER_ALEX]).toEqual({ state: "sent", message: "Emailed." });
+    expect(statuses[USER_SAM]).toEqual({
+      state: "skipped",
+      message: "Already reminded in the last 24 hours.",
+    });
+    expect(server.requestsTo(HTTPMethod.POST, REFRESH_URL)).toHaveLength(1);
+    expect(server.requestsTo(HTTPMethod.POST, SEND_URL)).toHaveLength(2);
+  });
+
+  /*
+   * The symptom itself, kept as a contrast: had the server kept answering 422
+   * for a request with no credentials, the client could not have told it from
+   * a real permission refusal, and correctly would not have refreshed. The
+   * reminder stays failed. This is why the fix is a 401 on the server and not
+   * a wider net on the client.
+   */
+  test("the old 422 answer is terminal: no refresh, no replay, reported as failed", async () => {
+    server.on(HTTPMethod.POST, SEND_URL, [
+      {
+        status: 422,
+        data: {
+          message: "You are not authorized to access this project's data.",
+        },
+      },
+    ]);
+
+    const statuses: SetupReminderStatuses = await requestSetupReminders([
+      USER_ALEX,
+    ]);
+
+    expect(statuses[USER_ALEX]!.state).toBe("failed");
+    expect(sentOnTheWire()).toEqual([`POST ${SEND_URL}`]);
+    expect(logoutSpy).not.toHaveBeenCalled();
+  });
+
+  test("a session that cannot be refreshed reports the reminder as not sent and goes to login", async () => {
+    server
+      .on(HTTPMethod.POST, SEND_URL, [
+        { status: 401, data: NO_CREDENTIALS_BODY },
+      ])
+      .on(HTTPMethod.POST, REFRESH_URL, [{ status: 401 }]);
+
+    const statuses: SetupReminderStatuses = await requestSetupReminders([
+      USER_ALEX,
+    ]);
+
+    // A 401 is refused before any mail is sent, so "not sent" is certain.
+    expect(statuses[USER_ALEX]!.state).toBe("failed");
+    // Never replayed: the reminder was not sent twice behind the reader's back.
+    expect(server.requestsTo(HTTPMethod.POST, SEND_URL)).toHaveLength(1);
+    expect(logoutSpy).toHaveBeenCalled();
+    expect(navigateSpy).toHaveBeenCalledWith(new Route("/accounts/login"), {
+      forceNavigate: true,
+    });
+  });
+
+  /*
+   * The mock at the top of this file stands in for the refresh-aware client,
+   * so every other test here would pass just the same if the reminder were
+   * sent through the bare Common/Utils/API - which has no refresh at all. Pin
+   * the import itself.
+   */
+  test("the reminder is sent through the refresh-aware client", () => {
+    const source: string = fs.readFileSync(
+      path.join(
+        __dirname,
+        "../../../../App/FeatureSet/Dashboard/src/Components/OnCallPolicy/EscalationRule/EscalationRuleReadiness.tsx",
+      ),
+      "utf8",
+    );
+
+    expect(source).toMatch(/import API from "Common\/UI\/Utils\/API\/API";/);
+    expect(source).not.toMatch(/from "Common\/Utils\/API"/);
+  });
+});
+
 /*
  * ---------------------------------------------------------------------------
  * EXPANDING TEAMS AND SCHEDULES

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

@@ -0,0 +1,255 @@
+import { describe, expect, test } from "@jest/globals";
+import {
+  EventOverlayScope,
+  getEventOverlayScope,
+} from "../../../../App/FeatureSet/Dashboard/src/Components/Metrics/Utils/EventOverlayScope";
+import Includes from "../../../Types/BaseDatabase/Includes";
+import MetricQueryConfigData from "../../../Types/Metrics/MetricQueryConfigData";
+
+type Attributes = Record<string, string | number | Includes>;
+
+const RESOURCE_ID: string = "11111111-0000-4000-8000-000000000001";
+const MACHINE_ID: string = "machine-id-from-the-otel-agent";
+const HOST_ID_ATTRIBUTES: Array<string> = ["host.id", "resource.host.id"];
+const VMWARE_CHILD_ATTRIBUTES: Array<string> = [
+  "vcenter.vm_template.id",
+  "resource.vcenter.vm_template.id",
+  "vcenter.vm_template.name",
+  "resource.vcenter.vm_template.name",
+  "vcenter.resource_pool.inventory_path",
+  "resource.vcenter.resource_pool.inventory_path",
+];
+const SERIES_ATTRIBUTES: Array<string> = [
+  "container.image.name",
+  "resource.container.image.name",
+  "service.instance.id",
+  "resource.service.instance.id",
+];
+const PROCESS_ATTRIBUTES: Array<string> = [
+  "process.pid",
+  "resource.process.pid",
+  "process.start_time",
+  "resource.process.start_time",
+];
+
+function scope(
+  attributes: Attributes,
+  eventScope?: Attributes,
+): EventOverlayScope {
+  const config: MetricQueryConfigData = {
+    metricQueryData: {
+      filterData: {
+        metricName: "system.cpu.utilization",
+        attributes: attributes,
+      },
+    },
+    ...(eventScope === undefined ? {} : { eventScope: eventScope }),
+  };
+  return getEventOverlayScope([config]);
+}
+
+function expectDatabaseQueries(
+  result: EventOverlayScope,
+  expected: Array<Record<string, unknown>>,
+): void {
+  expect(result.incidentQueries).toEqual(expected);
+  expect(result.alertQueries).toEqual(expected);
+}
+
+describe("OpenTelemetry host machine identity", (): void => {
+  test.each(HOST_ID_ATTRIBUTES)(
+    "%s selects Host.hostId for an arbitrary machine identifier",
+    (attribute: string): void => {
+      const result: EventOverlayScope = scope({ [attribute]: MACHINE_ID });
+
+      expectDatabaseQueries(result, [{ hosts: { hostId: MACHINE_ID } }]);
+      expect(result.changeEventQueries).toEqual([
+        { attributes: { [attribute]: MACHINE_ID } },
+      ]);
+    },
+  );
+
+  test.each(HOST_ID_ATTRIBUTES)(
+    "%s keeps a UUID-shaped machine identifier separate from the database ID",
+    (attribute: string): void => {
+      expectDatabaseQueries(scope({ [attribute]: RESOURCE_ID }), [
+        { hosts: { hostId: RESOURCE_ID } },
+      ]);
+    },
+  );
+
+  test.each(HOST_ID_ATTRIBUTES)(
+    "%s expands machine membership into exact hostId queries",
+    (attribute: string): void => {
+      const result: EventOverlayScope = scope({
+        [attribute]: new Includes(["machine-b", "machine-a", "machine-b"]),
+      });
+
+      expectDatabaseQueries(result, [
+        { hosts: { hostId: "machine-a" } },
+        { hosts: { hostId: "machine-b" } },
+      ]);
+      expect(result.changeEventQueries).toEqual([
+        { attributes: { [attribute]: "machine-a" } },
+        { attributes: { [attribute]: "machine-b" } },
+      ]);
+    },
+  );
+
+  test.each(HOST_ID_ATTRIBUTES)(
+    "%s intersects the hostname on the same Host relation",
+    (attribute: string): void => {
+      const attributes: Attributes = {
+        [attribute]: MACHINE_ID,
+        "resource.host.name": "checkout-prod",
+      };
+      const result: EventOverlayScope = scope(attributes);
+
+      expectDatabaseQueries(result, [
+        { hosts: { hostId: MACHINE_ID, hostIdentifier: "checkout-prod" } },
+      ]);
+      expect(result.changeEventQueries).toEqual([{ attributes: attributes }]);
+    },
+  );
+});
+
+describe("VMware child resource identity", (): void => {
+  test.each(VMWARE_CHILD_ATTRIBUTES)(
+    "%s constrains the breaching series without a parent filter",
+    (attribute: string): void => {
+      const attributes: Attributes = { [attribute]: "inventory/child-a" };
+      const result: EventOverlayScope = scope(attributes);
+
+      expectDatabaseQueries(result, [{ seriesLabels: attributes }]);
+      expect(result.changeEventQueries).toEqual([{ attributes: attributes }]);
+    },
+  );
+
+  test.each(VMWARE_CHILD_ATTRIBUTES)(
+    "%s retains both the vCenter and child identity",
+    (attribute: string): void => {
+      const attributes: Attributes = {
+        "resource.vmware.vcenter.name": "vcenter-prod",
+        [attribute]: "inventory/child-a",
+      };
+      const result: EventOverlayScope = scope(attributes);
+
+      expectDatabaseQueries(result, [
+        {
+          vmwareVCenters: { name: "vcenter-prod" },
+          seriesLabels: { [attribute]: "inventory/child-a" },
+        },
+      ]);
+      expect(result.changeEventQueries).toEqual([{ attributes: attributes }]);
+    },
+  );
+});
+
+describe("image and service instance identity", (): void => {
+  test.each(SERIES_ATTRIBUTES)(
+    "%s narrows events to the exact breaching series",
+    (attribute: string): void => {
+      const attributes: Attributes = { [attribute]: "checkout-a" };
+      const result: EventOverlayScope = scope(attributes);
+
+      expectDatabaseQueries(result, [{ seriesLabels: attributes }]);
+      expect(result.changeEventQueries).toEqual([{ attributes: attributes }]);
+    },
+  );
+
+  test.each(["container.image.name", "resource.container.image.name"])(
+    "%s retains Docker runtime and host restrictions",
+    (attribute: string): void => {
+      const attributes: Attributes = {
+        "resource.host.name": "docker-prod",
+        "resource.container.runtime": "docker",
+        [attribute]: "registry.example/checkout:v2",
+      };
+      const result: EventOverlayScope = scope(attributes);
+
+      expectDatabaseQueries(result, [
+        {
+          dockerHosts: { hostIdentifier: "docker-prod" },
+          seriesLabels: { [attribute]: "registry.example/checkout:v2" },
+        },
+      ]);
+      expect(result.changeEventQueries).toEqual([{ attributes: attributes }]);
+    },
+  );
+
+  test.each(["service.instance.id", "resource.service.instance.id"])(
+    "%s keeps the selected instance within the selected service",
+    (attribute: string): void => {
+      const attributes: Attributes = {
+        "resource.service.name": "checkout",
+        [attribute]: "checkout-instance-a",
+      };
+      const result: EventOverlayScope = scope(attributes);
+
+      expectDatabaseQueries(result, [
+        {
+          services: { name: "checkout" },
+          seriesLabels: { [attribute]: "checkout-instance-a" },
+        },
+      ]);
+      expect(result.changeEventQueries).toEqual([{ attributes: attributes }]);
+    },
+  );
+});
+
+describe("unsupported child resource scope", (): void => {
+  test.each(["serviceId", "hostId", "vmwareVCenterId"])(
+    "unknown explicit child identity cannot fall back to its known %s parent",
+    (parentAttribute: string): void => {
+      const result: EventOverlayScope = scope(
+        {},
+        {
+          [parentAttribute]: RESOURCE_ID,
+          "custom.child.id": "child-a",
+        },
+      );
+
+      expectDatabaseQueries(result, []);
+      expect(result.changeEventQueries).toEqual([]);
+    },
+  );
+
+  test("unknown explicit child metadata cannot use a parent from chart attributes as a fallback", (): void => {
+    const result: EventOverlayScope = scope(
+      { "resource.service.name": "checkout" },
+      { "custom.child.id": "child-a" },
+    );
+
+    expectDatabaseQueries(result, []);
+    expect(result.changeEventQueries).toEqual([]);
+  });
+
+  test.each(PROCESS_ATTRIBUTES)(
+    "%s never produces project-wide incident or alert queries",
+    (attribute: string): void => {
+      const attributes: Attributes = {
+        [attribute]: attribute.endsWith("pid") ? 412 : "2026-09-01T10:00:00Z",
+      };
+      const result: EventOverlayScope = scope(attributes);
+
+      expectDatabaseQueries(result, []);
+      expect(result.changeEventQueries).toEqual([
+        { attributes: { [attribute]: String(attributes[attribute]) } },
+      ]);
+    },
+  );
+
+  test.each(PROCESS_ATTRIBUTES)(
+    "%s keeps its restriction when combined with a known service parent",
+    (attribute: string): void => {
+      const attributes: Attributes = {
+        "resource.service.name": "checkout",
+        [attribute]: "process-a",
+      };
+      const result: EventOverlayScope = scope(attributes);
+
+      expectDatabaseQueries(result, []);
+      expect(result.changeEventQueries).toEqual([{ attributes: attributes }]);
+    },
+  );
+});