@oneuptime/common 12.0.33 → 13.0.0

package/Tests/Server/Utils/Monitor/Criteria/IncomingRequestHeaderCriteria.test.ts

@@ -0,0 +1,236 @@
+import IncomingRequestCriteria from "../../../../../Server/Utils/Monitor/Criteria/IncomingRequestCriteria";
+import DataToProcess from "../../../../../Server/Utils/Monitor/DataToProcess";
+import OneUptimeDate from "../../../../../Types/Date";
+import Dictionary from "../../../../../Types/Dictionary";
+import {
+  CheckOn,
+  CriteriaFilter,
+  FilterType,
+} from "../../../../../Types/Monitor/CriteriaFilter";
+import IncomingMonitorRequest from "../../../../../Types/Monitor/IncomingMonitor/IncomingMonitorRequest";
+import ObjectID from "../../../../../Types/ObjectID";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * CheckOn.RequestHeader and CheckOn.RequestHeaderValue on an Incoming
+ * Request monitor: "the ping must carry x-api-key", "the ping must NOT
+ * carry a header saying maintenance".
+ *
+ * Both are whole-token comparisons against the header map - a header is
+ * present or it is not - and both are case-insensitive on BOTH sides, which
+ * is the half that used to be missing: a filter typed the way HTTP headers
+ * are written ("X-Api-Key") was compared against a list that had already
+ * been lower-cased, so Contains never fired and NotContains fired on every
+ * request.
+ */
+
+function buildRequest(headers: Dictionary<string> | undefined): DataToProcess {
+  const now: Date = OneUptimeDate.getCurrentDate();
+
+  const request: IncomingMonitorRequest = {
+    projectId: ObjectID.generate(),
+    monitorId: ObjectID.generate(),
+    requestBody: "",
+    requestHeaders: headers,
+    incomingRequestReceivedAt: now,
+    checkedAt: now,
+  };
+
+  return request as DataToProcess;
+}
+
+function evaluate(
+  headers: Dictionary<string> | undefined,
+  criteriaFilter: CriteriaFilter,
+): Promise<string | null> {
+  return IncomingRequestCriteria.isMonitorInstanceCriteriaFilterMet({
+    dataToProcess: buildRequest(headers),
+    criteriaFilter,
+  });
+}
+
+function headerFilter(
+  filterType: FilterType,
+  value: string | undefined,
+): CriteriaFilter {
+  return { checkOn: CheckOn.RequestHeader, filterType, value };
+}
+
+function headerValueFilter(
+  filterType: FilterType,
+  value: string | undefined,
+): CriteriaFilter {
+  return { checkOn: CheckOn.RequestHeaderValue, filterType, value };
+}
+
+const HEADERS: Dictionary<string> = {
+  "X-Api-Key": "SecretToken",
+  "content-type": "application/json",
+};
+
+describe("IncomingRequestCriteria - CheckOn.RequestHeader", () => {
+  describe("Contains", () => {
+    test("a header the request carries matches, however either side is cased", async () => {
+      for (const typed of ["x-api-key", "X-Api-Key", "X-API-KEY"]) {
+        expect(
+          await evaluate(HEADERS, headerFilter(FilterType.Contains, typed)),
+        ).toContain("Request header contains");
+      }
+    });
+
+    test("the message quotes the filter as it was typed, not as it was compared", async () => {
+      expect(
+        await evaluate(HEADERS, headerFilter(FilterType.Contains, "X-Api-Key")),
+      ).toBe("Request header contains X-Api-Key.");
+    });
+
+    test("a header the request does not carry does not match", async () => {
+      expect(
+        await evaluate(
+          HEADERS,
+          headerFilter(FilterType.Contains, "authorization"),
+        ),
+      ).toBeNull();
+    });
+
+    test("a prefix of a header name does not match: this compares whole names", async () => {
+      expect(
+        await evaluate(HEADERS, headerFilter(FilterType.Contains, "x-api")),
+      ).toBeNull();
+    });
+
+    test("a request with no headers at all matches nothing", async () => {
+      expect(
+        await evaluate(
+          undefined,
+          headerFilter(FilterType.Contains, "x-api-key"),
+        ),
+      ).toBeNull();
+      expect(
+        await evaluate({}, headerFilter(FilterType.Contains, "x-api-key")),
+      ).toBeNull();
+    });
+
+    test("a filter with no value cannot decide, so it does not match", async () => {
+      expect(
+        await evaluate(HEADERS, headerFilter(FilterType.Contains, undefined)),
+      ).toBeNull();
+      expect(
+        await evaluate(HEADERS, headerFilter(FilterType.Contains, "")),
+      ).toBeNull();
+    });
+  });
+
+  describe("Not Contains", () => {
+    test("a header the request does not carry matches", async () => {
+      expect(
+        await evaluate(
+          HEADERS,
+          headerFilter(FilterType.NotContains, "authorization"),
+        ),
+      ).toContain("Request header does not contain");
+    });
+
+    test("a header the request DOES carry does not match, whatever its casing", async () => {
+      for (const typed of ["x-api-key", "X-Api-Key", "X-API-KEY"]) {
+        expect(
+          await evaluate(HEADERS, headerFilter(FilterType.NotContains, typed)),
+        ).toBeNull();
+      }
+    });
+
+    test("Contains and Not Contains never agree on the same header", async () => {
+      for (const name of ["X-Api-Key", "authorization", "content-type"]) {
+        const contains: string | null = await evaluate(
+          HEADERS,
+          headerFilter(FilterType.Contains, name),
+        );
+        const notContains: string | null = await evaluate(
+          HEADERS,
+          headerFilter(FilterType.NotContains, name),
+        );
+
+        expect(Boolean(contains)).not.toBe(Boolean(notContains));
+      }
+    });
+  });
+
+  test("a filter type this check does not support does not match", async () => {
+    expect(
+      await evaluate(HEADERS, headerFilter(FilterType.EqualTo, "x-api-key")),
+    ).toBeNull();
+  });
+});
+
+describe("IncomingRequestCriteria - CheckOn.RequestHeaderValue", () => {
+  describe("Contains", () => {
+    test("a value the request carries matches, however either side is cased", async () => {
+      for (const typed of ["secrettoken", "SecretToken", "SECRETTOKEN"]) {
+        expect(
+          await evaluate(
+            HEADERS,
+            headerValueFilter(FilterType.Contains, typed),
+          ),
+        ).toContain("Request header value contains");
+      }
+    });
+
+    test("a value no header carries does not match", async () => {
+      expect(
+        await evaluate(
+          HEADERS,
+          headerValueFilter(FilterType.Contains, "text/html"),
+        ),
+      ).toBeNull();
+    });
+
+    test("a substring of a value does not match: this compares whole values", async () => {
+      expect(
+        await evaluate(
+          HEADERS,
+          headerValueFilter(FilterType.Contains, "secret"),
+        ),
+      ).toBeNull();
+    });
+
+    test("a request with no headers at all matches nothing", async () => {
+      expect(
+        await evaluate(
+          undefined,
+          headerValueFilter(FilterType.Contains, "secrettoken"),
+        ),
+      ).toBeNull();
+    });
+  });
+
+  describe("Not Contains", () => {
+    test("a value no header carries matches", async () => {
+      expect(
+        await evaluate(
+          HEADERS,
+          headerValueFilter(FilterType.NotContains, "text/html"),
+        ),
+      ).toContain("Request header value does not contain");
+    });
+
+    test("a value a header DOES carry does not match, whatever its casing", async () => {
+      for (const typed of ["secrettoken", "SecretToken"]) {
+        expect(
+          await evaluate(
+            HEADERS,
+            headerValueFilter(FilterType.NotContains, typed),
+          ),
+        ).toBeNull();
+      }
+    });
+
+    test("a filter with no value cannot decide, so it does not match", async () => {
+      expect(
+        await evaluate(
+          HEADERS,
+          headerValueFilter(FilterType.NotContains, undefined),
+        ),
+      ).toBeNull();
+    });
+  });
+});

