@oneuptime/common 11.0.1 → 11.0.3

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

@@ -25,10 +25,16 @@ import logger from "../Utils/Logger";
 import ServiceModel from "../../Models/DatabaseModels/Service";
 import HostService from "./HostService";
 import DockerHostService from "./DockerHostService";
+import PodmanHostService from "./PodmanHostService";
 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 PodmanHost from "../../Models/DatabaseModels/PodmanHost";
 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 +353,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(
@@ -405,6 +412,22 @@ export class Service extends DatabaseService<Model> {
       }
     }
 
+    const podmanHosts: Array<PodmanHost> = await PodmanHostService.findBy({
+      query: { projectId: projectId },
+      select: { _id: true, retainTelemetryDataForDays: true },
+      skip: 0,
+      limit: LIMIT_MAX,
+      props: { isRoot: true },
+    });
+    for (const podmanHost of podmanHosts) {
+      if (podmanHost.id && podmanHost.retainTelemetryDataForDays) {
+        retentionByServiceId.set(
+          podmanHost.id.toString(),
+          podmanHost.retainTelemetryDataForDays,
+        );
+      }
+    }
+
     const clusters: Array<KubernetesCluster> =
       await KubernetesClusterService.findBy({
         query: { projectId: projectId },
@@ -422,6 +445,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

@@ -158,7 +158,10 @@ export class TraceAggregationService {
     new Map([
       ["hostId", ServiceType.Host],
       ["dockerHostId", ServiceType.DockerHost],
+      ["podmanHostId", ServiceType.PodmanHost],
       ["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/Types/Database/Permissions/OwnerTableRegistry.ts

@@ -18,6 +18,8 @@ import HostOwnerTeamService from "../../../Services/HostOwnerTeamService";
 import HostOwnerUserService from "../../../Services/HostOwnerUserService";
 import DockerHostOwnerTeamService from "../../../Services/DockerHostOwnerTeamService";
 import DockerHostOwnerUserService from "../../../Services/DockerHostOwnerUserService";
+import PodmanHostOwnerTeamService from "../../../Services/PodmanHostOwnerTeamService";
+import PodmanHostOwnerUserService from "../../../Services/PodmanHostOwnerUserService";
 import KubernetesClusterOwnerTeamService from "../../../Services/KubernetesClusterOwnerTeamService";
 import KubernetesClusterOwnerUserService from "../../../Services/KubernetesClusterOwnerUserService";
 import ServerlessFunctionOwnerTeamService from "../../../Services/ServerlessFunctionOwnerTeamService";
@@ -40,6 +42,7 @@ import ServiceService from "../../../Services/ServiceService";
 import MonitorService from "../../../Services/MonitorService";
 import HostService from "../../../Services/HostService";
 import DockerHostService from "../../../Services/DockerHostService";
+import PodmanHostService from "../../../Services/PodmanHostService";
 import KubernetesClusterService from "../../../Services/KubernetesClusterService";
 import ServerlessFunctionService from "../../../Services/ServerlessFunctionService";
 import CloudResourceService from "../../../Services/CloudResourceService";
@@ -180,6 +183,16 @@ const ownerTableRegistry: Map<string, OwnerTablePair> = new Map<
       modelService: DockerHostService,
     },
   ],
+  [
+    "PodmanHost",
+    {
+      ownerUserService: PodmanHostOwnerUserService,
+      ownerTeamService: PodmanHostOwnerTeamService,
+      fkColumn: "podmanHostId",
+      canOwnTelemetry: true,
+      modelService: PodmanHostService,
+    },
+  ],
   [
     "KubernetesCluster",
     {

package/Server/Utils/Monitor/MonitorAlert.ts

@@ -1,10 +1,13 @@
 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 DockerSwarmCluster from "../../../Models/DatabaseModels/DockerSwarmCluster";
 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 +27,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 +165,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 +395,42 @@ 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;
+            },
+          );
+        }
+        if (clusterContext.dockerSwarmClusterIds.length > 0) {
+          alert.dockerSwarmClusters = clusterContext.dockerSwarmClusterIds.map(
+            (id: string): DockerSwarmCluster => {
+              const cluster: DockerSwarmCluster = new DockerSwarmCluster();
+              cluster._id = id;
+              return cluster;
+            },
+          );
+        }
+
         alert.onCallDutyPolicies =
           criteriaAlert.onCallPolicyIds?.map((id: ObjectID) => {
             const onCallPolicy: OnCallDutyPolicy = new OnCallDutyPolicy();

package/Server/Utils/Monitor/MonitorClusterContext.ts

@@ -0,0 +1,158 @@
+import CephCluster from "../../../Models/DatabaseModels/CephCluster";
+import DockerSwarmCluster from "../../../Models/DatabaseModels/DockerSwarmCluster";
+import Monitor from "../../../Models/DatabaseModels/Monitor";
+import ProxmoxCluster from "../../../Models/DatabaseModels/ProxmoxCluster";
+import MonitorStep from "../../../Types/Monitor/MonitorStep";
+import MonitorType from "../../../Types/Monitor/MonitorType";
+import CephClusterService from "../../Services/CephClusterService";
+import DockerSwarmClusterService from "../../Services/DockerSwarmClusterService";
+import ProxmoxClusterService from "../../Services/ProxmoxClusterService";
+import QueryHelper from "../../Types/Database/QueryHelper";
+import logger from "../Logger";
+
+/*
+ * WI-11 contract: incidents/alerts created by Proxmox/Ceph monitors must
+ * be attached to the cluster they monitor — the per-cluster Activity
+ * pages and SideMenu badge counts query `proxmoxClusters` /
+ * `cephClusters` on Incident/Alert. Series labels cannot supply this
+ * identity: the shipped templates group by datapoint labels (`id`,
+ * `ceph_daemon`, `pool_id`), and ungrouped templates (e.g.
+ * ceph-health-error) have no series at all. The deterministic source is
+ * the monitor step config, which always carries `clusterIdentifier`
+ * (validated as required by MonitorStep), so the incident/alert creation
+ * paths resolve the cluster row from it once per evaluation.
+ */
+export interface MonitorClusterContext {
+  proxmoxClusterIds: Array<string>;
+  cephClusterIds: Array<string>;
+  dockerSwarmClusterIds: Array<string>;
+}
+
+export default class MonitorClusterContextUtil {
+  /*
+   * Resolve the Proxmox/Ceph cluster rows referenced by the monitor's
+   * step configs. Lookup-only — row creation belongs to ingest
+   * discovery (findOrCreateByName); a monitor pointing at a cluster
+   * that never sent data simply links nothing. The lookup is
+   * case-insensitive and project-scoped, matching the ingest contract
+   * (the agent-stamped name and the user-typed step identifier may
+   * differ only by case). Returns empty arrays for every other monitor
+   * type without touching the database.
+   */
+  public static async resolveClusterContextForMonitor(input: {
+    monitor: Monitor;
+  }): Promise<MonitorClusterContext> {
+    const context: MonitorClusterContext = {
+      proxmoxClusterIds: [],
+      cephClusterIds: [],
+      dockerSwarmClusterIds: [],
+    };
+
+    const monitorType: MonitorType | undefined = input.monitor.monitorType;
+
+    if (
+      monitorType !== MonitorType.Proxmox &&
+      monitorType !== MonitorType.Ceph &&
+      monitorType !== MonitorType.DockerSwarm
+    ) {
+      return context;
+    }
+
+    if (!input.monitor.projectId) {
+      return context;
+    }
+
+    const monitorSteps: Array<MonitorStep> =
+      input.monitor.monitorSteps?.data?.monitorStepsInstanceArray || [];
+
+    const clusterIdentifiers: Set<string> = new Set<string>();
+
+    for (const monitorStep of monitorSteps) {
+      let clusterIdentifier: string | undefined = undefined;
+
+      if (monitorType === MonitorType.Proxmox) {
+        clusterIdentifier = monitorStep.data?.proxmoxMonitor?.clusterIdentifier;
+      } else if (monitorType === MonitorType.Ceph) {
+        clusterIdentifier = monitorStep.data?.cephMonitor?.clusterIdentifier;
+      } else if (monitorType === MonitorType.DockerSwarm) {
+        clusterIdentifier =
+          monitorStep.data?.dockerSwarmMonitor?.clusterIdentifier;
+      }
+
+      if (clusterIdentifier && clusterIdentifier.trim().length > 0) {
+        clusterIdentifiers.add(clusterIdentifier.trim());
+      }
+    }
+
+    /*
+     * Cluster linking is best-effort context — a lookup failure must
+     * never block incident/alert creation, so errors are logged and
+     * swallowed per identifier.
+     */
+    for (const clusterIdentifier of clusterIdentifiers) {
+      try {
+        if (monitorType === MonitorType.Proxmox) {
+          const proxmoxCluster: ProxmoxCluster | null =
+            await ProxmoxClusterService.findOneBy({
+              query: {
+                projectId: input.monitor.projectId,
+                name: QueryHelper.findWithSameText(clusterIdentifier),
+              },
+              select: {
+                _id: true,
+              },
+              props: {
+                isRoot: true,
+              },
+            });
+
+          if (proxmoxCluster?._id) {
+            context.proxmoxClusterIds.push(String(proxmoxCluster._id));
+          }
+        } else if (monitorType === MonitorType.Ceph) {
+          const cephCluster: CephCluster | null =
+            await CephClusterService.findOneBy({
+              query: {
+                projectId: input.monitor.projectId,
+                name: QueryHelper.findWithSameText(clusterIdentifier),
+              },
+              select: {
+                _id: true,
+              },
+              props: {
+                isRoot: true,
+              },
+            });
+
+          if (cephCluster?._id) {
+            context.cephClusterIds.push(String(cephCluster._id));
+          }
+        } else {
+          const dockerSwarmCluster: DockerSwarmCluster | null =
+            await DockerSwarmClusterService.findOneBy({
+              query: {
+                projectId: input.monitor.projectId,
+                name: QueryHelper.findWithSameText(clusterIdentifier),
+              },
+              select: {
+                _id: true,
+              },
+              props: {
+                isRoot: true,
+              },
+            });
+
+          if (dockerSwarmCluster?._id) {
+            context.dockerSwarmClusterIds.push(String(dockerSwarmCluster._id));
+          }
+        }
+      } catch (err) {
+        logger.error(
+          `Failed to resolve ${monitorType} cluster "${clusterIdentifier}" for monitor ${input.monitor.id?.toString()}: ${err}`,
+        );
+      }
+    }
+
+    return context;
+  }
+}