@oneuptime/common 11.0.2 → 11.0.4

package/Server/Services/IncidentLabelRuleEngineService.ts

@@ -6,8 +6,10 @@ import IncidentSeverity from "../../Models/DatabaseModels/IncidentSeverity";
 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 Service from "../../Models/DatabaseModels/Service";
 import DockerHostService from "./DockerHostService";
+import PodmanHostService from "./PodmanHostService";
 import HostService from "./HostService";
 import IncidentFeedService from "./IncidentFeedService";
 import IncidentLabelRuleService from "./IncidentLabelRuleService";
@@ -33,6 +35,7 @@ class IncidentLabelRuleEngineServiceClass {
    *   - all labels of the incident's hosts when `inheritLabelsFromHosts`
    *   - all labels of the incident's Kubernetes clusters when `inheritLabelsFromKubernetesClusters`
    *   - all labels of the incident's Docker hosts when `inheritLabelsFromDockerHosts`
+   *   - all labels of the incident's Podman hosts when `inheritLabelsFromPodmanHosts`
    *   - all labels of the incident's services when `inheritLabelsFromServices`
    * The union is deduped against labels already on the incident before insert
    * to avoid PK conflicts on the IncidentLabel join table.
@@ -67,6 +70,7 @@ class IncidentLabelRuleEngineServiceClass {
             inheritLabelsFromHosts: true,
             inheritLabelsFromKubernetesClusters: true,
             inheritLabelsFromDockerHosts: true,
+            inheritLabelsFromPodmanHosts: true,
             inheritLabelsFromServices: true,
           },
           limit: 100,
@@ -82,6 +86,7 @@ class IncidentLabelRuleEngineServiceClass {
       let inheritFromHosts: boolean = false;
       let inheritFromKubernetesClusters: boolean = false;
       let inheritFromDockerHosts: boolean = false;
+      let inheritFromPodmanHosts: boolean = false;
       let inheritFromServices: boolean = false;
       const matchedRules: Array<IncidentLabelRule> = [];
 
@@ -111,6 +116,9 @@ class IncidentLabelRuleEngineServiceClass {
         if (rule.inheritLabelsFromDockerHosts) {
           inheritFromDockerHosts = true;
         }
+        if (rule.inheritLabelsFromPodmanHosts) {
+          inheritFromPodmanHosts = true;
+        }
         if (rule.inheritLabelsFromServices) {
           inheritFromServices = true;
         }
@@ -193,6 +201,25 @@ class IncidentLabelRuleEngineServiceClass {
         }
       }
 
+      if (inheritFromPodmanHosts && incident.podmanHosts?.length) {
+        for (const incidentPodmanHost of incident.podmanHosts) {
+          if (!incidentPodmanHost.id) {
+            continue;
+          }
+          const podmanHost: PodmanHost | null =
+            await PodmanHostService.findOneById({
+              id: incidentPodmanHost.id,
+              select: { labels: { _id: true } },
+              props: { isRoot: true },
+            });
+          for (const label of podmanHost?.labels || []) {
+            if (label.id) {
+              labelIdsToAdd.add(label.id.toString());
+            }
+          }
+        }
+      }
+
       if (inheritFromServices && incident.services?.length) {
         for (const incidentService of incident.services) {
           if (!incidentService.id) {

package/Server/Services/IncidentOwnerRuleEngineService.ts

@@ -14,6 +14,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 Service from "../../Models/DatabaseModels/Service";
 import ServiceOwnerTeam from "../../Models/DatabaseModels/ServiceOwnerTeam";
 import ServiceOwnerUser from "../../Models/DatabaseModels/ServiceOwnerUser";
@@ -31,6 +34,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 ServiceOwnerTeamService from "./ServiceOwnerTeamService";
 import ServiceOwnerUserService from "./ServiceOwnerUserService";
 import TeamService from "./TeamService";
@@ -81,6 +86,7 @@ class IncidentOwnerRuleEngineServiceClass {
             inheritOwnersFromHosts: true,
             inheritOwnersFromKubernetesClusters: true,
             inheritOwnersFromDockerHosts: true,
+            inheritOwnersFromPodmanHosts: true,
             inheritOwnersFromServices: true,
           },
           limit: 100,
@@ -107,6 +113,7 @@ class IncidentOwnerRuleEngineServiceClass {
       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 };
 
@@ -158,6 +165,12 @@ class IncidentOwnerRuleEngineServiceClass {
           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;
@@ -177,6 +190,8 @@ class IncidentOwnerRuleEngineServiceClass {
       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();
 
@@ -351,6 +366,47 @@ class IncidentOwnerRuleEngineServiceClass {
         }
       }
 
+      if (inheritFromPodmanHosts && incident.podmanHosts?.length) {
+        const podmanHostIds: Array<ObjectID> = incident.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 && incident.services?.length) {
         const serviceIds: Array<ObjectID> = incident.services
           .map((s: Service) => {
@@ -397,6 +453,7 @@ class IncidentOwnerRuleEngineServiceClass {
         ...inheritedFromHostUserIds,
         ...inheritedFromKubernetesClusterUserIds,
         ...inheritedFromDockerHostUserIds,
+        ...inheritedFromPodmanHostUserIds,
         ...inheritedFromServiceUserIds,
       ]);
       const inheritedTeamIds: Set<string> = new Set([
@@ -404,6 +461,7 @@ class IncidentOwnerRuleEngineServiceClass {
         ...inheritedFromHostTeamIds,
         ...inheritedFromKubernetesClusterTeamIds,
         ...inheritedFromDockerHostTeamIds,
+        ...inheritedFromPodmanHostTeamIds,
         ...inheritedFromServiceTeamIds,
       ]);
 
@@ -476,6 +534,10 @@ class IncidentOwnerRuleEngineServiceClass {
           inheritedFromDockerHostUserIds.size +
             inheritedFromDockerHostTeamIds.size >
           0,
+        inheritedFromPodmanHosts:
+          inheritedFromPodmanHostUserIds.size +
+            inheritedFromPodmanHostTeamIds.size >
+          0,
         inheritedFromServices:
           inheritedFromServiceUserIds.size + inheritedFromServiceTeamIds.size >
           0,
@@ -498,6 +560,7 @@ class IncidentOwnerRuleEngineServiceClass {
     inheritedFromHosts: boolean;
     inheritedFromKubernetesClusters: boolean;
     inheritedFromDockerHosts: boolean;
+    inheritedFromPodmanHosts: boolean;
     inheritedFromServices: boolean;
   }): Promise<void> {
     const {
@@ -509,6 +572,7 @@ class IncidentOwnerRuleEngineServiceClass {
       inheritedFromHosts,
       inheritedFromKubernetesClusters,
       inheritedFromDockerHosts,
+      inheritedFromPodmanHosts,
       inheritedFromServices,
     } = data;
     if (
@@ -593,6 +657,9 @@ class IncidentOwnerRuleEngineServiceClass {
       if (inheritedFromDockerHosts) {
         inheritedSources.push("Docker hosts");
       }
+      if (inheritedFromPodmanHosts) {
+        inheritedSources.push("Podman hosts");
+      }
       if (inheritedFromServices) {
         inheritedSources.push("services");
       }

package/Server/Services/IncidentService.ts

@@ -29,6 +29,7 @@ import { applyIncidentSelfPrivacyFilter } from "../Utils/Incident/IncidentPrivac
 import UserNotificationEventType from "../../Types/UserNotification/UserNotificationEventType";
 import StatusPageSubscriberNotificationStatus from "../../Types/StatusPage/StatusPageSubscriberNotificationStatus";
 import DockerHost from "../../Models/DatabaseModels/DockerHost";
+import PodmanHost from "../../Models/DatabaseModels/PodmanHost";
 import Host from "../../Models/DatabaseModels/Host";
 import KubernetesCluster from "../../Models/DatabaseModels/KubernetesCluster";
 import ServiceModel from "../../Models/DatabaseModels/Service";
@@ -571,6 +572,7 @@ export class Service extends DatabaseService<Model> {
             hosts: { _id: true },
             kubernetesClusters: { _id: true },
             dockerHosts: { _id: true },
+            podmanHosts: { _id: true },
             services: { _id: true },
             onCallDutyPolicies: { _id: true },
             labels: { _id: true },
@@ -689,6 +691,15 @@ export class Service extends DatabaseService<Model> {
             createBy.data.dockerHosts = stubs;
           }
         }
+        if (createBy.data.podmanHosts === undefined) {
+          const stubs: Array<PodmanHost> | undefined = stubBy(
+            PodmanHost,
+            incidentTemplate.podmanHosts,
+          );
+          if (stubs && stubs.length > 0) {
+            createBy.data.podmanHosts = stubs;
+          }
+        }
         if (createBy.data.services === undefined) {
           const stubs: Array<ServiceModel> | undefined = stubBy(
             ServiceModel,

package/Server/Services/Index.ts

@@ -35,14 +35,21 @@ import IncidentStateTimelineService from "./IncidentStateTimelineService";
 import LabelService from "./LabelService";
 import KubernetesClusterService from "./KubernetesClusterService";
 import DockerHostService from "./DockerHostService";
+import PodmanHostService from "./PodmanHostService";
 import ProxmoxClusterService from "./ProxmoxClusterService";
+import DockerSwarmClusterService from "./DockerSwarmClusterService";
 import CephClusterService from "./CephClusterService";
 import ProxmoxResourceService from "./ProxmoxResourceService";
+import DockerSwarmResourceService from "./DockerSwarmResourceService";
 import CephResourceService from "./CephResourceService";
 import ProxmoxClusterLabelRuleService from "./ProxmoxClusterLabelRuleService";
+import DockerSwarmClusterLabelRuleService from "./DockerSwarmClusterLabelRuleService";
 import ProxmoxClusterOwnerRuleService from "./ProxmoxClusterOwnerRuleService";
+import DockerSwarmClusterOwnerRuleService from "./DockerSwarmClusterOwnerRuleService";
 import ProxmoxClusterOwnerTeamService from "./ProxmoxClusterOwnerTeamService";
+import DockerSwarmClusterOwnerTeamService from "./DockerSwarmClusterOwnerTeamService";
 import ProxmoxClusterOwnerUserService from "./ProxmoxClusterOwnerUserService";
+import DockerSwarmClusterOwnerUserService from "./DockerSwarmClusterOwnerUserService";
 import CephClusterLabelRuleService from "./CephClusterLabelRuleService";
 import CephClusterOwnerRuleService from "./CephClusterOwnerRuleService";
 import CephClusterOwnerTeamService from "./CephClusterOwnerTeamService";
@@ -99,6 +106,10 @@ import ProfileSampleService from "./ProfileSampleService";
 import ProjectSmtpConfigService from "./ProjectSmtpConfigService";
 import ProjectSsoService from "./ProjectSsoService";
 import ProjectOidcService from "./ProjectOidcService";
+import GlobalSsoService from "./GlobalSsoService";
+import GlobalOidcService from "./GlobalOidcService";
+import GlobalSsoProjectService from "./GlobalSsoProjectService";
+import GlobalOidcProjectService from "./GlobalOidcProjectService";
 import PromoCodeService from "./PromoCodeService";
 import EnterpriseLicenseService from "./EnterpriseLicenseService";
 import OpenSourceDeploymentService from "./OpenSourceDeploymentService";
@@ -282,14 +293,21 @@ const services: Array<BaseService> = [
   LabelService,
   KubernetesClusterService,
   DockerHostService,
+  PodmanHostService,
   ProxmoxClusterService,
+  DockerSwarmClusterService,
   CephClusterService,
   ProxmoxResourceService,
+  DockerSwarmResourceService,
   CephResourceService,
   ProxmoxClusterLabelRuleService,
+  DockerSwarmClusterLabelRuleService,
   ProxmoxClusterOwnerRuleService,
+  DockerSwarmClusterOwnerRuleService,
   ProxmoxClusterOwnerTeamService,
+  DockerSwarmClusterOwnerTeamService,
   ProxmoxClusterOwnerUserService,
+  DockerSwarmClusterOwnerUserService,
   CephClusterLabelRuleService,
   CephClusterOwnerRuleService,
   CephClusterOwnerTeamService,
@@ -329,6 +347,10 @@ const services: Array<BaseService> = [
   AIAgentTaskPullRequestService,
   ProjectSsoService,
   ProjectOidcService,
+  GlobalSsoService,
+  GlobalOidcService,
+  GlobalSsoProjectService,
+  GlobalOidcProjectService,
 
   ScheduledMaintenanceCustomFieldService,
   ScheduledMaintenanceInternalNoteService,

package/Server/Services/LogAggregationService.ts

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

package/Server/Services/MetricAggregationService.ts

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

package/Server/Services/OpenTelemetryIngestService.ts

@@ -20,17 +20,21 @@ import TelemetryRetentionConfig from "../../Types/Telemetry/TelemetryRetentionCo
 import ServiceType from "../../Types/Telemetry/ServiceType";
 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 DockerSwarmCluster from "../../Models/DatabaseModels/DockerSwarmCluster";
 import ServerlessFunction from "../../Models/DatabaseModels/ServerlessFunction";
 import CloudResource from "../../Models/DatabaseModels/CloudResource";
 import RumApplication from "../../Models/DatabaseModels/RumApplication";
 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 DockerSwarmClusterService from "./DockerSwarmClusterService";
 import ServerlessFunctionService from "./ServerlessFunctionService";
 import CloudResourceService from "./CloudResourceService";
 import RumApplicationService from "./RumApplicationService";
@@ -675,6 +679,23 @@ export default class OTelIngestService {
             dockerHost?.telemetryRetentionConfig ?? null,
         };
       }
+      if (primaryEntityType === ServiceType.PodmanHost) {
+        const podmanHost: PodmanHost | null =
+          await PodmanHostService.findOneById({
+            id: resourceId,
+            select: {
+              retainTelemetryDataForDays: true,
+              telemetryRetentionConfig: true,
+            },
+            props: { isRoot: true },
+          });
+        return {
+          retainTelemetryDataForDays:
+            podmanHost?.retainTelemetryDataForDays ?? null,
+          telemetryRetentionConfig:
+            podmanHost?.telemetryRetentionConfig ?? null,
+        };
+      }
       if (primaryEntityType === ServiceType.KubernetesCluster) {
         const cluster: KubernetesCluster | null =
           await KubernetesClusterService.findOneById({
@@ -723,6 +744,22 @@ export default class OTelIngestService {
           telemetryRetentionConfig: cluster?.telemetryRetentionConfig ?? null,
         };
       }
+      if (primaryEntityType === ServiceType.DockerSwarmCluster) {
+        const cluster: DockerSwarmCluster | null =
+          await DockerSwarmClusterService.findOneById({
+            id: resourceId,
+            select: {
+              retainTelemetryDataForDays: true,
+              telemetryRetentionConfig: true,
+            },
+            props: { isRoot: true },
+          });
+        return {
+          retainTelemetryDataForDays:
+            cluster?.retainTelemetryDataForDays ?? null,
+          telemetryRetentionConfig: cluster?.telemetryRetentionConfig ?? null,
+        };
+      }
       if (primaryEntityType === ServiceType.ServerlessFunction) {
         const serverlessFunction: ServerlessFunction | null =
           await ServerlessFunctionService.findOneById({

package/Server/Services/PodmanHostLabelRuleEngineService.ts

@@ -0,0 +1,198 @@
+import Label from "../../Models/DatabaseModels/Label";
+import PodmanHost from "../../Models/DatabaseModels/PodmanHost";
+import PodmanHostLabelRule from "../../Models/DatabaseModels/PodmanHostLabelRule";
+import PodmanHostLabelRuleService from "./PodmanHostLabelRuleService";
+import PodmanHostService from "./PodmanHostService";
+import ObjectID from "../../Types/ObjectID";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import logger, { LogAttributes } from "../Utils/Logger";
+
+class PodmanHostLabelRuleEngineServiceClass {
+  /**
+   * Evaluates PodmanHostLabelRule rows for the given Podman host and attaches matched
+   * labels to it. The union is deduped against labels already on the Podman host
+   * before insert to avoid PK conflicts on the join table.
+   */
+  @CaptureSpan()
+  public async applyRulesToPodmanHost(podmanHost: PodmanHost): Promise<void> {
+    if (!podmanHost.id || !podmanHost.projectId) {
+      return;
+    }
+
+    try {
+      const rules: Array<PodmanHostLabelRule> =
+        await PodmanHostLabelRuleService.findBy({
+          query: {
+            projectId: podmanHost.projectId,
+            isEnabled: true,
+          },
+          props: { isRoot: true },
+          select: {
+            _id: true,
+            name: true,
+            podmanHostLabels: { _id: true },
+            podmanHostNamePattern: true,
+            podmanHostDescriptionPattern: true,
+            labelsToAdd: { _id: true },
+          },
+          limit: 100,
+          skip: 0,
+        });
+
+      if (rules.length === 0) {
+        return;
+      }
+
+      const podmanHostWithDetails: PodmanHost | null =
+        await PodmanHostService.findOneById({
+          id: podmanHost.id,
+          select: {
+            name: true,
+            description: true,
+            labels: { _id: true },
+          },
+          props: { isRoot: true },
+        });
+
+      if (!podmanHostWithDetails) {
+        return;
+      }
+
+      const labelIdsToAdd: Set<string> = new Set();
+
+      for (const rule of rules) {
+        const matches: boolean = this.doesPodmanHostMatchRule(
+          podmanHostWithDetails,
+          rule,
+        );
+        if (!matches) {
+          continue;
+        }
+        for (const label of rule.labelsToAdd || []) {
+          if (label.id) {
+            labelIdsToAdd.add(label.id.toString());
+          }
+        }
+      }
+
+      if (labelIdsToAdd.size === 0) {
+        return;
+      }
+
+      const existingLabelIds: Set<string> = new Set(
+        (podmanHostWithDetails.labels || [])
+          .map((l: Label) => {
+            return l.id?.toString() || "";
+          })
+          .filter((id: string) => {
+            return id !== "";
+          }),
+      );
+
+      const newLabelIds: Array<string> = Array.from(labelIdsToAdd).filter(
+        (id: string) => {
+          return !existingLabelIds.has(id);
+        },
+      );
+      if (newLabelIds.length === 0) {
+        return;
+      }
+
+      await PodmanHostService.getRepository()
+        .createQueryBuilder()
+        .relation(PodmanHost, "labels")
+        .of(podmanHost.id.toString())
+        .add(newLabelIds);
+
+      /*
+       * Sync in-memory podmanHost.labels so a downstream owner-rule engine in
+       * the same onCreateSuccess chain can match on rule-added labels.
+       */
+      const mergedLabelIds: Set<string> = new Set([
+        ...existingLabelIds,
+        ...newLabelIds,
+      ]);
+      podmanHost.labels = Array.from(mergedLabelIds).map((id: string) => {
+        const label: Label = new Label();
+        label.id = new ObjectID(id);
+        return label;
+      });
+
+      logger.debug(
+        `PodmanHostLabelRuleEngine attached ${newLabelIds.length} labels to Podman host ${podmanHost.id}`,
+        { projectId: podmanHost.projectId.toString() } as LogAttributes,
+      );
+    } catch (error) {
+      logger.error(`Error applying Podman host label rules: ${error}`, {
+        projectId: podmanHost.projectId?.toString(),
+        podmanHostId: podmanHost.id?.toString(),
+      } as LogAttributes);
+    }
+  }
+
+  private doesPodmanHostMatchRule(
+    podmanHost: PodmanHost,
+    rule: PodmanHostLabelRule,
+  ): boolean {
+    if (rule.podmanHostLabels && rule.podmanHostLabels.length > 0) {
+      if (!podmanHost.labels || podmanHost.labels.length === 0) {
+        return false;
+      }
+      const ruleLabelIds: Array<string> = rule.podmanHostLabels.map(
+        (l: Label) => {
+          return l.id?.toString() || "";
+        },
+      );
+      const labelIds: Array<string> = podmanHost.labels.map((l: Label) => {
+        return l.id?.toString() || "";
+      });
+      if (
+        !ruleLabelIds.some((id: string) => {
+          return labelIds.includes(id);
+        })
+      ) {
+        return false;
+      }
+    }
+
+    if (
+      rule.podmanHostNamePattern &&
+      (!podmanHost.name ||
+        !this.testRegex(rule.podmanHostNamePattern, podmanHost.name, rule))
+    ) {
+      return false;
+    }
+
+    if (
+      rule.podmanHostDescriptionPattern &&
+      (!podmanHost.description ||
+        !this.testRegex(
+          rule.podmanHostDescriptionPattern,
+          podmanHost.description,
+          rule,
+        ))
+    ) {
+      return false;
+    }
+
+    return true;
+  }
+
+  private testRegex(
+    pattern: string,
+    value: string,
+    rule: PodmanHostLabelRule,
+  ): boolean {
+    try {
+      const regex: RegExp = new RegExp(pattern, "i");
+      return regex.test(value);
+    } catch {
+      logger.warn(
+        `Invalid regex in Podman host label rule ${rule.id}: ${pattern}`,
+      );
+      return false;
+    }
+  }
+}
+
+export default new PodmanHostLabelRuleEngineServiceClass();

package/Server/Services/PodmanHostLabelRuleService.ts

@@ -0,0 +1,14 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/PodmanHostLabelRule";
+import { IsBillingEnabled } from "../EnvironmentConfig";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+    if (IsBillingEnabled) {
+      this.hardDeleteItemsOlderThanInDays("createdAt", 3 * 365);
+    }
+  }
+}
+
+export default new Service();