@oneuptime/common 11.0.0 → 11.0.2

package/Tests/Server/Services/ProxmoxResourceService.test.ts

@@ -0,0 +1,326 @@
+import ProxmoxResourceService, {
+  ParsedProxmoxResource,
+  ProxmoxResourceLatestMetric,
+} from "../../../Server/Services/ProxmoxResourceService";
+import ObjectID from "../../../Types/ObjectID";
+
+/*
+ * WI-21: the ProxmoxResource inventory write path. The service builds
+ * raw parameterized SQL against the TypeORM manager — these tests mock
+ * the query runner (no Postgres) and lock in the statement shape:
+ *
+ *   - COALESCE per identity/status column, so a batch that lacks an
+ *     info series (or the WI-24 backup-info collector) keeps the
+ *     last-known value instead of blanking it,
+ *   - the lastSeenAt dominance guard (out-of-order ingest never
+ *     regresses a newer snapshot),
+ *   - parameter tuples in exact column order — the INSERT column list
+ *     and the params must never drift,
+ *   - 500-row chunking,
+ *   - NULL metric values stay NULL (a qemu guest without the guest
+ *     agent must never read 0 disk).
+ */
+
+const PROJECT_ID: ObjectID = ObjectID.generate();
+const CLUSTER_ID: ObjectID = ObjectID.generate();
+
+type QueryCall = [string, Array<unknown>];
+
+function mockQueryRunner(result: unknown = []): jest.Mock {
+  const query: jest.Mock = jest.fn().mockResolvedValue(result);
+  jest
+    .spyOn(ProxmoxResourceService, "getRepository")
+    .mockReturnValue({ manager: { query } } as any);
+  return query;
+}
+
+function parsedResource(
+  overrides: Partial<ParsedProxmoxResource> = {},
+): ParsedProxmoxResource {
+  return {
+    kind: "Guest",
+    externalId: "qemu/100",
+    name: "web-vm",
+    vmid: 100,
+    guestType: "qemu",
+    parentNodeName: "pve1",
+    isUp: true,
+    haState: null,
+    onboot: true,
+    isBackedUp: null,
+    uptimeSeconds: 3600,
+    lastSeenAt: new Date("2026-06-13T00:00:00.000Z"),
+    ...overrides,
+  };
+}
+
+afterEach(() => {
+  jest.restoreAllMocks();
+});
+
+describe("ProxmoxResourceService.bulkUpsert", () => {
+  test("does nothing for an empty batch", async () => {
+    const query: jest.Mock = mockQueryRunner();
+    await ProxmoxResourceService.bulkUpsert({
+      projectId: PROJECT_ID,
+      proxmoxClusterId: CLUSTER_ID,
+      resources: [],
+    });
+    expect(query).not.toHaveBeenCalled();
+  });
+
+  test("emits an ON CONFLICT upsert with COALESCE per identity/status column", async () => {
+    const query: jest.Mock = mockQueryRunner();
+    await ProxmoxResourceService.bulkUpsert({
+      projectId: PROJECT_ID,
+      proxmoxClusterId: CLUSTER_ID,
+      resources: [parsedResource()],
+    });
+
+    expect(query).toHaveBeenCalledTimes(1);
+    const [sql] = query.mock.calls[0] as QueryCall;
+
+    expect(sql).toContain('INSERT INTO "ProxmoxResource"');
+    expect(sql).toContain(
+      'ON CONFLICT ("projectId", "proxmoxClusterId", "kind", "externalId")',
+    );
+
+    /*
+     * Every identity/status column COALESCEs against the existing row —
+     * a partial batch must never blank a previously learned value.
+     */
+    for (const column of [
+      "name",
+      "vmid",
+      "guestType",
+      "parentNodeName",
+      "isUp",
+      "haState",
+      "onboot",
+      "isBackedUp",
+      "uptimeSeconds",
+    ]) {
+      expect(sql).toContain(
+        `"${column}" = COALESCE(EXCLUDED."${column}", "ProxmoxResource"."${column}")`,
+      );
+    }
+
+    // lastSeenAt is overwritten (not COALESCEd) under the dominance guard.
+    expect(sql).toContain('"lastSeenAt" = EXCLUDED."lastSeenAt"');
+    expect(sql).toContain(
+      'WHERE EXCLUDED."lastSeenAt" >= "ProxmoxResource"."lastSeenAt"',
+    );
+  });
+
+  test("parameter tuple matches the INSERT column order exactly", async () => {
+    const query: jest.Mock = mockQueryRunner();
+    const lastSeenAt: Date = new Date("2026-06-13T00:00:00.000Z");
+    await ProxmoxResourceService.bulkUpsert({
+      projectId: PROJECT_ID,
+      proxmoxClusterId: CLUSTER_ID,
+      resources: [
+        parsedResource({
+          isBackedUp: false,
+          uptimeSeconds: 3600.9,
+          lastSeenAt,
+        }),
+      ],
+    });
+
+    const [sql, params] = query.mock.calls[0] as QueryCall;
+
+    // 15 columns per row: a 1-row batch carries exactly $1..$15.
+    expect(params).toHaveLength(15);
+    expect(sql).toContain(
+      "($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15)",
+    );
+    expect(params).toEqual([
+      PROJECT_ID.toString(),
+      CLUSTER_ID.toString(),
+      "Guest",
+      "qemu/100",
+      "web-vm",
+      100,
+      "qemu",
+      "pve1",
+      true,
+      null, // haState
+      true, // onboot
+      false, // isBackedUp (WI-24) — false is a value, distinct from null
+      3600, // uptimeSeconds truncated
+      lastSeenAt,
+      0, // version
+    ]);
+  });
+
+  test("tri-state isBackedUp: null rides through so COALESCE keeps the last-known flag", async () => {
+    const query: jest.Mock = mockQueryRunner();
+    await ProxmoxResourceService.bulkUpsert({
+      projectId: PROJECT_ID,
+      proxmoxClusterId: CLUSTER_ID,
+      resources: [parsedResource({ isBackedUp: null })],
+    });
+
+    const [, params] = query.mock.calls[0] as QueryCall;
+    // Column 12 (0-indexed 11) is isBackedUp.
+    expect(params[11]).toBeNull();
+  });
+
+  test("chunks batches of more than 500 rows into multiple statements", async () => {
+    const query: jest.Mock = mockQueryRunner();
+    const resources: Array<ParsedProxmoxResource> = [];
+    for (let i: number = 0; i < 501; i++) {
+      resources.push(parsedResource({ externalId: `qemu/${i}`, vmid: i }));
+    }
+
+    await ProxmoxResourceService.bulkUpsert({
+      projectId: PROJECT_ID,
+      proxmoxClusterId: CLUSTER_ID,
+      resources,
+    });
+
+    expect(query).toHaveBeenCalledTimes(2);
+    const [, firstParams] = query.mock.calls[0] as QueryCall;
+    const [, secondParams] = query.mock.calls[1] as QueryCall;
+    expect(firstParams).toHaveLength(500 * 15);
+    expect(secondParams).toHaveLength(15);
+  });
+});
+
+describe("ProxmoxResourceService.bulkUpdateLatestMetrics", () => {
+  function latestMetric(
+    overrides: Partial<ProxmoxResourceLatestMetric> = {},
+  ): ProxmoxResourceLatestMetric {
+    return {
+      kind: "Guest",
+      externalId: "qemu/100",
+      cpuPercent: 12.5,
+      memoryBytes: 1024,
+      maxMemoryBytes: 2048,
+      memoryPercent: 50,
+      diskBytes: null,
+      maxDiskBytes: null,
+      observedAt: new Date("2026-06-13T00:00:00.000Z"),
+      ...overrides,
+    };
+  }
+
+  test("does nothing for an empty batch", async () => {
+    const query: jest.Mock = mockQueryRunner();
+    await ProxmoxResourceService.bulkUpdateLatestMetrics({
+      projectId: PROJECT_ID,
+      proxmoxClusterId: CLUSTER_ID,
+      metrics: [],
+    });
+    expect(query).not.toHaveBeenCalled();
+  });
+
+  test("COALESCEs every mirror column and guards on metricsUpdatedAt", async () => {
+    const query: jest.Mock = mockQueryRunner();
+    await ProxmoxResourceService.bulkUpdateLatestMetrics({
+      projectId: PROJECT_ID,
+      proxmoxClusterId: CLUSTER_ID,
+      metrics: [latestMetric()],
+    });
+
+    const [sql] = query.mock.calls[0] as QueryCall;
+    expect(sql).toContain('UPDATE "ProxmoxResource"');
+    for (const [column, alias] of [
+      ["latestCpuPercent", "cpu"],
+      ["latestMemoryBytes", "mem"],
+      ["maxMemoryBytes", "maxMem"],
+      ["latestMemoryPercent", "memPct"],
+      ["latestDiskBytes", "disk"],
+      ["maxDiskBytes", "maxDisk"],
+    ]) {
+      expect(sql).toContain(
+        `"${column}" = COALESCE(v."${alias}", p."${column}")`,
+      );
+    }
+    // Out-of-order points never regress a newer observation.
+    expect(sql).toContain(
+      '(p."metricsUpdatedAt" IS NULL OR v."observedAt" >= p."metricsUpdatedAt")',
+    );
+  });
+
+  test("missing disk series stays NULL — never coerced to 0 (qemu without guest agent)", async () => {
+    const query: jest.Mock = mockQueryRunner();
+    await ProxmoxResourceService.bulkUpdateLatestMetrics({
+      projectId: PROJECT_ID,
+      proxmoxClusterId: CLUSTER_ID,
+      metrics: [latestMetric({ diskBytes: null, maxDiskBytes: null })],
+    });
+
+    const [, params] = query.mock.calls[0] as QueryCall;
+    /*
+     * Params: projectId, clusterId, then per row
+     * (kind, externalId, cpu, mem, maxMem, memPct, disk, maxDisk, observedAt).
+     */
+    expect(params).toHaveLength(2 + 9);
+    expect(params[2]).toBe("Guest");
+    expect(params[3]).toBe("qemu/100");
+    expect(params[8]).toBeNull(); // disk
+    expect(params[9]).toBeNull(); // maxDisk
+    // Bigint columns are sent as strings to avoid JS precision loss.
+    expect(params[5]).toBe("1024");
+    expect(params[6]).toBe("2048");
+  });
+});
+
+describe("ProxmoxResourceService.deleteStaleForCluster", () => {
+  test("normalizes the postgres [rows, affected] DELETE result", async () => {
+    mockQueryRunner([[], 7]);
+    const affected: number = await ProxmoxResourceService.deleteStaleForCluster(
+      {
+        proxmoxClusterId: CLUSTER_ID,
+        olderThan: new Date("2026-06-13T00:00:00.000Z"),
+      },
+    );
+    expect(affected).toBe(7);
+  });
+
+  test("returns 0 when the driver result carries no affected count", async () => {
+    mockQueryRunner({});
+    const affected: number = await ProxmoxResourceService.deleteStaleForCluster(
+      {
+        proxmoxClusterId: CLUSTER_ID,
+        olderThan: new Date("2026-06-13T00:00:00.000Z"),
+      },
+    );
+    expect(affected).toBe(0);
+  });
+});
+
+describe("ProxmoxResourceService.getStaleThresholdMinutes", () => {
+  const ENV_KEY: string = "PVE_INVENTORY_STALE_MINUTES";
+  let savedValue: string | undefined;
+
+  beforeEach(() => {
+    savedValue = process.env[ENV_KEY];
+  });
+
+  afterEach(() => {
+    if (savedValue === undefined) {
+      delete process.env[ENV_KEY];
+    } else {
+      process.env[ENV_KEY] = savedValue;
+    }
+  });
+
+  test("defaults to 15 minutes (3x the 5-minute scrape interval)", () => {
+    delete process.env[ENV_KEY];
+    expect(ProxmoxResourceService.getStaleThresholdMinutes()).toBe(15);
+  });
+
+  test("honors the env override", () => {
+    process.env[ENV_KEY] = "30";
+    expect(ProxmoxResourceService.getStaleThresholdMinutes()).toBe(30);
+  });
+
+  test("rejects overrides below the 5-minute floor and non-numbers", () => {
+    process.env[ENV_KEY] = "2";
+    expect(ProxmoxResourceService.getStaleThresholdMinutes()).toBe(15);
+    process.env[ENV_KEY] = "not-a-number";
+    expect(ProxmoxResourceService.getStaleThresholdMinutes()).toBe(15);
+  });
+});

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

