@oneuptime/common 13.0.5 → 13.0.6

package/Tests/Server/Utils/SecurityEvent/ConnectorErrorMessage.test.ts

@@ -1,6 +1,6 @@
 import { generateKeyPairSync } from "crypto";
 import DetectionRule from "../../../../Models/DatabaseModels/DetectionRule";
-import GoogleSecOpsConnection from "../../../../Models/DatabaseModels/GoogleSecOpsConnection";
+import SecurityEventConnection from "../../../../Models/DatabaseModels/SecurityEventConnection";
 import logger from "../../../../Server/Utils/Logger";
 import ConnectorErrorMessage, {
   MAX_CONNECTOR_ERROR_MESSAGE_LENGTH,
@@ -8,7 +8,7 @@ import ConnectorErrorMessage, {
 import GoogleSecOpsClient, {
   FetchLike,
   FetchResponseLike,
-} from "../../../../Server/Utils/SecurityEvent/GoogleSecOps/GoogleSecOpsClient";
+} from "../../../../Server/Utils/SecurityEvent/Connectors/GoogleSecOps/GoogleSecOpsClient";
 import { getMaxLengthFromTableColumnType } from "../../../../Types/Database/ColumnLength";
 import { TableColumnMetadata } from "../../../../Types/Database/TableColumn";
 import TableColumnType from "../../../../Types/Database/TableColumnType";
@@ -811,16 +811,16 @@ describe("ConnectorErrorMessage.recordFailure", () => {
 });
 
 describe("the lastError columns the clamp writes into", () => {
-  test("GoogleSecOpsConnection.lastError is unbounded text", () => {
+  test("SecurityEventConnection.lastError is unbounded text", () => {
     const metadata: TableColumnMetadata =
-      new GoogleSecOpsConnection().getTableColumnMetadata("lastError");
+      new SecurityEventConnection().getTableColumnMetadata("lastError");
 
     expect(metadata.type).toBe(TableColumnType.VeryLongText);
   });
 
-  test("GoogleSecOpsConnection.lastError has no max length, so a clamped message cannot be rejected", () => {
+  test("SecurityEventConnection.lastError has no max length, so a clamped message cannot be rejected", () => {
     const metadata: TableColumnMetadata =
-      new GoogleSecOpsConnection().getTableColumnMetadata("lastError");
+      new SecurityEventConnection().getTableColumnMetadata("lastError");
 
     /*
      * checkMaxLengthOfFields only length-checks a column when
@@ -867,7 +867,7 @@ describe("the lastError columns the clamp writes into", () => {
       new Error(repeatToLength("clickhouse query fragment ", 50000)),
     );
 
-    for (const model of [new GoogleSecOpsConnection(), new DetectionRule()]) {
+    for (const model of [new SecurityEventConnection(), new DetectionRule()]) {
       const metadata: TableColumnMetadata =
         model.getTableColumnMetadata("lastError");
       const maxLength: number | undefined = getMaxLengthFromTableColumnType(
@@ -884,7 +884,7 @@ describe("the lastError columns the clamp writes into", () => {
 
   test("both columns stay nullable and optional, so a successful run can clear them", () => {
     const connectionMetadata: TableColumnMetadata =
-      new GoogleSecOpsConnection().getTableColumnMetadata("lastError");
+      new SecurityEventConnection().getTableColumnMetadata("lastError");
     const ruleMetadata: TableColumnMetadata =
       new DetectionRule().getTableColumnMetadata("lastError");
 

package/Tests/Server/Utils/SecurityEvent/Connectors/ConnectorFetchSummary.test.ts

@@ -0,0 +1,261 @@
+import {
+  ConnectorFetchFailureSummary,
+  attachConnectorChecks,
+  attachConnectorFetchSummary,
+  readConnectorChecks,
+  readConnectorFetchSummary,
+} from "../../../../../Server/Utils/SecurityEvent/Connectors/Types";
+import APIException from "../../../../../Types/Exception/ApiException";
+import { JSONObject } from "../../../../../Types/JSON";
+import { SecurityConnectorCheck } from "../../../../../Types/SecurityEvent/Connectors/ConnectorDiagnostics";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * attachConnectorFetchSummary / readConnectorFetchSummary: how a connector
+ * that reads in passes hands what those passes gathered (warnings, request
+ * and record counts, provider details) to the poller on the error it
+ * throws. What is pinned is that the original error is never changed in
+ * type or message, never gains an enumerable property, never turns into a
+ * TypeError when it cannot take the property, and that the poller only
+ * ever reads a well-formed summary back.
+ */
+
+const SUMMARY: ConnectorFetchFailureSummary = {
+  warnings: [
+    "Curated rule detections could not be read (HTTP 403); this tenant may not have curated rule access. Rule detections and the alerts view were still read.",
+  ],
+  requestCount: 3,
+  fetchedCount: 2,
+  details: {
+    basis: "created-time",
+    sourceCounts: { ruleDetections: 2, curatedDetections: 0, alertsView: 0 },
+    includeNonAlertingDetections: false,
+  },
+};
+
+const PROPERTY: string = "oneuptimeConnectorFetchSummary";
+
+describe("attachConnectorFetchSummary and readConnectorFetchSummary", () => {
+  test("a summary attached to an error reads back equal, and the error keeps its identity, type and message", () => {
+    const original: APIException = new APIException(
+      "Google SecOps alerts fetch failed (HTTP 500): internal",
+    );
+
+    const returned: APIException = attachConnectorFetchSummary(
+      original,
+      SUMMARY,
+    );
+
+    expect(returned).toBe(original);
+    expect(returned).toBeInstanceOf(APIException);
+    expect(returned.message).toBe(
+      "Google SecOps alerts fetch failed (HTTP 500): internal",
+    );
+    expect(readConnectorFetchSummary(returned)).toEqual(SUMMARY);
+  });
+
+  test("the summary stays off the error's enumerable properties and out of its JSON", () => {
+    const error: Error = attachConnectorFetchSummary(
+      new Error("boom"),
+      SUMMARY,
+    );
+
+    expect(Object.keys(error)).not.toContain(PROPERTY);
+    expect(JSON.stringify({ ...error })).not.toContain("Curated");
+  });
+
+  test("a summary with no details reads back without a details key", () => {
+    const error: Error = attachConnectorFetchSummary(new Error("boom"), {
+      warnings: [],
+      requestCount: 1,
+      fetchedCount: 0,
+    });
+
+    const summary: ConnectorFetchFailureSummary | undefined =
+      readConnectorFetchSummary(error);
+
+    expect(summary).toEqual({ warnings: [], requestCount: 1, fetchedCount: 0 });
+    expect(summary).not.toHaveProperty("details");
+  });
+
+  test("the read is a copy: appending to its warnings leaves what the error carries unchanged", () => {
+    const error: Error = attachConnectorFetchSummary(new Error("boom"), {
+      warnings: ["first"],
+      requestCount: 1,
+      fetchedCount: 0,
+    });
+
+    readConnectorFetchSummary(error)!.warnings.push("appended by a caller");
+
+    expect(readConnectorFetchSummary(error)!.warnings).toEqual(["first"]);
+  });
+
+  test("checks and a summary ride on the same error independently", () => {
+    const checks: Array<SecurityConnectorCheck> = [
+      {
+        key: "read-alerts-view",
+        name: "Read alerts view by detection time",
+        status: "fail",
+        durationMs: 1,
+        message: "boom",
+      },
+    ];
+    const error: Error = attachConnectorFetchSummary(
+      attachConnectorChecks(new Error("boom"), checks),
+      SUMMARY,
+    );
+
+    expect(readConnectorChecks(error)).toEqual(checks);
+    expect(readConnectorFetchSummary(error)).toEqual(SUMMARY);
+  });
+
+  test("an error that never had a summary reads undefined", () => {
+    expect(readConnectorFetchSummary(new Error("boom"))).toBeUndefined();
+    expect(
+      readConnectorFetchSummary(attachConnectorChecks(new Error("boom"), [])),
+    ).toBeUndefined();
+  });
+
+  test.each<[string, unknown]>([
+    ["a string", "socket hang up"],
+    ["a number", 42],
+    ["null", null],
+    ["undefined", undefined],
+    ["false", false],
+  ])(
+    "a thrown value that is %s is returned as it was and reads undefined",
+    (_label: string, thrown: unknown) => {
+      expect(attachConnectorFetchSummary(thrown, SUMMARY)).toBe(thrown);
+      expect(readConnectorFetchSummary(thrown)).toBeUndefined();
+    },
+  );
+
+  test("a frozen error cannot take the summary: attaching neither throws nor replaces the error, and reading finds nothing", () => {
+    const original: Error = Object.freeze(new Error("frozen"));
+
+    let returned: Error | undefined = undefined;
+    expect(() => {
+      returned = attachConnectorFetchSummary(original, SUMMARY);
+    }).not.toThrow();
+
+    expect(returned).toBe(original);
+    expect(readConnectorFetchSummary(original)).toBeUndefined();
+  });
+
+  test("a non-extensible error is handled like a frozen one", () => {
+    const original: Error = Object.preventExtensions(new Error("sealed"));
+
+    expect(attachConnectorFetchSummary(original, SUMMARY)).toBe(original);
+    expect(readConnectorFetchSummary(original)).toBeUndefined();
+  });
+
+  test.each<[string, Error]>([
+    ["frozen", Object.freeze(new Error("frozen"))],
+    ["non-extensible", Object.preventExtensions(new Error("sealed"))],
+  ])(
+    "attachConnectorChecks on a %s error neither throws nor replaces it, so the connector rethrows the original",
+    (_label: string, original: Error) => {
+      const checks: Array<SecurityConnectorCheck> = [
+        {
+          key: "read-rule-detections",
+          name: "Read rule detections by created time",
+          status: "fail",
+          durationMs: 1,
+          message: "boom",
+        },
+      ];
+
+      let returned: Error | undefined = undefined;
+      expect(() => {
+        returned = attachConnectorChecks(original, checks);
+      }).not.toThrow();
+
+      expect(returned).toBe(original);
+      expect(readConnectorChecks(original)).toBeUndefined();
+    },
+  );
+
+  test.each<[string, unknown]>([
+    ["null", null],
+    ["a string", "summary"],
+    ["an array", [SUMMARY]],
+    [
+      "warnings that are not an array",
+      { warnings: "one warning", requestCount: 1, fetchedCount: 0 },
+    ],
+    ["no warnings", { requestCount: 1, fetchedCount: 0 }],
+    ["no requestCount", { warnings: [], fetchedCount: 0 }],
+    ["no fetchedCount", { warnings: [], requestCount: 1 }],
+    [
+      "a requestCount that is a string",
+      { warnings: [], requestCount: "3", fetchedCount: 0 },
+    ],
+    [
+      "a negative fetchedCount",
+      { warnings: [], requestCount: 1, fetchedCount: -1 },
+    ],
+    [
+      "a requestCount that is not a number",
+      { warnings: [], requestCount: Number.NaN, fetchedCount: 0 },
+    ],
+    [
+      "an infinite fetchedCount",
+      {
+        warnings: [],
+        requestCount: 1,
+        fetchedCount: Number.POSITIVE_INFINITY,
+      },
+    ],
+  ])(
+    "a stored summary with %s is ignored",
+    (_label: string, stored: unknown) => {
+      const error: Error = attachConnectorFetchSummary(
+        new Error("boom"),
+        stored as ConnectorFetchFailureSummary,
+      );
+
+      expect(readConnectorFetchSummary(error)).toBeUndefined();
+    },
+  );
+
+  test("warnings that are not strings are dropped and the rest are kept in order", () => {
+    const error: Error = attachConnectorFetchSummary(new Error("boom"), {
+      warnings: ["first", 7, null, { text: "no" }, "second"],
+      requestCount: 2,
+      fetchedCount: 1,
+    } as unknown as ConnectorFetchFailureSummary);
+
+    expect(readConnectorFetchSummary(error)).toEqual({
+      warnings: ["first", "second"],
+      requestCount: 2,
+      fetchedCount: 1,
+    });
+  });
+
+  test.each<[string, unknown]>([
+    ["null", null],
+    ["a string", "created-time"],
+    ["an array", [{ basis: "created-time" }]],
+    ["a number", 3],
+  ])(
+    "details that are %s are left out while the rest of the summary is kept",
+    (_label: string, details: unknown) => {
+      const error: Error = attachConnectorFetchSummary(new Error("boom"), {
+        warnings: ["kept"],
+        requestCount: 1,
+        fetchedCount: 0,
+        details: details as JSONObject,
+      });
+
+      const summary: ConnectorFetchFailureSummary | undefined =
+        readConnectorFetchSummary(error);
+
+      expect(summary).toEqual({
+        warnings: ["kept"],
+        requestCount: 1,
+        fetchedCount: 0,
+      });
+      expect(summary).not.toHaveProperty("details");
+    },
+  );
+});

package/Tests/Server/Utils/SecurityEvent/Connectors/ConnectorPlatformHealth.test.ts

@@ -323,15 +323,33 @@ describe("ConnectorPlatformHealth.getPlatformStatus", () => {
     expect(getJobSchedulers).toHaveBeenCalledWith(0, 1000, true);
   });
 
-  test("either connector family's scheduler counts as registered, by its raw job name", () => {
+  test("only the Security Event Connections poll cron counts as the scheduler, by its raw job name", () => {
     /*
-     * The raw RunCron names, colon included: BullMQ reports `name` as
-     * passed to queue.add, never the sanitized jobId.
+     * The raw RunCron name, colon included: BullMQ reports `name` as passed
+     * to queue.add, never the sanitized jobId. Google SecOps is polled by
+     * this cron now; its retired cron name must not be listed.
      */
-    expect(CONNECTOR_SCHEDULER_JOB_NAMES).toEqual([
-      GOOGLE_POLL_JOB,
-      GENERIC_POLL_JOB,
-    ]);
+    expect(CONNECTOR_SCHEDULER_JOB_NAMES).toEqual([GENERIC_POLL_JOB]);
+    expect(CONNECTOR_SCHEDULER_JOB_NAMES).not.toContain(GOOGLE_POLL_JOB);
+  });
+
+  test("the retired Google SecOps cron is not a connector scheduler, by name or by key", () => {
+    expect(
+      ConnectorPlatformHealth.isConnectorScheduler(
+        bullmqRepeatable(GOOGLE_POLL_JOB, NEXT_TICK_MS),
+      ),
+    ).toBe(false);
+    expect(
+      ConnectorPlatformHealth.isConnectorScheduler({
+        key: legacyRepeatKey(GOOGLE_POLL_JOB),
+        name: "SecurityEvents",
+      }),
+    ).toBe(false);
+    expect(
+      ConnectorPlatformHealth.isConnectorScheduler(
+        bullmqRepeatable(GENERIC_POLL_JOB),
+      ),
+    ).toBe(true);
   });
 
   test("a healthy registration, in the exact shape BullMQ returns, passes the scheduler check", async () => {
@@ -507,7 +525,7 @@ describe("ConnectorPlatformHealth.getPlatformStatus", () => {
           getJobSchedulers: (): Promise<Array<FakeScheduler | undefined>> => {
             return Promise.resolve([
               undefined,
-              bullmqRepeatable(GOOGLE_POLL_JOB, NEXT_TICK_MS),
+              bullmqRepeatable(GENERIC_POLL_JOB, NEXT_TICK_MS),
             ]);
           },
         }),
@@ -531,29 +549,65 @@ describe("ConnectorPlatformHealth.getPlatformStatus", () => {
     ).toBe(false);
   });
 
-  test("the Google scheduler alone marks the scheduler registered", async () => {
+  test("a leftover Google SecOps cron alone does not mark the scheduler registered", async () => {
+    /*
+     * The retired cron's repeatable can survive an upgrade in Redis. It
+     * enqueues nothing any more, so on its own it must read as a missing
+     * scheduler (a failed check), never as a healthy one.
+     */
     const status: ConnectorPlatformStatus =
       await ConnectorPlatformHealth.getPlatformStatus({
         queueOverride: makeQueue({
           getJobSchedulers: (): Promise<Array<FakeScheduler | undefined>> => {
-            return Promise.resolve([bullmqRepeatable(GOOGLE_POLL_JOB)]);
+            return Promise.resolve([
+              bullmqRepeatable(GOOGLE_POLL_JOB, NEXT_TICK_MS),
+              {
+                key: legacyRepeatKey(GOOGLE_POLL_JOB),
+                name: "SecurityEvents",
+                next: NEXT_TICK_MS,
+              },
+            ]);
+          },
+        }),
+        storageProbeOverride: storageUp,
+      });
+
+    expect(status.schedulerRegistered).toBe(false);
+    expect(status.schedulerNextRunAt).toBeUndefined();
+    expect(
+      findCheck(ConnectorPlatformHealth.toPlatformChecks(status), "scheduler")
+        .status,
+    ).toBe("fail");
+  });
+
+  test("a registered cron without a usable next tick invents no next-run timestamp", async () => {
+    const status: ConnectorPlatformStatus =
+      await ConnectorPlatformHealth.getPlatformStatus({
+        queueOverride: makeQueue({
+          getJobSchedulers: (): Promise<Array<FakeScheduler | undefined>> => {
+            return Promise.resolve([bullmqRepeatable(GENERIC_POLL_JOB)]);
           },
         }),
         storageProbeOverride: storageUp,
       });
 
     expect(status.schedulerRegistered).toBe(true);
-    // No usable `next` on the entry, so no next-run timestamp is invented.
     expect(status.schedulerNextRunAt).toBeUndefined();
   });
 
-  test("reports the earliest next tick when both schedulers are registered", async () => {
+  test("reports the earliest next tick of the poll cron's registrations and ignores a leftover Google SecOps cron", async () => {
     const status: ConnectorPlatformStatus =
       await ConnectorPlatformHealth.getPlatformStatus({
         queueOverride: makeQueue({
           getJobSchedulers: (): Promise<Array<FakeScheduler | undefined>> => {
             return Promise.resolve([
               bullmqRepeatable(GENERIC_POLL_JOB, NEXT_TICK_MS + 5_000),
+              {
+                key: legacyRepeatKey(GENERIC_POLL_JOB),
+                name: "SecurityEvents",
+                next: NEXT_TICK_MS + 2_000,
+              },
+              // Earliest of all, but it enqueues nothing any more.
               bullmqRepeatable(GOOGLE_POLL_JOB, NEXT_TICK_MS),
             ]);
           },
@@ -561,8 +615,9 @@ describe("ConnectorPlatformHealth.getPlatformStatus", () => {
         storageProbeOverride: storageUp,
       });
 
+    expect(status.schedulerRegistered).toBe(true);
     expect(status.schedulerNextRunAt).toBe(
-      new Date(NEXT_TICK_MS).toISOString(),
+      new Date(NEXT_TICK_MS + 2_000).toISOString(),
     );
   });
 

package/Tests/Server/Utils/SecurityEvent/{GoogleSecOpsAuth.test.ts → Connectors/GoogleSecOps/GoogleSecOpsAuth.test.ts}

@@ -1,15 +1,15 @@
 import { generateKeyPairSync } from "crypto";
 import jwt from "jsonwebtoken";
-import logger from "../../../../Server/Utils/Logger";
+import logger from "../../../../../../Server/Utils/Logger";
 import GoogleSecOpsClient, {
   FetchAlertsResult,
   FetchInitLike,
   FetchLike,
   FetchResponseLike,
-} from "../../../../Server/Utils/SecurityEvent/GoogleSecOps/GoogleSecOpsClient";
-import APIException from "../../../../Types/Exception/ApiException";
-import { JSONObject } from "../../../../Types/JSON";
-import { getJestSpyOn } from "../../../Spy";
+} from "../../../../../../Server/Utils/SecurityEvent/Connectors/GoogleSecOps/GoogleSecOpsClient";
+import APIException from "../../../../../../Types/Exception/ApiException";
+import { JSONObject } from "../../../../../../Types/JSON";
+import { getJestSpyOn } from "../../../../../Spy";
 import { afterEach, describe, expect, jest, test } from "@jest/globals";
 
 /*

package/Tests/Server/Utils/SecurityEvent/{GoogleSecOpsClient.test.ts → Connectors/GoogleSecOps/GoogleSecOpsClient.test.ts}

@@ -5,10 +5,10 @@ import GoogleSecOpsClient, {
   FetchInitLike,
   FetchLike,
   FetchResponseLike,
-} from "../../../../Server/Utils/SecurityEvent/GoogleSecOps/GoogleSecOpsClient";
-import APIException from "../../../../Types/Exception/ApiException";
-import BadDataException from "../../../../Types/Exception/BadDataException";
-import { JSONObject } from "../../../../Types/JSON";
+} from "../../../../../../Server/Utils/SecurityEvent/Connectors/GoogleSecOps/GoogleSecOpsClient";
+import APIException from "../../../../../../Types/Exception/ApiException";
+import BadDataException from "../../../../../../Types/Exception/BadDataException";
+import { JSONObject } from "../../../../../../Types/JSON";
 import { describe, expect, jest, test } from "@jest/globals";
 
 /*