@oneuptime/common 14.0.6 → 14.0.7

package/Tests/Types/Topology/TopologyTypeRules.test.ts

@@ -0,0 +1,176 @@
+import { describe, expect, test } from "@jest/globals";
+import { compareCodePoints } from "../../../Types/Topology/TopologyTypeRules";
+
+/*
+ * compareCodePoints is how the Dashboard breaks the ties the server breaks
+ * with COLLATE "C" (code-point order on a UTF-8 database). It must equal
+ * JavaScript's `<` for every string made of characters up to U+FFFF, and
+ * order characters beyond U+FFFF (surrogate pairs) after U+E000-U+FFFF,
+ * which `<` does not.
+ */
+
+function sign(value: number): number {
+  return value < 0 ? -1 : value > 0 ? 1 : 0;
+}
+
+/* An independent reference: compare the strings' code points one by one. */
+function referenceCompare(a: string, b: string): number {
+  const left: Array<number> = Array.from(a).map((char: string): number => {
+    return char.codePointAt(0)!;
+  });
+  const right: Array<number> = Array.from(b).map((char: string): number => {
+    return char.codePointAt(0)!;
+  });
+  const length: number = Math.min(left.length, right.length);
+  for (let index: number = 0; index < length; index++) {
+    if (left[index] !== right[index]) {
+      return left[index]! < right[index]! ? -1 : 1;
+    }
+  }
+  return sign(left.length - right.length);
+}
+
+function codeUnitCompare(a: string, b: string): number {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+/* A small deterministic generator, so a failure names its inputs. */
+function makeRandom(seed: number): () => number {
+  let state: number = seed >>> 0;
+  return (): number => {
+    state = (state * 1664525 + 1013904223) >>> 0;
+    return state / 4294967296;
+  };
+}
+
+/* Characters from the ranges where the two orders meet or part ways. */
+const ALPHABET: Array<string> = [
+  "a",
+  "b",
+  "z",
+  "0",
+  "-",
+  "é",
+  "中",
+  "퟿",
+  "",
+  "",
+  "fi",
+  "�",
+  "￿",
+  "\u{10000}",
+  "\u{1F600}",
+  "\u{1F601}",
+  "\u{10FFFF}",
+];
+
+function randomString(random: () => number, alphabet: Array<string>): string {
+  const length: number = Math.floor(random() * 5);
+  let out: string = "";
+  for (let index: number = 0; index < length; index++) {
+    out += alphabet[Math.floor(random() * alphabet.length)]!;
+  }
+  return out;
+}
+
+describe("compareCodePoints", () => {
+  test("equal strings compare equal", () => {
+    expect(compareCodePoints("", "")).toBe(0);
+    expect(compareCodePoints("node-a", "node-a")).toBe(0);
+    expect(compareCodePoints("\u{1F600}", "\u{1F600}")).toBe(0);
+  });
+
+  test("inside the Basic Multilingual Plane it orders exactly like `<`", () => {
+    const pairs: Array<[string, string]> = [
+      ["a", "b"],
+      ["node-a", "node-b"],
+      ["node", "node-a"],
+      ["", "a"],
+      ["Z", "a"],
+      ["a", "é"],
+      ["퟿", ""],
+      ["", "�"],
+      ["�", "￿"],
+      ["0123456789abcdef", "0123456789abcdf0"],
+    ];
+    for (const [a, b] of pairs) {
+      expect(compareCodePoints(a, b)).toBe(-1);
+      expect(compareCodePoints(b, a)).toBe(1);
+      expect(sign(compareCodePoints(a, b))).toBe(codeUnitCompare(a, b));
+    }
+  });
+
+  test("a character beyond U+FFFF sorts after U+E000..U+FFFF, where `<` puts it before", () => {
+    for (const high of ["", "", "�", "￿"]) {
+      for (const astral of ["\u{10000}", "\u{1F600}", "\u{10FFFF}"]) {
+        expect(compareCodePoints(high, astral)).toBe(-1);
+        expect(compareCodePoints(astral, high)).toBe(1);
+        expect(compareCodePoints(`node-${high}`, `node-${astral}`)).toBe(-1);
+        expect(compareCodePoints(`node-${astral}x`, `node-${high}`)).toBe(1);
+        /* The order `<` gives, which is what this exists to correct. */
+        expect(codeUnitCompare(high, astral)).toBe(1);
+      }
+    }
+  });
+
+  test("a character beyond U+FFFF still sorts after everything below U+D800", () => {
+    expect(compareCodePoints("퟿", "\u{10000}")).toBe(-1);
+    expect(compareCodePoints("z", "\u{1F600}")).toBe(-1);
+    expect(compareCodePoints("\u{1F600}", "z")).toBe(1);
+  });
+
+  test("two characters beyond U+FFFF compare by code point, high or low half", () => {
+    /* Different high surrogates (U+10000 is D800 DC00, U+1F600 is D83D DE00). */
+    expect(compareCodePoints("\u{10000}", "\u{1F600}")).toBe(-1);
+    /* Same high surrogate, different low surrogates. */
+    expect(compareCodePoints("\u{1F600}", "\u{1F601}")).toBe(-1);
+    expect(compareCodePoints("x\u{1F601}", "x\u{1F600}")).toBe(1);
+  });
+
+  test("a prefix sorts first", () => {
+    expect(compareCodePoints("node", "node-\u{1F600}")).toBe(-1);
+    expect(compareCodePoints("node-\u{1F600}", "node")).toBe(1);
+    expect(compareCodePoints("\u{1F600}", "\u{1F600}")).toBe(-1);
+  });
+
+  test("agrees with a code-point reference on thousands of mixed strings", () => {
+    const random: () => number = makeRandom(3973);
+    let disagreementsWithCodeUnits: number = 0;
+    for (let round: number = 0; round < 20000; round++) {
+      const a: string = randomString(random, ALPHABET);
+      const b: string = randomString(random, ALPHABET);
+      const expected: number = referenceCompare(a, b);
+      if (sign(compareCodePoints(a, b)) !== expected) {
+        throw new Error(
+          `compareCodePoints(${JSON.stringify(a)}, ${JSON.stringify(b)}) should be ${expected}`,
+        );
+      }
+      if (codeUnitCompare(a, b) !== expected) {
+        disagreementsWithCodeUnits++;
+      }
+    }
+    /* The inputs really did reach the cases where `<` is wrong. */
+    expect(disagreementsWithCodeUnits).toBeGreaterThan(100);
+  });
+
+  test('sorts a list the way COLLATE "C" would', () => {
+    const keys: Array<string> = [
+      "node-\u{1F600}",
+      "node-�",
+      "node-b",
+      "node-",
+      "node-a",
+      "node-\u{10000}",
+      "node",
+    ];
+    expect([...keys].sort(compareCodePoints)).toEqual([
+      "node",
+      "node-a",
+      "node-b",
+      "node-",
+      "node-�",
+      "node-\u{10000}",
+      "node-\u{1F600}",
+    ]);
+  });
+});

package/Tests/Utils/Incident/IncidentFromAlerts.test.ts

@@ -1,6 +1,9 @@
 import { describe, expect, test } from "@jest/globals";
 import IncidentFromAlerts, {
+  AlertForAcknowledgement,
   AlertForIncidentPrefill,
+  AlertsToAcknowledge,
+  AlertStateForAcknowledgement,
   INCIDENT_PREFILL_RESOURCE_KEYS,
   IncidentPrefillFromAlerts,
   NamedResource,
@@ -694,3 +697,302 @@ describe("IncidentFromAlerts", () => {
     });
   });
 });
