@oneuptime/common 14.0.5 → 14.0.6

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

@@ -0,0 +1,417 @@
+/*
+ * MonitorCriteriaEvaluator reaches the template renderer, which loads the
+ * native isolated-vm addon. Nothing here uses the sandbox and the
+ * prebuilt binary cannot always dlopen in the test environment.
+ */
+jest.mock("isolated-vm", () => {
+  return {};
+});
+
+import Monitor from "../../../../Models/DatabaseModels/Monitor";
+import MonitorCriteriaEvaluator from "../../../../Server/Utils/Monitor/MonitorCriteriaEvaluator";
+import MetricMonitorCriteria from "../../../../Server/Utils/Monitor/Criteria/MetricMonitorCriteria";
+import AggregateModel from "../../../../Types/BaseDatabase/AggregatedModel";
+import AggregatedResult from "../../../../Types/BaseDatabase/AggregatedResult";
+import FilterCondition from "../../../../Types/Filter/FilterCondition";
+import {
+  CheckOn,
+  CriteriaFilter,
+  EvaluateOverTimeType,
+  FilterType,
+} from "../../../../Types/Monitor/CriteriaFilter";
+import MetricMonitorResponse from "../../../../Types/Monitor/MetricMonitor/MetricMonitorResponse";
+import MonitorCriteria from "../../../../Types/Monitor/MonitorCriteria";
+import MonitorCriteriaInstance from "../../../../Types/Monitor/MonitorCriteriaInstance";
+import MonitorEvaluationSummary, {
+  MonitorEvaluationCriteriaResult,
+  MonitorEvaluationFilterResult,
+} from "../../../../Types/Monitor/MonitorEvaluationSummary";
+import MonitorStep from "../../../../Types/Monitor/MonitorStep";
+import MonitorType from "../../../../Types/Monitor/MonitorType";
+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 ObjectID from "../../../../Types/ObjectID";
+import ProbeApiIngestResponse from "../../../../Types/Probe/ProbeApiIngestResponse";
+import RollingTime from "../../../../Types/RollingTime/RollingTime";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * REGRESSION: a decimal metric threshold typed in the dashboard was
+ * truncated to an integer before it was compared.
+ *
+ * The criteria form saves CriteriaFilter.value as the STRING the user
+ * typed, and MetricMonitorCriteria read it through
+ * CompareCriteria.convertToNumber, which runs parseInt. So "0.9" on a
+ * ratio metric was compared as 0 — "error ratio > 0.9" fired on every
+ * non-zero sample — and "85.5" was compared as 85. The evaluation log
+ * meanwhile rendered the threshold with Number(), so it read "expected
+ * to be greater than 0.9" right next to a criteria it said was met by
+ * 0.5.
+ *
+ * Metric-value thresholds are now parsed with parseFloat. Every other
+ * checkOn keeps parseInt (ProfileMonitorCriteria.test.ts pins that).
+ */
+
+const CRITERIA_ID: string = "decimal-threshold";
+
+function buildStep(criteriaInstance: MonitorCriteriaInstance): MonitorStep {
+  const metricAliasData: MetricAliasData = {
+    metricVariable: "a",
+    title: "Error Ratio",
+    description: undefined,
+    legend: undefined,
+    legendUnit: undefined,
+  };
+
+  const queryConfig: MetricQueryConfigData = {
+    metricAliasData,
+    metricQueryData: {
+      filterData: { metricName: "http.server.error_rate" },
+    } as unknown as MetricQueryData,
+  };
+
+  const metricViewConfig: MetricsViewConfig = {
+    queryConfigs: [queryConfig],
+    formulaConfigs: [],
+  };
+
+  const criteria: MonitorCriteria = new MonitorCriteria();
+  criteria.data = {
+    monitorCriteriaInstanceArray: [criteriaInstance],
+  };
+
+  const monitorStep: MonitorStep = new MonitorStep();
+  monitorStep.data = {
+    id: ObjectID.generate().toString(),
+    monitorCriteria: criteria,
+  } as unknown as MonitorStep["data"];
+  monitorStep.data!.metricMonitor = {
+    metricViewConfig,
+    rollingTime: RollingTime.Past1Minute,
+  };
+
+  return monitorStep;
+}
+
+function buildResponse(sampleValues: Array<number>): MetricMonitorResponse {
+  const aggregated: AggregatedResult = {
+    data: sampleValues.map((value: number) => {
+      return {
+        timestamp: new Date("2026-09-25T00:00:00.000Z"),
+        value,
+      } as AggregateModel;
+    }),
+  };
+
+  return {
+    projectId: ObjectID.generate(),
+    monitorId: ObjectID.generate(),
+    metricResult: [aggregated],
+    metricViewConfig: { queryConfigs: [], formulaConfigs: [] },
+  } as unknown as MetricMonitorResponse;
+}
+
+// The filter exactly as the dashboard criteria form saves it.
+function dashboardFilter(input: {
+  filterType: FilterType;
+  value: string;
+}): CriteriaFilter {
+  return {
+    checkOn: CheckOn.MetricValue,
+    filterType: input.filterType,
+    value: input.value,
+    metricMonitorOptions: {
+      metricAlias: "a",
+      metricAggregationType: EvaluateOverTimeType.AnyValue,
+    },
+  };
+}
+
+function criteriaInstance(filter: CriteriaFilter): MonitorCriteriaInstance {
+  const instance: MonitorCriteriaInstance = new MonitorCriteriaInstance();
+  instance.data = {
+    id: CRITERIA_ID,
+    name: "Error ratio breach",
+    description: "",
+    monitorStatusId: undefined,
+    filterCondition: FilterCondition.All,
+    filters: [filter],
+    incidents: [],
+    alerts: [],
+    createAlerts: true,
+    createIncidents: true,
+    isEnabled: true,
+  } as unknown as MonitorCriteriaInstance["data"];
+  return instance;
+}
+
+async function processMonitorStep(input: {
+  filter: CriteriaFilter;
+  sampleValues: Array<number>;
+}): Promise<{
+  response: ProbeApiIngestResponse;
+  filterResult: MonitorEvaluationFilterResult;
+}> {
+  const monitor: Monitor = new Monitor();
+  monitor._id = ObjectID.generate().toString();
+  monitor.projectId = ObjectID.generate();
+  monitor.monitorType = MonitorType.Metrics;
+  monitor.name = "Error ratio";
+
+  const summary: MonitorEvaluationSummary = {
+    criteriaResults: [],
+    events: [],
+  } as unknown as MonitorEvaluationSummary;
+
+  const response: ProbeApiIngestResponse =
+    await MonitorCriteriaEvaluator.processMonitorStep({
+      dataToProcess: buildResponse(input.sampleValues),
+      monitorStep: buildStep(criteriaInstance(input.filter)),
+      monitor,
+      probeApiIngestResponse: {
+        monitorId: monitor.id!,
+        rootCause: null,
+      },
+      evaluationSummary: summary,
+    });
+
+  const criteriaResult: MonitorEvaluationCriteriaResult | undefined =
+    summary.criteriaResults[0];
+  expect(criteriaResult).toBeDefined();
+
+  const filterResult: MonitorEvaluationFilterResult | undefined =
+    criteriaResult!.filters[0];
+  expect(filterResult).toBeDefined();
+
+  return { response, filterResult: filterResult! };
+}
+
+async function metricCriteriaMet(input: {
+  filter: CriteriaFilter;
+  sampleValues: Array<number>;
+}): Promise<string | null> {
+  const criteria: MonitorCriteriaInstance = criteriaInstance(input.filter);
+
+  return await MetricMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+    dataToProcess: buildResponse(input.sampleValues),
+    criteriaFilter: input.filter,
+    monitorStep: buildStep(criteria),
+  });
+}
+
+describe("decimal metric thresholds, end to end through processMonitorStep", () => {
+  test('"> 0.9" does not fire on a 0.5 sample', async () => {
+    /*
+     * The bug: "0.9" was parsed as 0, and 0.5 > 0 met the criteria and
+     * opened an incident.
+     */
+    const { response, filterResult } = await processMonitorStep({
+      filter: dashboardFilter({
+        filterType: FilterType.GreaterThan,
+        value: "0.9",
+      }),
+      sampleValues: [0.5],
+    });
+
+    expect(response.criteriaMetId).toBeUndefined();
+    expect(response.rootCause).toBeNull();
+    expect(filterResult.met).toBe(false);
+    expect(filterResult.value).toBe("0.9");
+  });
+
+  test('"> 0.9" fires on a 0.95 sample and the root cause quotes 0.9', async () => {
+    const { response, filterResult } = await processMonitorStep({
+      filter: dashboardFilter({
+        filterType: FilterType.GreaterThan,
+        value: "0.9",
+      }),
+      sampleValues: [0.95],
+    });
+
+    expect(response.criteriaMetId).toBe(CRITERIA_ID);
+    expect(filterResult.met).toBe(true);
+    expect(response.rootCause).toContain("0.9");
+  });
+
+  test('"> 85.5" does not fire on 85.2, which is above the old truncated 85', async () => {
+    const { response, filterResult } = await processMonitorStep({
+      filter: dashboardFilter({
+        filterType: FilterType.GreaterThan,
+        value: "85.5",
+      }),
+      sampleValues: [85.2],
+    });
+
+    expect(response.criteriaMetId).toBeUndefined();
+    expect(filterResult.met).toBe(false);
+  });
+
+  test('"> 85.5" fires on 85.7', async () => {
+    const { response, filterResult } = await processMonitorStep({
+      filter: dashboardFilter({
+        filterType: FilterType.GreaterThan,
+        value: "85.5",
+      }),
+      sampleValues: [85.7],
+    });
+
+    expect(response.criteriaMetId).toBe(CRITERIA_ID);
+    expect(filterResult.met).toBe(true);
+  });
+
+  test("the evaluation log quotes the threshold that was actually compared", async () => {
+    /*
+     * Before the fix this filter was logged as met, with the message
+     * "Error Ratio was 0.5 in 1 reading, above the 0 threshold."
+     */
+    const notMet: { filterResult: MonitorEvaluationFilterResult } =
+      await processMonitorStep({
+        filter: dashboardFilter({
+          filterType: FilterType.GreaterThan,
+          value: "0.9",
+        }),
+        sampleValues: [0.5],
+      });
+
+    expect(notMet.filterResult.met).toBe(false);
+    expect(notMet.filterResult.message).toContain(
+      "expected to be greater than 0.9",
+    );
+    expect(notMet.filterResult.message).not.toContain("the 0 threshold");
+
+    const met: { filterResult: MonitorEvaluationFilterResult } =
+      await processMonitorStep({
+        filter: dashboardFilter({
+          filterType: FilterType.GreaterThan,
+          value: "0.9",
+        }),
+        sampleValues: [0.95],
+      });
+
+    expect(met.filterResult.met).toBe(true);
+    expect(met.filterResult.message).toContain("0.9 threshold");
+  });
+});
+
+describe("decimal metric thresholds in MetricMonitorCriteria", () => {
+  test('"< 0.5" fires on 0.3 (it compared as "< 0" before and never fired)', async () => {
+    expect(
+      await metricCriteriaMet({
+        filter: dashboardFilter({
+          filterType: FilterType.LessThan,
+          value: "0.5",
+        }),
+        sampleValues: [0.3],
+      }),
+    ).toBeTruthy();
+  });
+
+  test('"< 0.5" does not fire on 0.7', async () => {
+    expect(
+      await metricCriteriaMet({
+        filter: dashboardFilter({
+          filterType: FilterType.LessThan,
+          value: "0.5",
+        }),
+        sampleValues: [0.7],
+      }),
+    ).toBeNull();
+  });
+
+  test('">= 0.25" treats the boundary as met and 0.2 as not met', async () => {
+    const filter: CriteriaFilter = dashboardFilter({
+      filterType: FilterType.GreaterThanOrEqualTo,
+      value: "0.25",
+    });
+
+    expect(
+      await metricCriteriaMet({ filter, sampleValues: [0.25] }),
+    ).toBeTruthy();
+    expect(await metricCriteriaMet({ filter, sampleValues: [0.2] })).toBeNull();
+  });
+
+  test('"= 0.25" matches 0.25 and not 0', async () => {
+    const filter: CriteriaFilter = dashboardFilter({
+      filterType: FilterType.EqualTo,
+      value: "0.25",
+    });
+
+    expect(
+      await metricCriteriaMet({ filter, sampleValues: [0.25] }),
+    ).toBeTruthy();
+    expect(await metricCriteriaMet({ filter, sampleValues: [0] })).toBeNull();
+  });
+
+  test('a leading-dot ".5" is 0.5 (parseInt made it NaN, so the criteria never fired)', async () => {
+    expect(
+      await metricCriteriaMet({
+        filter: dashboardFilter({
+          filterType: FilterType.GreaterThan,
+          value: ".5",
+        }),
+        sampleValues: [0.6],
+      }),
+    ).toBeTruthy();
+  });
+
+  test("a negative decimal threshold keeps its fraction", async () => {
+    const filter: CriteriaFilter = dashboardFilter({
+      filterType: FilterType.LessThan,
+      value: "-0.5",
+    });
+
+    // parseInt("-0.5") is -0, so -0.2 < -0 used to fire.
+    expect(
+      await metricCriteriaMet({ filter, sampleValues: [-0.2] }),
+    ).toBeNull();
+    expect(
+      await metricCriteriaMet({ filter, sampleValues: [-0.7] }),
+    ).toBeTruthy();
+  });
+
+  test("an integer string threshold behaves exactly as before", async () => {
+    const filter: CriteriaFilter = dashboardFilter({
+      filterType: FilterType.GreaterThan,
+      value: "90",
+    });
+
+    expect(
+      await metricCriteriaMet({ filter, sampleValues: [91] }),
+    ).toBeTruthy();
+    expect(await metricCriteriaMet({ filter, sampleValues: [90] })).toBeNull();
+  });
+
+  test("a numeric (template-authored) decimal threshold is unchanged", async () => {
+    const filter: CriteriaFilter = {
+      ...dashboardFilter({ filterType: FilterType.GreaterThan, value: "" }),
+      value: 0.9,
+    };
+
+    expect(
+      await metricCriteriaMet({ filter, sampleValues: [0.95] }),
+    ).toBeTruthy();
+    expect(await metricCriteriaMet({ filter, sampleValues: [0.5] })).toBeNull();
+  });
+
+  test("a non-numeric or empty threshold leaves the criteria inert", async () => {
+    for (const value of ["abc", "", "   "]) {
+      expect(
+        await metricCriteriaMet({
+          filter: dashboardFilter({
+            filterType: FilterType.GreaterThan,
+            value,
+          }),
+          sampleValues: [1000],
+        }),
+      ).toBeNull();
+      expect(
+        await metricCriteriaMet({
+          filter: dashboardFilter({ filterType: FilterType.LessThan, value }),
+          sampleValues: [-1000],
+        }),
+      ).toBeNull();
+    }
+  });
+});

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