package/Tests/Server/Utils/Monitor/Criteria/MetricMonitorCriteria.test.ts

@@ -111,8 +111,15 @@ describe("MetricMonitorCriteria.isMonitorInstanceCriteriaFilterMet", () => {
       await MetricMonitorCriteria.isMonitorInstanceCriteriaFilterMet(inputs);
 
     expect(message).toBeTruthy();
-    expect(message).toContain("greater than 2000 ms");
-    expect(message).toContain("2500 ms");
+    /*
+     * The COMPARISON happens in the metric's native ms — that is what this
+     * test is about, and the context below pins it. The MESSAGE renders
+     * those same milliseconds at the scale a human reads them at, so 2500
+     * ms is written "2.5 sec"; the threshold gets the same treatment so
+     * the two halves of the sentence cannot disagree.
+     */
+    expect(message).toContain("greater than 2 sec");
+    expect(message).toContain("2.5 sec");
     expect(criteriaFilter.metricCriteriaContext?.unit).toBe("ms");
     expect(criteriaFilter.metricCriteriaContext?.breachingSample?.value).toBe(
       2500,
@@ -228,11 +235,23 @@ describe("MetricMonitorCriteria.isMonitorInstanceCriteriaFilterMet", () => {
       await MetricMonitorCriteria.isMonitorInstanceCriteriaFilterMet(inputs);
 
     /*
-     * No conversion possible, so the displayed unit/values use user's MB
-     * label but values are passed through.
+     * No conversion possible, so the sample value is passed through
+     * untouched and the criteria still speaks the user's chosen MB. Those
+     * two facts are the subject of this test and are asserted directly on
+     * the context.
+     *
+     * The rendered sentence is deliberately NOT asserted on: the user has
+     * mislabelled a 5000 ms sample as 5000 MB, and the renderer takes that
+     * label at its word and reads it out as "5 GB". Any string this
+     * sentence can produce is wrong, because the input is wrong — pinning
+     * one spelling of a wrong answer would only make the misconfiguration
+     * look supported.
      */
     expect(message).toBeTruthy();
-    expect(message).toContain("MB");
+    expect(criteriaFilter.metricCriteriaContext?.unit).toBe("MB");
+    expect(criteriaFilter.metricCriteriaContext?.breachingSample?.value).toBe(
+      5000,
+    );
   });
 
   test("no data + NoDataPolicy.Trigger triggers regardless of threshold", async () => {
@@ -495,7 +514,12 @@ describe("MetricMonitorCriteria.isMonitorInstanceCriteriaFilterMet", () => {
       await MetricMonitorCriteria.isMonitorInstanceCriteriaFilterMet(inputs);
 
     expect(message).toBeTruthy();
-    expect(message).toContain("10 samples between 110 and 200");
+    /*
+     * Both ends of the summary carry the unit, because either end can
+     * land on a different scale than the other once values spread far
+     * enough apart.
+     */
+    expect(message).toContain("10 samples between 110 ms and 200 ms");
     expect(message).toContain("greater than 100 ms");
     // The raw comma-joined dump is no longer in the message
     expect(message).not.toContain("110, 120, 130, 140, 150, 160");

package/Tests/Server/Utils/Monitor/Criteria/MetricMonitorCriteriaAnomalyUnits.test.ts

@@ -0,0 +1,246 @@
+/*
+ * The baseline lookup is the only thing standing between this test and
+ * ClickHouse. Stub it so the anomaly branch runs against a known baseline
+ * and the assertions are about the SENTENCE, which is what an alert email
+ * shows.
+ */
+jest.mock("../../../../../Server/Services/MetricBaselineService", () => {
+  const actual: Record<string, unknown> = jest.requireActual(
+    "../../../../../Server/Services/MetricBaselineService",
+  ) as Record<string, unknown>;
+
+  return {
+    ...actual,
+    __esModule: true,
+    default: {
+      getBaseline: jest.fn(),
+    },
+  };
+});
+
+import MetricMonitorCriteria from "../../../../../Server/Utils/Monitor/Criteria/MetricMonitorCriteria";
+import MetricBaselineService, {
+  BaselineSummary,
+} from "../../../../../Server/Services/MetricBaselineService";
+import AggregateModel from "../../../../../Types/BaseDatabase/AggregatedModel";
+import AggregatedResult from "../../../../../Types/BaseDatabase/AggregatedResult";
+import {
+  CheckOn,
+  CriteriaFilter,
+  FilterType,
+} from "../../../../../Types/Monitor/CriteriaFilter";
+import MetricAliasData from "../../../../../Types/Metrics/MetricAliasData";
+import MetricQueryConfigData from "../../../../../Types/Metrics/MetricQueryConfigData";
+import MetricQueryData from "../../../../../Types/Metrics/MetricQueryData";
+import MetricsViewConfig from "../../../../../Types/Metrics/MetricsViewConfig";
+import MetricMonitorResponse from "../../../../../Types/Monitor/MetricMonitor/MetricMonitorResponse";
+import MonitorStep from "../../../../../Types/Monitor/MonitorStep";
+import RollingTime from "../../../../../Types/RollingTime/RollingTime";
+import ObjectID from "../../../../../Types/ObjectID";
+import { beforeEach, describe, expect, jest, test } from "@jest/globals";
+
+/*
+ * THE ANOMALY SENTENCE.
+ *
+ * An anomaly breach produces its own root cause — it never reaches
+ * CompareCriteria — and it used to print `value.toFixed(3)` with the raw
+ * exporter unit glued on:
+ *
+ *   "container.memory.usage value 1073741824.000 By is 4.20σ above ..."
+ *
+ * The quantities in it are now rendered exactly as the Breaching Samples
+ * table renders them. σ is NOT one of those quantities: it is a count of
+ * standard deviations, dimensionless by construction, and must stay a
+ * bare number no matter what unit the metric carries.
+ */
+
+const BASELINE_MEAN: number = 268435456;
+const BASELINE_STDDEV: number = 134217728;
+const BREACHING_VALUE: number = 1073741824;
+
+function baseline(): BaselineSummary {
+  return {
+    sampleCount: 480,
+    mean: BASELINE_MEAN,
+    stddev: BASELINE_STDDEV,
+    median: BASELINE_MEAN,
+    p95: BASELINE_MEAN,
+    minObserved: 0,
+    maxObserved: BREACHING_VALUE,
+    isReliable: true,
+    windowDays: 14,
+    hourOfWeek: 0,
+  } as BaselineSummary;
+}
+
+function buildInputs(input: {
+  metricNativeUnit: string;
+  metricName: string;
+  sampleValue: number;
+}): {
+  criteriaFilter: CriteriaFilter;
+  monitorStep: MonitorStep;
+  dataToProcess: MetricMonitorResponse;
+  projectId: ObjectID;
+} {
+  const aliasData: MetricAliasData = {
+    metricVariable: "a",
+    title: input.metricName,
+    description: undefined,
+    legend: undefined,
+    legendUnit: input.metricNativeUnit,
+  };
+
+  const queryConfig: MetricQueryConfigData = {
+    metricAliasData: aliasData,
+    metricQueryData: {
+      filterData: {
+        metricName: input.metricName,
+      },
+    } as unknown as MetricQueryData,
+  };
+
+  const metricViewConfig: MetricsViewConfig = {
+    queryConfigs: [queryConfig],
+    formulaConfigs: [],
+  };
+
+  const monitorStep: MonitorStep = new MonitorStep();
+  monitorStep.data = {
+    id: ObjectID.generate().toString(),
+    monitorCriteria: { data: undefined } as never,
+  } as unknown as MonitorStep["data"];
+  monitorStep.data!.metricMonitor = {
+    metricViewConfig,
+    rollingTime: RollingTime.Past1Minute,
+  };
+
+  const aggregated: AggregatedResult = {
+    data: [
+      {
+        timestamp: new Date("2026-08-14T10:30:00.000Z"),
+        value: input.sampleValue,
+      } as AggregateModel,
+    ],
+  };
+
+  const projectId: ObjectID = ObjectID.generate();
+
+  return {
+    criteriaFilter: {
+      checkOn: CheckOn.MetricValue,
+      filterType: FilterType.AnomalouslyHigh,
+      metricMonitorOptions: {
+        metricAlias: "a",
+      },
+    } as CriteriaFilter,
+    monitorStep,
+    dataToProcess: {
+      projectId: projectId,
+      metricResult: [aggregated],
+      metricViewConfig,
+      monitorId: ObjectID.generate(),
+    },
+    projectId,
+  };
+}
+
+async function anomalyRootCause(input: {
+  metricNativeUnit: string;
+  metricName: string;
+  sampleValue: number;
+}): Promise<string> {
+  const inputs: ReturnType<typeof buildInputs> = buildInputs(input);
+
+  const message: string | null =
+    await MetricMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+      criteriaFilter: inputs.criteriaFilter,
+      monitorStep: inputs.monitorStep,
+      dataToProcess: inputs.dataToProcess,
+      projectId: inputs.projectId,
+    } as never);
+
+  expect(message).toBeTruthy();
+  return message as string;
+}
+
+describe("MetricMonitorCriteria - anomaly root cause units", () => {
+  beforeEach(() => {
+    (MetricBaselineService.getBaseline as unknown as jest.Mock).mockReset();
+    (
+      MetricBaselineService.getBaseline as unknown as jest.Mock
+    ).mockResolvedValue(baseline() as never);
+  });
+
+  test("value, mean and stddev are all rendered at human scale", async () => {
+    const rootCause: string = await anomalyRootCause({
+      metricName: "container.memory.usage",
+      metricNativeUnit: "By",
+      sampleValue: BREACHING_VALUE,
+    });
+
+    expect(rootCause).toContain("value 1.07 GB");
+    expect(rootCause).toContain("mean 268 MB");
+    expect(rootCause).toContain("σ 134 MB");
+
+    // The old rendering, in full.
+    expect(rootCause).not.toContain("1073741824.000");
+    expect(rootCause).not.toContain("268435456.000");
+    expect(rootCause).not.toContain("By");
+  });
+
+  /*
+   * The σ COUNT is not a quantity in the metric's unit — "6.00σ above the
+   * baseline" is six standard deviations, and rendering it as "6 GB"
+   * would be nonsense. It keeps its own two-decimal format.
+   */
+  test("the sigma count stays a bare number", async () => {
+    const rootCause: string = await anomalyRootCause({
+      metricName: "container.memory.usage",
+      metricNativeUnit: "By",
+      sampleValue: BREACHING_VALUE,
+    });
+
+    expect(rootCause).toMatch(/is \d+\.\d{2}σ above the same-hour baseline/);
+    expect(rootCause).not.toMatch(/is [\d.]+ [A-Za-z]+σ/);
+  });
+
+  test("a metric with no unit keeps its exact digits", async () => {
+    (
+      MetricBaselineService.getBaseline as unknown as jest.Mock
+    ).mockResolvedValue({
+      ...baseline(),
+      mean: 100,
+      stddev: 20,
+    } as never);
+
+    const rootCause: string = await anomalyRootCause({
+      metricName: "http.server.request.count",
+      metricNativeUnit: "",
+      sampleValue: 5000,
+    });
+
+    expect(rootCause).toContain("value 5000 ");
+    expect(rootCause).not.toContain("5K");
+  });
+
+  test("a ratio metric reads as a percentage", async () => {
+    (
+      MetricBaselineService.getBaseline as unknown as jest.Mock
+    ).mockResolvedValue({
+      ...baseline(),
+      mean: 0.2,
+      stddev: 0.05,
+    } as never);
+
+    const rootCause: string = await anomalyRootCause({
+      metricName: "system.cpu.utilization",
+      metricNativeUnit: "1",
+      sampleValue: 0.85,
+    });
+
+    expect(rootCause).toContain("value 85.00%");
+    expect(rootCause).toContain("mean 20.00%");
+    expect(rootCause).not.toContain("0.85 1");
+  });
+});