@oneuptime/common 12.0.34 → 13.0.0

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

@@ -312,7 +312,7 @@ describe("CompareCriteria aggregation semantics", () => {
       });
 
       expect(message).toBe(
-        "Any value of CPU is 95, 96, 97 % which is greater than 90 %.",
+        "Any value of CPU is 95.00%, 96.00%, 97.00% which is greater than 90.00%.",
       );
     });
 
@@ -328,7 +328,7 @@ describe("CompareCriteria aggregation semantics", () => {
         unit: "%",
       });
 
-      expect(message).toContain("80, 70");
+      expect(message).toContain("80.00%, 70.00%");
       expect(message).not.toContain("95");
     });
 
@@ -345,7 +345,7 @@ describe("CompareCriteria aggregation semantics", () => {
       });
 
       expect(message).toBe(
-        "All values of CPU is 95, 96 % which is greater than 90 %.",
+        "All values of CPU is 95.00%, 96.00% which is greater than 90.00%.",
       );
     });
 
@@ -513,15 +513,21 @@ describe("CompareCriteria aggregation semantics", () => {
       /*
        * The guard against over-suppression. If this ever goes quiet the
        * fix has widened into a general unit filter.
+       *
+       * The unit now rides each NUMBER at the scale that number landed on,
+       * so a sub-byte value reports "B" and 0.85 ms is written out as the
+       * 850 µs it is. Both halves of the sentence go through the same
+       * renderer, which is the property that matters here: the observed
+       * value and the threshold can never be quoted in different units.
        */
       expect(unitMessage("By")).toBe(
-        "Any value of Metric Value is 0.85 By which is greater than 0.8 By.",
+        "Any value of Metric Value is 0.85 B which is greater than 0.8 B.",
       );
       expect(unitMessage("%")).toBe(
-        "Any value of Metric Value is 0.85 % which is greater than 0.8 %.",
+        "Any value of Metric Value is 0.85% which is greater than 0.80%.",
       );
       expect(unitMessage("ms")).toBe(
-        "Any value of Metric Value is 0.85 ms which is greater than 0.8 ms.",
+        "Any value of Metric Value is 850 µs which is greater than 800 µs.",
       );
       // "1" is suppressed; a unit that merely CONTAINS a 1 is not.
       expect(unitMessage("m/s2")).toContain("0.85 m/s2");
@@ -532,7 +538,7 @@ describe("CompareCriteria aggregation semantics", () => {
       const message: string = unitMessage(" ms ");
 
       expect(message).toBe(
-        "Any value of Metric Value is 0.85 ms which is greater than 0.8 ms.",
+        "Any value of Metric Value is 850 µs which is greater than 800 µs.",
       );
       expect(message).not.toContain("  ");
     });

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

@@ -178,6 +178,35 @@ describe("DatabaseMonitorCriteria.isMonitorInstanceCriteriaFilterMet", () => {
       expect(result).toContain("95");
     });
 
+    /*
+     * A Database Health metric carries an explicit catalog unit, and
+     * DatabaseMonitorCriteria hands that unit to CompareCriteria for the
+     * alert email. The observation beside it used to render bytes with a
+     * 1024 divisor while labelling the rungs SI, so one byte count read
+     * three ways across the product: "1.07 GB" in the email, "1.00 GB" in
+     * the evaluation log, and "1000000000 bytes" in the expectation
+     * clause. All three now agree.
+     */
+    test("a bytes metric is rescaled decimally, matching the alert email", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({
+          metrics: {
+            [MonitorMetricType.DatabaseSizeBytes]: 1073741824,
+          },
+        }),
+        metricFilter(
+          MonitorMetricType.DatabaseSizeBytes,
+          FilterType.GreaterThan,
+          "1000000000",
+        ),
+      );
+
+      expect(result).toContain("1.07 GB");
+      // The 1024-based rendering this used to produce.
+      expect(result).not.toContain("1.00 GB");
+      expect(result).not.toContain("1073741824");
+    });
+
     test("percent metric 40 > 90 -> not met", async () => {
       const result: string | null = await evaluate(
         buildDataToProcess({

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");
+  });
+});

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

@@ -0,0 +1,280 @@
+import MonitorCriteriaMessageBuilder from "../../../../Server/Utils/Monitor/MonitorCriteriaMessageBuilder";
+import CompareCriteria from "../../../../Server/Utils/Monitor/Criteria/CompareCriteria";
+import Monitor from "../../../../Models/DatabaseModels/Monitor";
+import {
+  CheckOn,
+  CriteriaFilter,
+  EvaluateOverTimeType,
+  FilterType,
+} from "../../../../Types/Monitor/CriteriaFilter";
+import AggregateModel from "../../../../Types/BaseDatabase/AggregatedModel";
+import AggregatedResult from "../../../../Types/BaseDatabase/AggregatedResult";
+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 { describe, expect, test } from "@jest/globals";
+
+/*
+ * ONE SAMPLE, ONE DESCRIPTION.
+ *
+ * A metric breach is written twice, by two different code paths, and a
+ * user compares them side by side:
+ *
+ *   - the ALERT EMAIL's "Filter Conditions Met" line, produced by
+ *     CompareCriteria when the filter MATCHED, and
+ *   - the monitor's EVALUATION LOG line, produced by the observation and
+ *     expectation builders when the filter did NOT match.
+ *
+ * Only the first was migrated to MetricValueFormatter, so the same
+ * 1073741824-byte sample read "1.07 GB" in the inbox and
+ * "1073741824.00 By" on the monitor page — and a ratio metric read "6.00%"
+ * in one and "0.06" in the other.
+ *
+ * These tests assert the two paths render the same quantity the same way.
+ * They are deliberately about AGREEMENT rather than about either exact
+ * wording: the sentences around the number differ by design, the number
+ * and its unit must not.
+ */
+
+function buildInputs(input: {
+  metricNativeUnit: string;
+  metricName: string;
+  sampleValues: Array<number>;
+  criteriaFilter: CriteriaFilter;
+}): {
+  monitor: Monitor;
+  criteriaFilter: CriteriaFilter;
+  monitorStep: MonitorStep;
+  dataToProcess: MetricMonitorResponse;
+} {
+  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: input.sampleValues.map((v: number) => {
+      return {
+        timestamp: new Date(),
+        value: v,
+      } as AggregateModel;
+    }),
+  };
+
+  return {
+    monitor: new Monitor(),
+    criteriaFilter: input.criteriaFilter,
+    monitorStep,
+    dataToProcess: {
+      projectId: ObjectID.generate(),
+      metricResult: [aggregated],
+      metricViewConfig,
+      monitorId: ObjectID.generate(),
+    },
+  };
+}
+
+interface AgreementCase {
+  name: string;
+  metricName: string;
+  nativeUnit: string;
+  sample: number;
+  threshold: string;
+  /** The rendering both paths must produce for `sample`. */
+  expectedValue: string;
+  /** The rendering both paths must produce for `threshold`. */
+  expectedThreshold: string;
+}
+
+const CASES: Array<AgreementCase> = [
+  {
+    name: "bytes rescale to gigabytes",
+    metricName: "k8s.pod.memory.usage",
+    nativeUnit: "By",
+    sample: 1073741824,
+    threshold: "1000000000",
+    expectedValue: "1.07 GB",
+    expectedThreshold: "1 GB",
+  },
+  {
+    name: "milliseconds rescale to seconds",
+    metricName: "http.server.request.duration",
+    nativeUnit: "ms",
+    sample: 1500,
+    threshold: "1000",
+    expectedValue: "1.5 sec",
+    expectedThreshold: "1 sec",
+  },
+  {
+    name: "a fraction metric reads as a percentage",
+    metricName: "system.cpu.utilization",
+    nativeUnit: "1",
+    sample: 0.0585,
+    threshold: "0.05",
+    expectedValue: "5.85%",
+    expectedThreshold: "5.00%",
+  },
+  {
+    name: "a non-fraction metric carrying '1' stays bare",
+    metricName: "browser.cumulative_layout_shift",
+    nativeUnit: "1",
+    sample: 0.31,
+    threshold: "0.25",
+    expectedValue: "0.31",
+    expectedThreshold: "0.25",
+  },
+  {
+    name: "a metric with no unit keeps its exact digits",
+    metricName: "http.server.request.count",
+    nativeUnit: "",
+    sample: 5000,
+    threshold: "4900",
+    expectedValue: "5000",
+    expectedThreshold: "4900",
+  },
+];
+
+describe("the alert email and the evaluation log describe one sample identically", () => {
+  for (const testCase of CASES) {
+    test(testCase.name, () => {
+      const criteriaFilter: CriteriaFilter = {
+        checkOn: CheckOn.MetricValue,
+        filterType: FilterType.GreaterThan,
+        value: testCase.threshold,
+        metricMonitorOptions: {
+          metricAlias: "a",
+          metricAggregationType: EvaluateOverTimeType.AnyValue,
+        },
+      };
+
+      const inputs: ReturnType<typeof buildInputs> = buildInputs({
+        metricNativeUnit: testCase.nativeUnit,
+        metricName: testCase.metricName,
+        sampleValues: [testCase.sample],
+        criteriaFilter,
+      });
+
+      /*
+       * What the alert email says — CompareCriteria's sentence, which is
+       * returned verbatim as the root cause when the filter matched.
+       */
+      const emailLine: string = CompareCriteria.getCompareMessage({
+        values: testCase.sample,
+        threshold: Number(testCase.threshold),
+        criteriaFilter: criteriaFilter,
+        metricDisplayName: testCase.metricName,
+        metricName: testCase.metricName,
+        unit: testCase.nativeUnit || undefined,
+      });
+
+      // What the monitor's evaluation log says for the same sample.
+      const evalLogLine: string =
+        MonitorCriteriaMessageBuilder.buildCriteriaFilterMessage({
+          ...inputs,
+          didMeetCriteria: false,
+          matchMessage: null,
+        });
+
+      expect(emailLine).toContain(testCase.expectedValue);
+      expect(evalLogLine).toContain(testCase.expectedValue);
+
+      expect(emailLine).toContain(testCase.expectedThreshold);
+      expect(evalLogLine).toContain(testCase.expectedThreshold);
+    });
+  }
+
+  /*
+   * The specific strings the drift used to produce. Asserting their
+   * absence is what makes this suite fail loudly if either path is
+   * reverted to its own formatter.
+   */
+  test("neither path emits the pre-migration renderings", () => {
+    const criteriaFilter: CriteriaFilter = {
+      checkOn: CheckOn.MetricValue,
+      filterType: FilterType.GreaterThan,
+      value: "1000000000",
+      metricMonitorOptions: {
+        metricAlias: "a",
+        metricAggregationType: EvaluateOverTimeType.AnyValue,
+      },
+    };
+
+    const inputs: ReturnType<typeof buildInputs> = buildInputs({
+      metricNativeUnit: "By",
+      metricName: "k8s.pod.memory.usage",
+      sampleValues: [1073741824],
+      criteriaFilter,
+    });
+
+    const evalLogLine: string =
+      MonitorCriteriaMessageBuilder.buildCriteriaFilterMessage({
+        ...inputs,
+        didMeetCriteria: false,
+        matchMessage: null,
+      });
+
+    expect(evalLogLine).not.toContain("1073741824");
+    expect(evalLogLine).not.toContain(" By");
+  });
+
+  /*
+   * A matched filter short-circuits: the message builder returns
+   * CompareCriteria's sentence untouched. Pinning this keeps the two
+   * paths from being confused for one another — the agreement above is a
+   * property of two DIFFERENT renderers, not of one shared call.
+   */
+  test("a matched filter returns the email sentence verbatim", () => {
+    const criteriaFilter: CriteriaFilter = {
+      checkOn: CheckOn.MetricValue,
+      filterType: FilterType.GreaterThan,
+      value: "1000000000",
+    };
+
+    const inputs: ReturnType<typeof buildInputs> = buildInputs({
+      metricNativeUnit: "By",
+      metricName: "k8s.pod.memory.usage",
+      sampleValues: [1073741824],
+      criteriaFilter,
+    });
+
+    expect(
+      MonitorCriteriaMessageBuilder.buildCriteriaFilterMessage({
+        ...inputs,
+        didMeetCriteria: true,
+        matchMessage: "Metric Value is 1.07 GB which is greater than 1 GB.",
+      }),
+    ).toBe("Metric Value is 1.07 GB which is greater than 1 GB.");
+  });
+});