@@ -0,0 +1,322 @@
+import MonitorCriteriaEvaluator from "../../../../Server/Utils/Monitor/MonitorCriteriaEvaluator";
+import Monitor from "../../../../Models/DatabaseModels/Monitor";
+import MonitorStep from "../../../../Types/Monitor/MonitorStep";
+import MetricMonitorResponse, {
+  ProxmoxAffectedResource,
+  CephAffectedResource,
+} from "../../../../Types/Monitor/MetricMonitor/MetricMonitorResponse";
+import {
+  getProxmoxAlertTemplateById,
+  ProxmoxAlertTemplate,
+} from "../../../../Types/Monitor/ProxmoxAlertTemplates";
+import {
+  getCephAlertTemplateById,
+  CephAlertTemplate,
+} from "../../../../Types/Monitor/CephAlertTemplates";
+import ObjectID from "../../../../Types/ObjectID";
+
+/*
+ * WI-21 monitor-routing seam: the worker-side monitorProxmox /
+ * monitorCeph functions (App/FeatureSet/Workers) attach a
+ * proxmoxResourceBreakdown / cephResourceBreakdown to the
+ * MetricMonitorResponse; MonitorCriteriaEvaluator renders that into
+ * the incident root-cause context. These tests drive the evaluator's
+ * Proxmox/Ceph branches directly and lock in the render contract:
+ *
+ *   - Proxmox table is Resource / Type / Node / Value; Ceph table is
+ *     Daemon / Pool / Host / Value,
+ *   - zero-value rows are dropped (supplementary context — the
+ *     per-series criteria still alert on them), worst value first,
+ *     top 10 with an "... and N more" suffix,
+ *   - identity-less (cluster-wide) breakdowns render NO table and fall
+ *     back to the metric summary,
+ *   - the cluster context lines surface the monitor step's
+ *     clusterIdentifier and resource filters (the pve.scope / pve.id /
+ *     ceph_daemon / pool_id equality filters the worker maps to).
+ *
+ * The monitor steps come from the REAL alert templates so this also
+ * covers the template → evaluator hand-off shape end to end.
+ */
+
+type EvaluatorPrivate = {
+  buildProxmoxRootCauseContext: (input: {
+    dataToProcess: unknown;
+    monitorStep: MonitorStep;
+    monitor: Monitor;
+  }) => string | null;
+  buildCephRootCauseContext: (input: {
+    dataToProcess: unknown;
+    monitorStep: MonitorStep;
+    monitor: Monitor;
+  }) => string | null;
+};
+
+const Evaluator: EvaluatorPrivate =
+  MonitorCriteriaEvaluator as unknown as EvaluatorPrivate;
+
+function templateArgs(): any {
+  return {
+    clusterIdentifier: "prod-cluster",
+    onlineMonitorStatusId: ObjectID.generate(),
+    offlineMonitorStatusId: ObjectID.generate(),
+    defaultIncidentSeverityId: ObjectID.generate(),
+    defaultAlertSeverityId: ObjectID.generate(),
+    monitorName: "Test Monitor",
+  };
+}
+
+function proxmoxStep(): MonitorStep {
+  const template: ProxmoxAlertTemplate | undefined =
+    getProxmoxAlertTemplateById("pve-node-offline");
+  if (!template) {
+    throw new Error("pve-node-offline template missing");
+  }
+  return template.getMonitorStep(templateArgs());
+}
+
+function cephStep(): MonitorStep {
+  const template: CephAlertTemplate | undefined =
+    getCephAlertTemplateById("ceph-osd-down");
+  if (!template) {
+    throw new Error("ceph-osd-down template missing");
+  }
+  return template.getMonitorStep(templateArgs());
+}
+
+function metricResponse(
+  overrides: Partial<MetricMonitorResponse> = {},
+): MetricMonitorResponse {
+  return {
+    projectId: ObjectID.generate(),
+    monitorId: ObjectID.generate(),
+    metricResult: [],
+    metricViewConfig: { queryConfigs: [], formulaConfigs: [] },
+    ...overrides,
+  };
+}
+
+describe("MonitorCriteriaEvaluator - Proxmox root cause breakdown", () => {
+  test("renders the Resource/Type/Node/Value table: zero rows dropped, worst first", () => {
+    const affectedResources: Array<ProxmoxAffectedResource> = [
+      {
+        resourceId: "qemu/100",
+        resourceName: "web-vm",
+        resourceType: "qemu",
+        scope: "guest",
+        nodeName: "pve1",
+        metricValue: 42,
+      },
+      {
+        resourceId: "qemu/101",
+        resourceName: "db-vm",
+        resourceType: "qemu",
+        scope: "guest",
+        nodeName: "pve2",
+        metricValue: 97,
+      },
+      // Zero-value row — must be dropped from the table.
+      {
+        resourceId: "qemu/102",
+        resourceName: "idle-vm",
+        resourceType: "qemu",
+        scope: "guest",
+        nodeName: "pve1",
+        metricValue: 0,
+      },
+    ];
+
+    const context: string | null = Evaluator.buildProxmoxRootCauseContext({
+      dataToProcess: metricResponse({
+        proxmoxResourceBreakdown: {
+          clusterName: "prod-cluster",
+          metricName: "pve_cpu_usage_ratio",
+          metricFriendlyName: "CPU Usage",
+          affectedResources,
+          attributes: {},
+        },
+      }),
+      monitorStep: proxmoxStep(),
+      monitor: new Monitor(),
+    });
+
+    expect(context).not.toBeNull();
+    expect(context).toContain("**Proxmox Cluster Details**");
+    expect(context).toContain("- Cluster: prod-cluster");
+    expect(context).toContain("- Metric: CPU Usage (`pve_cpu_usage_ratio`)");
+
+    expect(context).toContain("| Resource | Type | Node | Value |");
+    // Worst (97) sorts above 42; the zero row is gone entirely.
+    const dbIndex: number = context!.indexOf("`db-vm` (`qemu/101`)");
+    const webIndex: number = context!.indexOf("`web-vm` (`qemu/100`)");
+    expect(dbIndex).toBeGreaterThan(-1);
+    expect(webIndex).toBeGreaterThan(dbIndex);
+    expect(context).not.toContain("idle-vm");
+    expect(context).toContain("**Affected Resources** (2 total)");
+    expect(context).toContain(
+      "| `db-vm` (`qemu/101`) | qemu | `pve2` | **97** |",
+    );
+  });
+
+  test("caps the table at 10 rows, worst first, with an overflow suffix", () => {
+    const affectedResources: Array<ProxmoxAffectedResource> = [];
+    for (let i: number = 1; i <= 12; i++) {
+      affectedResources.push({
+        resourceId: `qemu/${100 + i}`,
+        resourceType: "qemu",
+        scope: "guest",
+        metricValue: i,
+      });
+    }
+
+    const context: string | null = Evaluator.buildProxmoxRootCauseContext({
+      dataToProcess: metricResponse({
+        proxmoxResourceBreakdown: {
+          clusterName: "prod-cluster",
+          metricName: "pve_cpu_usage_ratio",
+          metricFriendlyName: "CPU Usage",
+          affectedResources,
+          attributes: {},
+        },
+      }),
+      monitorStep: proxmoxStep(),
+      monitor: new Monitor(),
+    });
+
+    expect(context).toContain("**Affected Resources** (12 total)");
+    expect(context).toContain("*... and 2 more affected resources*");
+    // The worst rows survive the cap; the mildest two are cut.
+    expect(context).toContain("**12**");
+    expect(context).toContain("**3**");
+    expect(context).not.toContain("| `qemu/102` | qemu | - | **2** |");
+    expect(context).not.toContain("| `qemu/101` | qemu | - | **1** |");
+  });
+
+  test("identity-less (cluster-wide) breakdowns render no table and fall back to the metric summary", () => {
+    const context: string | null = Evaluator.buildProxmoxRootCauseContext({
+      dataToProcess: metricResponse({
+        proxmoxResourceBreakdown: {
+          clusterName: "prod-cluster",
+          metricName: "pve_not_backed_up_total",
+          metricFriendlyName: "Guests Without Backup",
+          affectedResources: [
+            // WI-24 cluster gauge: a value but NO identity labels.
+            { metricValue: 3 },
+          ],
+          attributes: {},
+        },
+        metricResult: [{ data: [{}, {}] } as any],
+      }),
+      monitorStep: proxmoxStep(),
+      monitor: new Monitor(),
+    });
+
+    expect(context).not.toContain("| Resource | Type | Node | Value |");
+    expect(context).toContain("**Metric Summary**");
+    expect(context).toContain("- 2 metric data point(s) returned");
+  });
+
+  test("surfaces the worker's resource-filter mapping (pve.scope / pve.id) in the cluster context", () => {
+    const step: MonitorStep = proxmoxStep();
+    /*
+     * The worker maps resourceFilters to pve.scope / pve.id equality
+     * attributes; the evaluator surfaces the same filters so the
+     * incident shows WHAT was scoped.
+     */
+    step.data!.proxmoxMonitor!.resourceFilters = {
+      scope: "guest" as any,
+      pveId: "100",
+    };
+
+    const context: string | null = Evaluator.buildProxmoxRootCauseContext({
+      dataToProcess: metricResponse(),
+      monitorStep: step,
+      monitor: new Monitor(),
+    });
+
+    expect(context).toContain("- Cluster: prod-cluster");
+    expect(context).toContain("- Scope Filter: guest");
+    expect(context).toContain("- Resource ID Filter: 100");
+    // No breakdown attached: the metric name comes from the step's query.
+    expect(context).toContain("- Metric: `pve_up`");
+  });
+});
+
+describe("MonitorCriteriaEvaluator - Ceph root cause breakdown", () => {
+  test("renders the Daemon/Pool/Host/Value table with pool name+id cells", () => {
+    const affectedResources: Array<CephAffectedResource> = [
+      { daemon: "osd.3", hostname: "ceph-node-1", metricValue: 250 },
+      { poolId: "2", poolName: "rbd", metricValue: 91 },
+      // Zero row dropped.
+      { daemon: "osd.5", hostname: "ceph-node-2", metricValue: 0 },
+    ];
+
+    const context: string | null = Evaluator.buildCephRootCauseContext({
+      dataToProcess: metricResponse({
+        cephResourceBreakdown: {
+          clusterName: "prod-cluster",
+          metricName: "ceph_osd_apply_latency_ms",
+          metricFriendlyName: "OSD Apply Latency",
+          affectedResources,
+          attributes: {},
+        },
+      }),
+      monitorStep: cephStep(),
+      monitor: new Monitor(),
+    });
+
+    expect(context).toContain("**Ceph Cluster Details**");
+    expect(context).toContain("- Cluster: prod-cluster");
+    expect(context).toContain(
+      "- Metric: OSD Apply Latency (`ceph_osd_apply_latency_ms`)",
+    );
+
+    expect(context).toContain("| Daemon | Pool | Host | Value |");
+    expect(context).toContain("| `osd.3` | - | `ceph-node-1` | **250** |");
+    expect(context).toContain("| - | `rbd` (`2`) | - | **91** |");
+    expect(context).not.toContain("osd.5");
+    expect(context).toContain("**Affected Resources** (2 total)");
+
+    // Worst-first ordering: the 250 row precedes the 91 row.
+    const osdIndex: number = context!.indexOf("`osd.3`");
+    const poolIndex: number = context!.indexOf("`rbd` (`2`)");
+    expect(osdIndex).toBeGreaterThan(-1);
+    expect(poolIndex).toBeGreaterThan(osdIndex);
+  });
+
+  test("cluster-wide series (ceph_health_status) render no table", () => {
+    const context: string | null = Evaluator.buildCephRootCauseContext({
+      dataToProcess: metricResponse({
+        cephResourceBreakdown: {
+          clusterName: "prod-cluster",
+          metricName: "ceph_health_status",
+          metricFriendlyName: "Cluster Health",
+          affectedResources: [{ metricValue: 2 }],
+          attributes: {},
+        },
+      }),
+      monitorStep: cephStep(),
+      monitor: new Monitor(),
+    });
+
+    expect(context).toContain("- Cluster: prod-cluster");
+    expect(context).not.toContain("| Daemon | Pool | Host | Value |");
+  });
+
+  test("surfaces the worker's resource-filter mapping (ceph_daemon / pool_id) in the cluster context", () => {
+    const step: MonitorStep = cephStep();
+    step.data!.cephMonitor!.resourceFilters = {
+      osdId: "osd.3",
+      poolId: "2",
+    };
+
+    const context: string | null = Evaluator.buildCephRootCauseContext({
+      dataToProcess: metricResponse(),
+      monitorStep: step,
+      monitor: new Monitor(),
+    });
+
+    expect(context).toContain("- OSD Filter: osd.3");
+    expect(context).toContain("- Pool ID Filter: 2");
+    expect(context).toContain("- Metric: `ceph_osd_up`");
+  });
+});

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

