@oneuptime/common 11.0.2 → 11.0.3

package/Types/Podman/PodmanInventoryExtractor.ts

@@ -0,0 +1,343 @@
+import OneUptimeDate from "../Date";
+import { JSONObject } from "../JSON";
+import { ParsedPodmanResource } from "../../Server/Services/PodmanResourceService";
+
+/*
+ * ------------------------------------------------------------------
+ *                     PodmanInventoryExtractor
+ * ------------------------------------------------------------------
+ *
+ * Parses a single inventory log record emitted by the OneUptime
+ * Podman Agent's snapshot script. The script polls the local Podman
+ * daemon every 5 minutes for containers / images / networks /
+ * volumes and emits one JSON object per line into a log file that
+ * the OTel filelog receiver forwards as an OTLP log.
+ *
+ * The agreed wire format is a JSON envelope:
+ *
+ *   {
+ *     "kind":  "Container" | "Image" | "Network" | "Volume",
+ *     "data":  { ...native podman payload... }
+ *   }
+ *
+ * The kind discriminator is set as a log record attribute by the
+ * agent's filelog operator chain, but we also keep it inside the
+ * envelope so the parser can sanity-check.
+ *
+ * Each kind has a small dedicated parser that pulls out the fields
+ * we promote to first-class columns on `PodmanResource` (name,
+ * containerId, imageName, state, labels, creation timestamp). The
+ * full payload is *not* persisted — it lives on the original log
+ * record in ClickHouse if a user ever needs the raw blob.
+ *
+ * ------------------------------------------------------------------
+ */
+
+export const INVENTORY_KIND_ATTRIBUTE: string = "oneuptime.podman.kind";
+
+export const INVENTORIED_PODMAN_KINDS: ReadonlyArray<string> = [
+  "Container",
+  "Image",
+  "Network",
+  "Volume",
+];
+
+const INVENTORIED_KIND_SET: Set<string> = new Set(
+  INVENTORIED_PODMAN_KINDS.map((k: string) => {
+    return k.toLowerCase();
+  }),
+);
+
+export function isInventoriedPodmanKind(kind: string): boolean {
+  return INVENTORIED_KIND_SET.has(kind.toLowerCase());
+}
+
+/*
+ * Map a kind in any common form (lowercase plural, lowercase
+ * singular, or PascalCase) to the canonical PascalCase kind we store
+ * in the database. Returns null for anything we don't model.
+ */
+export function canonicalPodmanKind(raw: string): string | null {
+  const trimmed: string = (raw || "").trim().toLowerCase();
+  if (!trimmed) {
+    return null;
+  }
+  const map: Record<string, string> = {
+    container: "Container",
+    containers: "Container",
+    image: "Image",
+    images: "Image",
+    network: "Network",
+    networks: "Network",
+    volume: "Volume",
+    volumes: "Volume",
+  };
+  return map[trimmed] || null;
+}
+
+function parseLogBody(logBody: string): JSONObject | null {
+  try {
+    const parsed: unknown = JSON.parse(logBody);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed as JSONObject;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+function readString(obj: JSONObject, key: string): string | null {
+  const v: unknown = obj[key];
+  if (typeof v === "string" && v.trim().length > 0) {
+    return v.trim();
+  }
+  return null;
+}
+
+function readJSONObject(obj: JSONObject, key: string): JSONObject | null {
+  const v: unknown = obj[key];
+  if (v && typeof v === "object" && !Array.isArray(v)) {
+    return v as JSONObject;
+  }
+  return null;
+}
+
+function parseTimestamp(raw: string | null): Date | null {
+  if (!raw) {
+    return null;
+  }
+  try {
+    const d: Date = OneUptimeDate.fromString(raw);
+    if (isNaN(d.getTime())) {
+      return null;
+    }
+    return d;
+  } catch {
+    return null;
+  }
+}
+
+/*
+ * Container shape emitted by `podman container ls --format json` plus
+ * a few enrichments the agent script adds:
+ *   { Id, Names, Image, State, Status, CreatedAt, Labels }
+ *
+ * Names from the Podman CLI is a slash-prefixed comma-joined string
+ * ("/web,/web-1"). We strip the leading slash and take the first
+ * entry — that's what `docker_stats` reports as `container.name` in
+ * metric attributes, so the row keys stay consistent across paths.
+ */
+function parseContainer(
+  data: JSONObject,
+  lastSeenAt: Date,
+): ParsedPodmanResource | null {
+  const rawNames: string | null = readString(data, "Names");
+  const rawName: string | null = readString(data, "Name");
+  const namesField: string = rawNames || rawName || "";
+  const firstName: string = namesField
+    .split(",")
+    .map((n: string) => {
+      return n.trim().replace(/^\//, "");
+    })
+    .filter((n: string) => {
+      return n.length > 0;
+    })[0]!;
+
+  if (!firstName) {
+    return null;
+  }
+
+  const idRaw: string | null = readString(data, "Id");
+  const containerId: string | null = idRaw ? idRaw.substring(0, 12) : null;
+  const imageName: string | null = readString(data, "Image");
+  const state: string | null = readString(data, "State");
+  const labels: JSONObject | null = readJSONObject(data, "Labels");
+  const created: Date | null = parseTimestamp(readString(data, "CreatedAt"));
+
+  return {
+    kind: "Container",
+    name: firstName,
+    containerId,
+    imageName,
+    state: state ? state.toLowerCase() : null,
+    labels,
+    resourceCreationTimestamp: created,
+    lastSeenAt,
+  };
+}
+
+/*
+ * Image shape from `podman image ls --format json`:
+ *   { ID, Repository, Tag, CreatedAt, Labels }
+ *
+ * Name = Repository:Tag (matches what container.image.name emits).
+ * Skip dangling images (Repository=<none> with no tag) — they would
+ * collide on the unique key and are noise in a list view.
+ */
+function parseImage(
+  data: JSONObject,
+  lastSeenAt: Date,
+): ParsedPodmanResource | null {
+  const repository: string | null = readString(data, "Repository");
+  const tag: string | null = readString(data, "Tag");
+  const explicitName: string | null = readString(data, "Name");
+
+  let name: string | null = explicitName;
+  if (!name && repository && repository !== "<none>") {
+    name = tag && tag !== "<none>" ? `${repository}:${tag}` : repository;
+  }
+
+  if (!name) {
+    return null;
+  }
+
+  const idRaw: string | null = readString(data, "ID") || readString(data, "Id");
+  const containerId: string | null = idRaw
+    ? idRaw.replace(/^sha256:/, "").substring(0, 12)
+    : null;
+  const labels: JSONObject | null = readJSONObject(data, "Labels");
+  const created: Date | null = parseTimestamp(readString(data, "CreatedAt"));
+
+  return {
+    kind: "Image",
+    name,
+    containerId,
+    imageName: null,
+    state: null,
+    labels,
+    resourceCreationTimestamp: created,
+    lastSeenAt,
+  };
+}
+
+/*
+ * Network shape from `podman network ls --format json`:
+ *   { ID, Name, Driver, Scope, CreatedAt, Labels }
+ */
+function parseNetwork(
+  data: JSONObject,
+  lastSeenAt: Date,
+): ParsedPodmanResource | null {
+  const name: string | null = readString(data, "Name");
+  if (!name) {
+    return null;
+  }
+  const idRaw: string | null = readString(data, "ID") || readString(data, "Id");
+  const driver: string | null = readString(data, "Driver");
+  const scope: string | null = readString(data, "Scope");
+  const labels: JSONObject | null = readJSONObject(data, "Labels");
+  const created: Date | null = parseTimestamp(readString(data, "CreatedAt"));
+
+  /*
+   * Driver and scope are surfaced in the State column in the widget
+   * (e.g. "bridge / local"). Encoded as "driver/scope" so we don't
+   * need a new column on the table.
+   */
+  const stateParts: Array<string> = [];
+  if (driver) {
+    stateParts.push(driver);
+  }
+  if (scope) {
+    stateParts.push(scope);
+  }
+
+  return {
+    kind: "Network",
+    name,
+    containerId: idRaw ? idRaw.substring(0, 12) : null,
+    imageName: null,
+    state: stateParts.length > 0 ? stateParts.join("/") : null,
+    labels,
+    resourceCreationTimestamp: created,
+    lastSeenAt,
+  };
+}
+
+/*
+ * Volume shape from `podman volume ls --format json`:
+ *   { Name, Driver, Mountpoint, Scope, Labels, CreatedAt }
+ */
+function parseVolume(
+  data: JSONObject,
+  lastSeenAt: Date,
+): ParsedPodmanResource | null {
+  const name: string | null = readString(data, "Name");
+  if (!name) {
+    return null;
+  }
+  const driver: string | null = readString(data, "Driver");
+  const scope: string | null = readString(data, "Scope");
+  const labels: JSONObject | null = readJSONObject(data, "Labels");
+  const created: Date | null = parseTimestamp(readString(data, "CreatedAt"));
+
+  const stateParts: Array<string> = [];
+  if (driver) {
+    stateParts.push(driver);
+  }
+  if (scope) {
+    stateParts.push(scope);
+  }
+
+  return {
+    kind: "Volume",
+    name,
+    containerId: null,
+    imageName: null,
+    state: stateParts.length > 0 ? stateParts.join("/") : null,
+    labels,
+    resourceCreationTimestamp: created,
+    lastSeenAt,
+  };
+}
+
+export interface ExtractedPodmanInventoryRecord {
+  resource: ParsedPodmanResource;
+}
+
+/**
+ * Parse a single inventory log line. Returns null when the body is
+ * malformed or the kind is not modeled — callers should swallow nulls
+ * silently rather than fail the whole batch.
+ */
+export function extractPodmanInventoryResource(data: {
+  kind: string;
+  logBody: string;
+  lastSeenAt: Date;
+}): ExtractedPodmanInventoryRecord | null {
+  const canonical: string | null = canonicalPodmanKind(data.kind);
+  if (!canonical) {
+    return null;
+  }
+
+  const body: JSONObject | null = parseLogBody(data.logBody);
+  if (!body) {
+    return null;
+  }
+
+  /*
+   * The agent wraps the native podman payload in `{ kind, data }`.
+   * Older snapshot lines or test inputs may be the raw payload — we
+   * accept either by pulling `data` if present, else using the body
+   * directly.
+   */
+  const inner: JSONObject =
+    (readJSONObject(body, "data") as JSONObject) || body;
+
+  let parsed: ParsedPodmanResource | null = null;
+  if (canonical === "Container") {
+    parsed = parseContainer(inner, data.lastSeenAt);
+  } else if (canonical === "Image") {
+    parsed = parseImage(inner, data.lastSeenAt);
+  } else if (canonical === "Network") {
+    parsed = parseNetwork(inner, data.lastSeenAt);
+  } else if (canonical === "Volume") {
+    parsed = parseVolume(inner, data.lastSeenAt);
+  }
+
+  if (!parsed) {
+    return null;
+  }
+
+  return { resource: parsed };
+}

package/Types/Telemetry/EntityType.ts

@@ -38,6 +38,18 @@ enum EntityType {
   ProxmoxNode = "proxmox.node",
   ProxmoxGuest = "proxmox.guest",
   CephCluster = "ceph.cluster",
+  /*
+   * Docker Swarm types are OneUptime-defined (no upstream semconv
+   * exists) but follow the same dotted naming convention. The
+   * identifying attributes (`docker.swarm.cluster.name`,
+   * `docker.swarm.node.id`, `docker.swarm.service.id`) are stamped by
+   * the OneUptime Docker Swarm agent's collector config / inventory
+   * poller.
+   */
+  DockerSwarmCluster = "docker.swarm.cluster",
+  DockerSwarmNode = "docker.swarm.node",
+  DockerSwarmService = "docker.swarm.service",
+  DockerSwarmTask = "docker.swarm.task",
   TelemetrySdk = "telemetry.sdk",
 }
 

package/Types/Telemetry/ServiceType.ts

@@ -13,9 +13,11 @@ enum ServiceType {
   Incident = "Incident",
   Host = "Host",
   DockerHost = "DockerHost",
+  PodmanHost = "PodmanHost",
   KubernetesCluster = "KubernetesCluster",
   ProxmoxCluster = "ProxmoxCluster",
   CephCluster = "CephCluster",
+  DockerSwarmCluster = "DockerSwarmCluster",
   ServerlessFunction = "ServerlessFunction",
   CloudResource = "CloudResource",
   RealUserMonitor = "RealUserMonitor",

package/UI/Components/Icon/Icon.tsx

@@ -2894,6 +2894,63 @@ const Icon: FunctionComponent<ComponentProps> = ({
         />
       </>,
     );
+  } else if (icon === IconProp.Podman) {
+    /*
+     * Podman glyph — a pod (rounded enclosure) grouping containers, with a
+     * small seal-head nod to Podman's mascot. Intentionally a hand-drawn
+     * generic mark (not the official Podman seal logo / trademark), matching
+     * the generic-glyph convention used for Kubernetes/Docker above and
+     * deliberately distinct from the Docker whale.
+     */
+    return getSvgWrapper(
+      <>
+        {/* Pod enclosure */}
+        <rect
+          x="3"
+          y="8"
+          width="18"
+          height="11"
+          rx="2"
+          strokeLinecap="round"
+          strokeLinejoin="round"
+        />
+        {/* Grouped containers inside the pod */}
+        <rect
+          x="6"
+          y="12"
+          width="3.5"
+          height="4"
+          rx="0.4"
+          strokeLinecap="round"
+          strokeLinejoin="round"
+        />
+        <rect
+          x="10.25"
+          y="12"
+          width="3.5"
+          height="4"
+          rx="0.4"
+          strokeLinecap="round"
+          strokeLinejoin="round"
+        />
+        <rect
+          x="14.5"
+          y="12"
+          width="3.5"
+          height="4"
+          rx="0.4"
+          strokeLinecap="round"
+          strokeLinejoin="round"
+        />
+        {/* Seal head peeking over the pod */}
+        <circle cx="17" cy="5.5" r="2" />
+        <path
+          strokeLinecap="round"
+          strokeLinejoin="round"
+          d="M19 6.2c1 0.1 1.8-0.2 2.4-0.9"
+        />
+      </>,
+    );
   } else if (icon === IconProp.Proxmox) {
     /*
      * Generic hypervisor glyph — VM tiles running on a server base.

package/UI/Components/LogsViewer/LogsViewer.tsx

@@ -23,6 +23,7 @@ import ErrorMessage from "../ErrorMessage/ErrorMessage";
 import Service from "../../../Models/DatabaseModels/Service";
 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 { LIMIT_PER_PROJECT } from "../../../Types/Database/LimitMax";
 import SortOrder from "../../../Types/BaseDatabase/SortOrder";
@@ -228,6 +229,9 @@ const LogsViewer: FunctionComponent<ComponentProps> = (
   const [dockerHostMap, setDockerHostMap] = useState<Dictionary<DockerHost>>(
     {},
   );
+  const [podmanHostMap, setPodmanHostMap] = useState<Dictionary<PodmanHost>>(
+    {},
+  );
   const [kubernetesClusterMap, setKubernetesClusterMap] = useState<
     Dictionary<KubernetesCluster>
   >({});
@@ -394,10 +398,17 @@ const LogsViewer: FunctionComponent<ComponentProps> = (
         setIsPageLoading(true);
         setPageError("");
 
-        const [telemetryServices, hosts, dockerHosts, kubernetesClusters]: [
+        const [
+          telemetryServices,
+          hosts,
+          dockerHosts,
+          podmanHosts,
+          kubernetesClusters,
+        ]: [
           ListResult<Service>,
           ListResult<Host>,
           ListResult<DockerHost>,
+          ListResult<PodmanHost>,
           ListResult<KubernetesCluster>,
         ] = await Promise.all([
           ModelAPI.getList({
@@ -439,6 +450,19 @@ const LogsViewer: FunctionComponent<ComponentProps> = (
               name: SortOrder.Ascending,
             },
           }),
+          ModelAPI.getList({
+            modelType: PodmanHost,
+            query: {},
+            select: {
+              name: true,
+              hostIdentifier: true,
+            },
+            limit: LIMIT_PER_PROJECT,
+            skip: 0,
+            sort: {
+              name: SortOrder.Ascending,
+            },
+          }),
           ModelAPI.getList({
             modelType: KubernetesCluster,
             query: {},
@@ -492,6 +516,14 @@ const LogsViewer: FunctionComponent<ComponentProps> = (
           dockerHostsById[dockerHost.id.toString()] = dockerHost;
         });
 
+        const podmanHostsById: Dictionary<PodmanHost> = {};
+        podmanHosts.data.forEach((podmanHost: PodmanHost) => {
+          if (!podmanHost.id) {
+            return;
+          }
+          podmanHostsById[podmanHost.id.toString()] = podmanHost;
+        });
+
         const clustersById: Dictionary<KubernetesCluster> = {};
         kubernetesClusters.data.forEach((cluster: KubernetesCluster) => {
           if (!cluster.id) {
@@ -503,6 +535,7 @@ const LogsViewer: FunctionComponent<ComponentProps> = (
         setServiceMap(services);
         setHostMap(hostsById);
         setDockerHostMap(dockerHostsById);
+        setPodmanHostMap(podmanHostsById);
         setKubernetesClusterMap(clustersById);
       } catch (err) {
         setPageError(
@@ -846,6 +879,14 @@ const LogsViewer: FunctionComponent<ComponentProps> = (
             dockerHost?.name || dockerHost?.hostIdentifier || filter.value,
         };
       }
+      if (filter.facetKey === "podmanHostId" && podmanHostMap[filter.value]) {
+        const podmanHost: PodmanHost | undefined = podmanHostMap[filter.value];
+        return {
+          ...filter,
+          displayValue:
+            podmanHost?.name || podmanHost?.hostIdentifier || filter.value,
+        };
+      }
       if (
         filter.facetKey === "kubernetesClusterId" &&
         kubernetesClusterMap[filter.value]
@@ -866,6 +907,7 @@ const LogsViewer: FunctionComponent<ComponentProps> = (
     serviceMap,
     hostMap,
     dockerHostMap,
+    podmanHostMap,
     kubernetesClusterMap,
   ]);
 
@@ -1084,6 +1126,7 @@ const LogsViewer: FunctionComponent<ComponentProps> = (
               serviceMap={serviceMap}
               hostMap={hostMap}
               dockerHostMap={dockerHostMap}
+              podmanHostMap={podmanHostMap}
               kubernetesClusterMap={kubernetesClusterMap}
               onIncludeFilter={props.onFacetInclude || (() => {})}
               onExcludeFilter={props.onFacetExclude || (() => {})}

package/UI/Components/LogsViewer/components/LogsFacetSidebar.tsx

@@ -9,6 +9,7 @@ import FacetSection from "./FacetSection";
 import Service from "../../../../Models/DatabaseModels/Service";
 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 Dictionary from "../../../../Types/Dictionary";
 import ComponentLoader from "../../ComponentLoader/ComponentLoader";
@@ -21,6 +22,7 @@ export interface LogsFacetSidebarProps {
   serviceMap: Dictionary<Service>;
   hostMap?: Dictionary<Host>;
   dockerHostMap?: Dictionary<DockerHost>;
+  podmanHostMap?: Dictionary<PodmanHost>;
   kubernetesClusterMap?: Dictionary<KubernetesCluster>;
   onIncludeFilter: (facetKey: string, value: string) => void;
   onExcludeFilter: (facetKey: string, value: string) => void;
@@ -42,6 +44,7 @@ const RESOURCE_FACET_KEYS: ReadonlySet<string> = new Set([
   "primaryEntityId",
   "hostId",
   "dockerHostId",
+  "podmanHostId",
   "kubernetesClusterId",
 ]);
 
@@ -126,6 +129,23 @@ function buildDockerHostDisplayMap(
   return map;
 }
 
+function buildPodmanHostDisplayMap(
+  podmanHostMap: Dictionary<PodmanHost> | undefined,
+): Record<string, string> {
+  const map: Record<string, string> = {};
+  if (!podmanHostMap) {
+    return map;
+  }
+  for (const [id, podmanHost] of Object.entries(podmanHostMap)) {
+    const label: string | undefined =
+      podmanHost?.name || podmanHost?.hostIdentifier;
+    if (label) {
+      map[id] = label;
+    }
+  }
+  return map;
+}
+
 function buildClusterDisplayMap(
   clusterMap: Dictionary<KubernetesCluster> | undefined,
 ): Record<string, string> {
@@ -149,6 +169,7 @@ function getFacetTitle(key: string): string {
     primaryEntityId: "Service",
     hostId: "Host",
     dockerHostId: "Docker Host",
+    podmanHostId: "Podman Host",
     kubernetesClusterId: "Kubernetes Cluster",
     traceId: "Trace ID",
     spanId: "Span ID",
@@ -180,6 +201,10 @@ const LogsFacetSidebar: FunctionComponent<LogsFacetSidebarProps> = (
     return buildDockerHostDisplayMap(props.dockerHostMap);
   }, [props.dockerHostMap]);
 
+  const podmanHostDisplayMap: Record<string, string> = useMemo(() => {
+    return buildPodmanHostDisplayMap(props.podmanHostMap);
+  }, [props.podmanHostMap]);
+
   const clusterDisplayMap: Record<string, string> = useMemo(() => {
     return buildClusterDisplayMap(props.kubernetesClusterMap);
   }, [props.kubernetesClusterMap]);
@@ -190,6 +215,7 @@ const LogsFacetSidebar: FunctionComponent<LogsFacetSidebarProps> = (
       "primaryEntityId",
       "hostId",
       "dockerHostId",
+      "podmanHostId",
       "kubernetesClusterId",
     ];
     const otherKeys: Array<string> = Object.keys(props.facetData).filter(
@@ -287,6 +313,8 @@ const LogsFacetSidebar: FunctionComponent<LogsFacetSidebarProps> = (
             valueDisplayMap = hostDisplayMap;
           } else if (key === "dockerHostId") {
             valueDisplayMap = dockerHostDisplayMap;
+          } else if (key === "podmanHostId") {
+            valueDisplayMap = podmanHostDisplayMap;
           } else if (key === "kubernetesClusterId") {
             valueDisplayMap = clusterDisplayMap;
           } else if (key === "severityText") {

package/UI/Components/MonitorTemplateVariables/TemplateVariablesCatalog.ts

@@ -53,6 +53,9 @@ export default class TemplateVariablesCatalog {
       input.monitorType === MonitorType.Metrics ||
       input.monitorType === MonitorType.Kubernetes ||
       input.monitorType === MonitorType.Docker ||
+      input.monitorType === MonitorType.Host ||
+      input.monitorType === MonitorType.Podman ||
+      input.monitorType === MonitorType.DockerSwarm ||
       input.monitorType === MonitorType.Proxmox ||
       input.monitorType === MonitorType.Ceph
     ) {
@@ -487,6 +490,9 @@ export default class TemplateVariablesCatalog {
       case MonitorType.Metrics:
       case MonitorType.Kubernetes:
       case MonitorType.Docker:
+      case MonitorType.Host:
+      case MonitorType.Podman:
+      case MonitorType.DockerSwarm:
       case MonitorType.Proxmox:
       case MonitorType.Ceph:
         return {

package/UI/Utils/TelemetryService.ts

@@ -102,6 +102,7 @@ export default class TelemetryServiceUtil {
     const typeLabels: Record<string, string> = {
       [ServiceType.Host]: "Host telemetry",
       [ServiceType.DockerHost]: "Docker host telemetry",
+      [ServiceType.PodmanHost]: "Podman host telemetry",
       [ServiceType.KubernetesCluster]: "Kubernetes telemetry",
       [ServiceType.ProxmoxCluster]: "Proxmox Cluster",
       [ServiceType.CephCluster]: "Ceph Cluster",