@oneuptime/common 11.0.2 → 11.0.3

package/Types/Monitor/MonitorStep.ts

@@ -50,9 +50,18 @@ 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";
@@ -176,9 +185,18 @@ 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;
 }
@@ -220,7 +238,10 @@ export default class MonitorStep extends DatabaseProperty {
       externalStatusPageMonitor: undefined,
       kubernetesMonitor: undefined,
       dockerMonitor: undefined,
+      hostMonitor: undefined,
+      podmanMonitor: undefined,
       proxmoxMonitor: undefined,
+      dockerSwarmMonitor: undefined,
       cephMonitor: undefined,
     };
   }
@@ -266,7 +287,10 @@ export default class MonitorStep extends DatabaseProperty {
       externalStatusPageMonitor: undefined,
       kubernetesMonitor: undefined,
       dockerMonitor: undefined,
+      hostMonitor: undefined,
+      podmanMonitor: undefined,
       proxmoxMonitor: undefined,
+      dockerSwarmMonitor: undefined,
       cephMonitor: undefined,
     };
 
@@ -457,6 +481,18 @@ 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 {
@@ -464,6 +500,13 @@ export default class MonitorStep extends DatabaseProperty {
     return this;
   }
 
+  public setDockerSwarmMonitor(
+    dockerSwarmMonitor: MonitorStepDockerSwarmMonitor,
+  ): MonitorStep {
+    this.data!.dockerSwarmMonitor = dockerSwarmMonitor;
+    return this;
+  }
+
   public setCephMonitor(cephMonitor: MonitorStepCephMonitor): MonitorStep {
     this.data!.cephMonitor = cephMonitor;
     return this;
@@ -505,7 +548,10 @@ export default class MonitorStep extends DatabaseProperty {
         exceptionMonitor: undefined,
         kubernetesMonitor: undefined,
         dockerMonitor: undefined,
+        hostMonitor: undefined,
+        podmanMonitor: undefined,
         proxmoxMonitor: undefined,
+        dockerSwarmMonitor: undefined,
         cephMonitor: undefined,
       },
     };
@@ -673,6 +719,26 @@ 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";
@@ -683,6 +749,16 @@ export default class MonitorStep extends DatabaseProperty {
       }
     }
 
+    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";
@@ -776,9 +852,20 @@ 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,
@@ -920,9 +1007,18 @@ 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,
@@ -964,7 +1060,10 @@ 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",

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/MonitorType.ts

@@ -8,6 +8,9 @@ enum MonitorType {
   Ping = "Ping",
   Kubernetes = "Kubernetes",
   Docker = "Docker",
+  Host = "Host",
+  Podman = "Podman",
+  DockerSwarm = "Docker Swarm",
   Proxmox = "Proxmox",
   Ceph = "Ceph",
   IP = "IP",
@@ -101,6 +104,18 @@ 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],
@@ -142,6 +157,9 @@ export class MonitorTypeHelper {
       monitorType === MonitorType.Profiles ||
       monitorType === MonitorType.Kubernetes ||
       monitorType === MonitorType.Docker ||
+      monitorType === MonitorType.Host ||
+      monitorType === MonitorType.Podman ||
+      monitorType === MonitorType.DockerSwarm ||
       monitorType === MonitorType.Proxmox ||
       monitorType === MonitorType.Ceph
     );
@@ -195,6 +213,27 @@ 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",
@@ -411,6 +450,9 @@ export class MonitorTypeHelper {
       MonitorType.ExternalStatusPage,
       MonitorType.Kubernetes,
       MonitorType.Docker,
+      MonitorType.Host,
+      MonitorType.Podman,
+      MonitorType.DockerSwarm,
       MonitorType.Proxmox,
       MonitorType.Ceph,
     ];