@oneuptime/common 12.0.9 → 12.0.11

package/Server/Utils/Monitor/MonitorIncident.ts

@@ -1,20 +1,10 @@
-import CephCluster from "../../../Models/DatabaseModels/CephCluster";
-import DockerSwarmCluster from "../../../Models/DatabaseModels/DockerSwarmCluster";
-import DockerHost from "../../../Models/DatabaseModels/DockerHost";
-import Host from "../../../Models/DatabaseModels/Host";
 import Incident from "../../../Models/DatabaseModels/Incident";
 import IncidentSeverity from "../../../Models/DatabaseModels/IncidentSeverity";
 import IncidentStateTimeline from "../../../Models/DatabaseModels/IncidentStateTimeline";
 import IncidentMember from "../../../Models/DatabaseModels/IncidentMember";
-import KubernetesCluster from "../../../Models/DatabaseModels/KubernetesCluster";
 import Label from "../../../Models/DatabaseModels/Label";
 import Monitor from "../../../Models/DatabaseModels/Monitor";
 import OnCallDutyPolicy from "../../../Models/DatabaseModels/OnCallDutyPolicy";
-import PodmanHost from "../../../Models/DatabaseModels/PodmanHost";
-import ProxmoxCluster from "../../../Models/DatabaseModels/ProxmoxCluster";
-import IoTFleet from "../../../Models/DatabaseModels/IoTFleet";
-import Service from "../../../Models/DatabaseModels/Service";
-import Includes from "../../../Types/BaseDatabase/Includes";
 import SortOrder from "../../../Types/BaseDatabase/SortOrder";
 import { LIMIT_PER_PROJECT } from "../../../Types/Database/LimitMax";
 import Dictionary from "../../../Types/Dictionary";
@@ -25,14 +15,7 @@ import ObjectID from "../../../Types/ObjectID";
 import ProbeMonitorResponse from "../../../Types/Probe/ProbeMonitorResponse";
 import { TelemetryQuery } from "../../../Types/Telemetry/TelemetryQuery";
 import { DisableAutomaticIncidentCreation } from "../../EnvironmentConfig";
-import CephClusterService from "../../Services/CephClusterService";
-import DockerHostService from "../../Services/DockerHostService";
-import HostService from "../../Services/HostService";
 import IncidentService from "../../Services/IncidentService";
-import KubernetesClusterService from "../../Services/KubernetesClusterService";
-import PodmanHostService from "../../Services/PodmanHostService";
-import ProxmoxClusterService from "../../Services/ProxmoxClusterService";
-import ServiceService from "../../Services/ServiceService";
 import IncidentSeverityService from "../../Services/IncidentSeverityService";
 import ProjectScopedReferenceValidator from "../Database/ProjectScopedReferenceValidator";
 import IncidentStateTimelineService from "../../Services/IncidentStateTimelineService";
@@ -57,9 +40,7 @@ import { PerSeriesCriteriaMatch } from "../../../Types/Probe/ProbeApiIngestRespo
 import MonitorClusterContextUtil, {
   MonitorClusterContext,
 } from "./MonitorClusterContext";
