@oneuptime/common 11.0.1 → 11.0.2

package/Server/Services/ProxmoxResourceService.ts

@@ -0,0 +1,404 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/ProxmoxResource";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import ObjectID from "../../Types/ObjectID";
+import OneUptimeDate from "../../Types/Date";
+import QueryHelper from "../Types/Database/QueryHelper";
+import logger from "../Utils/Logger";
+
+/*
+ * ------------------------------------------------------------------
+ * ProxmoxResourceService
+ *
+ * Writes and reads the Proxmox inventory table populated by the
+ * telemetry ingest path. Callers are either:
+ *   - OtelMetricsIngestService (bulkUpsert + bulkUpdateLatestMetrics,
+ *     from the pve_* snapshot scan in processMetricsAsync)
+ *   - CleanupStaleResources worker (deleteStaleForCluster)
+ *   - ProxmoxResourceAPI / the dashboard pages (reads via the
+ *     inherited DatabaseService CRUD)
+ *
+ * Identity + status and the latest-metric mirror both arrive on the
+ * same metric scrape (unlike K8s, which needs a separate k8sobjects
+ * log stream for identity), so both writes happen in the same flush.
+ *
+ * ------------------------------------------------------------------
+ */
+
+export interface ParsedProxmoxResource {
+  kind: string; // Node | Guest | Storage
+  externalId: string; // raw pve `id` label, e.g. node/pve1, qemu/100
+  name: string | null;
+  vmid: number | null;
+  guestType: string | null; // qemu | lxc
+  parentNodeName: string | null;
+  isUp: boolean | null;
+  haState: string | null;
+  onboot: boolean | null;
+  /*
+   * WI-24 backup coverage: true = covered by at least one backup job,
+   * false = a pve_not_backed_up_info series carried this guest's id,
+   * null = batch lacked the backup-info collector output (keeps the
+   * last-known value via COALESCE) or non-Guest kind.
+   */
+  isBackedUp: boolean | null;
+  uptimeSeconds: number | null;
+  lastSeenAt: Date;
+}
+
+export interface ProxmoxResourceLatestMetric {
+  kind: string;
+  externalId: string;
+  cpuPercent: number | null;
+  memoryBytes: number | null;
+  maxMemoryBytes: number | null;
+  memoryPercent: number | null;
+  diskBytes: number | null;
+  maxDiskBytes: number | null;
+  observedAt: Date;
+}
+
+export interface ProxmoxInventorySummary {
+  countsByKind: Record<string, number>;
+  nodeOnlineCount: number;
+  guestRunningCount: number;
+}
+
+const UPSERT_BATCH_SIZE: number = 500;
+const STALE_DELETE_WARN_THRESHOLD: number = 100;
+
+/*
+ * Column order used by bulkUpsert() and its generated parameter tuples.
+ * Keep this and the INSERT column list in perfect sync.
+ */
+const UPSERT_COLUMNS: Array<string> = [
+  "projectId",
+  "proxmoxClusterId",
+  "kind",
+  "externalId",
+  "name",
+  "vmid",
+  "guestType",
+  "parentNodeName",
+  "isUp",
+  "haState",
+  "onboot",
+  "isBackedUp",
+  "uptimeSeconds",
+  "lastSeenAt",
+  "version",
+];
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  /**
+   * Upsert a batch of parsed resources for a single (project, cluster)
+   * pair. Uses ON CONFLICT on the UNIQUE (projectId, proxmoxClusterId,
+   * kind, externalId) index with a dominance guard on lastSeenAt so
+   * out-of-order ingest never regresses a newer snapshot.
+   *
+   * Identity/status columns COALESCE against the existing row (unlike
+   * the K8s upsert, which overwrites): a pve-exporter batch is usually
+   * a complete scrape, but a batch that happens to lack an info series
+   * (e.g. only pve_up made it through a pipeline filter) must not blank
+   * name/vmid/haState that an earlier batch already filled.
+   */
+  @CaptureSpan()
+  public async bulkUpsert(data: {
+    projectId: ObjectID;
+    proxmoxClusterId: ObjectID;
+    resources: Array<ParsedProxmoxResource>;
+  }): Promise<void> {
+    if (data.resources.length === 0) {
+      return;
+    }
+
+    // Chunk to keep individual statement parameter counts reasonable.
+    for (let i: number = 0; i < data.resources.length; i += UPSERT_BATCH_SIZE) {
+      const chunk: Array<ParsedProxmoxResource> = data.resources.slice(
+        i,
+        i + UPSERT_BATCH_SIZE,
+      );
+
+      const valueFragments: Array<string> = [];
+      const params: Array<unknown> = [];
+      let paramIndex: number = 1;
+
+      for (const r of chunk) {
+        const placeholders: Array<string> = [];
+        for (let c: number = 0; c < UPSERT_COLUMNS.length; c++) {
+          placeholders.push(`$${paramIndex++}`);
+        }
+        valueFragments.push(`(${placeholders.join(", ")})`);
+
+        params.push(
+          data.projectId.toString(),
+          data.proxmoxClusterId.toString(),
+          r.kind,
+          r.externalId,
+          r.name,
+          r.vmid,
+          r.guestType,
+          r.parentNodeName,
+          r.isUp,
+          r.haState,
+          r.onboot,
+          r.isBackedUp,
+          r.uptimeSeconds !== null ? Math.trunc(r.uptimeSeconds) : null,
+          r.lastSeenAt,
+          0, // version (BaseModel @VersionColumn)
+        );
+      }
+
+      const sql: string = `
+        INSERT INTO "ProxmoxResource" (
+          "projectId", "proxmoxClusterId", "kind", "externalId",
+          "name", "vmid", "guestType", "parentNodeName",
+          "isUp", "haState", "onboot", "isBackedUp", "uptimeSeconds",
+          "lastSeenAt", "version"
+        )
+        VALUES ${valueFragments.join(", ")}
+        ON CONFLICT ("projectId", "proxmoxClusterId", "kind", "externalId")
+        DO UPDATE SET
+          "name" = COALESCE(EXCLUDED."name", "ProxmoxResource"."name"),
+          "vmid" = COALESCE(EXCLUDED."vmid", "ProxmoxResource"."vmid"),
+          "guestType" = COALESCE(EXCLUDED."guestType", "ProxmoxResource"."guestType"),
+          "parentNodeName" = COALESCE(EXCLUDED."parentNodeName", "ProxmoxResource"."parentNodeName"),
+          "isUp" = COALESCE(EXCLUDED."isUp", "ProxmoxResource"."isUp"),
+          "haState" = COALESCE(EXCLUDED."haState", "ProxmoxResource"."haState"),
+          "onboot" = COALESCE(EXCLUDED."onboot", "ProxmoxResource"."onboot"),
+          "isBackedUp" = COALESCE(EXCLUDED."isBackedUp", "ProxmoxResource"."isBackedUp"),
+          "uptimeSeconds" = COALESCE(EXCLUDED."uptimeSeconds", "ProxmoxResource"."uptimeSeconds"),
+          "lastSeenAt" = EXCLUDED."lastSeenAt",
+          "updatedAt" = now()
+        WHERE EXCLUDED."lastSeenAt" >= "ProxmoxResource"."lastSeenAt"
+      `;
+
+      await this.getRepository().manager.query(sql, params);
+    }
+  }
+
+  /**
+   * Update the latest-metric mirror columns for a batch of resources.
+   * Plain UPDATE: in practice the row always exists because bulkUpsert
+   * runs in the same flush; if it somehow doesn't, the write is
+   * silently skipped and the next flush catches up.
+   *
+   * Guarded by metricsUpdatedAt so out-of-order points don't regress a
+   * newer observation. COALESCE keeps the existing value when a batch
+   * lacks a series — notably latestDiskBytes stays NULL (never 0) for
+   * qemu guests without the QEMU guest agent.
+   */
+  @CaptureSpan()
+  public async bulkUpdateLatestMetrics(data: {
+    projectId: ObjectID;
+    proxmoxClusterId: ObjectID;
+    metrics: Array<ProxmoxResourceLatestMetric>;
+  }): Promise<void> {
+    if (data.metrics.length === 0) {
+      return;
+    }
+
+    for (let i: number = 0; i < data.metrics.length; i += UPSERT_BATCH_SIZE) {
+      const chunk: Array<ProxmoxResourceLatestMetric> = data.metrics.slice(
+        i,
+        i + UPSERT_BATCH_SIZE,
+      );
+
+      const valueFragments: Array<string> = [];
+      const params: Array<unknown> = [
+        data.projectId.toString(),
+        data.proxmoxClusterId.toString(),
+      ];
+      let paramIndex: number = 3;
+
+      for (const m of chunk) {
+        valueFragments.push(
+          `($${paramIndex++}, $${paramIndex++}, $${paramIndex++}::numeric, $${paramIndex++}::bigint, $${paramIndex++}::bigint, $${paramIndex++}::numeric, $${paramIndex++}::bigint, $${paramIndex++}::bigint, $${paramIndex++}::timestamptz)`,
+        );
+        params.push(
+          m.kind,
+          m.externalId,
+          m.cpuPercent !== null && m.cpuPercent !== undefined
+            ? m.cpuPercent
+            : null,
+          m.memoryBytes !== null && m.memoryBytes !== undefined
+            ? Math.trunc(m.memoryBytes).toString()
+            : null,
+          m.maxMemoryBytes !== null && m.maxMemoryBytes !== undefined
+            ? Math.trunc(m.maxMemoryBytes).toString()
+            : null,
+          m.memoryPercent !== null && m.memoryPercent !== undefined
+            ? m.memoryPercent
+            : null,
+          m.diskBytes !== null && m.diskBytes !== undefined
+            ? Math.trunc(m.diskBytes).toString()
+            : null,
+          m.maxDiskBytes !== null && m.maxDiskBytes !== undefined
+            ? Math.trunc(m.maxDiskBytes).toString()
+            : null,
+          m.observedAt,
+        );
+      }
+
+      const sql: string = `
+        UPDATE "ProxmoxResource" AS p
+        SET
+          "latestCpuPercent" = COALESCE(v."cpu", p."latestCpuPercent"),
+          "latestMemoryBytes" = COALESCE(v."mem", p."latestMemoryBytes"),
+          "maxMemoryBytes" = COALESCE(v."maxMem", p."maxMemoryBytes"),
+          "latestMemoryPercent" = COALESCE(v."memPct", p."latestMemoryPercent"),
+          "latestDiskBytes" = COALESCE(v."disk", p."latestDiskBytes"),
+          "maxDiskBytes" = COALESCE(v."maxDisk", p."maxDiskBytes"),
+          "metricsUpdatedAt" = v."observedAt",
+          "updatedAt" = now()
+        FROM (VALUES ${valueFragments.join(", ")})
+          AS v("kind", "externalId", "cpu", "mem", "maxMem", "memPct", "disk", "maxDisk", "observedAt")
+        WHERE
+          p."projectId" = $1
+          AND p."proxmoxClusterId" = $2
+          AND p."kind" = v."kind"
+          AND p."externalId" = v."externalId"
+          AND (p."metricsUpdatedAt" IS NULL OR v."observedAt" >= p."metricsUpdatedAt")
+      `;
+
+      await this.getRepository().manager.query(sql, params);
+    }
+  }
+
+  /**
+   * Hard-delete all resources in a cluster whose last scrape is older
+   * than olderThan. Returns the number of deleted rows. Only called by
+   * the cleanup worker for clusters that are still connected — a
+   * disconnected cluster keeps its last-known inventory.
+   */
+  @CaptureSpan()
+  public async deleteStaleForCluster(data: {
+    proxmoxClusterId: ObjectID;
+    olderThan: Date;
+  }): Promise<number> {
+    const result: Array<{ affected?: number }> | { affected?: number } =
+      await this.getRepository().manager.query(
+        `DELETE FROM "ProxmoxResource" WHERE "proxmoxClusterId" = $1 AND "lastSeenAt" < $2`,
+        [data.proxmoxClusterId.toString(), data.olderThan],
+      );
+
+    // Postgres driver returns [rows, affected] for DELETE — normalize.
+    let affected: number = 0;
+    if (Array.isArray(result) && result.length >= 2) {
+      const second: unknown = (result as Array<unknown>)[1];
+      if (typeof second === "number") {
+        affected = second;
+      }
+    }
+
+    if (affected > STALE_DELETE_WARN_THRESHOLD) {
+      logger.warn(
+        `ProxmoxResource cleanup deleted ${affected} stale rows for cluster ${data.proxmoxClusterId.toString()} — larger than expected; investigate agent health.`,
+      );
+    }
+
+    return affected;
+  }
+
+  /**
+   * Compute the sidebar/overview summary in Postgres: counts per kind
+   * plus the online/running breakdowns, in a single round-trip.
+   */
+  @CaptureSpan()
+  public async getInventorySummary(data: {
+    projectId: ObjectID;
+    proxmoxClusterId: ObjectID;
+  }): Promise<ProxmoxInventorySummary> {
+    const rows: Array<{
+      kind: string;
+      count: string;
+      upCount: string;
+    }> = await this.getRepository().manager.query(
+      `SELECT "kind",
+              COUNT(*)::text AS count,
+              COUNT(*) FILTER (WHERE "isUp" IS TRUE)::text AS "upCount"
+       FROM "ProxmoxResource"
+       WHERE "projectId" = $1 AND "proxmoxClusterId" = $2 AND "deletedAt" IS NULL
+       GROUP BY "kind"`,
+      [data.projectId.toString(), data.proxmoxClusterId.toString()],
+    );
+
+    const countsByKind: Record<string, number> = {};
+    let nodeOnlineCount: number = 0;
+    let guestRunningCount: number = 0;
+    for (const row of rows) {
+      countsByKind[row.kind] = parseInt(row.count, 10) || 0;
+      if (row.kind === "Node") {
+        nodeOnlineCount = parseInt(row.upCount, 10) || 0;
+      }
+      if (row.kind === "Guest") {
+        guestRunningCount = parseInt(row.upCount, 10) || 0;
+      }
+    }
+
+    return {
+      countsByKind,
+      nodeOnlineCount,
+      guestRunningCount,
+    };
+  }
+
+  /**
+   * Host cross-link heuristic (WI-17): resolve the cluster a guest
+   * with this name belongs to. Case-insensitive — host.name casing
+   * (canonicalized at ingest) rarely matches the PVE guest name's
+   * casing exactly. Returns null when no guest matches.
+   */
+  @CaptureSpan()
+  public async findGuestClusterIdByName(data: {
+    projectId: ObjectID;
+    name: string;
+  }): Promise<ObjectID | null> {
+    const guest: Model | null = await this.findOneBy({
+      query: {
+        projectId: data.projectId,
+        kind: "Guest",
+        name: QueryHelper.findWithSameText(data.name),
+      },
+      select: {
+        _id: true,
+        proxmoxClusterId: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    return guest?.proxmoxClusterId || null;
+  }
+
+  /**
+   * Helper for the cleanup worker: snapshot-interval aware cutoff.
+   * 3× the 5-minute scrape interval by default. Tune via
+   * PVE_INVENTORY_STALE_MINUTES (min 5).
+   */
+  public getStaleThresholdDate(nowOverride?: Date): Date {
+    const minutes: number = this.getStaleThresholdMinutes();
+    return OneUptimeDate.addRemoveMinutes(
+      nowOverride || OneUptimeDate.getCurrentDate(),
+      -minutes,
+    );
+  }
+
+  public getStaleThresholdMinutes(): number {
+    const raw: string | undefined = process.env["PVE_INVENTORY_STALE_MINUTES"];
+    if (raw) {
+      const parsed: number = parseInt(raw, 10);
+      if (!isNaN(parsed) && parsed >= 5) {
+        return parsed;
+      }
+    }
+    return 15;
+  }
+}
+
+export default new Service();

package/Server/Services/RumApplicationService.ts

@@ -253,15 +253,23 @@ export class Service extends DatabaseService<Model> {
 
   @CaptureSpan()
   public async markDisconnectedApplications(): Promise<void> {
-    const fiveMinutesAgo: Date = OneUptimeDate.addRemoveMinutes(
+    /*
+     * Threshold must stay well above the 5-minute OTel ingest
+     * maintenance fence (MAINTENANCE_FENCE_TTL_SECONDS in
+     * OtelIngestBaseService) — lastSeenAt is legitimately up to
+     * ~5 minutes stale during continuous telemetry, so a threshold
+     * equal to the fence TTL flaps healthy resources. 15 minutes
+     * gives 3x headroom.
+     */
+    const fifteenMinutesAgo: Date = OneUptimeDate.addRemoveMinutes(
       OneUptimeDate.getCurrentDate(),
-      -5,
+      -15,
     );
 
     const connectedApps: Array<Model> = await this.findBy({
       query: {
         otelCollectorStatus: "connected",
-        lastSeenAt: QueryHelper.lessThan(fiveMinutesAgo),
+        lastSeenAt: QueryHelper.lessThan(fifteenMinutesAgo),
       },
       select: {
         _id: true,

package/Server/Services/ServerlessFunctionService.ts

@@ -303,15 +303,23 @@ export class Service extends DatabaseService<Model> {
 
   @CaptureSpan()
   public async markDisconnectedFunctions(): Promise<void> {
-    const fiveMinutesAgo: Date = OneUptimeDate.addRemoveMinutes(
+    /*
+     * Threshold must stay well above the 5-minute OTel ingest
+     * maintenance fence (MAINTENANCE_FENCE_TTL_SECONDS in
+     * OtelIngestBaseService) — lastSeenAt is legitimately up to
+     * ~5 minutes stale during continuous telemetry, so a threshold
+     * equal to the fence TTL flaps healthy resources. 15 minutes
+     * gives 3x headroom.
+     */
+    const fifteenMinutesAgo: Date = OneUptimeDate.addRemoveMinutes(
       OneUptimeDate.getCurrentDate(),
-      -5,
+      -15,
     );
 
     const connectedFunctions: Array<Model> = await this.findBy({
       query: {
         otelCollectorStatus: "connected",
-        lastSeenAt: QueryHelper.lessThan(fiveMinutesAgo),
+        lastSeenAt: QueryHelper.lessThan(fifteenMinutesAgo),
       },
       select: {
         _id: true,

package/Server/Services/TelemetryUsageBillingService.ts

@@ -26,9 +26,13 @@ import ServiceModel from "../../Models/DatabaseModels/Service";
 import HostService from "./HostService";
 import DockerHostService from "./DockerHostService";
 import KubernetesClusterService from "./KubernetesClusterService";
+import ProxmoxClusterService from "./ProxmoxClusterService";
+import CephClusterService from "./CephClusterService";
 import Host from "../../Models/DatabaseModels/Host";
 import DockerHost from "../../Models/DatabaseModels/DockerHost";
 import KubernetesCluster from "../../Models/DatabaseModels/KubernetesCluster";
+import ProxmoxCluster from "../../Models/DatabaseModels/ProxmoxCluster";
+import CephCluster from "../../Models/DatabaseModels/CephCluster";
 import ServiceType from "../../Types/Telemetry/ServiceType";
 import {
   AverageSpanRowSizeInBytes,
@@ -347,9 +351,10 @@ export class Service extends DatabaseService<Model> {
   /*
    * Map of resourceId -> retainTelemetryDataForDays for every resource in
    * the project that can own telemetry (Service, Host, DockerHost,
-   * KubernetesCluster). Used to scale billed cost by the actual retention
-   * applied to each resource's telemetry. Resources without an override
-   * (and the unattributed bucket) fall back to the project default.
+   * KubernetesCluster, ProxmoxCluster, CephCluster). Used to scale billed
+   * cost by the actual retention applied to each resource's telemetry.
+   * Resources without an override (and the unattributed bucket) fall back
+   * to the project default.
    */
   @CaptureSpan()
   private async buildTelemetryRetentionMap(
@@ -422,6 +427,39 @@ export class Service extends DatabaseService<Model> {
       }
     }
 
+    const proxmoxClusters: Array<ProxmoxCluster> =
+      await ProxmoxClusterService.findBy({
+        query: { projectId: projectId },
+        select: { _id: true, retainTelemetryDataForDays: true },
+        skip: 0,
+        limit: LIMIT_MAX,
+        props: { isRoot: true },
+      });
+    for (const proxmoxCluster of proxmoxClusters) {
+      if (proxmoxCluster.id && proxmoxCluster.retainTelemetryDataForDays) {
+        retentionByServiceId.set(
+          proxmoxCluster.id.toString(),
+          proxmoxCluster.retainTelemetryDataForDays,
+        );
+      }
+    }
+
+    const cephClusters: Array<CephCluster> = await CephClusterService.findBy({
+      query: { projectId: projectId },
+      select: { _id: true, retainTelemetryDataForDays: true },
+      skip: 0,
+      limit: LIMIT_MAX,
+      props: { isRoot: true },
+    });
+    for (const cephCluster of cephClusters) {
+      if (cephCluster.id && cephCluster.retainTelemetryDataForDays) {
+        retentionByServiceId.set(
+          cephCluster.id.toString(),
+          cephCluster.retainTelemetryDataForDays,
+        );
+      }
+    }
+
     return retentionByServiceId;
   }
 

package/Server/Services/TraceAggregationService.ts

@@ -159,6 +159,8 @@ export class TraceAggregationService {
       ["hostId", ServiceType.Host],
       ["dockerHostId", ServiceType.DockerHost],
       ["kubernetesClusterId", ServiceType.KubernetesCluster],
+      ["proxmoxClusterId", ServiceType.ProxmoxCluster],
+      ["cephClusterId", ServiceType.CephCluster],
       ["serverlessFunctionId", ServiceType.ServerlessFunction],
       ["cloudResourceId", ServiceType.CloudResource],
       ["rumApplicationId", ServiceType.RealUserMonitor],

package/Server/Types/AnalyticsDatabase/AggregateBy.ts

@@ -1,8 +1,8 @@
 import AggregationInterval from "../../../Types/BaseDatabase/AggregationInterval";
+import AggregationIntervalUtil from "../../../Types/BaseDatabase/AggregationIntervalUtil";
 import CommonAggregateBy from "../../../Types/BaseDatabase/AggregateBy";
 import AnalyticsBaseModel from "../../../Models/AnalyticsModels/AnalyticsBaseModel/AnalyticsBaseModel";
 import DatabaseCommonInteractionProps from "../../../Types/BaseDatabase/DatabaseCommonInteractionProps";
-import OneUptimeDate from "../../../Types/Date";
 import CaptureSpan from "../../Utils/Telemetry/CaptureSpan";
 
 export default interface AggregateBy<TBaseModel extends AnalyticsBaseModel>
@@ -11,32 +11,17 @@ export default interface AggregateBy<TBaseModel extends AnalyticsBaseModel>
 }
 
 export class AggregateUtil {
+  /*
+   * Delegates to the isomorphic AggregationIntervalUtil so browser
+   * code reconstructing the server's bucket grid (heartbeat
+   * availability charts) always agrees with the interval the
+   * statement generator compiles into `toStartOfInterval(...)`.
+   */
   @CaptureSpan()
   public static getAggregationInterval(data: {
     startDate: Date;
     endDate: Date;
   }): AggregationInterval {
-    data.startDate = OneUptimeDate.fromString(data.startDate);
-    data.endDate = OneUptimeDate.fromString(data.endDate);
-
-    const diff: number = data.endDate.getTime() - data.startDate.getTime();
-
-    if (diff <= 1000 * 60 * 60 * 3) {
-      // if less than 3 hours, then get minute precision
-      return AggregationInterval.Minute;
-    } else if (diff <= 1000 * 60 * 60 * 24 * 7) {
-      // 3 days
-      return AggregationInterval.Hour;
-    } else if (diff <= 1000 * 60 * 60 * 24 * 7 * 6) {
-      // 3 weeks
-      return AggregationInterval.Day;
-    } else if (diff <= 1000 * 60 * 60 * 24 * 30 * 6) {
-      // 3 months
-      return AggregationInterval.Week;
-    } else if (diff <= 1000 * 60 * 60 * 24 * 365 * 6) {
-      // 3 years
-      return AggregationInterval.Month;
-    }
-    return AggregationInterval.Year;
+    return AggregationIntervalUtil.getAggregationIntervalForWindow(data);
   }
 }

package/Server/Utils/Monitor/MonitorAlert.ts

@@ -1,10 +1,12 @@
 import Alert from "../../../Models/DatabaseModels/Alert";
 import AlertSeverity from "../../../Models/DatabaseModels/AlertSeverity";
 import AlertStateTimeline from "../../../Models/DatabaseModels/AlertStateTimeline";
+import CephCluster from "../../../Models/DatabaseModels/CephCluster";
 import Host from "../../../Models/DatabaseModels/Host";
 import Label from "../../../Models/DatabaseModels/Label";
 import Monitor from "../../../Models/DatabaseModels/Monitor";
 import OnCallDutyPolicy from "../../../Models/DatabaseModels/OnCallDutyPolicy";
+import ProxmoxCluster from "../../../Models/DatabaseModels/ProxmoxCluster";
 import Service from "../../../Models/DatabaseModels/Service";
 import SortOrder from "../../../Types/BaseDatabase/SortOrder";
 import { LIMIT_PER_PROJECT } from "../../../Types/Database/LimitMax";
@@ -24,6 +26,9 @@ import ServiceService from "../../Services/ServiceService";
 import logger, { LogAttributes } from "../Logger";
 import CaptureSpan from "../Telemetry/CaptureSpan";
 import DataToProcess from "./DataToProcess";
+import MonitorClusterContextUtil, {
+  MonitorClusterContext,
+} from "./MonitorClusterContext";
 import MonitorTemplateUtil from "./MonitorTemplateUtil";
 import { JSONObject } from "../../../Types/JSON";
 import OneUptimeDate from "../../../Types/Date";
@@ -159,6 +164,19 @@ export default class MonitorAlert {
       return;
     }
 
+    /*
+     * Proxmox/Ceph monitors: resolve the monitored cluster once per
+     * evaluation (lookup-only, from the step config's clusterIdentifier)
+     * so every alert created below is attached to it. Series labels
+     * cannot supply this — they carry datapoint labels (`id`,
+     * `ceph_daemon`, `pool_id`), not cluster identity, and ungrouped
+     * templates have no series at all. No-op for other monitor types.
+     */
+    const clusterContext: MonitorClusterContext =
+      await MonitorClusterContextUtil.resolveClusterContextForMonitor({
+        monitor: input.monitor,
+      });
+
     const seriesToProcess: Array<PerSeriesCriteriaMatch | undefined> =
       input.matchesPerSeries && input.matchesPerSeries.length > 0
         ? input.matchesPerSeries
@@ -376,6 +394,33 @@ export default class MonitorAlert {
           }
         }
 
+        /*
+         * Deterministic Proxmox/Ceph cluster link from the monitor's
+         * step config (resolved once above). Series labels never carry
+         * cluster identity for these monitor types, so this — not the
+         * label path above — is what makes the per-cluster Activity
+         * tabs and badge counts see monitor-created alerts. Runs for
+         * both grouped and ungrouped alerts.
+         */
+        if (clusterContext.proxmoxClusterIds.length > 0) {
+          alert.proxmoxClusters = clusterContext.proxmoxClusterIds.map(
+            (id: string): ProxmoxCluster => {
+              const cluster: ProxmoxCluster = new ProxmoxCluster();
+              cluster._id = id;
+              return cluster;
+            },
+          );
+        }
+        if (clusterContext.cephClusterIds.length > 0) {
+          alert.cephClusters = clusterContext.cephClusterIds.map(
+            (id: string): CephCluster => {
+              const cluster: CephCluster = new CephCluster();
+              cluster._id = id;
+              return cluster;
+            },
+          );
+        }
+
         alert.onCallDutyPolicies =
           criteriaAlert.onCallPolicyIds?.map((id: ObjectID) => {
             const onCallPolicy: OnCallDutyPolicy = new OnCallDutyPolicy();