+
+/*
+ * Which alerts the create page offers to acknowledge as the incident is
+ * declared. States are compared by order, as the server does: anything at or
+ * after the project's Acknowledged state (Resolved, or a custom state in
+ * between) has been acknowledged already. An alert whose state cannot be
+ * placed is offered - the server skips it if it turns out to be acknowledged.
+ */
+describe("IncidentFromAlerts.getAlertsToAcknowledge", () => {
+  const CREATED: AlertStateForAcknowledgement = {
+    id: "state-created",
+    order: 1,
+    isAcknowledgedState: false,
+  };
+  const ACKNOWLEDGED: AlertStateForAcknowledgement = {
+    id: "state-acknowledged",
+    order: 2,
+    isAcknowledgedState: true,
+  };
+  const RESOLVED: AlertStateForAcknowledgement = {
+    id: "state-resolved",
+    order: 3,
+    isAcknowledgedState: false,
+  };
+
+  const DEFAULT_ALERT_STATES: Array<AlertStateForAcknowledgement> = [
+    CREATED,
+    ACKNOWLEDGED,
+    RESOLVED,
+  ];
+
+  type AlertInStateFunction = (
+    id: string,
+    currentAlertStateId?: string | undefined,
+  ) => AlertForAcknowledgement;
+
+  const alertIn: AlertInStateFunction = (
+    id: string,
+    currentAlertStateId?: string | undefined,
+  ): AlertForAcknowledgement => {
+    return { id: id, currentAlertStateId: currentAlertStateId };
+  };
+
+  type GetFunction = (
+    alerts: Array<AlertForAcknowledgement>,
+    alertStates?: Array<AlertStateForAcknowledgement>,
+  ) => AlertsToAcknowledge | null;
+
+  const get: GetFunction = (
+    alerts: Array<AlertForAcknowledgement>,
+    alertStates?: Array<AlertStateForAcknowledgement>,
+  ): AlertsToAcknowledge | null => {
+    return IncidentFromAlerts.getAlertsToAcknowledge({
+      alerts: alerts,
+      alertStates: alertStates || DEFAULT_ALERT_STATES,
+    });
+  };
+
+  describe("when nothing could be acknowledged", () => {
+    test("is null when the project has no alert states at all", () => {
+      expect(get([alertIn("a1", CREATED.id)], [])).toBeNull();
+    });
+
+    test("is null when no state is the Acknowledged state", () => {
+      expect(
+        get(
+          [alertIn("a1", CREATED.id)],
+          [CREATED, { ...ACKNOWLEDGED, isAcknowledgedState: false }, RESOLVED],
+        ),
+      ).toBeNull();
+    });
+
+    test("is null when the Acknowledged flag is missing rather than false", () => {
+      expect(
+        get(
+          [alertIn("a1", CREATED.id)],
+          [
+            CREATED,
+            { id: ACKNOWLEDGED.id, order: ACKNOWLEDGED.order },
+            RESOLVED,
+          ],
+        ),
+      ).toBeNull();
+    });
+
+    test("is null when the Acknowledged state has no order to compare by", () => {
+      expect(
+        get(
+          [alertIn("a1", CREATED.id)],
+          [CREATED, { ...ACKNOWLEDGED, order: undefined }, RESOLVED],
+        ),
+      ).toBeNull();
+    });
+
+    test("is null without an Acknowledged state even when there are no alerts", () => {
+      expect(get([], [CREATED, RESOLVED])).toBeNull();
+    });
+  });
+
+  describe("comparing by order", () => {
+    test("offers an alert whose state comes before Acknowledged", () => {
+      expect(get([alertIn("a1", CREATED.id)])).toEqual({
+        alertIds: ["a1"],
+        alreadyAcknowledgedCount: 0,
+      });
+    });
+
+    test("leaves out an alert that is in the Acknowledged state itself", () => {
+      expect(get([alertIn("a1", ACKNOWLEDGED.id)])).toEqual({
+        alertIds: [],
+        alreadyAcknowledgedCount: 1,
+      });
+    });
+
+    test("leaves out an alert that is resolved", () => {
+      expect(get([alertIn("a1", RESOLVED.id)])).toEqual({
+        alertIds: [],
+        alreadyAcknowledgedCount: 1,
+      });
+    });
+
+    test("treats a custom state between Acknowledged and Resolved as acknowledged already", () => {
+      const investigating: AlertStateForAcknowledgement = {
+        id: "state-investigating",
+        order: 3,
+      };
+      const resolved: AlertStateForAcknowledgement = {
+        id: "state-resolved",
+        order: 4,
+      };
+
+      expect(
+        get(
+          [alertIn("a1", investigating.id), alertIn("a2", resolved.id)],
+          [CREATED, ACKNOWLEDGED, investigating, resolved],
+        ),
+      ).toEqual({ alertIds: [], alreadyAcknowledgedCount: 2 });
+    });
+
+    test("offers an alert in a custom state before Acknowledged", () => {
+      const triaged: AlertStateForAcknowledgement = {
+        id: "state-triaged",
+        order: 2,
+      };
+      const acknowledged: AlertStateForAcknowledgement = {
+        id: "state-acknowledged",
+        order: 3,
+        isAcknowledgedState: true,
+      };
+
+      expect(
+        get(
+          [alertIn("a1", triaged.id), alertIn("a2", CREATED.id)],
+          [CREATED, triaged, acknowledged, { ...RESOLVED, order: 4 }],
+        ),
+      ).toEqual({ alertIds: ["a1", "a2"], alreadyAcknowledgedCount: 0 });
+    });
+
+    test("compares by order, not by where the state sits in the list", () => {
+      // Listed newest-first: the list position must not decide anything.
+      const reversed: Array<AlertStateForAcknowledgement> = [
+        RESOLVED,
+        ACKNOWLEDGED,
+        CREATED,
+      ];
+
+      expect(
+        get(
+          [
+            alertIn("a1", RESOLVED.id),
+            alertIn("a2", CREATED.id),
+            alertIn("a3", ACKNOWLEDGED.id),
+          ],
+          reversed,
+        ),
+      ).toEqual({ alertIds: ["a2"], alreadyAcknowledgedCount: 2 });
+    });
+
+    test("an Acknowledged order of 0 is still an order", () => {
+      const acknowledgedAtZero: AlertStateForAcknowledgement = {
+        id: "state-acknowledged",
+        order: 0,
+        isAcknowledgedState: true,
+      };
+      const before: AlertStateForAcknowledgement = {
+        id: "state-before",
+        order: -1,
+      };
+
+      expect(
+        get(
+          [
+            alertIn("a1", acknowledgedAtZero.id),
+            alertIn("a2", before.id),
+            alertIn("a3", RESOLVED.id),
+          ],
+          [before, acknowledgedAtZero, RESOLVED],
+        ),
+      ).toEqual({ alertIds: ["a2"], alreadyAcknowledgedCount: 2 });
+    });
+  });
+
+  describe("alerts whose state cannot be placed", () => {
+    test("offers an alert whose current state is not one of the project's states", () => {
+      expect(get([alertIn("a1", "state-from-another-project")])).toEqual({
+        alertIds: ["a1"],
+        alreadyAcknowledgedCount: 0,
+      });
+    });
+
+    test("offers an alert with no current state id", () => {
+      expect(get([alertIn("a1", undefined), alertIn("a2", "")])).toEqual({
+        alertIds: ["a1", "a2"],
+        alreadyAcknowledgedCount: 0,
+      });
+    });
+
+    test("offers an alert whose current state has no order", () => {
+      const unordered: AlertStateForAcknowledgement = {
+        id: "state-unordered",
+      };
+
+      expect(
+        get(
+          [alertIn("a1", unordered.id)],
+          [CREATED, ACKNOWLEDGED, RESOLVED, unordered],
+        ),
+      ).toEqual({ alertIds: ["a1"], alreadyAcknowledgedCount: 0 });
+    });
+  });
+
+  test("matches state ids case-insensitively and ignoring surrounding spaces", () => {
+    const upperAcknowledged: AlertStateForAcknowledgement = {
+      id: "AAAAAAAA-AAAA-4AAA-8AAA-000000000002",
+      order: 2,
+      isAcknowledgedState: true,
+    };
+    const upperCreated: AlertStateForAcknowledgement = {
+      id: "AAAAAAAA-AAAA-4AAA-8AAA-000000000001",
+      order: 1,
+    };
+
+    expect(
+      get(
+        [
+          alertIn("a1", " aaaaaaaa-aaaa-4aaa-8aaa-000000000002 "),
+          alertIn("a2", "aaaaaaaa-aaaa-4aaa-8aaa-000000000001"),
+        ],
+        [upperCreated, upperAcknowledged],
+      ),
+    ).toEqual({ alertIds: ["a2"], alreadyAcknowledgedCount: 1 });
+  });
+
+  test("keeps the alerts in the order they were given and counts the rest", () => {
+    const result: AlertsToAcknowledge | null = get([
+      alertIn("a5", CREATED.id),
+      alertIn("a1", ACKNOWLEDGED.id),
+      alertIn("a4", undefined),
+      alertIn("a2", RESOLVED.id),
+      alertIn("a3", CREATED.id),
+      alertIn("a6", RESOLVED.id),
+    ]);
+
+    expect(result).toEqual({
+      alertIds: ["a5", "a4", "a3"],
+      alreadyAcknowledgedCount: 3,
+    });
+  });
+
+  test("returns the alert ids exactly as given", () => {
+    expect(get([alertIn("ALERT-One", CREATED.id)])!.alertIds).toEqual([
+      "ALERT-One",
+    ]);
+  });
+
+  test("is empty, not null, when there are no alerts", () => {
+    expect(get([])).toEqual({ alertIds: [], alreadyAcknowledgedCount: 0 });
+  });
+
+  test("does not change its input", () => {
+    const alerts: Array<AlertForAcknowledgement> = [
+      alertIn("a1", CREATED.id),
+      alertIn("a2", ACKNOWLEDGED.id),
+    ];
+    const alertStates: Array<AlertStateForAcknowledgement> = [
+      RESOLVED,
+      CREATED,
+      ACKNOWLEDGED,
+    ];
+
+    get(alerts, alertStates);
+
+    expect(alerts).toEqual([
+      { id: "a1", currentAlertStateId: CREATED.id },
+      { id: "a2", currentAlertStateId: ACKNOWLEDGED.id },
+    ]);
+    expect(alertStates).toEqual([RESOLVED, CREATED, ACKNOWLEDGED]);
+  });
+});

