@oneuptime/common 11.0.2 → 11.0.3

package/Server/Services/ScheduledMaintenanceLabelRuleEngineService.ts

@@ -3,10 +3,12 @@ import Host from "../../Models/DatabaseModels/Host";
 import KubernetesCluster from "../../Models/DatabaseModels/KubernetesCluster";
 import Label from "../../Models/DatabaseModels/Label";
 import Monitor from "../../Models/DatabaseModels/Monitor";
+import PodmanHost from "../../Models/DatabaseModels/PodmanHost";
 import ScheduledMaintenance from "../../Models/DatabaseModels/ScheduledMaintenance";
 import ScheduledMaintenanceLabelRule from "../../Models/DatabaseModels/ScheduledMaintenanceLabelRule";
 import Service from "../../Models/DatabaseModels/Service";
 import DockerHostService from "./DockerHostService";
+import PodmanHostService from "./PodmanHostService";
 import HostService from "./HostService";
 import KubernetesClusterService from "./KubernetesClusterService";
 import LabelService from "./LabelService";
@@ -32,6 +34,7 @@ class ScheduledMaintenanceLabelRuleEngineServiceClass {
    *   - all labels of the event's hosts when `inheritLabelsFromHosts`
    *   - all labels of the event's Kubernetes clusters when `inheritLabelsFromKubernetesClusters`
    *   - all labels of the event's Docker hosts when `inheritLabelsFromDockerHosts`
+   *   - all labels of the event's Podman hosts when `inheritLabelsFromPodmanHosts`
    *   - all labels of the event's services when `inheritLabelsFromServices`
    * The union is deduped against labels already on the event before insert
    * to avoid PK conflicts on the ScheduledMaintenanceLabel join table.
@@ -67,6 +70,7 @@ class ScheduledMaintenanceLabelRuleEngineServiceClass {
             inheritLabelsFromHosts: true,
             inheritLabelsFromKubernetesClusters: true,
             inheritLabelsFromDockerHosts: true,
+            inheritLabelsFromPodmanHosts: true,
             inheritLabelsFromServices: true,
           },
           limit: 100,
@@ -82,6 +86,7 @@ class ScheduledMaintenanceLabelRuleEngineServiceClass {
       let inheritFromHosts: boolean = false;
       let inheritFromKubernetesClusters: boolean = false;
       let inheritFromDockerHosts: boolean = false;
+      let inheritFromPodmanHosts: boolean = false;
       let inheritFromServices: boolean = false;
       const matchedRules: Array<ScheduledMaintenanceLabelRule> = [];
 
@@ -111,6 +116,9 @@ class ScheduledMaintenanceLabelRuleEngineServiceClass {
         if (rule.inheritLabelsFromDockerHosts) {
           inheritFromDockerHosts = true;
         }
+        if (rule.inheritLabelsFromPodmanHosts) {
+          inheritFromPodmanHosts = true;
+        }
         if (rule.inheritLabelsFromServices) {
           inheritFromServices = true;
         }
@@ -120,6 +128,7 @@ class ScheduledMaintenanceLabelRuleEngineServiceClass {
         inheritFromHosts ||
         inheritFromKubernetesClusters ||
         inheritFromDockerHosts ||
+        inheritFromPodmanHosts ||
         inheritFromServices;
 
       let eventWithResources: ScheduledMaintenance | null = null;
@@ -130,6 +139,7 @@ class ScheduledMaintenanceLabelRuleEngineServiceClass {
             hosts: { _id: true },
             kubernetesClusters: { _id: true },
             dockerHosts: { _id: true },
+            podmanHosts: { _id: true },
             services: { _id: true },
           },
           props: { isRoot: true },
@@ -213,6 +223,25 @@ class ScheduledMaintenanceLabelRuleEngineServiceClass {
         }
       }
 
+      if (inheritFromPodmanHosts && eventWithResources?.podmanHosts?.length) {
+        for (const eventPodmanHost of eventWithResources.podmanHosts) {
+          if (!eventPodmanHost.id) {
+            continue;
+          }
+          const podmanHost: PodmanHost | null =
+            await PodmanHostService.findOneById({
+              id: eventPodmanHost.id,
+              select: { labels: { _id: true } },
+              props: { isRoot: true },
+            });
+          for (const label of podmanHost?.labels || []) {
+            if (label.id) {
+              labelIdsToAdd.add(label.id.toString());
+            }
+          }
+        }
+      }
+
       if (inheritFromServices && eventWithResources?.services?.length) {
         for (const eventService of eventWithResources.services) {
           if (!eventService.id) {

package/Server/Services/ScheduledMaintenanceOwnerRuleEngineService.ts

@@ -11,6 +11,9 @@ import Label from "../../Models/DatabaseModels/Label";
 import Monitor from "../../Models/DatabaseModels/Monitor";
 import MonitorOwnerTeam from "../../Models/DatabaseModels/MonitorOwnerTeam";
 import MonitorOwnerUser from "../../Models/DatabaseModels/MonitorOwnerUser";
+import PodmanHost from "../../Models/DatabaseModels/PodmanHost";
+import PodmanHostOwnerTeam from "../../Models/DatabaseModels/PodmanHostOwnerTeam";
+import PodmanHostOwnerUser from "../../Models/DatabaseModels/PodmanHostOwnerUser";
 import ScheduledMaintenance from "../../Models/DatabaseModels/ScheduledMaintenance";
 import ScheduledMaintenanceOwnerRule from "../../Models/DatabaseModels/ScheduledMaintenanceOwnerRule";
 import Service from "../../Models/DatabaseModels/Service";
@@ -27,6 +30,8 @@ import KubernetesClusterOwnerUserService from "./KubernetesClusterOwnerUserServi
 import MonitorOwnerTeamService from "./MonitorOwnerTeamService";
 import MonitorOwnerUserService from "./MonitorOwnerUserService";
 import MonitorService from "./MonitorService";
+import PodmanHostOwnerTeamService from "./PodmanHostOwnerTeamService";
+import PodmanHostOwnerUserService from "./PodmanHostOwnerUserService";
 import ScheduledMaintenanceFeedService from "./ScheduledMaintenanceFeedService";
 import ScheduledMaintenanceOwnerRuleService from "./ScheduledMaintenanceOwnerRuleService";
 import ScheduledMaintenanceService from "./ScheduledMaintenanceService";
@@ -82,6 +87,7 @@ class ScheduledMaintenanceOwnerRuleEngineServiceClass {
             inheritOwnersFromHosts: true,
             inheritOwnersFromKubernetesClusters: true,
             inheritOwnersFromDockerHosts: true,
+            inheritOwnersFromPodmanHosts: true,
             inheritOwnersFromServices: true,
           },
           limit: 100,
@@ -108,6 +114,7 @@ class ScheduledMaintenanceOwnerRuleEngineServiceClass {
       let inheritFromHosts: boolean = false;
       let inheritFromKubernetesClusters: boolean = false;
       let inheritFromDockerHosts: boolean = false;
+      let inheritFromPodmanHosts: boolean = false;
       let inheritFromServices: boolean = false;
       const inheritNotifyMode: { value: boolean | null } = { value: null };
 
@@ -159,6 +166,12 @@ class ScheduledMaintenanceOwnerRuleEngineServiceClass {
           inheritNotifyMode.value =
             inheritNotifyMode.value === true ? true : notify;
         }
+        if (rule.inheritOwnersFromPodmanHosts) {
+          inheritFromPodmanHosts = true;
+          ruleAddedAny = true;
+          inheritNotifyMode.value =
+            inheritNotifyMode.value === true ? true : notify;
+        }
         if (rule.inheritOwnersFromServices) {
           inheritFromServices = true;
           ruleAddedAny = true;
@@ -178,6 +191,8 @@ class ScheduledMaintenanceOwnerRuleEngineServiceClass {
       const inheritedFromKubernetesClusterTeamIds: Set<string> = new Set();
       const inheritedFromDockerHostUserIds: Set<string> = new Set();
       const inheritedFromDockerHostTeamIds: Set<string> = new Set();
+      const inheritedFromPodmanHostUserIds: Set<string> = new Set();
+      const inheritedFromPodmanHostTeamIds: Set<string> = new Set();
       const inheritedFromServiceUserIds: Set<string> = new Set();
       const inheritedFromServiceTeamIds: Set<string> = new Set();
 
@@ -353,6 +368,47 @@ class ScheduledMaintenanceOwnerRuleEngineServiceClass {
         }
       }
 
+      if (inheritFromPodmanHosts && scheduledMaintenance.podmanHosts?.length) {
+        const podmanHostIds: Array<ObjectID> = scheduledMaintenance.podmanHosts
+          .map((p: PodmanHost) => {
+            return p.id;
+          })
+          .filter((id: ObjectID | null | undefined): id is ObjectID => {
+            return Boolean(id);
+          });
+        if (podmanHostIds.length > 0) {
+          const [podmanHostOwnerUsers, podmanHostOwnerTeams]: [
+            Array<PodmanHostOwnerUser>,
+            Array<PodmanHostOwnerTeam>,
+          ] = await Promise.all([
+            PodmanHostOwnerUserService.findBy({
+              query: { podmanHostId: QueryHelper.any(podmanHostIds) },
+              select: { userId: true },
+              props: { isRoot: true },
+              limit: LIMIT_MAX,
+              skip: 0,
+            }),
+            PodmanHostOwnerTeamService.findBy({
+              query: { podmanHostId: QueryHelper.any(podmanHostIds) },
+              select: { teamId: true },
+              props: { isRoot: true },
+              limit: LIMIT_MAX,
+              skip: 0,
+            }),
+          ]);
+          for (const ownerUser of podmanHostOwnerUsers) {
+            if (ownerUser.userId) {
+              inheritedFromPodmanHostUserIds.add(ownerUser.userId.toString());
+            }
+          }
+          for (const ownerTeam of podmanHostOwnerTeams) {
+            if (ownerTeam.teamId) {
+              inheritedFromPodmanHostTeamIds.add(ownerTeam.teamId.toString());
+            }
+          }
+        }
+      }
+
       if (inheritFromServices && scheduledMaintenance.services?.length) {
         const serviceIds: Array<ObjectID> = scheduledMaintenance.services
           .map((s: Service) => {
@@ -399,6 +455,7 @@ class ScheduledMaintenanceOwnerRuleEngineServiceClass {
         ...inheritedFromHostUserIds,
         ...inheritedFromKubernetesClusterUserIds,
         ...inheritedFromDockerHostUserIds,
+        ...inheritedFromPodmanHostUserIds,
         ...inheritedFromServiceUserIds,
       ]);
       const inheritedTeamIds: Set<string> = new Set([
@@ -406,6 +463,7 @@ class ScheduledMaintenanceOwnerRuleEngineServiceClass {
         ...inheritedFromHostTeamIds,
         ...inheritedFromKubernetesClusterTeamIds,
         ...inheritedFromDockerHostTeamIds,
+        ...inheritedFromPodmanHostTeamIds,
         ...inheritedFromServiceTeamIds,
       ]);
 
@@ -480,6 +538,10 @@ class ScheduledMaintenanceOwnerRuleEngineServiceClass {
           inheritedFromDockerHostUserIds.size +
             inheritedFromDockerHostTeamIds.size >
           0,
+        inheritedFromPodmanHosts:
+          inheritedFromPodmanHostUserIds.size +
+            inheritedFromPodmanHostTeamIds.size >
+          0,
         inheritedFromServices:
           inheritedFromServiceUserIds.size + inheritedFromServiceTeamIds.size >
           0,
@@ -505,6 +567,7 @@ class ScheduledMaintenanceOwnerRuleEngineServiceClass {
     inheritedFromHosts: boolean;
     inheritedFromKubernetesClusters: boolean;
     inheritedFromDockerHosts: boolean;
+    inheritedFromPodmanHosts: boolean;
     inheritedFromServices: boolean;
   }): Promise<void> {
     const {
@@ -516,6 +579,7 @@ class ScheduledMaintenanceOwnerRuleEngineServiceClass {
       inheritedFromHosts,
       inheritedFromKubernetesClusters,
       inheritedFromDockerHosts,
+      inheritedFromPodmanHosts,
       inheritedFromServices,
     } = data;
     if (
@@ -600,6 +664,9 @@ class ScheduledMaintenanceOwnerRuleEngineServiceClass {
       if (inheritedFromDockerHosts) {
         inheritedSources.push("Docker hosts");
       }
+      if (inheritedFromPodmanHosts) {
+        inheritedSources.push("Podman hosts");
+      }
       if (inheritedFromServices) {
         inheritedSources.push("services");
       }

package/Server/Services/TelemetryUsageBillingService.ts

@@ -25,11 +25,13 @@ 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";
@@ -410,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 },

package/Server/Services/TraceAggregationService.ts

@@ -158,6 +158,7 @@ export class TraceAggregationService {
     new Map([
       ["hostId", ServiceType.Host],
       ["dockerHostId", ServiceType.DockerHost],
+      ["podmanHostId", ServiceType.PodmanHost],
       ["kubernetesClusterId", ServiceType.KubernetesCluster],
       ["proxmoxClusterId", ServiceType.ProxmoxCluster],
       ["cephClusterId", ServiceType.CephCluster],

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

@@ -2,6 +2,7 @@ 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";
@@ -420,6 +421,15 @@ export default class MonitorAlert {
             },
           );
         }
+        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) => {

package/Server/Utils/Monitor/MonitorClusterContext.ts

@@ -1,9 +1,11 @@
 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";
@@ -23,6 +25,7 @@ import logger from "../Logger";
 export interface MonitorClusterContext {
   proxmoxClusterIds: Array<string>;
   cephClusterIds: Array<string>;
+  dockerSwarmClusterIds: Array<string>;
 }
 
 export default class MonitorClusterContextUtil {
@@ -42,13 +45,15 @@ export default class MonitorClusterContextUtil {
     const context: MonitorClusterContext = {
       proxmoxClusterIds: [],
       cephClusterIds: [],
+      dockerSwarmClusterIds: [],
     };
 
     const monitorType: MonitorType | undefined = input.monitor.monitorType;
 
     if (
       monitorType !== MonitorType.Proxmox &&
-      monitorType !== MonitorType.Ceph
+      monitorType !== MonitorType.Ceph &&
+      monitorType !== MonitorType.DockerSwarm
     ) {
       return context;
     }
@@ -63,10 +68,16 @@ export default class MonitorClusterContextUtil {
     const clusterIdentifiers: Set<string> = new Set<string>();
 
     for (const monitorStep of monitorSteps) {
-      const clusterIdentifier: string | undefined =
-        monitorType === MonitorType.Proxmox
-          ? monitorStep.data?.proxmoxMonitor?.clusterIdentifier
-          : monitorStep.data?.cephMonitor?.clusterIdentifier;
+      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());
@@ -98,7 +109,7 @@ export default class MonitorClusterContextUtil {
           if (proxmoxCluster?._id) {
             context.proxmoxClusterIds.push(String(proxmoxCluster._id));
           }
-        } else {
+        } else if (monitorType === MonitorType.Ceph) {
           const cephCluster: CephCluster | null =
             await CephClusterService.findOneBy({
               query: {
@@ -116,6 +127,24 @@ export default class MonitorClusterContextUtil {
           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(