@oneuptime/common 11.0.1 → 11.0.3

package/Types/Monitor/MonitorStep.ts

@@ -50,6 +50,21 @@ import MonitorStepKubernetesMonitor, {
 import MonitorStepDockerMonitor, {
   MonitorStepDockerMonitorUtil,
 } from "./MonitorStepDockerMonitor";
+import MonitorStepHostMonitor, {
+  MonitorStepHostMonitorUtil,
+} from "./MonitorStepHostMonitor";
+import MonitorStepPodmanMonitor, {
+  MonitorStepPodmanMonitorUtil,
+} from "./MonitorStepPodmanMonitor";
+import MonitorStepProxmoxMonitor, {
+  MonitorStepProxmoxMonitorUtil,
+} from "./MonitorStepProxmoxMonitor";
+import MonitorStepDockerSwarmMonitor, {
+  MonitorStepDockerSwarmMonitorUtil,
+} from "./MonitorStepDockerSwarmMonitor";
+import MonitorStepCephMonitor, {
+  MonitorStepCephMonitorUtil,
+} from "./MonitorStepCephMonitor";
 import Zod, { ZodSchema } from "../../Utils/Schema/Zod";
 
 /*
@@ -169,6 +184,21 @@ export interface MonitorStepType {
 
   // Docker monitor
   dockerMonitor?: MonitorStepDockerMonitor | undefined;
+
+  // Host monitor
+  hostMonitor?: MonitorStepHostMonitor | undefined;
+
+  // Podman monitor
+  podmanMonitor?: MonitorStepPodmanMonitor | undefined;
+
+  // Proxmox monitor
+  proxmoxMonitor?: MonitorStepProxmoxMonitor | undefined;
+
+  // Docker Swarm monitor
+  dockerSwarmMonitor?: MonitorStepDockerSwarmMonitor | undefined;
+
+  // Ceph monitor
+  cephMonitor?: MonitorStepCephMonitor | undefined;
 }
 
 export default class MonitorStep extends DatabaseProperty {
@@ -208,6 +238,11 @@ export default class MonitorStep extends DatabaseProperty {
       externalStatusPageMonitor: undefined,
       kubernetesMonitor: undefined,
       dockerMonitor: undefined,
+      hostMonitor: undefined,
+      podmanMonitor: undefined,
+      proxmoxMonitor: undefined,
+      dockerSwarmMonitor: undefined,
+      cephMonitor: undefined,
     };
   }
 
@@ -252,6 +287,11 @@ export default class MonitorStep extends DatabaseProperty {
       externalStatusPageMonitor: undefined,
       kubernetesMonitor: undefined,
       dockerMonitor: undefined,
+      hostMonitor: undefined,
+      podmanMonitor: undefined,
+      proxmoxMonitor: undefined,
+      dockerSwarmMonitor: undefined,
+      cephMonitor: undefined,
     };
 
     return monitorStep;
@@ -441,6 +481,37 @@ export default class MonitorStep extends DatabaseProperty {
     return this;
   }
 
+  public setHostMonitor(hostMonitor: MonitorStepHostMonitor): MonitorStep {
+    this.data!.hostMonitor = hostMonitor;
+    return this;
+  }
+
+  public setPodmanMonitor(
+    podmanMonitor: MonitorStepPodmanMonitor,
+  ): MonitorStep {
+    this.data!.podmanMonitor = podmanMonitor;
+    return this;
+  }
+
+  public setProxmoxMonitor(
+    proxmoxMonitor: MonitorStepProxmoxMonitor,
+  ): MonitorStep {
+    this.data!.proxmoxMonitor = proxmoxMonitor;
+    return this;
+  }
+
+  public setDockerSwarmMonitor(
+    dockerSwarmMonitor: MonitorStepDockerSwarmMonitor,
+  ): MonitorStep {
+    this.data!.dockerSwarmMonitor = dockerSwarmMonitor;
+    return this;
+  }
+
+  public setCephMonitor(cephMonitor: MonitorStepCephMonitor): MonitorStep {
+    this.data!.cephMonitor = cephMonitor;
+    return this;
+  }
+
   public setCustomCode(customCode: string): MonitorStep {
     this.data!.customCode = customCode;
     return this;
@@ -477,6 +548,11 @@ export default class MonitorStep extends DatabaseProperty {
         exceptionMonitor: undefined,
         kubernetesMonitor: undefined,
         dockerMonitor: undefined,
+        hostMonitor: undefined,
+        podmanMonitor: undefined,
+        proxmoxMonitor: undefined,
+        dockerSwarmMonitor: undefined,
+        cephMonitor: undefined,
       },
     };
   }
@@ -643,6 +719,56 @@ export default class MonitorStep extends DatabaseProperty {
       }
     }
 
+    if (monitorType === MonitorType.Host) {
+      if (!value.data.hostMonitor) {
+        return "Host monitor configuration is required";
+      }
+
+      if (!value.data.hostMonitor.hostIdentifier) {
+        return "Host is required";
+      }
+    }
+
+    if (monitorType === MonitorType.Podman) {
+      if (!value.data.podmanMonitor) {
+        return "Podman monitor configuration is required";
+      }
+
+      if (!value.data.podmanMonitor.hostIdentifier) {
+        return "Podman host is required";
+      }
+    }
+
+    if (monitorType === MonitorType.Proxmox) {
+      if (!value.data.proxmoxMonitor) {
+        return "Proxmox monitor configuration is required";
+      }
+
+      if (!value.data.proxmoxMonitor.clusterIdentifier) {
+        return "Proxmox cluster is required";
+      }
+    }
+
+    if (monitorType === MonitorType.DockerSwarm) {
+      if (!value.data.dockerSwarmMonitor) {
+        return "Docker Swarm monitor configuration is required";
+      }
+
+      if (!value.data.dockerSwarmMonitor.clusterIdentifier) {
+        return "Docker Swarm cluster is required";
+      }
+    }
+
+    if (monitorType === MonitorType.Ceph) {
+      if (!value.data.cephMonitor) {
+        return "Ceph monitor configuration is required";
+      }
+
+      if (!value.data.cephMonitor.clusterIdentifier) {
+        return "Ceph cluster is required";
+      }
+    }
+
     return null;
   }
 
@@ -726,6 +852,23 @@ export default class MonitorStep extends DatabaseProperty {
           dockerMonitor: this.data.dockerMonitor
             ? MonitorStepDockerMonitorUtil.toJSON(this.data.dockerMonitor)
             : undefined,
+          hostMonitor: this.data.hostMonitor
+            ? MonitorStepHostMonitorUtil.toJSON(this.data.hostMonitor)
+            : undefined,
+          podmanMonitor: this.data.podmanMonitor
+            ? MonitorStepPodmanMonitorUtil.toJSON(this.data.podmanMonitor)
+            : undefined,
+          proxmoxMonitor: this.data.proxmoxMonitor
+            ? MonitorStepProxmoxMonitorUtil.toJSON(this.data.proxmoxMonitor)
+            : undefined,
+          dockerSwarmMonitor: this.data.dockerSwarmMonitor
+            ? MonitorStepDockerSwarmMonitorUtil.toJSON(
+                this.data.dockerSwarmMonitor,
+              )
+            : undefined,
+          cephMonitor: this.data.cephMonitor
+            ? MonitorStepCephMonitorUtil.toJSON(this.data.cephMonitor)
+            : undefined,
         },
       });
     }
@@ -864,6 +1007,21 @@ export default class MonitorStep extends DatabaseProperty {
       dockerMonitor: json["dockerMonitor"]
         ? (json["dockerMonitor"] as JSONObject)
         : undefined,
+      hostMonitor: json["hostMonitor"]
+        ? (json["hostMonitor"] as JSONObject)
+        : undefined,
+      podmanMonitor: json["podmanMonitor"]
+        ? (json["podmanMonitor"] as JSONObject)
+        : undefined,
+      proxmoxMonitor: json["proxmoxMonitor"]
+        ? (json["proxmoxMonitor"] as JSONObject)
+        : undefined,
+      dockerSwarmMonitor: json["dockerSwarmMonitor"]
+        ? (json["dockerSwarmMonitor"] as JSONObject)
+        : undefined,
+      cephMonitor: json["cephMonitor"]
+        ? (json["cephMonitor"] as JSONObject)
+        : undefined,
     }) as any;
 
     return monitorStep;
@@ -902,6 +1060,11 @@ export default class MonitorStep extends DatabaseProperty {
         externalStatusPageMonitor: Zod.any().optional(),
         kubernetesMonitor: Zod.any().optional(),
         dockerMonitor: Zod.any().optional(),
+        hostMonitor: Zod.any().optional(),
+        podmanMonitor: Zod.any().optional(),
+        proxmoxMonitor: Zod.any().optional(),
+        dockerSwarmMonitor: Zod.any().optional(),
+        cephMonitor: Zod.any().optional(),
       }).openapi({
         type: "object",
         example: {

package/Types/Monitor/MonitorStepCephMonitor.ts

@@ -0,0 +1,57 @@
+import { JSONObject } from "../JSON";
+import MetricsViewConfig from "../Metrics/MetricsViewConfig";
+import RollingTime from "../RollingTime/RollingTime";
+
+/**
+ * The kind of Ceph resource a metric series belongs to. Unlike Proxmox
+ * there is no agent-stamped scope attribute — ceph-mgr series are already
+ * equality-filterable by `ceph_daemon` / `pool_id` — so this enum is a
+ * catalog/UI hint only, never a query filter.
+ */
+export enum CephResourceScope {
+  Cluster = "Cluster",
+  Mon = "Mon",
+  Osd = "OSD",
+  Pool = "Pool",
+}
+
+export interface CephResourceFilters {
+  osdId?: string | undefined; // datapoint label `ceph_daemon` (e.g. "osd.3")
+  /**
+   * → equality on the `pool_id` datapoint label (e.g. "2"). Pool data
+   * series (ceph_pool_stored, ceph_pool_max_avail, ceph_pool_rd/wr…)
+   * carry ONLY `pool_id` — there is no pool-name label on data series;
+   * the name exists solely on ceph_pool_metadata. Filter by id and join
+   * ceph_pool_metadata when a display name is needed.
+   */
+  poolId?: string | undefined;
+}
+
+export default interface MonitorStepCephMonitor {
+  clusterIdentifier: string;
+  resourceFilters: CephResourceFilters;
+  metricViewConfig: MetricsViewConfig;
+  rollingTime: RollingTime;
+}
+
+export class MonitorStepCephMonitorUtil {
+  public static getDefault(): MonitorStepCephMonitor {
+    return {
+      clusterIdentifier: "",
+      resourceFilters: {},
+      metricViewConfig: {
+        queryConfigs: [],
+        formulaConfigs: [],
+      },
+      rollingTime: RollingTime.Past1Minute,
+    };
+  }
+
+  public static fromJSON(json: JSONObject): MonitorStepCephMonitor {
+    return json as any as MonitorStepCephMonitor;
+  }
+
+  public static toJSON(monitor: MonitorStepCephMonitor): JSONObject {
+    return monitor as any as JSONObject;
+  }
+}

package/Types/Monitor/MonitorStepDockerSwarmMonitor.ts

@@ -0,0 +1,74 @@
+import { JSONObject } from "../JSON";
+import MetricsViewConfig from "../Metrics/MetricsViewConfig";
+import RollingTime from "../RollingTime/RollingTime";
+
+/*
+ * Docker Swarm telemetry contract (the trap these filters avoid): the
+ * OneUptime Docker Swarm Agent stamps ONLY the resource attribute
+ * `docker.swarm.cluster.name` on every batch — it does NOT stamp
+ * `container.runtime` or `host.name`. The metrics that actually arrive
+ * come from the docker_stats receiver and are the standard `container.*`
+ * series. The docker_stats receiver labels each datapoint with the
+ * container's identity (`container.name`, `container.image.name`),
+ * which Swarm derives from the service/task that owns the container —
+ * Swarm service tasks are named `<service>.<slot>.<taskid>`. These
+ * identity labels are datapoint attributes, stored unprefixed in
+ * ClickHouse, so filters here target `container.name` (NOT
+ * `resource.container.name`). The optional node/service filters are
+ * substring-friendly identity hints applied on top of the always-on
+ * cluster scope.
+ */
+export interface DockerSwarmResourceFilters {
+  /**
+   * → equality on the `container.name` datapoint attribute. A Swarm
+   * service task's container is named `<service>.<slot>.<taskid>`, so
+   * an exact container name pins one task replica.
+   */
+  containerName?: string | undefined;
+  /**
+   * → equality on the `container.image.name` datapoint attribute. Scopes
+   * the query to every task running a given image.
+   */
+  containerImage?: string | undefined;
+  /**
+   * → equality on the `docker.swarm.node.name` datapoint attribute when
+   * the agent stamps it. Scopes the query to containers running on one
+   * Swarm node. Optional — leave empty to span the whole cluster.
+   */
+  nodeName?: string | undefined;
+  /**
+   * → equality on the `docker.swarm.service.name` datapoint attribute
+   * when the agent stamps it. Scopes the query to one Swarm service's
+   * tasks. Optional.
+   */
+  serviceName?: string | undefined;
+}
+
+export default interface MonitorStepDockerSwarmMonitor {
+  clusterIdentifier: string;
+  resourceFilters: DockerSwarmResourceFilters;
+  metricViewConfig: MetricsViewConfig;
+  rollingTime: RollingTime;
+}
+
+export class MonitorStepDockerSwarmMonitorUtil {
+  public static getDefault(): MonitorStepDockerSwarmMonitor {
+    return {
+      clusterIdentifier: "",
+      resourceFilters: {},
+      metricViewConfig: {
+        queryConfigs: [],
+        formulaConfigs: [],
+      },
+      rollingTime: RollingTime.Past1Minute,
+    };
+  }
+
+  public static fromJSON(json: JSONObject): MonitorStepDockerSwarmMonitor {
+    return json as any as MonitorStepDockerSwarmMonitor;
+  }
+
+  public static toJSON(monitor: MonitorStepDockerSwarmMonitor): JSONObject {
+    return monitor as any as JSONObject;
+  }
+}

package/Types/Monitor/MonitorStepHostMonitor.ts

@@ -0,0 +1,30 @@
+import { JSONObject } from "../JSON";
+import MetricsViewConfig from "../Metrics/MetricsViewConfig";
+import RollingTime from "../RollingTime/RollingTime";
+
+export default interface MonitorStepHostMonitor {
+  hostIdentifier: string;
+  metricViewConfig: MetricsViewConfig;
+  rollingTime: RollingTime;
+}
+
+export class MonitorStepHostMonitorUtil {
+  public static getDefault(): MonitorStepHostMonitor {
+    return {
+      hostIdentifier: "",
+      metricViewConfig: {
+        queryConfigs: [],
+        formulaConfigs: [],
+      },
+      rollingTime: RollingTime.Past1Minute,
+    };
+  }
+
+  public static fromJSON(json: JSONObject): MonitorStepHostMonitor {
+    return json as any as MonitorStepHostMonitor;
+  }
+
+  public static toJSON(monitor: MonitorStepHostMonitor): JSONObject {
+    return monitor as any as JSONObject;
+  }
+}

package/Types/Monitor/MonitorStepPodmanMonitor.ts

@@ -0,0 +1,38 @@
+import { JSONObject } from "../JSON";
+import MetricsViewConfig from "../Metrics/MetricsViewConfig";
+import RollingTime from "../RollingTime/RollingTime";
+
+export interface PodmanContainerFilters {
+  containerName?: string | undefined;
+  containerImage?: string | undefined;
+  hostName?: string | undefined;
+}
+
+export default interface MonitorStepPodmanMonitor {
+  hostIdentifier: string;
+  containerFilters: PodmanContainerFilters;
+  metricViewConfig: MetricsViewConfig;
+  rollingTime: RollingTime;
+}
+
+export class MonitorStepPodmanMonitorUtil {
+  public static getDefault(): MonitorStepPodmanMonitor {
+    return {
+      hostIdentifier: "",
+      containerFilters: {},
+      metricViewConfig: {
+        queryConfigs: [],
+        formulaConfigs: [],
+      },
+      rollingTime: RollingTime.Past1Minute,
+    };
+  }
+
+  public static fromJSON(json: JSONObject): MonitorStepPodmanMonitor {
+    return json as any as MonitorStepPodmanMonitor;
+  }
+
+  public static toJSON(monitor: MonitorStepPodmanMonitor): JSONObject {
+    return monitor as any as JSONObject;
+  }
+}

package/Types/Monitor/MonitorStepProxmoxMonitor.ts

@@ -0,0 +1,81 @@
+import { JSONObject } from "../JSON";
+import MetricsViewConfig from "../Metrics/MetricsViewConfig";
+import RollingTime from "../RollingTime/RollingTime";
+
+/**
+ * The kind of Proxmox resource a metric series belongs to. Enum values are
+ * byte-equal to the `pve.scope` datapoint attribute stamped by the agent's
+ * OTTL transform processor (which splits pve-exporter's `id` label —
+ * `node/pve1`, `qemu/100`, `lxc/101`, `storage/local` — into `pve.scope`,
+ * `pve.type` and `pve.id`), so the monitor worker can map a scope filter to
+ * an attribute-equality clause with no translation.
+ */
+export enum ProxmoxResourceScope {
+  Cluster = "cluster",
+  Node = "node",
+  Guest = "guest",
+  Storage = "storage",
+}
+
+/*
+ * pve-exporter label semantics (the trap these filters avoid): data metrics
+ * (pve_up, pve_cpu_usage_ratio, pve_memory_*, pve_disk_*, pve_network_*,
+ * pve_ha_state) carry ONLY the `id` datapoint label — the `name` and `node`
+ * labels exist solely on the *_info metadata series (pve_node_info,
+ * pve_guest_info, pve_storage_info). Filters therefore target `id` and the
+ * agent-stamped `pve.scope` / `pve.id` attributes, never `name`.
+ */
+export interface ProxmoxResourceFilters {
+  /**
+   * → equality on the `pve.scope` datapoint attribute
+   * (node | guest | storage | cluster).
+   */
+  scope?: ProxmoxResourceScope | undefined;
+  /**
+   * → equality on the `pve.id` datapoint attribute — the part of the `id`
+   * label after the slash ("pve1" for node/pve1, "100" for qemu/100,
+   * "local" for storage/local). Pair with `scope` to target one resource.
+   */
+  pveId?: string | undefined;
+  /**
+   * → `pve.scope=node` + `pve.id=<nodeName>` equality. Scopes to the
+   * node's OWN series (for nodes, `pve.id` IS the node name). This cannot
+   * filter guest/storage series by their parent node — that relationship
+   * only exists on the *_info metadata series.
+   */
+  nodeName?: string | undefined;
+  /**
+   * → equality on the raw `id` datapoint label (e.g. "qemu/100",
+   * "lxc/101"). Wins over the other filters when set.
+   */
+  guestId?: string | undefined;
+}
+
+export default interface MonitorStepProxmoxMonitor {
+  clusterIdentifier: string;
+  resourceFilters: ProxmoxResourceFilters;
+  metricViewConfig: MetricsViewConfig;
+  rollingTime: RollingTime;
+}
+
+export class MonitorStepProxmoxMonitorUtil {
+  public static getDefault(): MonitorStepProxmoxMonitor {
+    return {
+      clusterIdentifier: "",
+      resourceFilters: {},
+      metricViewConfig: {
+        queryConfigs: [],
+        formulaConfigs: [],
+      },
+      rollingTime: RollingTime.Past1Minute,
+    };
+  }
+
+  public static fromJSON(json: JSONObject): MonitorStepProxmoxMonitor {
+    return json as any as MonitorStepProxmoxMonitor;
+  }
+
+  public static toJSON(monitor: MonitorStepProxmoxMonitor): JSONObject {
+    return monitor as any as JSONObject;
+  }
+}

package/Types/Monitor/MonitorType.ts

@@ -8,6 +8,11 @@ enum MonitorType {
   Ping = "Ping",
   Kubernetes = "Kubernetes",
   Docker = "Docker",
+  Host = "Host",
+  Podman = "Podman",
+  DockerSwarm = "Docker Swarm",
+  Proxmox = "Proxmox",
+  Ceph = "Ceph",
   IP = "IP",
   IncomingRequest = "Incoming Request",
   IncomingEmail = "Incoming Email",
@@ -99,6 +104,26 @@ export class MonitorTypeHelper {
         label: "Docker",
         monitorTypes: [MonitorType.Docker],
       },
+      {
+        label: "Host",
+        monitorTypes: [MonitorType.Host],
+      },
+      {
+        label: "Podman",
+        monitorTypes: [MonitorType.Podman],
+      },
+      {
+        label: "Docker Swarm",
+        monitorTypes: [MonitorType.DockerSwarm],
+      },
+      {
+        label: "Proxmox",
+        monitorTypes: [MonitorType.Proxmox],
+      },
+      {
+        label: "Ceph",
+        monitorTypes: [MonitorType.Ceph],
+      },
       {
         label: "Telemetry",
         monitorTypes: [
@@ -131,7 +156,12 @@ export class MonitorTypeHelper {
       monitorType === MonitorType.Exceptions ||
       monitorType === MonitorType.Profiles ||
       monitorType === MonitorType.Kubernetes ||
-      monitorType === MonitorType.Docker
+      monitorType === MonitorType.Docker ||
+      monitorType === MonitorType.Host ||
+      monitorType === MonitorType.Podman ||
+      monitorType === MonitorType.DockerSwarm ||
+      monitorType === MonitorType.Proxmox ||
+      monitorType === MonitorType.Ceph
     );
   }
 
@@ -183,6 +213,41 @@ export class MonitorTypeHelper {
           "This monitor type lets you monitor Docker containers — CPU, memory, network, restarts, and lifecycle events.",
         icon: IconProp.Cube,
       },
+      {
+        monitorType: MonitorType.Host,
+        title: "Host",
+        description:
+          "This monitor type lets you monitor OpenTelemetry-instrumented hosts and servers (the Hosts product) — CPU, memory, disk, network, load average, and process count via the OneUptime Infrastructure Agent. It is the telemetry-metric counterpart to the agent-push Server / VM Monitor.",
+        icon: IconProp.Server,
+      },
+      {
+        monitorType: MonitorType.Podman,
+        title: "Podman Container",
+        description:
+          "This monitor type lets you monitor Podman containers — CPU, memory, network, restarts, and lifecycle events.",
+        icon: IconProp.Cube,
+      },
+      {
+        monitorType: MonitorType.DockerSwarm,
+        title: "Docker Swarm",
+        description:
+          "This monitor type lets you monitor Docker Swarm clusters — per-task container CPU, memory, network, process count, and uptime across the cluster's services and nodes.",
+        icon: IconProp.Cube,
+      },
+      {
+        monitorType: MonitorType.Proxmox,
+        title: "Proxmox",
+        description:
+          "This monitor type lets you monitor Proxmox VE clusters — node availability, VM and container (guest) health, CPU, memory, storage, and HA state.",
+        icon: IconProp.ServerStack,
+      },
+      {
+        monitorType: MonitorType.Ceph,
+        title: "Ceph",
+        description:
+          "This monitor type lets you monitor Ceph storage clusters — cluster health, monitor quorum, OSD availability, pool capacity, and placement group states.",
+        icon: IconProp.Database,
+      },
       {
         monitorType: MonitorType.IP,
         title: "IP",
@@ -385,6 +450,11 @@ export class MonitorTypeHelper {
       MonitorType.ExternalStatusPage,
       MonitorType.Kubernetes,
       MonitorType.Docker,
+      MonitorType.Host,
+      MonitorType.Podman,
+      MonitorType.DockerSwarm,
+      MonitorType.Proxmox,
+      MonitorType.Ceph,
     ];
   }