package/Types/Incident/IncidentAlertLink.ts

@@ -12,6 +12,25 @@
  */
 export const INCIDENT_ALERT_IDS_TO_LINK_KEY: string = "alertIdsToLink";
 
+/*
+ * Declaring an incident from alerts does not, on its own, change the alerts:
+ * they keep escalating until somebody acknowledges them. Sending
+ * `miscDataProps[INCIDENT_ACKNOWLEDGE_ALERTS_TO_LINK_KEY] = true` along with
+ * INCIDENT_ALERT_IDS_TO_LINK_KEY also acknowledges them, as the declaring
+ * user, once they are linked - which is what stops their on-call escalation.
+ * Alerts already acknowledged (or past it) are left as they are, and the
+ * caller must be allowed to change the state of every alert that is not.
+ * Off unless asked for.
+ *
+ * One exception: when the incident is declared straight into an
+ * acknowledged or resolved state and the project's linked-alert switches
+ * already move linked alerts along with it, those alerts are left to the
+ * switches (one writer per alert) - acknowledged or resolved as the switch
+ * does it, not credited to the declaring user.
+ */
+export const INCIDENT_ACKNOWLEDGE_ALERTS_TO_LINK_KEY: string =
+  "acknowledgeAlertsToLink";
+
 /*
  * The create-incident page reads the alerts to declare an incident from out of
  * this query string parameter, as a comma separated list of alert ids.

package/Types/Telemetry/InventoryLiveness.ts

@@ -54,3 +54,29 @@ export const getInventoryLivenessState: (
 
   return InventoryLiveness.Stale;
 };
+
+/**
+ * `getInventoryLivenessState` as a Postgres expression over the row aliased
+ * `tableAlias`, which must already be quoted (`"InventoryItem"`).
+ *
+ * The one SQL definition of the rule: the `inventoryStatus` virtual column
+ * selects and filters with it, and the Inventory Overview counts "Gone
+ * Quiet" with it, so the number on that tile and the rows the Stale facet
+ * returns cannot disagree about what stale means.
+ *
+ * Measured against the database clock. The function above floors elapsed
+ * minutes before applying inclusive thresholds — 30m59s is still Live and
+ * 24h00m59s is still Recent — and strict comparisons against the following
+ * minute preserve exactly those boundaries.
+ */
+export const getInventoryLivenessSql: (tableAlias: string) => string = (
+  tableAlias: string,
+): string => {
+  return `CASE
+        WHEN ${tableAlias}."source" IS DISTINCT FROM '${EntitySource.Discovered}' THEN '${InventoryLiveness.NotTracked}'
+        WHEN ${tableAlias}."lastSeenAt" IS NULL THEN '${InventoryLiveness.Never}'
+        WHEN ${tableAlias}."lastSeenAt" > CURRENT_TIMESTAMP - INTERVAL '${INVENTORY_LIVE_WINDOW_MINUTES + 1} minutes' THEN '${InventoryLiveness.Live}'
+        WHEN ${tableAlias}."lastSeenAt" > CURRENT_TIMESTAMP - INTERVAL '${INVENTORY_STALE_AFTER_MINUTES + 1} minutes' THEN '${InventoryLiveness.Recent}'
+        ELSE '${InventoryLiveness.Stale}'
+      END`;
+};