@oneuptime/common 11.0.1 → 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

@@ -27,6 +27,29 @@ enum EntityType {
   KubernetesNode = "k8s.node",
   KubernetesPod = "k8s.pod",
   KubernetesDeployment = "k8s.deployment",
+  /*
+   * Proxmox VE / Ceph types are OneUptime-defined (no upstream semconv
+   * exists for either) but follow the same dotted naming convention. The
+   * identifying attributes (`proxmox.cluster.name`, `proxmox.node.name`,
+   * `proxmox.guest.vmid`, `ceph.cluster.name`) are stamped by our agent
+   * collector configs — see Internal/Roadmap/ProxmoxCephProducts.md §1.
+   */
+  ProxmoxCluster = "proxmox.cluster",
+  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,7 +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,147 @@ 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.
+     * Intentionally NOT the official Proxmox logo (trademark of Proxmox
+     * Server Solutions GmbH); follows the hand-drawn-generic convention
+     * used for Kubernetes/Docker above.
+     */
+    return getSvgWrapper(
+      <>
+        {/* Virtual machine tiles */}
+        <rect
+          x="4"
+          y="4"
+          width="4.5"
+          height="4.5"
+          rx="0.5"
+          strokeLinecap="round"
+          strokeLinejoin="round"
+        />
+        <rect
+          x="9.75"
+          y="4"
+          width="4.5"
+          height="4.5"
+          rx="0.5"
+          strokeLinecap="round"
+          strokeLinejoin="round"
+        />
+        <rect
+          x="15.5"
+          y="4"
+          width="4.5"
+          height="4.5"
+          rx="0.5"
+          strokeLinecap="round"
+          strokeLinejoin="round"
+        />
+        {/* Connectors from VMs down to the hypervisor */}
+        <line x1="6.25" y1="8.5" x2="6.25" y2="14.5" strokeLinecap="round" />
+        <line x1="12" y1="8.5" x2="12" y2="14.5" strokeLinecap="round" />
+        <line x1="17.75" y1="8.5" x2="17.75" y2="14.5" strokeLinecap="round" />
+        {/* Hypervisor / server base */}
+        <rect
+          x="3"
+          y="14.5"
+          width="18"
+          height="5.5"
+          rx="1"
+          strokeLinecap="round"
+          strokeLinejoin="round"
+        />
+        <circle cx="6" cy="17.25" r="0.6" fill="currentColor" />
+        <line x1="9" y1="17.25" x2="18" y2="17.25" strokeLinecap="round" />
+      </>,
+    );
+  } else if (icon === IconProp.Ceph) {
+    /*
+     * Generic hexagon-cluster glyph — honeycomb of storage nodes.
+     * Intentionally NOT the official Ceph logo (trademark of the Ceph
+     * Foundation); follows the hand-drawn-generic convention used for
+     * Kubernetes/Docker above.
+     */
+    return getSvgWrapper(
+      <>
+        <polygon
+          points="7.6,3.6 11.24,5.7 11.24,9.9 7.6,12 3.96,9.9 3.96,5.7"
+          strokeLinecap="round"
+          strokeLinejoin="round"
+        />
+        <polygon
+          points="16.4,3.6 20.04,5.7 20.04,9.9 16.4,12 12.76,9.9 12.76,5.7"
+          strokeLinecap="round"
+          strokeLinejoin="round"
+        />
+        <polygon
+          points="12,12 15.64,14.1 15.64,18.3 12,20.4 8.36,18.3 8.36,14.1"
+          strokeLinecap="round"
+          strokeLinejoin="round"
+        />
+        <circle cx="7.6" cy="7.8" r="0.8" fill="currentColor" />
+        <circle cx="16.4" cy="7.8" r="0.8" fill="currentColor" />
+        <circle cx="12" cy="16.2" r="0.8" fill="currentColor" />
+      </>,
+    );
   } else if (icon === IconProp.Gauge) {
     // Gauge/speedometer icon — semicircular meter with needle
     return getSvgWrapper(

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 || (() => {})}