@oneuptime/common 11.3.20 → 11.3.22

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

@@ -0,0 +1,390 @@
+import MetricMonitorCriteria from "../../../../../Server/Utils/Monitor/Criteria/MetricMonitorCriteria";
+import MonitorCriteriaDataExtractor from "../../../../../Server/Utils/Monitor/MonitorCriteriaDataExtractor";
+import AggregateModel from "../../../../../Types/BaseDatabase/AggregatedModel";
+import AggregatedResult from "../../../../../Types/BaseDatabase/AggregatedResult";
+import {
+  CheckOn,
+  CriteriaFilter,
+  EvaluateOverTimeType,
+  FilterType,
+} from "../../../../../Types/Monitor/CriteriaFilter";
+import MetricFormulaConfigData from "../../../../../Types/Metrics/MetricFormulaConfigData";
+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, {
+  MonitorStepType,
+} from "../../../../../Types/Monitor/MonitorStep";
+import { MonitorStepCephMonitorUtil } from "../../../../../Types/Monitor/MonitorStepCephMonitor";
+import { MonitorStepDockerMonitorUtil } from "../../../../../Types/Monitor/MonitorStepDockerMonitor";
+import { MonitorStepDockerSwarmMonitorUtil } from "../../../../../Types/Monitor/MonitorStepDockerSwarmMonitor";
+import { MonitorStepHostMonitorUtil } from "../../../../../Types/Monitor/MonitorStepHostMonitor";
+import { MonitorStepKubernetesMonitorUtil } from "../../../../../Types/Monitor/MonitorStepKubernetesMonitor";
+import { MonitorStepPodmanMonitorUtil } from "../../../../../Types/Monitor/MonitorStepPodmanMonitor";
+import { MonitorStepProxmoxMonitorUtil } from "../../../../../Types/Monitor/MonitorStepProxmoxMonitor";
+import RollingTime from "../../../../../Types/RollingTime/RollingTime";
+import ObjectID from "../../../../../Types/ObjectID";
+
+/*
+ * Criteria evaluation resolves `metricAlias` → result slot via the query
+ * configs on the monitor step. Telemetry monitors other than the plain
+ * Metric monitor (IoT, Kubernetes, Docker, ...) store their query configs
+ * under their own step shape (e.g. `data.iotMonitor.metricViewConfig`), so
+ * alias resolution must read from whichever shape the step carries — not
+ * just `data.metricMonitor`. These tests pin that behavior: a criteria
+ * referencing the second query's alias must evaluate the second result
+ * slot, never silently fall back to slot 0.
+ */
+
+function buildQueryConfig(input: {
+  alias: string;
+  metricName: string;
+}): MetricQueryConfigData {
+  return {
+    metricAliasData: {
+      metricVariable: input.alias,
+      title: input.metricName,
+      description: undefined,
+      legend: undefined,
+      legendUnit: undefined,
+    },
+    metricQueryData: {
+      filterData: {
+        metricName: input.metricName,
+      },
+    } as unknown as MetricQueryData,
+  };
+}
+
+/*
+ * Two queries — "a" (iot_battery_percent) and "b"
+ * (iot_signal_strength_dbm) — plus an optional formula "f" = a + b.
+ * Result slots: 0 → a, 1 → b, 2 → f.
+ */
+function buildViewConfig(input?: { withFormula?: boolean }): MetricsViewConfig {
+  const formulaConfigs: Array<MetricFormulaConfigData> = input?.withFormula
+    ? [
+        {
+          metricAliasData: {
+            metricVariable: "f",
+            title: "Battery + Signal",
+            description: undefined,
+            legend: undefined,
+            legendUnit: undefined,
+          },
+          metricFormulaData: {
+            metricFormula: "a + b",
+          },
+        },
+      ]
+    : [];
+
+  return {
+    queryConfigs: [
+      buildQueryConfig({ alias: "a", metricName: "iot_battery_percent" }),
+      buildQueryConfig({ alias: "b", metricName: "iot_signal_strength_dbm" }),
+    ],
+    formulaConfigs,
+  };
+}
+
+/*
+ * Bare step whose telemetry shape is attached by `assignShape` — the
+ * point of these tests is that `data.metricMonitor` stays undefined.
+ */
+function buildStep(
+  assignShape: (data: MonitorStepType, viewConfig: MetricsViewConfig) => void,
+  viewConfig: MetricsViewConfig,
+): MonitorStep {
+  const monitorStep: MonitorStep = new MonitorStep();
+  monitorStep.data = {
+    id: ObjectID.generate().toString(),
+    monitorCriteria: { data: undefined } as never,
+  } as unknown as MonitorStep["data"];
+  assignShape(monitorStep.data!, viewConfig);
+  return monitorStep;
+}
+
+function buildIoTStep(viewConfig: MetricsViewConfig): MonitorStep {
+  return buildStep((data: MonitorStepType, v: MetricsViewConfig) => {
+    data.iotMonitor = {
+      fleetIdentifier: "plant-a-fleet",
+      resourceFilters: {},
+      metricViewConfig: v,
+      rollingTime: RollingTime.Past1Minute,
+    };
+  }, viewConfig);
+}
+
+/*
+ * One aggregated result per result slot, in query/formula order.
+ */
+function buildResponse(input: {
+  viewConfig: MetricsViewConfig;
+  resultSlots: Array<Array<number>>;
+}): MetricMonitorResponse {
+  const metricResult: Array<AggregatedResult> = input.resultSlots.map(
+    (values: Array<number>) => {
+      return {
+        data: values.map((v: number) => {
+          return {
+            timestamp: new Date(),
+            value: v,
+          } as AggregateModel;
+        }),
+      };
+    },
+  );
+
+  return {
+    projectId: ObjectID.generate(),
+    metricResult,
+    metricViewConfig: input.viewConfig,
+    monitorId: ObjectID.generate(),
+  };
+}
+
+function greaterThanFilter(input: {
+  alias: string;
+  threshold: string;
+}): CriteriaFilter {
+  return {
+    checkOn: CheckOn.MetricValue,
+    filterType: FilterType.GreaterThan,
+    value: input.threshold,
+    metricMonitorOptions: {
+      metricAlias: input.alias,
+      metricAggregationType: EvaluateOverTimeType.AnyValue,
+    },
+  };
+}
+
+describe("MetricMonitorCriteria — IoT monitor step alias resolution", () => {
+  test("criteria on the second alias evaluates the second series", async () => {
+    const viewConfig: MetricsViewConfig = buildViewConfig();
+    const criteriaFilter: CriteriaFilter = greaterThanFilter({
+      alias: "b",
+      threshold: "30",
+    });
+
+    // Slot 0 (alias a) stays under the threshold; slot 1 (alias b) breaches.
+    const message: string | null =
+      await MetricMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+        dataToProcess: buildResponse({
+          viewConfig,
+          resultSlots: [[10, 12], [55]],
+        }),
+        criteriaFilter,
+        monitorStep: buildIoTStep(viewConfig),
+      });
+
+    expect(message).toBeTruthy();
+    expect(message).toContain("55");
+    expect(criteriaFilter.metricCriteriaContext?.metricName).toBe(
+      "iot_signal_strength_dbm",
+    );
+    expect(criteriaFilter.metricCriteriaContext?.breachingSample?.value).toBe(
+      55,
+    );
+  });
+
+  test("criteria on the second alias ignores a breach in the first series", async () => {
+    const viewConfig: MetricsViewConfig = buildViewConfig();
+
+    // Slot 0 (alias a) breaches, but the criteria targets alias b.
+    const message: string | null =
+      await MetricMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+        dataToProcess: buildResponse({
+          viewConfig,
+          resultSlots: [[90], [10]],
+        }),
+        criteriaFilter: greaterThanFilter({ alias: "b", threshold: "30" }),
+        monitorStep: buildIoTStep(viewConfig),
+      });
+
+    expect(message).toBeNull();
+  });
+
+  test("formula alias resolves to the formula result slot", async () => {
+    const viewConfig: MetricsViewConfig = buildViewConfig({
+      withFormula: true,
+    });
+    const criteriaFilter: CriteriaFilter = greaterThanFilter({
+      alias: "f",
+      threshold: "100",
+    });
+
+    // Slots: a → 10, b → 20, f (formula) → 150. Only the formula breaches.
+    const message: string | null =
+      await MetricMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+        dataToProcess: buildResponse({
+          viewConfig,
+          resultSlots: [[10], [20], [150]],
+        }),
+        criteriaFilter,
+        monitorStep: buildIoTStep(viewConfig),
+      });
+
+    expect(message).toBeTruthy();
+    expect(message).toContain("150");
+    expect(criteriaFilter.metricCriteriaContext?.isFormula).toBe(true);
+  });
+});
+
+describe("MonitorCriteriaDataExtractor — IoT monitor step alias resolution", () => {
+  test("extractMetricValues returns the aliased series, not slot 0", () => {
+    const viewConfig: MetricsViewConfig = buildViewConfig();
+
+    const extracted: { alias: string | null; values: Array<number> } | null =
+      MonitorCriteriaDataExtractor.extractMetricValues({
+        criteriaFilter: greaterThanFilter({ alias: "b", threshold: "30" }),
+        dataToProcess: buildResponse({
+          viewConfig,
+          resultSlots: [
+            [10, 12],
+            [55, 60],
+          ],
+        }),
+        monitorStep: buildIoTStep(viewConfig),
+      });
+
+    expect(extracted).not.toBeNull();
+    expect(extracted?.alias).toBe("b");
+    expect(extracted?.values).toEqual([55, 60]);
+  });
+});
+
+describe("MetricMonitorCriteria — other telemetry step shapes", () => {
+  type ShapeCase = {
+    name: string;
+    assignShape: (data: MonitorStepType, viewConfig: MetricsViewConfig) => void;
+  };
+
+  const shapeCases: Array<ShapeCase> = [
+    {
+      name: "kubernetesMonitor",
+      assignShape: (data: MonitorStepType, v: MetricsViewConfig) => {
+        data.kubernetesMonitor = {
+          ...MonitorStepKubernetesMonitorUtil.getDefault(),
+          metricViewConfig: v,
+        };
+      },
+    },
+    {
+      name: "dockerMonitor",
+      assignShape: (data: MonitorStepType, v: MetricsViewConfig) => {
+        data.dockerMonitor = {
+          ...MonitorStepDockerMonitorUtil.getDefault(),
+          metricViewConfig: v,
+        };
+      },
+    },
+    {
+      name: "dockerSwarmMonitor",
+      assignShape: (data: MonitorStepType, v: MetricsViewConfig) => {
+        data.dockerSwarmMonitor = {
+          ...MonitorStepDockerSwarmMonitorUtil.getDefault(),
+          metricViewConfig: v,
+        };
+      },
+    },
+    {
+      name: "hostMonitor",
+      assignShape: (data: MonitorStepType, v: MetricsViewConfig) => {
+        data.hostMonitor = {
+          ...MonitorStepHostMonitorUtil.getDefault(),
+          metricViewConfig: v,
+        };
+      },
+    },
+    {
+      name: "podmanMonitor",
+      assignShape: (data: MonitorStepType, v: MetricsViewConfig) => {
+        data.podmanMonitor = {
+          ...MonitorStepPodmanMonitorUtil.getDefault(),
+          metricViewConfig: v,
+        };
+      },
+    },
+    {
+      name: "proxmoxMonitor",
+      assignShape: (data: MonitorStepType, v: MetricsViewConfig) => {
+        data.proxmoxMonitor = {
+          ...MonitorStepProxmoxMonitorUtil.getDefault(),
+          metricViewConfig: v,
+        };
+      },
+    },
+    {
+      name: "cephMonitor",
+      assignShape: (data: MonitorStepType, v: MetricsViewConfig) => {
+        data.cephMonitor = {
+          ...MonitorStepCephMonitorUtil.getDefault(),
+          metricViewConfig: v,
+        };
+      },
+    },
+  ];
+
+  test.each(shapeCases)(
+    "$name: criteria on the second alias evaluates the second series",
+    async (shapeCase: ShapeCase) => {
+      const viewConfig: MetricsViewConfig = buildViewConfig();
+      const criteriaFilter: CriteriaFilter = greaterThanFilter({
+        alias: "b",
+        threshold: "30",
+      });
+
+      const message: string | null =
+        await MetricMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+          dataToProcess: buildResponse({
+            viewConfig,
+            resultSlots: [[10, 12], [55]],
+          }),
+          criteriaFilter,
+          monitorStep: buildStep(shapeCase.assignShape, viewConfig),
+        });
+
+      expect(message).toBeTruthy();
+      expect(message).toContain("55");
+      expect(criteriaFilter.metricCriteriaContext?.metricName).toBe(
+        "iot_signal_strength_dbm",
+      );
+    },
+  );
+});
+
+describe("MetricMonitorCriteria — metric monitor step (regression)", () => {
+  test("alias resolution still reads data.metricMonitor", async () => {
+    const viewConfig: MetricsViewConfig = buildViewConfig();
+    const criteriaFilter: CriteriaFilter = greaterThanFilter({
+      alias: "b",
+      threshold: "30",
+    });
+
+    const message: string | null =
+      await MetricMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+        dataToProcess: buildResponse({
+          viewConfig,
+          resultSlots: [[10, 12], [55]],
+        }),
+        criteriaFilter,
+        monitorStep: buildStep(
+          (data: MonitorStepType, v: MetricsViewConfig) => {
+            data.metricMonitor = {
+              metricViewConfig: v,
+              rollingTime: RollingTime.Past1Minute,
+            };
+          },
+          viewConfig,
+        ),
+      });
+
+    expect(message).toBeTruthy();
+    expect(message).toContain("55");
+    expect(criteriaFilter.metricCriteriaContext?.metricName).toBe(
+      "iot_signal_strength_dbm",
+    );
+  });
+});

