@oneuptime/common 11.0.2 → 11.0.3

package/Server/Utils/Monitor/MonitorCriteriaEvaluator.ts

@@ -58,6 +58,8 @@ import MetricMonitorResponse, {
   ProxmoxResourceBreakdown,
   CephAffectedResource,
   CephResourceBreakdown,
+  DockerSwarmAffectedResource,
+  DockerSwarmResourceBreakdown,
 } from "../../../Types/Monitor/MetricMonitor/MetricMonitorResponse";
 import MetricSeriesResult from "../../../Types/Monitor/MetricMonitor/MetricSeriesResult";
 import MetricCriteriaContext, {
@@ -66,8 +68,11 @@ import MetricCriteriaContext, {
   MetricComponentValue,
 } from "../../../Types/Monitor/MetricMonitor/MetricCriteriaContext";
 import MonitorStepDockerMonitor from "../../../Types/Monitor/MonitorStepDockerMonitor";
+import MonitorStepHostMonitor from "../../../Types/Monitor/MonitorStepHostMonitor";
+import MonitorStepPodmanMonitor from "../../../Types/Monitor/MonitorStepPodmanMonitor";
 import MonitorStepProxmoxMonitor from "../../../Types/Monitor/MonitorStepProxmoxMonitor";
 import MonitorStepCephMonitor from "../../../Types/Monitor/MonitorStepCephMonitor";
+import MonitorStepDockerSwarmMonitor from "../../../Types/Monitor/MonitorStepDockerSwarmMonitor";
 
 export default class MonitorCriteriaEvaluator {
   public static async processMonitorStep(input: {
@@ -237,6 +242,9 @@ ${contextBlock}
       input.monitor.monitorType !== MonitorType.Metrics &&
       input.monitor.monitorType !== MonitorType.Kubernetes &&
       input.monitor.monitorType !== MonitorType.Docker &&
+      input.monitor.monitorType !== MonitorType.Host &&
+      input.monitor.monitorType !== MonitorType.Podman &&
+      input.monitor.monitorType !== MonitorType.DockerSwarm &&
       input.monitor.monitorType !== MonitorType.Proxmox &&
       input.monitor.monitorType !== MonitorType.Ceph
     ) {
@@ -685,6 +693,9 @@ ${contextBlock}
       input.monitor.monitorType === MonitorType.Metrics ||
       input.monitor.monitorType === MonitorType.Kubernetes ||
       input.monitor.monitorType === MonitorType.Docker ||
+      input.monitor.monitorType === MonitorType.Host ||
+      input.monitor.monitorType === MonitorType.Podman ||
+      input.monitor.monitorType === MonitorType.DockerSwarm ||
       input.monitor.monitorType === MonitorType.Proxmox ||
       input.monitor.monitorType === MonitorType.Ceph
     ) {
@@ -819,11 +830,26 @@ ${contextBlock}
       return MonitorCriteriaEvaluator.buildDockerRootCauseContext(input);
     }
 
+    // Handle Host monitors with resource context
+    if (input.monitor.monitorType === MonitorType.Host) {
+      return MonitorCriteriaEvaluator.buildHostRootCauseContext(input);
+    }
+
+    // Handle Podman monitors with resource context
+    if (input.monitor.monitorType === MonitorType.Podman) {
+      return MonitorCriteriaEvaluator.buildPodmanRootCauseContext(input);
+    }
+
     // Handle Proxmox monitors with resource context
     if (input.monitor.monitorType === MonitorType.Proxmox) {
       return MonitorCriteriaEvaluator.buildProxmoxRootCauseContext(input);
     }
 
+    // Handle Docker Swarm monitors with resource context
+    if (input.monitor.monitorType === MonitorType.DockerSwarm) {
+      return MonitorCriteriaEvaluator.buildDockerSwarmRootCauseContext(input);
+    }
+
     // Handle Ceph monitors with resource context
     if (input.monitor.monitorType === MonitorType.Ceph) {
       return MonitorCriteriaEvaluator.buildCephRootCauseContext(input);
@@ -1593,6 +1619,124 @@ ${contextBlock}
     return sections.length > 0 ? sections.join("\n") : null;
   }
 
+  private static buildHostRootCauseContext(input: {
+    dataToProcess: DataToProcess;
+    monitorStep: MonitorStep;
+    monitor: Monitor;
+  }): string | null {
+    const metricResponse: MetricMonitorResponse =
+      input.dataToProcess as MetricMonitorResponse;
+
+    const sections: Array<string> = [];
+
+    // Host context
+    const hostMonitor: MonitorStepHostMonitor | undefined =
+      input.monitorStep.data?.hostMonitor;
+
+    if (hostMonitor) {
+      const hostDetails: Array<string> = [];
+      hostDetails.push(`- Host: ${hostMonitor.hostIdentifier || "Unknown"}`);
+
+      // Add metric name from the query config
+      if (
+        hostMonitor.metricViewConfig?.queryConfigs?.length > 0 &&
+        hostMonitor.metricViewConfig.queryConfigs[0]
+      ) {
+        const metricName: string = hostMonitor.metricViewConfig.queryConfigs[0]
+          .metricQueryData?.filterData?.metricName as string;
+        if (metricName) {
+          hostDetails.push(`- Metric: \`${metricName}\``);
+        }
+      }
+
+      sections.push(`**Host Details**\n${hostDetails.join("\n")}`);
+    }
+
+    // Metric results summary
+    if (metricResponse.metricResult && metricResponse.metricResult.length > 0) {
+      const resultDetails: Array<string> = [];
+
+      for (const result of metricResponse.metricResult) {
+        if (result.data && result.data.length > 0) {
+          resultDetails.push(
+            `- ${result.data.length} metric data point(s) returned`,
+          );
+        }
+      }
+
+      if (resultDetails.length > 0) {
+        sections.push(`\n\n**Metric Summary**\n${resultDetails.join("\n")}`);
+      }
+    }
+
+    return sections.length > 0 ? sections.join("\n") : null;
+  }
+
+  private static buildPodmanRootCauseContext(input: {
+    dataToProcess: DataToProcess;
+    monitorStep: MonitorStep;
+    monitor: Monitor;
+  }): string | null {
+    const metricResponse: MetricMonitorResponse =
+      input.dataToProcess as MetricMonitorResponse;
+
+    const sections: Array<string> = [];
+
+    // Podman host context
+    const podmanMonitor: MonitorStepPodmanMonitor | undefined =
+      input.monitorStep.data?.podmanMonitor;
+
+    if (podmanMonitor) {
+      const hostDetails: Array<string> = [];
+      hostDetails.push(`- Host: ${podmanMonitor.hostIdentifier || "Unknown"}`);
+
+      if (podmanMonitor.containerFilters?.containerName) {
+        hostDetails.push(
+          `- Container Name Filter: ${podmanMonitor.containerFilters.containerName}`,
+        );
+      }
+
+      if (podmanMonitor.containerFilters?.containerImage) {
+        hostDetails.push(
+          `- Container Image Filter: ${podmanMonitor.containerFilters.containerImage}`,
+        );
+      }
+
+      // Add metric name from the query config
+      if (
+        podmanMonitor.metricViewConfig?.queryConfigs?.length > 0 &&
+        podmanMonitor.metricViewConfig.queryConfigs[0]
+      ) {
+        const metricName: string = podmanMonitor.metricViewConfig
+          .queryConfigs[0].metricQueryData?.filterData?.metricName as string;
+        if (metricName) {
+          hostDetails.push(`- Metric: \`${metricName}\``);
+        }
+      }
+
+      sections.push(`**Podman Host Details**\n${hostDetails.join("\n")}`);
+    }
+
+    // Metric results summary
+    if (metricResponse.metricResult && metricResponse.metricResult.length > 0) {
+      const resultDetails: Array<string> = [];
+
+      for (const result of metricResponse.metricResult) {
+        if (result.data && result.data.length > 0) {
+          resultDetails.push(
+            `- ${result.data.length} metric data point(s) returned`,
+          );
+        }
+      }
+
+      if (resultDetails.length > 0) {
+        sections.push(`\n\n**Metric Summary**\n${resultDetails.join("\n")}`);
+      }
+    }
+
+    return sections.length > 0 ? sections.join("\n") : null;
+  }
+
   private static buildProxmoxRootCauseContext(input: {
     dataToProcess: DataToProcess;
     monitorStep: MonitorStep;
@@ -1758,6 +1902,168 @@ ${contextBlock}
     return sections.length > 0 ? sections.join("\n") : null;
   }
 
+  private static buildDockerSwarmRootCauseContext(input: {
+    dataToProcess: DataToProcess;
+    monitorStep: MonitorStep;
+    monitor: Monitor;
+  }): string | null {
+    const metricResponse: MetricMonitorResponse =
+      input.dataToProcess as MetricMonitorResponse;
+
+    const breakdown: DockerSwarmResourceBreakdown | undefined =
+      metricResponse.dockerSwarmResourceBreakdown;
+
+    const sections: Array<string> = [];
+
+    // Docker Swarm cluster context
+    const dockerSwarmMonitor: MonitorStepDockerSwarmMonitor | undefined =
+      input.monitorStep.data?.dockerSwarmMonitor;
+
+    if (dockerSwarmMonitor || breakdown) {
+      const clusterDetails: Array<string> = [];
+      clusterDetails.push(
+        `- Cluster: ${breakdown?.clusterName || dockerSwarmMonitor?.clusterIdentifier || "Unknown"}`,
+      );
+
+      if (breakdown) {
+        clusterDetails.push(
+          `- Metric: ${breakdown.metricFriendlyName} (\`${breakdown.metricName}\`)`,
+        );
+      } else if (
+        dockerSwarmMonitor &&
+        dockerSwarmMonitor.metricViewConfig?.queryConfigs?.length > 0 &&
+        dockerSwarmMonitor.metricViewConfig.queryConfigs[0]
+      ) {
+        const metricName: string = dockerSwarmMonitor.metricViewConfig
+          .queryConfigs[0].metricQueryData?.filterData?.metricName as string;
+        if (metricName) {
+          clusterDetails.push(`- Metric: \`${metricName}\``);
+        }
+      }
+
+      if (dockerSwarmMonitor?.resourceFilters?.serviceName) {
+        clusterDetails.push(
+          `- Service Filter: ${dockerSwarmMonitor.resourceFilters.serviceName}`,
+        );
+      }
+
+      if (dockerSwarmMonitor?.resourceFilters?.nodeName) {
+        clusterDetails.push(
+          `- Node Filter: ${dockerSwarmMonitor.resourceFilters.nodeName}`,
+        );
+      }
+
+      if (dockerSwarmMonitor?.resourceFilters?.containerName) {
+        clusterDetails.push(
+          `- Container Name Filter: ${dockerSwarmMonitor.resourceFilters.containerName}`,
+        );
+      }
+
+      if (dockerSwarmMonitor?.resourceFilters?.containerImage) {
+        clusterDetails.push(
+          `- Container Image Filter: ${dockerSwarmMonitor.resourceFilters.containerImage}`,
+        );
+      }
+
+      sections.push(
+        `**Docker Swarm Cluster Details**\n${clusterDetails.join("\n")}`,
+      );
+    }
+
+    // Affected resources (Task / Service / Node / Value)
+    let renderedBreakdownTable: boolean = false;
+
+    if (breakdown && breakdown.affectedResources.length > 0) {
+      /*
+       * K8s/Proxmox-parity render: drop zero-value rows, worst (highest)
+       * first, top 10. For the task-down template the breaching rows ARE
+       * the zero-uptime ones — those still drive alerting through the
+       * per-series criteria evaluation; this table is supplementary
+       * context only.
+       */
+      const sortedResources: Array<DockerSwarmAffectedResource> = [
+        ...breakdown.affectedResources,
+      ]
+        .filter((r: DockerSwarmAffectedResource) => {
+          return r.metricValue > 0;
+        })
+        .sort(
+          (a: DockerSwarmAffectedResource, b: DockerSwarmAffectedResource) => {
+            return b.metricValue - a.metricValue;
+          },
+        );
+
+      /*
+       * Skip the table when no row carries any identity label
+       * (cluster-wide series) — it would add nothing.
+       */
+      const hasIdentity: boolean = sortedResources.some(
+        (r: DockerSwarmAffectedResource) => {
+          return r.containerName || r.serviceName || r.nodeName;
+        },
+      );
+
+      if (sortedResources.length > 0 && hasIdentity) {
+        const resourcesToShow: Array<DockerSwarmAffectedResource> =
+          sortedResources.slice(0, 10);
+
+        const resourceLines: Array<string> = [];
+        resourceLines.push(`| Task / Container | Service | Node | Value |`);
+        resourceLines.push(`| --- | --- | --- | --- |`);
+
+        for (const resource of resourcesToShow) {
+          const taskCell: string = resource.containerName
+            ? `\`${resource.containerName}\``
+            : "-";
+          const serviceCell: string = resource.serviceName
+            ? `\`${resource.serviceName}\``
+            : "-";
+          const nodeCell: string = resource.nodeName
+            ? `\`${resource.nodeName}\``
+            : "-";
+
+          resourceLines.push(
+            `| ${taskCell} | ${serviceCell} | ${nodeCell} | **${resource.metricValue}** |`,
+          );
+        }
+
+        if (sortedResources.length > 10) {
+          resourceLines.push(
+            `\n*... and ${sortedResources.length - 10} more affected tasks*`,
+          );
+        }
+
+        sections.push(
+          `\n\n**Affected Tasks** (${sortedResources.length} total)\n\n${resourceLines.join("\n")}`,
+        );
+        renderedBreakdownTable = true;
+      }
+    }
+
+    // Metric results summary (fallback context when no table rendered)
+    if (
+      !renderedBreakdownTable &&
+      metricResponse.metricResult &&
+      metricResponse.metricResult.length > 0
+    ) {
+      const resultDetails: Array<string> = [];
+
+      for (const result of metricResponse.metricResult) {
+        if (result.data && result.data.length > 0) {
+          resultDetails.push(
+            `- ${result.data.length} metric data point(s) returned`,
+          );
+        }
+      }
+
+      if (resultDetails.length > 0) {
+        sections.push(`\n\n**Metric Summary**\n${resultDetails.join("\n")}`);
+      }
+    }
+
+    return sections.length > 0 ? sections.join("\n") : null;
+  }
+
   private static buildCephRootCauseContext(input: {
     dataToProcess: DataToProcess;
     monitorStep: MonitorStep;

package/Server/Utils/Monitor/MonitorIncident.ts

@@ -1,4 +1,5 @@
 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";
@@ -9,6 +10,7 @@ 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 Service from "../../../Models/DatabaseModels/Service";
 import Includes from "../../../Types/BaseDatabase/Includes";
@@ -27,6 +29,7 @@ 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";
@@ -577,6 +580,7 @@ export default class MonitorIncident {
     const [
       resolvedHosts,
       resolvedDockerHosts,
+      resolvedPodmanHosts,
       resolvedClusters,
       resolvedServices,
       resolvedProxmoxClusters,
@@ -596,6 +600,13 @@ export default class MonitorIncident {
         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,
@@ -642,6 +653,15 @@ export default class MonitorIncident {
         },
       );
     }
+    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 => {
@@ -735,6 +755,31 @@ export default class MonitorIncident {
 
       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;
+    }
   }
 
   /*

package/Server/Utils/Monitor/MonitorMaintenanceSuppression.ts

@@ -23,6 +23,7 @@ export interface ResourceKeySet {
 export interface MaintainedResourceKeys {
   hosts: ResourceKeySet;
   dockerHosts: ResourceKeySet;
+  podmanHosts: ResourceKeySet;
   kubernetesClusters: ResourceKeySet;
   /*
    * Proxmox/Ceph clusters have no `oneuptime.*.id` label stamp, so only
@@ -112,6 +113,11 @@ export default class MonitorMaintenanceSuppression {
           refs.dockerHostNames,
           input.maintained.dockerHosts.names,
         ) ||
+        this.intersects(refs.podmanHostIds, input.maintained.podmanHosts.ids) ||
+        this.intersects(
+          refs.podmanHostNames,
+          input.maintained.podmanHosts.names,
+        ) ||
         this.intersects(
           refs.kubernetesClusterIds,
           input.maintained.kubernetesClusters.ids,
@@ -156,6 +162,8 @@ export default class MonitorMaintenanceSuppression {
       maintained.hosts.names.size > 0 ||
       maintained.dockerHosts.ids.size > 0 ||
       maintained.dockerHosts.names.size > 0 ||
+      maintained.podmanHosts.ids.size > 0 ||
+      maintained.podmanHosts.names.size > 0 ||
       maintained.kubernetesClusters.ids.size > 0 ||
       maintained.kubernetesClusters.names.size > 0 ||
       maintained.proxmoxClusters.ids.size > 0 ||
@@ -181,6 +189,7 @@ export default class MonitorMaintenanceSuppression {
     const maintained: MaintainedResourceKeys = {
       hosts: { ids: new Set<string>(), names: new Set<string>() },
       dockerHosts: { ids: new Set<string>(), names: new Set<string>() },
+      podmanHosts: { ids: new Set<string>(), names: new Set<string>() },
       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>() },
@@ -199,6 +208,7 @@ export default class MonitorMaintenanceSuppression {
           _id: true,
           hosts: { _id: true, hostIdentifier: true },
           dockerHosts: { _id: true, hostIdentifier: true },
+          podmanHosts: { _id: true, hostIdentifier: true },
           kubernetesClusters: { _id: true, clusterIdentifier: true },
           proxmoxClusters: { _id: true, name: true },
           cephClusters: { _id: true, name: true },
@@ -222,6 +232,13 @@ export default class MonitorMaintenanceSuppression {
           dockerHost.hostIdentifier,
         );
       }
+      for (const podmanHost of event.podmanHosts || []) {
+        this.addKey(
+          maintained.podmanHosts,
+          podmanHost._id,
+          podmanHost.hostIdentifier,
+        );
+      }
       for (const cluster of event.kubernetesClusters || []) {
         this.addKey(
           maintained.kubernetesClusters,

package/Server/Utils/Monitor/MonitorTemplateUtil.ts

@@ -361,6 +361,9 @@ export default class MonitorTemplateUtil {
         data.monitorType === MonitorType.Metrics ||
         data.monitorType === MonitorType.Kubernetes ||
         data.monitorType === MonitorType.Docker ||
+        data.monitorType === MonitorType.Host ||
+        data.monitorType === MonitorType.Podman ||
+        data.monitorType === MonitorType.DockerSwarm ||
         data.monitorType === MonitorType.Proxmox ||
         data.monitorType === MonitorType.Ceph
       ) {

package/Server/Utils/Monitor/SeriesResourceLabels.ts

@@ -48,6 +48,22 @@ export const DockerHostNameLabelKeys: ReadonlyArray<string> = [
   "oneuptime.docker.host.name",
 ];
 
+/*
+ * For Podman hosts we deliberately ignore raw `host.name` /
+ * `oneuptime.host.name`: those are the Host's territory. The ingest
+ * pipeline stamps `oneuptime.podman.host.*` independently when the
+ * source is a podman host, so only those keys identify a PodmanHost.
+ */
+export const PodmanHostIdLabelKeys: ReadonlyArray<string> = [
+  "resource.oneuptime.podman.host.id",
+  "oneuptime.podman.host.id",
+];
+
+export const PodmanHostNameLabelKeys: ReadonlyArray<string> = [
+  "resource.oneuptime.podman.host.name",
+  "oneuptime.podman.host.name",
+];
+
 export const KubernetesClusterIdLabelKeys: ReadonlyArray<string> = [
   "resource.oneuptime.kubernetes.cluster.id",
   "oneuptime.kubernetes.cluster.id",
@@ -112,6 +128,8 @@ export interface SeriesResourceRefs {
   hostNames: Array<string>;
   dockerHostIds: Array<string>;
   dockerHostNames: Array<string>;
+  podmanHostIds: Array<string>;
+  podmanHostNames: Array<string>;
   kubernetesClusterIds: Array<string>;
   kubernetesClusterNames: Array<string>;
   proxmoxClusterNames: Array<string>;
@@ -166,6 +184,14 @@ export default class SeriesResourceLabels {
         seriesLabels,
         DockerHostNameLabelKeys,
       ),
+      podmanHostIds: this.collectLabelValues(
+        seriesLabels,
+        PodmanHostIdLabelKeys,
+      ),
+      podmanHostNames: this.collectLabelValues(
+        seriesLabels,
+        PodmanHostNameLabelKeys,
+      ),
       kubernetesClusterIds: this.collectLabelValues(
         seriesLabels,
         KubernetesClusterIdLabelKeys,

package/Server/Utils/Telemetry/ResourceFacetResolver.ts

@@ -5,6 +5,7 @@ import MultiSearch from "../../../Types/BaseDatabase/MultiSearch";
 import ServiceModel from "../../../Models/DatabaseModels/Service";
 import HostModel from "../../../Models/DatabaseModels/Host";
 import DockerHostModel from "../../../Models/DatabaseModels/DockerHost";
+import PodmanHostModel from "../../../Models/DatabaseModels/PodmanHost";
 import KubernetesClusterModel from "../../../Models/DatabaseModels/KubernetesCluster";
 import ServerlessFunctionModel from "../../../Models/DatabaseModels/ServerlessFunction";
 import CloudResourceModel from "../../../Models/DatabaseModels/CloudResource";
@@ -12,6 +13,7 @@ import RumApplicationModel from "../../../Models/DatabaseModels/RumApplication";
 import ServiceService from "../../Services/ServiceService";
 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";
@@ -34,6 +36,7 @@ export const RESOURCE_FACET_KEYS: ReadonlySet<string> = new Set([
   "serviceId",
   "hostId",
   "dockerHostId",
+  "podmanHostId",
   "kubernetesClusterId",
   "serverlessFunctionId",
   "cloudResourceId",
@@ -118,6 +121,13 @@ export default class ResourceFacetResolver {
           searchText,
           limit,
         );
+      case "podmanHostId":
+        return ResourceFacetResolver.queryPodmanHosts(
+          projectId,
+          spec.counts,
+          searchText,
+          limit,
+        );
       case "kubernetesClusterId":
         return ResourceFacetResolver.queryKubernetesClusters(
           projectId,
@@ -260,6 +270,45 @@ export default class ResourceFacetResolver {
     );
   }
 
+  private static async queryPodmanHosts(
+    projectId: ObjectID,
+    counts: Map<string, number>,
+    searchText: string | undefined,
+    limit: number,
+  ): Promise<Array<ResolvedFacetValue>> {
+    const query: Record<string, unknown> = { projectId };
+    if (searchText) {
+      query["name"] = new MultiSearch({
+        fields: ["name", "hostIdentifier"],
+        value: searchText,
+      });
+    }
+
+    const podmanHosts: Array<PodmanHostModel> = await PodmanHostService.findBy({
+      query: query as any,
+      select: {
+        _id: true,
+        name: true,
+        hostIdentifier: true,
+      },
+      limit: new PositiveNumber(limit),
+      skip: new PositiveNumber(0),
+      props: { isRoot: true },
+    });
+
+    return ResourceFacetResolver.mergeCounts(
+      podmanHosts.map(
+        (p: PodmanHostModel): { id: string; displayName: string } => {
+          return {
+            id: p._id ? p._id.toString() : "",
+            displayName: p.name || p.hostIdentifier || "Unknown",
+          };
+        },
+      ),
+      counts,
+    );
+  }
+
   private static async queryKubernetesClusters(
     projectId: ObjectID,
     counts: Map<string, number>,

package/Server/Utils/Telemetry/Telemetry.ts

@@ -163,6 +163,16 @@ export default class TelemetryUtil {
     };
   }
 
+  public static getAttributesForPodmanHostIdAndHostName(data: {
+    podmanHostId: ObjectID;
+    hostName: string;
+  }): Dictionary<AttributeType> {
+    return {
+      "oneuptime.podman.host.id": data.podmanHostId.toString(),
+      "oneuptime.podman.host.name": data.hostName,
+    };
+  }
+
   public static getAttributesForKubernetesClusterIdAndName(data: {
     kubernetesClusterId: ObjectID;
     clusterName: string;