@oneuptime/common 11.0.2 → 11.0.4

package/Server/Services/PodmanResourceService.ts

@@ -0,0 +1,310 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/PodmanResource";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import ObjectID from "../../Types/ObjectID";
+import OneUptimeDate from "../../Types/Date";
+import { JSONObject } from "../../Types/JSON";
+import logger from "../Utils/Logger";
+
+/*
+ * ------------------------------------------------------------------
+ * PodmanResourceService
+ *
+ * Writes and reads the Podman inventory table populated by the
+ * telemetry ingest path. Container rows are upserted from the
+ * docker_stats receiver metric stream — every container.* metric
+ * carries container.id / container.name / container.image.name
+ * resource attributes, which is enough to maintain a live inventory
+ * of running containers per host without any agent-side change.
+ *
+ * Image / Network / Volume kinds are reserved for a follow-up agent
+ * change that adds a snapshot poller; the schema is ready for them.
+ *
+ * Rows are hard-deleted once lastSeenAt falls behind the staleness
+ * threshold (default: 15 min) so containers that stopped emitting
+ * metrics fall off the list automatically.
+ * ------------------------------------------------------------------
+ */
+
+export interface ParsedPodmanContainer {
+  containerName: string;
+  containerId: string | null;
+  imageName: string | null;
+  state: string;
+  cpuPercent: number | null;
+  memoryBytes: number | null;
+  observedAt: Date;
+}
+
+export interface ParsedPodmanResource {
+  kind: string;
+  name: string;
+  containerId: string | null;
+  imageName: string | null;
+  state: string | null;
+  labels: JSONObject | null;
+  resourceCreationTimestamp: Date | null;
+  lastSeenAt: Date;
+}
+
+export interface PodmanHostInventoryCounts {
+  containersRunning: number;
+  containersStopped: number;
+  containersPaused: number;
+}
+
+const UPSERT_BATCH_SIZE: number = 500;
+const STALE_DELETE_WARN_THRESHOLD: number = 100;
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  /**
+   * Upsert a batch of Container rows for a single (project, host)
+   * pair. Uses ON CONFLICT on the UNIQUE (projectId, podmanHostId,
+   * kind, name) index with a dominance guard on lastSeenAt so
+   * out-of-order ingest never regresses a newer observation.
+   *
+   * Containers are upserted from metric snapshots (no separate
+   * inventory snapshot path), so this also writes
+   * latestCpuPercent / latestMemoryBytes / metricsUpdatedAt in the
+   * same statement — saves a round trip vs. the K8s pattern of
+   * upsert-then-update.
+   */
+  @CaptureSpan()
+  public async bulkUpsertContainers(data: {
+    projectId: ObjectID;
+    podmanHostId: ObjectID;
+    containers: Array<ParsedPodmanContainer>;
+  }): Promise<void> {
+    if (data.containers.length === 0) {
+      return;
+    }
+
+    for (
+      let i: number = 0;
+      i < data.containers.length;
+      i += UPSERT_BATCH_SIZE
+    ) {
+      const chunk: Array<ParsedPodmanContainer> = data.containers.slice(
+        i,
+        i + UPSERT_BATCH_SIZE,
+      );
+
+      const valueFragments: Array<string> = [];
+      const params: Array<unknown> = [];
+      let p: number = 1;
+
+      for (const c of chunk) {
+        valueFragments.push(
+          `($${p++}, $${p++}, $${p++}, $${p++}, $${p++}, $${p++}, $${p++}, $${p++}::numeric, $${p++}::bigint, $${p++}::timestamptz, $${p++}::timestamptz, $${p++})`,
+        );
+        params.push(
+          data.projectId.toString(),
+          data.podmanHostId.toString(),
+          "Container",
+          c.containerName,
+          c.containerId,
+          c.imageName,
+          c.state,
+          c.cpuPercent !== null && c.cpuPercent !== undefined
+            ? c.cpuPercent
+            : null,
+          c.memoryBytes !== null && c.memoryBytes !== undefined
+            ? Math.trunc(c.memoryBytes).toString()
+            : null,
+          c.observedAt,
+          c.observedAt,
+          0, // version (BaseModel @VersionColumn)
+        );
+      }
+
+      const sql: string = `
+        INSERT INTO "PodmanResource" (
+          "projectId", "podmanHostId", "kind", "name",
+          "containerId", "imageName", "state",
+          "latestCpuPercent", "latestMemoryBytes",
+          "metricsUpdatedAt", "lastSeenAt", "version"
+        )
+        VALUES ${valueFragments.join(", ")}
+        ON CONFLICT ("projectId", "podmanHostId", "kind", "name")
+        DO UPDATE SET
+          "containerId" = COALESCE(EXCLUDED."containerId", "PodmanResource"."containerId"),
+          "imageName" = COALESCE(EXCLUDED."imageName", "PodmanResource"."imageName"),
+          "state" = EXCLUDED."state",
+          "latestCpuPercent" = COALESCE(EXCLUDED."latestCpuPercent", "PodmanResource"."latestCpuPercent"),
+          "latestMemoryBytes" = COALESCE(EXCLUDED."latestMemoryBytes", "PodmanResource"."latestMemoryBytes"),
+          "metricsUpdatedAt" = EXCLUDED."metricsUpdatedAt",
+          "lastSeenAt" = EXCLUDED."lastSeenAt",
+          "updatedAt" = now()
+        WHERE EXCLUDED."lastSeenAt" >= "PodmanResource"."lastSeenAt"
+      `;
+
+      await this.getRepository().manager.query(sql, params);
+    }
+  }
+
+  /**
+   * Upsert a batch of resources for any kind. Used by the snapshot
+   * ingest path (Container / Image / Network / Volume rows from the
+   * Podman agent's inventory poller). Container rows from this path
+   * carry full state (running / exited / paused / restarting / dead /
+   * created), unlike the metric-derived path which only sees running
+   * containers.
+   */
+  @CaptureSpan()
+  public async bulkUpsert(data: {
+    projectId: ObjectID;
+    podmanHostId: ObjectID;
+    resources: Array<ParsedPodmanResource>;
+  }): Promise<void> {
+    if (data.resources.length === 0) {
+      return;
+    }
+
+    for (let i: number = 0; i < data.resources.length; i += UPSERT_BATCH_SIZE) {
+      const chunk: Array<ParsedPodmanResource> = data.resources.slice(
+        i,
+        i + UPSERT_BATCH_SIZE,
+      );
+
+      const valueFragments: Array<string> = [];
+      const params: Array<unknown> = [];
+      let p: number = 1;
+
+      for (const r of chunk) {
+        valueFragments.push(
+          `($${p++}, $${p++}, $${p++}, $${p++}, $${p++}, $${p++}, $${p++}, $${p++}, $${p++}::timestamptz, $${p++}::timestamptz, $${p++})`,
+        );
+        params.push(
+          data.projectId.toString(),
+          data.podmanHostId.toString(),
+          r.kind,
+          r.name,
+          r.containerId,
+          r.imageName,
+          r.state,
+          r.labels ? JSON.stringify(r.labels) : null,
+          r.resourceCreationTimestamp,
+          r.lastSeenAt,
+          0, // version
+        );
+      }
+
+      const sql: string = `
+        INSERT INTO "PodmanResource" (
+          "projectId", "podmanHostId", "kind", "name",
+          "containerId", "imageName", "state", "labels",
+          "resourceCreationTimestamp", "lastSeenAt", "version"
+        )
+        VALUES ${valueFragments.join(", ")}
+        ON CONFLICT ("projectId", "podmanHostId", "kind", "name")
+        DO UPDATE SET
+          "containerId" = COALESCE(EXCLUDED."containerId", "PodmanResource"."containerId"),
+          "imageName" = COALESCE(EXCLUDED."imageName", "PodmanResource"."imageName"),
+          "state" = COALESCE(EXCLUDED."state", "PodmanResource"."state"),
+          "labels" = COALESCE(EXCLUDED."labels", "PodmanResource"."labels"),
+          "resourceCreationTimestamp" = COALESCE(EXCLUDED."resourceCreationTimestamp", "PodmanResource"."resourceCreationTimestamp"),
+          "lastSeenAt" = EXCLUDED."lastSeenAt",
+          "updatedAt" = now()
+        WHERE EXCLUDED."lastSeenAt" >= "PodmanResource"."lastSeenAt"
+      `;
+
+      await this.getRepository().manager.query(sql, params);
+    }
+  }
+
+  /**
+   * Hard-delete all resources on a host whose last observation is
+   * older than olderThan. Returns the number of deleted rows.
+   */
+  @CaptureSpan()
+  public async deleteStaleForHost(data: {
+    podmanHostId: ObjectID;
+    olderThan: Date;
+  }): Promise<number> {
+    const result: Array<{ affected?: number }> | { affected?: number } =
+      await this.getRepository().manager.query(
+        `DELETE FROM "PodmanResource" WHERE "podmanHostId" = $1 AND "lastSeenAt" < $2`,
+        [data.podmanHostId.toString(), data.olderThan],
+      );
+
+    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(
+        `PodmanResource cleanup deleted ${affected} stale rows for host ${data.podmanHostId.toString()} — larger than expected; investigate agent health.`,
+      );
+    }
+
+    return affected;
+  }
+
+  /**
+   * Compute container state breakdowns for a single host from the
+   * inventory table. Used by the cleanup worker to refresh the cached
+   * counts on PodmanHost so the Hosts page / dashboard widget shows
+   * accurate numbers without needing a SQL aggregation per render.
+   */
+  @CaptureSpan()
+  public async getContainerCountsForHost(data: {
+    projectId: ObjectID;
+    podmanHostId: ObjectID;
+  }): Promise<PodmanHostInventoryCounts> {
+    const rows: Array<{
+      running: string;
+      stopped: string;
+      paused: string;
+    }> = await this.getRepository().manager.query(
+      `SELECT
+         COUNT(*) FILTER (WHERE LOWER("state") = 'running')::text AS "running",
+         COUNT(*) FILTER (WHERE LOWER("state") IN ('exited', 'dead', 'created'))::text AS "stopped",
+         COUNT(*) FILTER (WHERE LOWER("state") = 'paused')::text AS "paused"
+       FROM "PodmanResource"
+       WHERE "projectId" = $1
+         AND "podmanHostId" = $2
+         AND "kind" = 'Container'
+         AND "deletedAt" IS NULL`,
+      [data.projectId.toString(), data.podmanHostId.toString()],
+    );
+
+    const row:
+      | { running: string; stopped: string; paused: string }
+      | undefined = rows[0];
+    return {
+      containersRunning: row ? parseInt(row.running, 10) || 0 : 0,
+      containersStopped: row ? parseInt(row.stopped, 10) || 0 : 0,
+      containersPaused: row ? parseInt(row.paused, 10) || 0 : 0,
+    };
+  }
+
+  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["PODMAN_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/ProjectService.ts

@@ -103,6 +103,14 @@ export class ProjectService extends DatabaseService<Model> {
    */
   private requireSsoForLoginCache: InMemoryTTLCache<boolean> =
     new InMemoryTTLCache(10_000);
+  /*
+   * Caches the `requireSsoWithSsoProviderId` discriminator per project so the
+   * enforce-SSO middleware can require that the SSO token was issued by a
+   * specific provider. Stored as a string id (or null when unset). Populated
+   * alongside `getRequireSsoForLogin` so the common path stays a single query.
+   */
+  private requireSsoWithSsoProviderIdCache: InMemoryTTLCache<string | null> =
+    new InMemoryTTLCache(10_000);
   /*
    * Caches the current billing plan per project. `getCurrentPlan` is hit
    * by `CommonAPI.getDatabaseCommonInteractionProps` on every
@@ -351,6 +359,10 @@ export class ProjectService extends DatabaseService<Model> {
       this.requireSsoForLoginCache.clear();
     }
 
+    if (updateBy.data.requireSsoWithSsoProviderId !== undefined) {
+      this.requireSsoWithSsoProviderIdCache.clear();
+    }
+
     if (IsBillingEnabled) {
       if (
         updateBy.data.businessDetails ||
@@ -1338,7 +1350,7 @@ export class ProjectService extends DatabaseService<Model> {
 
     const project: Model | null = await this.findOneById({
       id: projectId,
-      select: { requireSsoForLogin: true },
+      select: { requireSsoForLogin: true, requireSsoWithSsoProviderId: true },
       props: { isRoot: true },
     });
 
@@ -1349,9 +1361,40 @@ export class ProjectService extends DatabaseService<Model> {
 
     const value: boolean = Boolean(project.requireSsoForLogin);
     this.requireSsoForLoginCache.set(key, value, 60_000);
+    this.requireSsoWithSsoProviderIdCache.set(
+      key,
+      project.requireSsoWithSsoProviderId
+        ? project.requireSsoWithSsoProviderId.toString()
+        : null,
+      60_000,
+    );
     return value;
   }
 
+  /**
+   * Returns the specific SSO provider id a project requires for SSO-enforced
+   * login, or null when any trusted provider is acceptable. Cached for 60s and
+   * populated by `getRequireSsoForLogin`, so the enforce path stays one query.
+   */
+  @CaptureSpan()
+  public async getRequireSsoWithSsoProviderId(
+    projectId: ObjectID,
+  ): Promise<ObjectID | null> {
+    const key: string = projectId.toString();
+    const cached: string | null | undefined =
+      this.requireSsoWithSsoProviderIdCache.get(key);
+    if (cached !== undefined) {
+      return cached ? new ObjectID(cached) : null;
+    }
+
+    // Populate both caches via the existing single-query path.
+    await this.getRequireSsoForLogin(projectId);
+
+    const populated: string | null | undefined =
+      this.requireSsoWithSsoProviderIdCache.get(key);
+    return populated ? new ObjectID(populated) : null;
+  }
+
   @CaptureSpan()
   public async getOwners(projectId: ObjectID): Promise<Array<User>> {
     if (!projectId) {

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],