@oneuptime/common 12.0.20 → 12.0.21

package/Tests/Server/Utils/AI/SRE/Insights/Detectors/ExceptionIdentity.test.ts

@@ -0,0 +1,224 @@
+import {
+  EXCEPTION_LABEL_MESSAGE_MAX_LENGTH,
+  buildExceptionFailureModeKey,
+  buildExceptionLabel,
+} from "../../../../../../../Server/Utils/AI/SRE/Insights/Detectors/ExceptionIdentity";
+import Crypto from "../../../../../../../Utils/Crypto";
+import { normalizeExceptionText } from "../../../../../../../Server/Utils/Telemetry/ExceptionSanitizer";
+import ObjectID from "../../../../../../../Types/ObjectID";
+import { describe, expect, test } from "@jest/globals";
+
+describe("ExceptionIdentity", () => {
+  describe("buildExceptionLabel", () => {
+    test("falls back to a fixed label when both type and message are empty", () => {
+      expect(buildExceptionLabel("", "")).toBe("Unknown exception");
+      expect(buildExceptionLabel(undefined, undefined)).toBe(
+        "Unknown exception",
+      );
+      // Whitespace-only inputs trim down to empty and hit the same fallback.
+      expect(buildExceptionLabel("   ", "  \t ")).toBe("Unknown exception");
+    });
+
+    test("uses the type alone when there is no message", () => {
+      expect(buildExceptionLabel("TypeError", "")).toBe("TypeError");
+      expect(buildExceptionLabel("  TypeError  ", undefined)).toBe("TypeError");
+    });
+
+    test("uses the message alone when there is no type", () => {
+      expect(buildExceptionLabel("", "connection refused")).toBe(
+        "connection refused",
+      );
+      expect(buildExceptionLabel(undefined, "  connection refused  ")).toBe(
+        "connection refused",
+      );
+    });
+
+    test("combines type and message with a colon separator", () => {
+      expect(
+        buildExceptionLabel(
+          "TypeError",
+          "Cannot read properties of undefined (reading 'user')",
+        ),
+      ).toBe("TypeError: Cannot read properties of undefined (reading 'user')");
+    });
+
+    test("does not repeat the type when the message already starts with it", () => {
+      // "Error: <message>" — the runtime-prefixed shape.
+      expect(buildExceptionLabel("Error", "Error: connect ECONNREFUSED")).toBe(
+        "Error: connect ECONNREFUSED",
+      );
+      // "<Type> <message>" — space-separated prefix.
+      expect(
+        buildExceptionLabel("ValueError", "ValueError invalid literal"),
+      ).toBe("ValueError invalid literal");
+      // Message reported verbatim as the type.
+      expect(buildExceptionLabel("401", "401")).toBe("401");
+    });
+
+    test("treats the type-prefix check case-insensitively", () => {
+      expect(buildExceptionLabel("error", "ERROR: boom")).toBe("ERROR: boom");
+      expect(buildExceptionLabel("TypeError", "typeerror: boom")).toBe(
+        "typeerror: boom",
+      );
+    });
+
+    test("does not collapse when the type only appears mid-message", () => {
+      // "Error" is a substring but not a prefix, so both halves are kept.
+      expect(buildExceptionLabel("Error", "Fatal Error happened")).toBe(
+        "Error: Fatal Error happened",
+      );
+    });
+
+    test("truncates a long message and appends an ellipsis", () => {
+      const longMessage: string = "x".repeat(
+        EXCEPTION_LABEL_MESSAGE_MAX_LENGTH + 50,
+      );
+      const label: string = buildExceptionLabel("TypeError", longMessage);
+
+      const expectedShort: string =
+        "x".repeat(EXCEPTION_LABEL_MESSAGE_MAX_LENGTH) + "…";
+      expect(label).toBe(`TypeError: ${expectedShort}`);
+      // The ellipsis is a single char, so the message portion is cap + 1.
+      expect(label.endsWith("…")).toBe(true);
+    });
+
+    test("does not truncate a message exactly at the cap", () => {
+      const exact: string = "y".repeat(EXCEPTION_LABEL_MESSAGE_MAX_LENGTH);
+      expect(buildExceptionLabel("", exact)).toBe(exact);
+      expect(buildExceptionLabel("", exact).endsWith("…")).toBe(false);
+    });
+
+    test("honors a custom message max length", () => {
+      expect(buildExceptionLabel("E", "abcdefghij", 4)).toBe("E: abcd…");
+      expect(buildExceptionLabel("", "abcdefghij", 4)).toBe("abcd…");
+    });
+  });
+
+  describe("buildExceptionFailureModeKey", () => {
+    const entityId: ObjectID = ObjectID.generate();
+
+    test("is deterministic for the same inputs", () => {
+      const args: {
+        primaryEntityId: ObjectID;
+        exceptionType: string;
+        message: string;
+      } = {
+        primaryEntityId: entityId,
+        exceptionType: "TypeError",
+        message: "Cannot read properties of undefined",
+      };
+
+      expect(buildExceptionFailureModeKey(args)).toBe(
+        buildExceptionFailureModeKey(args),
+      );
+    });
+
+    test("keeps the entity id in the clear and hashes the content half", () => {
+      const key: string = buildExceptionFailureModeKey({
+        primaryEntityId: entityId,
+        exceptionType: "TypeError",
+        message: "boom",
+      });
+
+      const expectedHash: string = Crypto.getSha256Hash(
+        `TypeError|${normalizeExceptionText("boom")}`,
+      );
+      expect(key).toBe(`${entityId.toString()}:${expectedHash}`);
+      // sha256 hex is exactly 64 lowercase hex chars.
+      expect(key.split(":")[1]).toMatch(/^[0-9a-f]{64}$/);
+    });
+
+    test("collapses messages that differ only by a normalized dynamic value", () => {
+      // Two UUIDs normalize to <UUID>, so both throws are one failure mode.
+      const first: string = buildExceptionFailureModeKey({
+        primaryEntityId: entityId,
+        exceptionType: "NotFoundException",
+        message: "user 550e8400-e29b-41d4-a716-446655440000 not found",
+      });
+      const second: string = buildExceptionFailureModeKey({
+        primaryEntityId: entityId,
+        exceptionType: "NotFoundException",
+        message: "user 11111111-2222-3333-4444-555555555555 not found",
+      });
+
+      expect(first).toBe(second);
+    });
+
+    test("separates different exception types under the same entity", () => {
+      const typeError: string = buildExceptionFailureModeKey({
+        primaryEntityId: entityId,
+        exceptionType: "TypeError",
+        message: "same message",
+      });
+      const rangeError: string = buildExceptionFailureModeKey({
+        primaryEntityId: entityId,
+        exceptionType: "RangeError",
+        message: "same message",
+      });
+
+      expect(typeError).not.toBe(rangeError);
+    });
+
+    test("separates the same failure across different entities", () => {
+      const other: ObjectID = ObjectID.generate();
+      const a: string = buildExceptionFailureModeKey({
+        primaryEntityId: entityId,
+        exceptionType: "TypeError",
+        message: "boom",
+      });
+      const b: string = buildExceptionFailureModeKey({
+        primaryEntityId: other,
+        exceptionType: "TypeError",
+        message: "boom",
+      });
+
+      expect(a).not.toBe(b);
+      expect(a.startsWith(`${entityId.toString()}:`)).toBe(true);
+      expect(b.startsWith(`${other.toString()}:`)).toBe(true);
+    });
+
+    test("uses a stable placeholder when the entity is unattributed", () => {
+      const key: string = buildExceptionFailureModeKey({
+        primaryEntityId: undefined,
+        exceptionType: "TypeError",
+        message: "boom",
+      });
+
+      expect(key.startsWith("unattributed-entity:")).toBe(true);
+      // Still deterministic without an entity.
+      expect(key).toBe(
+        buildExceptionFailureModeKey({
+          primaryEntityId: undefined,
+          exceptionType: "TypeError",
+          message: "boom",
+        }),
+      );
+    });
+
+    test("trims the type before hashing so padding does not fork the key", () => {
+      const padded: string = buildExceptionFailureModeKey({
+        primaryEntityId: entityId,
+        exceptionType: "  TypeError  ",
+        message: "  boom  ",
+      });
+      const clean: string = buildExceptionFailureModeKey({
+        primaryEntityId: entityId,
+        exceptionType: "TypeError",
+        message: "boom",
+      });
+
+      expect(padded).toBe(clean);
+    });
+
+    test("handles a missing type and message without throwing", () => {
+      const key: string = buildExceptionFailureModeKey({
+        primaryEntityId: entityId,
+        exceptionType: undefined,
+        message: undefined,
+      });
+
+      const expectedHash: string = Crypto.getSha256Hash(`|`);
+      expect(key).toBe(`${entityId.toString()}:${expectedHash}`);
+    });
+  });
+});