@@ -12,6 +12,8 @@ function emptyMaintained(): MaintainedResourceKeys {
     hosts: { ids: new Set<string>(), names: new Set<string>() },
     dockerHosts: { ids: new Set<string>(), names: new Set<string>() },
     kubernetesClusters: { ids: new Set<string>(), names: new Set<string>() },
+    proxmoxClusters: { ids: new Set<string>(), names: new Set<string>() },
+    cephClusters: { ids: new Set<string>(), names: new Set<string>() },
     services: { ids: new Set<string>(), names: new Set<string>() },
   };
 }
@@ -91,6 +93,17 @@ describe("SeriesResourceLabels", () => {
       expect(refs.kubernetesClusterNames).toEqual(["c1"]);
       expect(refs.serviceNames).toEqual(["s1"]);
     });
+
+    it("maps proxmox and ceph cluster name keys (prefixed and unprefixed)", () => {
+      const refs: SeriesResourceRefs = SeriesResourceLabels.extractResourceRefs(
+        {
+          "resource.proxmox.cluster.name": "pve-1",
+          "ceph.cluster.name": "ceph-1",
+        },
+      );
+      expect(refs.proxmoxClusterNames).toEqual(["pve-1"]);
+      expect(refs.cephClusterNames).toEqual(["ceph-1"]);
+    });
   });
 });