@oneuptime/common 12.0.34 → 13.0.1

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

@@ -774,6 +774,248 @@ describe("CompareCriteria", () => {
       ).toBe("Metric Value is 100 ms which is greater than 50 ms.");
     });
 
+    /*
+     * HUMAN-READABLE UNITS.
+     *
+     * This sentence is the "Filter Conditions Met" line of the alert and
+     * incident email. It used to glue the exporter's raw UCUM code onto
+     * raw digits, so a memory breach the dashboard drew as "1.07 GB"
+     * arrived in the inbox as "1073741824 By".
+     *
+     * The unit rides each NUMBER rather than the sentence, because
+     * auto-scaling can land two samples of one window on different scales
+     * and a single trailing suffix cannot describe both.
+     */
+    test("renders a byte value and its threshold at human scale", () => {
+      const filter: CriteriaFilter = makeFilter({
+        checkOn: CheckOn.MetricValue,
+        filterType: FilterType.GreaterThan,
+      });
+      expect(
+        CompareCriteria.getCompareMessage({
+          values: 1073741824,
+          threshold: 1000000000,
+          criteriaFilter: filter,
+          unit: "By",
+        }),
+      ).toBe("Metric Value is 1.07 GB which is greater than 1 GB.");
+    });
+
+    test("rescales a duration", () => {
+      const filter: CriteriaFilter = makeFilter({
+        checkOn: CheckOn.MetricValue,
+        filterType: FilterType.GreaterThan,
+      });
+      expect(
+        CompareCriteria.getCompareMessage({
+          values: 1500,
+          threshold: 1000,
+          criteriaFilter: filter,
+          unit: "ms",
+        }),
+      ).toBe("Metric Value is 1.5 sec which is greater than 1 sec.");
+    });
+
+    test("gives every listed sample its own scale", () => {
+      const filter: CriteriaFilter = makeFilter({
+        checkOn: CheckOn.MetricValue,
+        filterType: FilterType.GreaterThan,
+        evaluateOverTime: true,
+        evaluateOverTimeOptions: {
+          timeValueInMinutes: 5,
+          evaluateOverTimeType: EvaluateOverTimeType.AllValues,
+        },
+      });
+      expect(
+        CompareCriteria.getCompareMessage({
+          values: [921600, 1258291],
+          threshold: 900000,
+          criteriaFilter: filter,
+          unit: "By",
+        }),
+      ).toBe(
+        "All values of Metric Value over the last 5 minutes is 922 KB, 1.26 MB which is greater than 900 KB.",
+      );
+    });
+
+    test("units ride both ends of the 'N samples between X and Y' summary", () => {
+      const filter: CriteriaFilter = makeFilter({
+        checkOn: CheckOn.MetricValue,
+        filterType: FilterType.GreaterThan,
+        evaluateOverTimeOptions: {
+          timeValueInMinutes: 5,
+          evaluateOverTimeType: EvaluateOverTimeType.AllValues,
+        },
+      });
+      const message: string = CompareCriteria.getCompareMessage({
+        values: [1e9, 2e9, 3e9, 4e9, 5e9, 6e9],
+        threshold: 5e8,
+        criteriaFilter: filter,
+        unit: "By",
+      });
+
+      expect(message).toContain("6 samples between 1 GB and 6 GB");
+      expect(message).toContain("greater than 500 MB");
+    });
+
+    /*
+     * OTel's dimensionless "1" used to be printed: a CLS breach read
+     * "is 0.31 1 which is greater than or equal to 0.25 1".
+     */
+    test("the dimensionless '1' is suppressed on a non-fraction metric", () => {
+      const filter: CriteriaFilter = makeFilter({
+        checkOn: CheckOn.MetricValue,
+        filterType: FilterType.GreaterThanOrEqualTo,
+      });
+      const message: string = CompareCriteria.getCompareMessage({
+        values: 0.31,
+        threshold: 0.25,
+        criteriaFilter: filter,
+        metricDisplayName: "browser.cumulative_layout_shift",
+        metricName: "browser.cumulative_layout_shift",
+        unit: "1",
+      });
+
+      expect(message).toBe(
+        "browser.cumulative_layout_shift is 0.31 which is greater than or equal to 0.25.",
+      );
+      expect(message).not.toContain("0.31 1");
+    });
+
+    test("a fraction metric still carrying '1' reads as a percentage", () => {
+      const filter: CriteriaFilter = makeFilter({
+        checkOn: CheckOn.MetricValue,
+        filterType: FilterType.GreaterThan,
+      });
+      const message: string = CompareCriteria.getCompareMessage({
+        values: 0.0585,
+        threshold: 0.05,
+        criteriaFilter: filter,
+        metricDisplayName: "system.cpu.utilization",
+        metricName: "system.cpu.utilization",
+        unit: "1",
+      });
+
+      expect(message).toBe(
+        "system.cpu.utilization is 5.85% which is greater than 5.00%.",
+      );
+    });
+
+    test("a UCUM annotation-only unit is suppressed", () => {
+      const filter: CriteriaFilter = makeFilter({
+        checkOn: CheckOn.MetricValue,
+        filterType: FilterType.GreaterThan,
+      });
+      const message: string = CompareCriteria.getCompareMessage({
+        values: 512,
+        threshold: 500,
+        criteriaFilter: filter,
+        unit: "{thread}",
+      });
+
+      expect(message).toBe("Metric Value is 512 which is greater than 500.");
+      expect(message).not.toContain("{thread}");
+    });
+
+    /*
+     * THE FORMULA GUARD. metricDisplayName is the formula EXPRESSION for a
+     * formula criteria, and `a / b_ratio` ends in `_ratio` — the suffix
+     * the fraction heuristic keys on. Only `metricName`, which callers
+     * pass exclusively for plain metric criteria, may reach that
+     * heuristic; a formula reported at 100× its value would be a far worse
+     * bug than an unlabelled number.
+     */
+    test("a formula expression is never read as a fraction metric name", () => {
+      const filter: CriteriaFilter = makeFilter({
+        checkOn: CheckOn.MetricValue,
+        filterType: FilterType.GreaterThan,
+      });
+      const message: string = CompareCriteria.getCompareMessage({
+        values: 0.42,
+        threshold: 0.4,
+        criteriaFilter: filter,
+        metricDisplayName: "a / b_ratio",
+        unit: "1",
+      });
+
+      expect(message).toBe("a / b_ratio is 0.42 which is greater than 0.4.");
+      expect(message).not.toContain("42.00%");
+    });
+
+    /*
+     * BACKWARD COMPATIBILITY. Only MetricMonitorCriteria and
+     * DatabaseMonitorCriteria pass a unit; every other monitor type
+     * carries its unit inside the CheckOn label ("Response Time (in ms)")
+     * and must keep byte-identical, unabbreviated output.
+     */
+    test("a message with no unit is unchanged, digits and all", () => {
+      const filter: CriteriaFilter = makeFilter({
+        checkOn: CheckOn.ResponseTime,
+        filterType: FilterType.GreaterThan,
+      });
+
+      const expected: string =
+        "Response Time (in ms) is 5000 which is greater than 4900.";
+
+      expect(
+        CompareCriteria.getCompareMessage({
+          values: 5000,
+          threshold: 4900,
+          criteriaFilter: filter,
+        }),
+      ).toBe(expected);
+      expect(
+        CompareCriteria.getCompareMessage({
+          values: 5000,
+          threshold: 4900,
+          criteriaFilter: filter,
+          unit: undefined,
+        }),
+      ).toBe(expected);
+      expect(
+        CompareCriteria.getCompareMessage({
+          values: 5000,
+          threshold: 4900,
+          criteriaFilter: filter,
+          unit: "",
+        }),
+      ).toBe(expected);
+    });
+
+    test("non-numeric filter types ignore a supplied unit", () => {
+      const filter: CriteriaFilter = makeFilter({
+        checkOn: CheckOn.MetricValue,
+        filterType: FilterType.Contains,
+      });
+
+      const message: string = CompareCriteria.getCompareMessage({
+        values: "abc",
+        threshold: "b",
+        criteriaFilter: filter,
+        unit: "By",
+      });
+
+      expect(message).not.toContain("By");
+      expect(message).not.toContain("GB");
+    });
+
+    test("a non-finite value never reaches the scaling ladder", () => {
+      const filter: CriteriaFilter = makeFilter({
+        checkOn: CheckOn.MetricValue,
+        filterType: FilterType.GreaterThan,
+      });
+
+      const message: string = CompareCriteria.getCompareMessage({
+        values: Infinity,
+        threshold: 1000,
+        criteriaFilter: filter,
+        unit: "By",
+      });
+
+      expect(message).toContain("is Infinity which is");
+      expect(message).not.toContain("InfinityP");
+    });
+
     test("includes the disk path for disk usage checks", () => {
       const withPath: CriteriaFilter = makeFilter({
         checkOn: CheckOn.DiskUsagePercent,

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/Criteria/TelemetryStepMetricAlias.test.ts

@@ -23,6 +23,7 @@ import { MonitorStepHostMonitorUtil } from "../../../../../Types/Monitor/Monitor
 import { MonitorStepKubernetesMonitorUtil } from "../../../../../Types/Monitor/MonitorStepKubernetesMonitor";
 import { MonitorStepPodmanMonitorUtil } from "../../../../../Types/Monitor/MonitorStepPodmanMonitor";
 import { MonitorStepProxmoxMonitorUtil } from "../../../../../Types/Monitor/MonitorStepProxmoxMonitor";
+import { MonitorStepVMwareMonitorUtil } from "../../../../../Types/Monitor/MonitorStepVMwareMonitor";
 import RollingTime from "../../../../../Types/RollingTime/RollingTime";
 import ObjectID from "../../../../../Types/ObjectID";
 
@@ -316,6 +317,15 @@ describe("MetricMonitorCriteria — other telemetry step shapes", () => {
         };
       },
     },
+    {
+      name: "vmwareMonitor",
+      assignShape: (data: MonitorStepType, v: MetricsViewConfig) => {
+        data.vmwareMonitor = {
+          ...MonitorStepVMwareMonitorUtil.getDefault(),
+          metricViewConfig: v,
+        };
+      },
+    },
     {
       name: "cephMonitor",
       assignShape: (data: MonitorStepType, v: MetricsViewConfig) => {