package/Tests/Server/Utils/Attribution.test.ts

@@ -206,14 +206,13 @@ describe("Attribution", () => {
    * -------------------------------------------------------------------------
    * sanitizeUtm
    *
-   * UTM values reach the server in two spellings from three unauthenticated
-   * doors: snake_case off a URL and out of Cal booking metadata, camelCase out
-   * of the signup form's JSON body. All of them write the same columns, so all
-   * of them read through here.
+   * UTM values reach the server in two spellings: snake_case off a URL, and
+   * camelCase out of the signup form's JSON body. Both write the same columns,
+   * so both read through here.
    * -------------------------------------------------------------------------
    */
   describe("sanitizeUtm", () => {
-    test("reads the snake_case spelling a URL and Cal metadata carry", () => {
+    test("reads the snake_case spelling a URL carries", () => {
       expect(
         Attribution.sanitizeUtm({
           utm_source: "google",

package/Tests/Server/Utils/Marketing/MarketingEventUtil.test.ts

@@ -74,8 +74,8 @@ describe("MarketingEventUtil", () => {
      */
     test("carries the address and a matching SHA-256", () => {
       const event: MarketingEvent = MarketingEventUtil.buildEvent({
-        eventType: MarketingEventType.MeetingBooked,
-        eventId: "meeting_booked:b1",
+        eventType: MarketingEventType.SignUp,
+        eventId: "sign_up:u2",
         occurredAt: new Date(),
         email: "Buyer@Example.com",
       });

package/Tests/Server/Utils/Monitor/MonitorCriteriaExpectationBuilder.test.ts

@@ -0,0 +1,300 @@
+import MonitorCriteriaExpectationBuilder from "../../../../Server/Utils/Monitor/MonitorCriteriaExpectationBuilder";
+import {
+  CheckOn,
+  CriteriaFilter,
+  EvaluateOverTimeType,
+  FilterType,
+} from "../../../../Types/Monitor/CriteriaFilter";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * A minimal CriteriaFilter builder so each test states only the fields it
+ * cares about; everything else stays undefined the way the persisted shape
+ * allows.
+ */
+const makeFilter: (overrides: Partial<CriteriaFilter>) => CriteriaFilter = (
+  overrides: Partial<CriteriaFilter>,
+): CriteriaFilter => {
+  return {
+    checkOn: CheckOn.ResponseTime,
+    filterType: undefined,
+    value: undefined,
+    ...overrides,
+  };
+};
+
+describe("MonitorCriteriaExpectationBuilder", () => {
+  describe("getCriteriaFilterDescription", () => {
+    test("joins checkOn, filterType and value with single spaces", () => {
+      const description: string =
+        MonitorCriteriaExpectationBuilder.getCriteriaFilterDescription(
+          makeFilter({
+            checkOn: CheckOn.ResponseTime,
+            filterType: FilterType.GreaterThan,
+            value: 500,
+          }),
+        );
+
+      expect(description).toBe("Response Time (in ms) Greater Than 500");
+    });
+
+    test("omits filterType and value when they are absent", () => {
+      const description: string =
+        MonitorCriteriaExpectationBuilder.getCriteriaFilterDescription(
+          makeFilter({ checkOn: CheckOn.IsOnline }),
+        );
+
+      expect(description).toBe("Is Online");
+    });
+
+    test("keeps a zero value (does not treat 0 as missing)", () => {
+      const description: string =
+        MonitorCriteriaExpectationBuilder.getCriteriaFilterDescription(
+          makeFilter({
+            checkOn: CheckOn.ResponseTime,
+            filterType: FilterType.EqualTo,
+            value: 0,
+          }),
+        );
+
+      expect(description).toBe("Response Time (in ms) Equal To 0");
+    });
+
+    test("drops a null value but keeps the filter type", () => {
+      const description: string =
+        MonitorCriteriaExpectationBuilder.getCriteriaFilterDescription(
+          makeFilter({
+            checkOn: CheckOn.ResponseTime,
+            filterType: FilterType.IsEmpty,
+            value: null as unknown as undefined,
+          }),
+        );
+
+      expect(description).toBe("Response Time (in ms) Is Empty");
+    });
+
+    test("stringifies a string value as-is", () => {
+      const description: string =
+        MonitorCriteriaExpectationBuilder.getCriteriaFilterDescription(
+          makeFilter({
+            checkOn: CheckOn.ResponseBody,
+            filterType: FilterType.Contains,
+            value: "healthy",
+          }),
+        );
+
+      expect(description).toBe("Response Body Contains healthy");
+    });
+  });
+
+  describe("describeCriteriaExpectation", () => {
+    test("returns null when no filter type is set", () => {
+      expect(
+        MonitorCriteriaExpectationBuilder.describeCriteriaExpectation(
+          makeFilter({ filterType: undefined, value: 5 }),
+        ),
+      ).toBeNull();
+    });
+
+    test("renders each numeric comparison in plain English", () => {
+      const cases: Array<[FilterType, string]> = [
+        [FilterType.GreaterThan, "to be greater than 5"],
+        [FilterType.GreaterThanOrEqualTo, "to be greater than or equal to 5"],
+        [FilterType.LessThan, "to be less than 5"],
+        [FilterType.LessThanOrEqualTo, "to be less than or equal to 5"],
+        [FilterType.EqualTo, "to equal 5"],
+        [FilterType.NotEqualTo, "to not equal 5"],
+      ];
+
+      for (const [filterType, expected] of cases) {
+        expect(
+          MonitorCriteriaExpectationBuilder.describeCriteriaExpectation(
+            makeFilter({ filterType, value: 5 }),
+          ),
+        ).toBe(expected);
+      }
+    });
+
+    test("appends the unit suffix to numeric-threshold comparisons only", () => {
+      expect(
+        MonitorCriteriaExpectationBuilder.describeCriteriaExpectation(
+          makeFilter({ filterType: FilterType.GreaterThan, value: 5 }),
+          { unit: "sec" },
+        ),
+      ).toBe("to be greater than 5 sec");
+
+      // String comparisons carry their own wording and get no unit suffix.
+      expect(
+        MonitorCriteriaExpectationBuilder.describeCriteriaExpectation(
+          makeFilter({ filterType: FilterType.Contains, value: "ok" }),
+          { unit: "sec" },
+        ),
+      ).toBe("to contain ok");
+    });
+
+    test("renders string comparisons", () => {
+      const cases: Array<[FilterType, string]> = [
+        [FilterType.Contains, "to contain ok"],
+        [FilterType.NotContains, "to not contain ok"],
+        [FilterType.StartsWith, "to start with ok"],
+        [FilterType.EndsWith, "to end with ok"],
+      ];
+
+      for (const [filterType, expected] of cases) {
+        expect(
+          MonitorCriteriaExpectationBuilder.describeCriteriaExpectation(
+            makeFilter({ filterType, value: "ok" }),
+          ),
+        ).toBe(expected);
+      }
+    });
+
+    test("renders valueless filter types with fixed wording", () => {
+      const cases: Array<[FilterType, string]> = [
+        [FilterType.IsEmpty, "to be empty"],
+        [FilterType.IsNotEmpty, "to not be empty"],
+        [FilterType.True, "to be true"],
+        [FilterType.False, "to be false"],
+        [FilterType.IsExecuting, "to be executing"],
+        [FilterType.IsNotExecuting, "to not be executing"],
+        [FilterType.EvaluatesToTrue, "to evaluate to true"],
+      ];
+
+      for (const [filterType, expected] of cases) {
+        expect(
+          MonitorCriteriaExpectationBuilder.describeCriteriaExpectation(
+            makeFilter({ filterType }),
+          ),
+        ).toBe(expected);
+      }
+    });
+
+    test("describes heartbeat windows with and without a value", () => {
+      expect(
+        MonitorCriteriaExpectationBuilder.describeCriteriaExpectation(
+          makeFilter({ filterType: FilterType.RecievedInMinutes, value: 10 }),
+        ),
+      ).toBe("to receive a heartbeat within 10 minutes");
+
+      expect(
+        MonitorCriteriaExpectationBuilder.describeCriteriaExpectation(
+          makeFilter({ filterType: FilterType.RecievedInMinutes }),
+        ),
+      ).toBe("to receive a heartbeat within the configured window");
+
+      expect(
+        MonitorCriteriaExpectationBuilder.describeCriteriaExpectation(
+          makeFilter({
+            filterType: FilterType.NotRecievedInMinutes,
+            value: 3,
+          }),
+        ),
+      ).toBe("to miss a heartbeat for at least 3 minutes");
+
+      expect(
+        MonitorCriteriaExpectationBuilder.describeCriteriaExpectation(
+          makeFilter({ filterType: FilterType.NotRecievedInMinutes }),
+        ),
+      ).toBe("to miss a heartbeat within the configured window");
+    });
+
+    test("falls back to the raw filter type for unhandled types", () => {
+      expect(
+        MonitorCriteriaExpectationBuilder.describeCriteriaExpectation(
+          makeFilter({ filterType: FilterType.Anomalous, value: 42 }),
+        ),
+      ).toBe("Anomalous 42");
+
+      expect(
+        MonitorCriteriaExpectationBuilder.describeCriteriaExpectation(
+          makeFilter({ filterType: FilterType.Anomalous }),
+        ),
+      ).toBe("Anomalous");
+    });
+
+    test("appends an evaluation window when configured", () => {
+      expect(
+        MonitorCriteriaExpectationBuilder.describeCriteriaExpectation(
+          makeFilter({
+            filterType: FilterType.GreaterThan,
+            value: 5,
+            evaluateOverTime: true,
+            evaluateOverTimeOptions: {
+              timeValueInMinutes: 15,
+              evaluateOverTimeType: EvaluateOverTimeType.Average,
+            },
+          }),
+          { unit: "ms" },
+        ),
+      ).toBe("to be greater than 5 ms over the last 15 minutes using average");
+    });
+  });
+
+  describe("getEvaluationWindowDescription", () => {
+    test("returns null when nothing about a window is configured", () => {
+      expect(
+        MonitorCriteriaExpectationBuilder.getEvaluationWindowDescription(
+          makeFilter({ filterType: FilterType.GreaterThan, value: 5 }),
+        ),
+      ).toBeNull();
+    });
+
+    test("describes only the time span when no aggregation is set", () => {
+      expect(
+        MonitorCriteriaExpectationBuilder.getEvaluationWindowDescription(
+          makeFilter({
+            evaluateOverTime: true,
+            evaluateOverTimeOptions: {
+              timeValueInMinutes: 30,
+              evaluateOverTimeType: undefined,
+            },
+          }),
+        ),
+      ).toBe("over the last 30 minutes");
+    });
+
+    test("ignores the time span when evaluateOverTime is off", () => {
+      // The span is only surfaced when evaluateOverTime is true.
+      expect(
+        MonitorCriteriaExpectationBuilder.getEvaluationWindowDescription(
+          makeFilter({
+            evaluateOverTime: false,
+            evaluateOverTimeOptions: {
+              timeValueInMinutes: 30,
+              evaluateOverTimeType: EvaluateOverTimeType.Sum,
+            },
+          }),
+        ),
+      ).toBe("using sum");
+    });
+
+    test("falls back to the metric aggregation type when no over-time type is set", () => {
+      expect(
+        MonitorCriteriaExpectationBuilder.getEvaluationWindowDescription(
+          makeFilter({
+            metricMonitorOptions: {
+              metricAggregationType: EvaluateOverTimeType.MaximumValue,
+            },
+          }),
+        ),
+      ).toBe("using maximum value");
+    });
+
+    test("prefers the over-time type over the metric aggregation type", () => {
+      expect(
+        MonitorCriteriaExpectationBuilder.getEvaluationWindowDescription(
+          makeFilter({
+            evaluateOverTime: true,
+            evaluateOverTimeOptions: {
+              timeValueInMinutes: 5,
+              evaluateOverTimeType: EvaluateOverTimeType.Average,
+            },
+            metricMonitorOptions: {
+              metricAggregationType: EvaluateOverTimeType.Sum,
+            },
+          }),
+        ),
+      ).toBe("over the last 5 minutes using average");
+    });
+  });
+});

package/Tests/UI/Components/Charts/ChartGhostSeries.test.tsx

@@ -0,0 +1,103 @@
+import { AreaChart } from "../../../../UI/Components/Charts/ChartLibrary/AreaChart/AreaChart";
+import { LineChart } from "../../../../UI/Components/Charts/ChartLibrary/LineChart/LineChart";
+import "@testing-library/jest-dom";
+import { render } from "@testing-library/react";
+import React from "react";
+import { describe, expect, jest, test } from "@jest/globals";
+
+/*
+ * ResponsiveContainer measures its parent, which is always 0x0 in jsdom,
+ * so the chart renders nothing without a fixed size.
+ */
+jest.mock("recharts", () => {
+  const actual: Record<string, any> = jest.requireActual("recharts") as Record<
+    string,
+    any
+  >;
+  return {
+    ...actual,
+    ResponsiveContainer: ({ children }: { children: React.ReactElement }) => {
+      return React.cloneElement(children, {
+        width: 600,
+        height: 300,
+      } as Record<string, unknown>);
+    },
+  };
+});
+
+/*
+ * Compare-to-previous ghost series must be visually and interactively
+ * second-class: dashed, and never part of the fat invisible click-target
+ * lines that make live series selectable.
+ */
+
+type ChartRow = Record<string, any>;
+
+const data: Array<ChartRow> = [
+  { time: "10:00", live: 10, "live (previous)": 8 },
+  { time: "10:05", live: 20, "live (previous)": 12 },
+  { time: "10:10", live: 15, "live (previous)": 9 },
+];
+
+describe.each([
+  ["LineChart", LineChart],
+  ["AreaChart", AreaChart],
+] as Array<[string, typeof LineChart | typeof AreaChart]>)(
+  "%s ghost series",
+  (_name: string, Chart: typeof LineChart | typeof AreaChart) => {
+    test("ghost categories render dashed; live ones do not", () => {
+      const { container } = render(
+        <Chart
+          data={data}
+          index="time"
+          categories={["live", "live (previous)"]}
+          ghostCategories={["live (previous)"]}
+        />,
+      );
+
+      const dashed: Array<Element> = Array.from(
+        container.querySelectorAll('path[stroke-dasharray="6 4"]'),
+      );
+      expect(dashed.length).toBeGreaterThan(0);
+
+      /*
+       * The live series' curve must NOT be dashed — recharts names each
+       * series path group; assert at least one series curve without the
+       * ghost dash exists.
+       */
+      const allCurves: Array<Element> = Array.from(
+        container.querySelectorAll(".recharts-layer path"),
+      ).filter((el: Element) => {
+        return el.getAttribute("stroke-dasharray") !== "6 4";
+      });
+      expect(allCurves.length).toBeGreaterThan(0);
+    });
+
+    test("ghosts are excluded from the fat click-target lines", () => {
+      const { container } = render(
+        <Chart
+          data={data}
+          index="time"
+          categories={["live", "live (previous)"]}
+          ghostCategories={["live (previous)"]}
+          onValueChange={() => {
+            // Enables the click-target machinery, like the wrappers do.
+          }}
+        />,
+      );
+
+      /*
+       * LineChart renders invisible strokeWidth-12 click-targets per
+       * SELECTABLE series; ghosts must not get one. (AreaChart has no
+       * fat-line mechanism — zero is correct there.)
+       */
+      const fatLines: Array<Element> = Array.from(
+        container.querySelectorAll('path[stroke-width="12"]'),
+      );
+      expect(fatLines.length).toBeLessThanOrEqual(1);
+      for (const fatLine of fatLines) {
+        expect(fatLine.getAttribute("name")).not.toContain("(previous)");
+      }
+    });
+  },
+);