package/Tests/Server/Utils/Telemetry/IoTSnapshotScan.test.ts

@@ -0,0 +1,202 @@
+import {
+  IoTDeviceBufferEntry,
+  IoTFleetSnapshotBufferEntry,
+  IOT_MAX_FUTURE_CLOCK_SKEW_MINUTES,
+  bufferIoTSnapshotMetric,
+  clampIoTTimestamp,
+} from "../../../../Server/Utils/Telemetry/IoTSnapshotScan";
+import { JSONObject } from "../../../../Types/JSON";
+
+/*
+ * Malformed-device hardening for the IoT snapshot scan:
+ *
+ *   - a `device.id` longer than the ShortText column limit (100) is
+ *     truncated at ingest, so one bad device can never fail the
+ *     500-row inventory INSERT chunk downstream — and two ids sharing
+ *     the truncated prefix fold into ONE entry (a duplicate conflict
+ *     target inside a single INSERT would abort the statement),
+ *   - a future-skewed device clock is clamped to ingest time, so the
+ *     `>=` lastSeenAt dominance guard can't get wedged by one bogus
+ *     future timestamp and then reject every legitimate update.
+ */
+
+const FLEET: string = "0a1b2c3d-0000-0000-0000-000000000001";
+const SHORT_TEXT_LIMIT: number = 100;
+
+type LabelMap = Record<string, string>;
+
+function toNano(ms: number): string {
+  return `${ms}000000`;
+}
+
+function datapoint(data: {
+  value: number;
+  atMs?: number;
+  labels?: LabelMap;
+  asDouble?: boolean;
+}): JSONObject {
+  const attributes: Array<JSONObject> = Object.entries(data.labels || {}).map(
+    ([key, value]: [string, string]) => {
+      return { key, value: { stringValue: value } };
+    },
+  );
+  return {
+    ...(data.asDouble ? { asDouble: data.value } : { asInt: data.value }),
+    timeUnixNano: toNano(data.atMs ?? Date.now()),
+    attributes,
+  };
+}
+
+interface IoTBuffers {
+  resourceBuffer: Map<string, Map<string, IoTDeviceBufferEntry>>;
+  fleetBuffer: Map<string, IoTFleetSnapshotBufferEntry>;
+}
+
+function iotBuffers(): IoTBuffers {
+  return { resourceBuffer: new Map(), fleetBuffer: new Map() };
+}
+
+function feed(buffers: IoTBuffers, metricName: string, dp: JSONObject): void {
+  bufferIoTSnapshotMetric({
+    fleetIdStr: FLEET,
+    metricName,
+    datapoint: dp,
+    resourceBuffer: buffers.resourceBuffer,
+    fleetBuffer: buffers.fleetBuffer,
+  });
+}
+
+function entries(buffers: IoTBuffers): Array<IoTDeviceBufferEntry> {
+  return Array.from(buffers.resourceBuffer.get(FLEET)?.values() || []);
+}
+
+describe("clampIoTTimestamp", () => {
+  const now: Date = new Date("2026-07-02T12:00:00.000Z");
+
+  test("keeps a past timestamp untouched", () => {
+    const past: Date = new Date("2026-07-02T11:00:00.000Z");
+    expect(clampIoTTimestamp(past, now)).toEqual(past);
+  });
+
+  test("keeps a future timestamp within the skew tolerance", () => {
+    const slightlyAhead: Date = new Date(
+      now.getTime() + (IOT_MAX_FUTURE_CLOCK_SKEW_MINUTES - 1) * 60 * 1000,
+    );
+    expect(clampIoTTimestamp(slightlyAhead, now)).toEqual(slightlyAhead);
+  });
+
+  test("clamps a timestamp beyond the skew tolerance back to now", () => {
+    const farAhead: Date = new Date(now.getTime() + 60 * 60 * 1000);
+    expect(clampIoTTimestamp(farAhead, now)).toEqual(now);
+  });
+});
+
+describe("bufferIoTSnapshotMetric — device.id length hardening", () => {
+  test("truncates a device.id longer than the 100-char column limit", () => {
+    const longId: string = "x".repeat(150);
+    const buffers: IoTBuffers = iotBuffers();
+
+    feed(buffers, "iot_device_up", {
+      ...datapoint({ value: 1, labels: { "device.id": longId } }),
+    });
+
+    const buffered: Array<IoTDeviceBufferEntry> = entries(buffers);
+    expect(buffered).toHaveLength(1);
+    expect(buffered[0]!.externalId).toBe("x".repeat(SHORT_TEXT_LIMIT));
+    expect(buffered[0]!.externalId.length).toBe(SHORT_TEXT_LIMIT);
+  });
+
+  test("keeps a device.id exactly at the column limit untouched", () => {
+    const exactId: string = "y".repeat(SHORT_TEXT_LIMIT);
+    const buffers: IoTBuffers = iotBuffers();
+
+    feed(buffers, "iot_device_up", {
+      ...datapoint({ value: 1, labels: { "device.id": exactId } }),
+    });
+
+    expect(entries(buffers)[0]!.externalId).toBe(exactId);
+  });
+
+  test("two over-long ids sharing the truncated prefix fold into one entry", () => {
+    const shared: string = "z".repeat(SHORT_TEXT_LIMIT);
+    const buffers: IoTBuffers = iotBuffers();
+
+    feed(buffers, "iot_device_up", {
+      ...datapoint({ value: 1, labels: { "device.id": `${shared}-alpha` } }),
+    });
+    feed(buffers, "iot_device_up", {
+      ...datapoint({ value: 0, labels: { "device.id": `${shared}-bravo` } }),
+    });
+
+    // One folded identity — never two rows hitting one conflict target.
+    const buffered: Array<IoTDeviceBufferEntry> = entries(buffers);
+    expect(buffered).toHaveLength(1);
+    expect(buffered[0]!.externalId).toBe(shared);
+  });
+});
+
+describe("bufferIoTSnapshotMetric — future clock-skew hardening", () => {
+  test("clamps an observedAt beyond the skew tolerance to ingest time", () => {
+    const buffers: IoTBuffers = iotBuffers();
+    const before: number = Date.now();
+
+    feed(buffers, "iot_battery_percent", {
+      ...datapoint({
+        value: 55,
+        asDouble: true,
+        atMs: Date.now() + 60 * 60 * 1000, // device clock 1h ahead
+        labels: { "device.id": "sensor-1" },
+      }),
+    });
+
+    const after: number = Date.now();
+    const observedAt: Date = entries(buffers)[0]!.observedAt;
+    expect(observedAt.getTime()).toBeGreaterThanOrEqual(before);
+    expect(observedAt.getTime()).toBeLessThanOrEqual(after);
+  });
+
+  test("keeps an observedAt within the skew tolerance untouched", () => {
+    const buffers: IoTBuffers = iotBuffers();
+    const slightlyAheadMs: number =
+      Date.now() + (IOT_MAX_FUTURE_CLOCK_SKEW_MINUTES - 1) * 60 * 1000;
+
+    feed(buffers, "iot_battery_percent", {
+      ...datapoint({
+        value: 55,
+        asDouble: true,
+        atMs: slightlyAheadMs,
+        labels: { "device.id": "sensor-1" },
+      }),
+    });
+
+    expect(entries(buffers)[0]!.observedAt.getTime()).toBe(
+      Math.trunc(slightlyAheadMs),
+    );
+  });
+
+  test("a clamped future point no longer wedges newest-wins folding", () => {
+    const buffers: IoTBuffers = iotBuffers();
+
+    // Skewed device stamps 1h ahead — clamped to ~now at ingest.
+    feed(buffers, "iot_battery_percent", {
+      ...datapoint({
+        value: 50,
+        asDouble: true,
+        atMs: Date.now() + 60 * 60 * 1000,
+        labels: { "device.id": "sensor-1" },
+      }),
+    });
+
+    // A legitimate later reading must still win the fold.
+    feed(buffers, "iot_battery_percent", {
+      ...datapoint({
+        value: 80,
+        asDouble: true,
+        atMs: Date.now() + 1000,
+        labels: { "device.id": "sensor-1" },
+      }),
+    });
+
+    expect(entries(buffers)[0]!.latestBatteryPercent).toBe(80);
+  });
+});