@@ -1355,6 +1355,102 @@ describe("A threshold saved as a string reads like the number", () => {
     expect(rootCause).not.toContain("node/pve1");
     expect(rootCause).not.toContain("node/pve3");
   });
+
+  describe('pve-node-high-cpu with its decimal threshold as "0.9"', () => {
+    /*
+     * The template fires on `> 0.9` and recovers on `<= 0.9` over a 0–1
+     * ratio. Read with parseInt, "0.9" was 0: the monitor went offline on
+     * any CPU at all, and could only recover at exactly 0.
+     */
+    function highCpuStep(): MonitorStep {
+      const monitorStep: MonitorStep = stringifyThresholds(
+        ungroup(proxmoxStep("pve-node-high-cpu")),
+      );
+
+      // Fixture guard: an ungrouped `> "0.9"`.
+      const filter: CriteriaFilter = metricFiltersOf(firingOf(monitorStep))[0]!;
+      expect(filter.filterType).toBe(FilterType.GreaterThan);
+      expect(filter.value).toBe("0.9");
+      expect(filter.metricMonitorOptions?.thresholdUnit).toBeFalsy();
+
+      return monitorStep;
+    }
+
+    function nodeCpuResponse(input: {
+      monitorStep: MonitorStep;
+      windowValue: number;
+      nodes: Dictionary<number>;
+    }): MetricMonitorResponse {
+      return ungroupedResponse({
+        monitorStep: input.monitorStep,
+        fixture: PROXMOX,
+        declaredUnits: { pve_cpu_usage_ratio: "1" },
+        valuesByAlias: { node_cpu: [input.windowValue] },
+        scans: [
+          {
+            alias: "node_cpu",
+            metricUnit: "1",
+            resources: Object.entries(input.nodes).map(
+              ([resourceId, value]: [string, number]) => {
+                return {
+                  resourceId: resourceId,
+                  resourceType: "node",
+                  scope: "node",
+                  metricValue: value,
+                  lowestMetricValue: value,
+                };
+              },
+            ),
+          },
+        ],
+      });
+    }
+
+    test("a cluster at 50% CPU does not fire, and the recovery criteria holds", async () => {
+      const monitorStep: MonitorStep = highCpuStep();
+      const recovery: MonitorCriteriaInstance =
+        monitorStep.data!.monitorCriteria!.data!
+          .monitorCriteriaInstanceArray[1]!;
+
+      const response: ProbeApiIngestResponse = await evaluate({
+        monitorStep: monitorStep,
+        fixture: PROXMOX,
+        response: nodeCpuResponse({
+          monitorStep: monitorStep,
+          windowValue: 0.5,
+          nodes: { "node/pve1": 0.5 },
+        }),
+      });
+
+      expect(rootCauseFor(response, firingOf(monitorStep))).toBe("");
+      expect(response.criteriaMetId?.toString()).toBe(
+        recovery.data!.id!.toString(),
+      );
+    });
+
+    test("only the node past 0.9 is listed", async () => {
+      const monitorStep: MonitorStep = highCpuStep();
+
+      const rootCause: string = await firingRootCause({
+        monitorStep: monitorStep,
+        fixture: PROXMOX,
+        response: nodeCpuResponse({
+          monitorStep: monitorStep,
+          windowValue: 0.95,
+          nodes: { "node/pve2": 0.5, "node/pve1": 0.95 },
+        }),
+      });
+
+      const heads: Array<string> = entryHeads(
+        listSection(rootCause, "Affected Resources"),
+      );
+
+      expect(heads).toHaveLength(1);
+      expect(heads[0]).toContain("`node/pve1`");
+      // The node at 50% is healthy under a "> 0.9" criteria.
+      expect(rootCause).not.toContain("node/pve2");
+    });
+  });
 });
 
 /*

package/Tests/Types/BaseDatabase/AggregationType.test.ts

@@ -9,14 +9,16 @@ describe("AggregationType", () => {
   describe("PercentileAggregationLevels", () => {
     test("maps each percentile enum to its quantile fraction", () => {
       expect(PercentileAggregationLevels[AggregationType.P50]).toBe(0.5);
+      expect(PercentileAggregationLevels[AggregationType.P75]).toBe(0.75);
       expect(PercentileAggregationLevels[AggregationType.P90]).toBe(0.9);
       expect(PercentileAggregationLevels[AggregationType.P95]).toBe(0.95);
       expect(PercentileAggregationLevels[AggregationType.P99]).toBe(0.99);
     });
 
-    test("contains exactly the four percentile aggregations", () => {
+    test("contains exactly the five percentile aggregations", () => {
       expect(Object.keys(PercentileAggregationLevels).sort()).toEqual([
         "P50",
+        "P75",
         "P90",
         "P95",
         "P99",
@@ -27,6 +29,7 @@ describe("AggregationType", () => {
   describe("isPercentileAggregation", () => {
     test("returns true for every percentile aggregation", () => {
       expect(isPercentileAggregation(AggregationType.P50)).toBe(true);
+      expect(isPercentileAggregation(AggregationType.P75)).toBe(true);
       expect(isPercentileAggregation(AggregationType.P90)).toBe(true);
       expect(isPercentileAggregation(AggregationType.P95)).toBe(true);
       expect(isPercentileAggregation(AggregationType.P99)).toBe(true);
@@ -44,6 +47,7 @@ describe("AggregationType", () => {
   describe("getPercentileLevel", () => {
     test("returns the quantile fraction for percentile aggregations", () => {
       expect(getPercentileLevel(AggregationType.P50)).toBe(0.5);
+      expect(getPercentileLevel(AggregationType.P75)).toBe(0.75);
       expect(getPercentileLevel(AggregationType.P99)).toBe(0.99);
     });