-import SeriesResourceLabels, {
-  SeriesResourceRefs,
-} from "./SeriesResourceLabels";
+import SeriesResourceLinker from "./SeriesResourceLinker";
 
 export default class MonitorIncident {
   @CaptureSpan()
@@ -671,8 +652,8 @@ export default class MonitorIncident {
         if (seriesLabels && Object.keys(seriesLabels).length > 0) {
           incident.seriesLabels = seriesLabels;
 
-          await this.linkResourceContextFromSeries({
-            incident,
+          await SeriesResourceLinker.linkSeriesResourcesToModel({
+            model: incident,
             seriesLabels,
             projectId: input.monitor.projectId!,
           });
@@ -685,7 +666,10 @@ export default class MonitorIncident {
          * path resolved, so the per-cluster Activity tabs always see
          * monitor-created incidents.
          */
-        this.attachClusterContext({ incident, clusterContext });
+        SeriesResourceLinker.attachClusterContext({
+          model: incident,
+          clusterContext,
+        });
 
         incident.onCallDutyPolicies =
           criteriaIncident.onCallPolicyIds?.map((id: ObjectID) => {
@@ -881,320 +865,6 @@ export default class MonitorIncident {
     return mergedIds;
   }
 
-  /*
-   * Pull every host / docker-host / k8s-cluster / proxmox-cluster /
-   * ceph-cluster / service identifier out of the series labels and
-   * attach the matching project-scoped records to the incident. The
-   * label-key → resource-type mapping lives in SeriesResourceLabels
-   * (shared with the scheduled-maintenance suppression path so the two
-   * never disagree about which labels identify which resource). Lookups
-   * are always project-scoped so a stale or hostile stamp can't pull in
-   * a record from another tenant.
-   */
-  private static async linkResourceContextFromSeries(input: {
-    incident: Incident;
-    seriesLabels: JSONObject;
-    projectId: ObjectID;
-  }): Promise<void> {
-    const refs: SeriesResourceRefs = SeriesResourceLabels.extractResourceRefs(
-      input.seriesLabels,
-    );
-
-    const [
-      resolvedHosts,
-      resolvedDockerHosts,
-      resolvedPodmanHosts,
-      resolvedClusters,
-      resolvedServices,
-      resolvedProxmoxClusters,
-      resolvedCephClusters,
-    ] = await Promise.all([
-      this.resolveResourceIds({
-        ids: refs.hostIds,
-        names: refs.hostNames,
-        nameColumn: "hostIdentifier",
-        projectId: input.projectId,
-        findBy: HostService.findBy.bind(HostService),
-      }),
-      this.resolveResourceIds({
-        ids: refs.dockerHostIds,
-        names: refs.dockerHostNames,
-        nameColumn: "hostIdentifier",
-        projectId: input.projectId,
-        findBy: DockerHostService.findBy.bind(DockerHostService),
-      }),
-      this.resolveResourceIds({
-        ids: refs.podmanHostIds,
-        names: refs.podmanHostNames,
-        nameColumn: "hostIdentifier",
-        projectId: input.projectId,
-        findBy: PodmanHostService.findBy.bind(PodmanHostService),
-      }),
-      this.resolveResourceIds({
-        ids: refs.kubernetesClusterIds,
-        names: refs.kubernetesClusterNames,
-        nameColumn: "clusterIdentifier",
-        projectId: input.projectId,
-        findBy: KubernetesClusterService.findBy.bind(KubernetesClusterService),
-      }),
-      this.resolveResourceIds({
-        ids: refs.serviceIds,
-        names: refs.serviceNames,
-        nameColumn: "name",
-        projectId: input.projectId,
-        findBy: ServiceService.findBy.bind(ServiceService),
-      }),
-      this.resolveResourceIds({
-        ids: [],
-        names: refs.proxmoxClusterNames,
-        nameColumn: "name",
-        projectId: input.projectId,
-        findBy: ProxmoxClusterService.findBy.bind(ProxmoxClusterService),
-      }),
-      this.resolveResourceIds({
-        ids: [],
-        names: refs.cephClusterNames,
-        nameColumn: "name",
-        projectId: input.projectId,
-        findBy: CephClusterService.findBy.bind(CephClusterService),
-      }),
-    ]);
-
-    if (resolvedHosts.length > 0) {
-      input.incident.hosts = resolvedHosts.map((id: string): Host => {
-        const host: Host = new Host();
-        host._id = id;
-        return host;
-      });
-    }
-    if (resolvedDockerHosts.length > 0) {
-      input.incident.dockerHosts = resolvedDockerHosts.map(
-        (id: string): DockerHost => {
-          const dockerHost: DockerHost = new DockerHost();
-          dockerHost._id = id;
-          return dockerHost;
-        },
-      );
-    }
-    if (resolvedPodmanHosts.length > 0) {
-      input.incident.podmanHosts = resolvedPodmanHosts.map(
-        (id: string): PodmanHost => {
-          const podmanHost: PodmanHost = new PodmanHost();
-          podmanHost._id = id;
-          return podmanHost;
-        },
-      );
-    }
-    if (resolvedClusters.length > 0) {
-      input.incident.kubernetesClusters = resolvedClusters.map(
-        (id: string): KubernetesCluster => {
-          const cluster: KubernetesCluster = new KubernetesCluster();
-          cluster._id = id;
-          return cluster;
-        },
-      );
-    }
-    if (resolvedServices.length > 0) {
-      input.incident.services = resolvedServices.map((id: string): Service => {
-        const service: Service = new Service();
-        service._id = id;
-        return service;
-      });
-    }
-    if (resolvedProxmoxClusters.length > 0) {
-      input.incident.proxmoxClusters = resolvedProxmoxClusters.map(
-        (id: string): ProxmoxCluster => {
-          const cluster: ProxmoxCluster = new ProxmoxCluster();
-          cluster._id = id;
-          return cluster;
-        },
-      );
-    }
-    if (resolvedCephClusters.length > 0) {
-      input.incident.cephClusters = resolvedCephClusters.map(
-        (id: string): CephCluster => {
-          const cluster: CephCluster = new CephCluster();
-          cluster._id = id;
-          return cluster;
-        },
-      );
-    }
-  }
-
-  /*
-   * Attach the monitor-step-resolved Proxmox/Ceph cluster ids to the
-   * incident, merging with (never overwriting) anything the
-   * series-label path already linked. Both paths can resolve the same
-   * cluster, so dedupe by id.
-   */
-  private static attachClusterContext(input: {
-    incident: Incident;
-    clusterContext: MonitorClusterContext;
-  }): void {
-    if (input.clusterContext.proxmoxClusterIds.length > 0) {
-      const existingIds: Set<string> = new Set<string>(
-        (input.incident.proxmoxClusters || []).map(
-          (cluster: ProxmoxCluster) => {
-            return String(cluster._id);
-          },
-        ),
-      );
-
-      const merged: Array<ProxmoxCluster> = [
-        ...(input.incident.proxmoxClusters || []),
-      ];
-
-      for (const id of input.clusterContext.proxmoxClusterIds) {
-        if (existingIds.has(id)) {
-          continue;
-        }
-        const cluster: ProxmoxCluster = new ProxmoxCluster();
-        cluster._id = id;
-        merged.push(cluster);
-      }
-
-      input.incident.proxmoxClusters = merged;
-    }
-
-    if (input.clusterContext.cephClusterIds.length > 0) {
-      const existingIds: Set<string> = new Set<string>(
-        (input.incident.cephClusters || []).map((cluster: CephCluster) => {
-          return String(cluster._id);
-        }),
-      );
-
-      const merged: Array<CephCluster> = [
-        ...(input.incident.cephClusters || []),
-      ];
-
-      for (const id of input.clusterContext.cephClusterIds) {
-        if (existingIds.has(id)) {
-          continue;
-        }
-        const cluster: CephCluster = new CephCluster();
-        cluster._id = id;
-        merged.push(cluster);
-      }
-
-      input.incident.cephClusters = merged;
-    }
-
-    if (input.clusterContext.dockerSwarmClusterIds.length > 0) {
-      const existingIds: Set<string> = new Set<string>(
-        (input.incident.dockerSwarmClusters || []).map(
-          (cluster: DockerSwarmCluster) => {
-            return String(cluster._id);
-          },
-        ),
-      );
-
-      const merged: Array<DockerSwarmCluster> = [
-        ...(input.incident.dockerSwarmClusters || []),
-      ];
-
-      for (const id of input.clusterContext.dockerSwarmClusterIds) {
-        if (existingIds.has(id)) {
-          continue;
-        }
-        const cluster: DockerSwarmCluster = new DockerSwarmCluster();
-        cluster._id = id;
-        merged.push(cluster);
-      }
-
-      input.incident.dockerSwarmClusters = merged;
-    }
-
-    if (input.clusterContext.iotFleetIds.length > 0) {
-      const existingIds: Set<string> = new Set<string>(
-        (input.incident.iotFleets || []).map((fleet: IoTFleet) => {
-          return String(fleet._id);
-        }),
-      );
-
-      const merged: Array<IoTFleet> = [...(input.incident.iotFleets || [])];
-
-      for (const id of input.clusterContext.iotFleetIds) {
-        if (existingIds.has(id)) {
-          continue;
-        }
-        const fleet: IoTFleet = new IoTFleet();
-        fleet._id = id;
-        merged.push(fleet);
-      }
-
-      input.incident.iotFleets = merged;
-    }
-  }
-
-  /*
-   * Resolve a mix of ids and names to a deduped set of database ids
-   * for one resource type, project-scoped. Either or both lists may
-   * be empty; if both are empty the method short-circuits with no DB
-   * round-trip.
-   */
-  private static async resolveResourceIds(input: {
-    ids: Array<string>;
-    names: Array<string>;
-    nameColumn: string;
-    projectId: ObjectID;
-    /*
-     * Loosely typed because the three resource services (Host,
-     * DockerHost, KubernetesCluster) each have their own
-     * `Query<TBaseModel>` shape and we deliberately abstract over
-     * them. We only need the row's `_id` back, which every model
-     * exposes via `DatabaseBaseModel`.
-     */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    findBy: (args: any) => Promise<Array<{ _id?: string | undefined }>>;
-  }): Promise<Array<string>> {
-    if (input.ids.length === 0 && input.names.length === 0) {
-      return [];
-    }
-
-    const resolved: Set<string> = new Set<string>();
-
-    const lookups: Array<Promise<Array<{ _id?: string | undefined }>>> = [];
-    if (input.ids.length > 0) {
-      lookups.push(
-        input.findBy({
-          query: {
-            projectId: input.projectId,
-            _id: new Includes(input.ids),
-          },
-          select: { _id: true },
-          skip: 0,
-          limit: LIMIT_PER_PROJECT,
-          props: { isRoot: true },
-        }),
-      );
-    }
-    if (input.names.length > 0) {
-      lookups.push(
-        input.findBy({
-          query: {
-            projectId: input.projectId,
-            [input.nameColumn]: new Includes(input.names),
-          },
-          select: { _id: true },
-          skip: 0,
-          limit: LIMIT_PER_PROJECT,
-          props: { isRoot: true },
-        }),
-      );
-    }
-
-    const buckets: Array<Array<{ _id?: string | undefined }>> =
-      await Promise.all(lookups);
-    for (const bucket of buckets) {
-      for (const row of bucket) {
-        if (row._id) {
-          resolved.add(String(row._id));
-        }
-      }
-    }
-    return Array.from(resolved);
-  }
-
   private static async resolveOpenIncident(input: {
     openIncident: Incident;
     rootCause: string;

package/Server/Utils/Monitor/MonitorMaintenanceSuppression.ts

@@ -31,6 +31,12 @@ export interface MaintainedResourceKeys {
    */
   proxmoxClusters: ResourceKeySet;
   cephClusters: ResourceKeySet;
+  /*
+   * Docker Swarm clusters, like Proxmox/Ceph clusters, have no
+   * `oneuptime.*.id` label stamp, so only the name set is ever matched;
+   * the id set exists for shape parity.
+   */
+  dockerSwarmClusters: ResourceKeySet;
   /*
    * IoT fleets, like Proxmox/Ceph clusters, have no `oneuptime.*.id`
    * label stamp, so only the name set is ever matched; the id set
@@ -140,6 +146,10 @@ export default class MonitorMaintenanceSuppression {
           refs.cephClusterNames,
           input.maintained.cephClusters.names,
         ) ||
+        this.intersects(
+          refs.dockerSwarmClusterNames,
+          input.maintained.dockerSwarmClusters.names,
+        ) ||
         this.intersects(refs.iotFleetNames, input.maintained.iotFleets.names) ||
         this.intersects(refs.serviceIds, input.maintained.services.ids) ||
         this.intersects(refs.serviceNames, input.maintained.services.names);
@@ -177,6 +187,8 @@ export default class MonitorMaintenanceSuppression {
       maintained.proxmoxClusters.names.size > 0 ||
       maintained.cephClusters.ids.size > 0 ||
       maintained.cephClusters.names.size > 0 ||
+      maintained.dockerSwarmClusters.ids.size > 0 ||
+      maintained.dockerSwarmClusters.names.size > 0 ||
       maintained.iotFleets.ids.size > 0 ||
       maintained.iotFleets.names.size > 0 ||
       maintained.services.ids.size > 0 ||
@@ -186,8 +198,9 @@ export default class MonitorMaintenanceSuppression {
 
   /*
    * Collect the ids + identifiers of every Host / DockerHost /
-   * KubernetesCluster / ProxmoxCluster / CephCluster / Service attached
-   * to an ongoing maintenance event in this project. Monitors attached
+   * PodmanHost / KubernetesCluster / ProxmoxCluster / CephCluster /
+   * DockerSwarmCluster / IoTFleet / Service attached to an ongoing
+   * maintenance event in this project. Monitors attached
    * to the event are intentionally not collected here — those are
    * already handled upstream by the whole-monitor disable flag, which
    * short-circuits evaluation before we ever reach per-series creation.
@@ -202,6 +215,10 @@ export default class MonitorMaintenanceSuppression {
       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>() },
+      dockerSwarmClusters: {
+        ids: new Set<string>(),
+        names: new Set<string>(),
+      },
       iotFleets: { ids: new Set<string>(), names: new Set<string>() },
       services: { ids: new Set<string>(), names: new Set<string>() },
     };
@@ -222,6 +239,7 @@ export default class MonitorMaintenanceSuppression {
           kubernetesClusters: { _id: true, clusterIdentifier: true },
           proxmoxClusters: { _id: true, name: true },
           cephClusters: { _id: true, name: true },
+          dockerSwarmClusters: { _id: true, name: true },
           iotFleets: { _id: true, name: true },
           services: { _id: true, name: true },
         },
@@ -267,6 +285,13 @@ export default class MonitorMaintenanceSuppression {
       for (const cephCluster of event.cephClusters || []) {
         this.addKey(maintained.cephClusters, cephCluster._id, cephCluster.name);
       }
+      for (const swarmCluster of event.dockerSwarmClusters || []) {
+        this.addKey(
+          maintained.dockerSwarmClusters,
+          swarmCluster._id,
+          swarmCluster.name,
+        );
+      }
       for (const iotFleet of event.iotFleets || []) {
         this.addKey(maintained.iotFleets, iotFleet._id, iotFleet.name);
       }

package/Server/Utils/Monitor/SeriesResourceLabels.ts

@@ -64,6 +64,25 @@ export const PodmanHostNameLabelKeys: ReadonlyArray<string> = [
   "oneuptime.podman.host.name",
 ];
 
+/*
+ * Docker Swarm cluster identity rides the agent-stamped resource
+ * attribute (`docker.swarm.cluster.name`) and its ClickHouse
+ * `resource.`-prefixed twin. The Swarm agent's collector config stamps
+ * it on every signal as the documented join key, and ingest keys cluster
+ * rows by that name only — there is no `oneuptime.*.id` stamp — so only
+ * name keys exist. The name maps to the cluster model's `name` column.
+ * Like Proxmox/Ceph, the shipped Swarm alert templates group by
+ * datapoint labels (`container.name`), so their series labels do NOT
+ * carry this key; the deterministic cluster link for those monitors
+ * comes from the monitor step config instead (see MonitorClusterContext).
+ * These keys cover user-built monitors that group by the cluster
+ * attribute.
+ */
+export const DockerSwarmClusterNameLabelKeys: ReadonlyArray<string> = [
+  "resource.docker.swarm.cluster.name",
+  "docker.swarm.cluster.name",
+];
+
 export const KubernetesClusterIdLabelKeys: ReadonlyArray<string> = [
   "resource.oneuptime.kubernetes.cluster.id",
   "oneuptime.kubernetes.cluster.id",
@@ -129,6 +148,14 @@ export const ServiceIdLabelKeys: ReadonlyArray<string> = [
 ];
 
 export const ServiceNameLabelKeys: ReadonlyArray<string> = [
+  /*
+   * Ingest stamps `oneuptime.service.name` alongside `oneuptime.service.id`
+   * on every row (Telemetry.getAttributesForServiceIdAndServiceName). It
+   * carries the same Service row's name as the raw `service.name` resource
+   * attribute, so the group-by dropdown can surface either spelling.
+   */
+  "resource.oneuptime.service.name",
+  "oneuptime.service.name",
   "resource.service.name",
   "service.name",
 ];
@@ -149,6 +176,7 @@ export interface SeriesResourceRefs {
   podmanHostNames: Array<string>;
   kubernetesClusterIds: Array<string>;
   kubernetesClusterNames: Array<string>;
+  dockerSwarmClusterNames: Array<string>;
   proxmoxClusterNames: Array<string>;
   cephClusterNames: Array<string>;
   iotFleetNames: Array<string>;
@@ -218,6 +246,10 @@ export default class SeriesResourceLabels {
         seriesLabels,
         KubernetesClusterNameLabelKeys,
       ),
+      dockerSwarmClusterNames: this.collectLabelValues(
+        seriesLabels,
+        DockerSwarmClusterNameLabelKeys,
+      ),
       proxmoxClusterNames: this.collectLabelValues(
         seriesLabels,
         ProxmoxClusterNameLabelKeys,