@oneuptime/common 12.0.34 → 13.0.1

package/Types/Monitor/MonitorType.ts

@@ -12,6 +12,7 @@ enum MonitorType {
   Podman = "Podman",
   DockerSwarm = "Docker Swarm",
   Proxmox = "Proxmox",
+  VMware = "VMware",
   Ceph = "Ceph",
   IoTDevice = "IoT Device",
   IP = "IP",
@@ -141,6 +142,7 @@ export class MonitorTypeHelper {
           MonitorType.Podman,
           MonitorType.DockerSwarm,
           MonitorType.Proxmox,
+          MonitorType.VMware,
           MonitorType.Ceph,
           MonitorType.IoTDevice,
         ],
@@ -184,6 +186,7 @@ export class MonitorTypeHelper {
       monitorType === MonitorType.Podman ||
       monitorType === MonitorType.DockerSwarm ||
       monitorType === MonitorType.Proxmox ||
+      monitorType === MonitorType.VMware ||
       monitorType === MonitorType.Ceph ||
       monitorType === MonitorType.IoTDevice
     );
@@ -380,6 +383,26 @@ export class MonitorTypeHelper {
           "cluster",
         ],
       },
+      {
+        monitorType: MonitorType.VMware,
+        title: "VMware",
+        description:
+          "ESXi host, virtual machine, datastore and cluster health from vCenter.",
+        icon: IconProp.VMware,
+        keywords: [
+          "vsphere",
+          "vcenter",
+          "esxi",
+          "vm",
+          "virtual machine",
+          "hypervisor",
+          "datastore",
+          "vsan",
+          "virtualization",
+          "cluster",
+          "resource pool",
+        ],
+      },
       {
         monitorType: MonitorType.Ceph,
         title: "Ceph",
@@ -860,6 +883,7 @@ export class MonitorTypeHelper {
       MonitorType.Podman,
       MonitorType.DockerSwarm,
       MonitorType.Proxmox,
+      MonitorType.VMware,
       MonitorType.Ceph,
       MonitorType.IoTDevice,
     ];

package/Types/Monitor/Recommendation/MonitorRecommendationCatalog.ts

@@ -52,6 +52,10 @@ import {
   getAllServiceAlertTemplates,
   getServiceAlertTemplates,
 } from "../ServiceAlertTemplates";
+import {
+  VMwareAlertTemplate,
+  getAllVMwareAlertTemplates,
+} from "../VMwareAlertTemplates";
 
 /*
  * A resource type's entry in the registry.
@@ -74,6 +78,7 @@ export interface MonitorRecommendationResourceTypeDefinition {
   // The field name in the owning module's own args interface.
   identifierFieldName:
     | "clusterIdentifier"
+    | "vcenterIdentifier"
     | "hostIdentifier"
     | "fleetIdentifier"
     | "rumApplicationId"
@@ -285,6 +290,26 @@ function getProxmoxRecommendations(): Array<MonitorRecommendation> {
   });
 }
 
+function getVMwareRecommendations(): Array<MonitorRecommendation> {
+  return getAllVMwareAlertTemplates().map((template: VMwareAlertTemplate) => {
+    return normalize({
+      resourceType: MonitorRecommendationResourceType.VMware,
+      monitorType: MonitorType.VMware,
+      template: template,
+      getMonitorStep: (args: MonitorRecommendationArgs) => {
+        return template.getMonitorStep({
+          vcenterIdentifier: args.resourceIdentifier,
+          onlineMonitorStatusId: args.onlineMonitorStatusId,
+          offlineMonitorStatusId: args.offlineMonitorStatusId,
+          defaultIncidentSeverityId: args.defaultIncidentSeverityId,
+          defaultAlertSeverityId: args.defaultAlertSeverityId,
+          monitorName: args.monitorName,
+        });
+      },
+    });
+  });
+}
+
 function getCephRecommendations(): Array<MonitorRecommendation> {
   return getAllCephAlertTemplates().map((template: CephAlertTemplate) => {
     return normalize({
@@ -444,6 +469,14 @@ const RESOURCE_TYPE_DEFINITIONS: Array<MonitorRecommendationResourceTypeDefiniti
       icon: IconProp.Server,
       getRecommendations: getProxmoxRecommendations,
     },
+    {
+      resourceType: MonitorRecommendationResourceType.VMware,
+      monitorTypes: [MonitorType.VMware],
+      resourceLabel: "vCenter",
+      identifierFieldName: "vcenterIdentifier",
+      icon: IconProp.VMware,
+      getRecommendations: getVMwareRecommendations,
+    },
     {
       resourceType: MonitorRecommendationResourceType.Ceph,
       monitorTypes: [MonitorType.Ceph],

package/Types/Monitor/Recommendation/MonitorRecommendationTypes.ts

@@ -27,6 +27,7 @@ export enum MonitorRecommendationResourceType {
   DockerSwarm = "DockerSwarm",
   Podman = "Podman",
   Proxmox = "Proxmox",
+  VMware = "VMware",
   Ceph = "Ceph",
   IoTDevice = "IoTDevice",
   RumApplication = "RumApplication",
@@ -78,6 +79,7 @@ export type MonitorRecommendationSeverity = "Critical" | "Warning";
  * except for the name of the resource-identifier field:
  *
  *   clusterIdentifier -> Kubernetes, DockerSwarm, Proxmox, Ceph
+ *   vcenterIdentifier -> VMware
  *   hostIdentifier    -> Host, Docker, Podman
  *   fleetIdentifier   -> IoTDevice
  *   rumApplicationId  -> RUM application

package/Types/Monitor/Recommendation/MonitorRecommendationUtil.ts

@@ -27,6 +27,7 @@ import {
  */
 interface RecommendationMonitorStepConfig {
   clusterIdentifier?: string | undefined;
+  vcenterIdentifier?: string | undefined;
   hostIdentifier?: string | undefined;
   fleetIdentifier?: string | undefined;
   telemetryServiceIds?: Array<ObjectID | string> | undefined;
@@ -382,6 +383,7 @@ export default class MonitorRecommendationUtil {
 
     const resourceIdentifier: string =
       config.clusterIdentifier ||
+      config.vcenterIdentifier ||
       config.hostIdentifier ||
       config.fleetIdentifier ||
       this.getTelemetryResourceIdentifier(config) ||
@@ -459,6 +461,7 @@ export default class MonitorRecommendationUtil {
       "dockerSwarmMonitor",
       "podmanMonitor",
       "proxmoxMonitor",
+      "vmwareMonitor",
       "cephMonitor",
       "iotMonitor",
       "metricMonitor",

package/Types/Monitor/SeriesContext/SeriesDebugHints.ts

@@ -466,6 +466,161 @@ export default class SeriesDebugHints {
     return commands;
   }
 
+  /**
+   * govc (the vSphere CLI from the govmomi project) against the vCenter
+   * the agent scrapes. Every command below is an `info` / `usage` /
+   * `ls` read; govc takes its endpoint and read-only credentials from
+   * GOVC_URL / GOVC_USERNAME / GOVC_PASSWORD, so nothing here needs a
+   * host argument.
+   *
+   * Identity comes from the OTel `vcenter` receiver's RESOURCE
+   * attributes, which arrive `resource.`-prefixed; findLabelValue checks
+   * both spellings. Most specific object first, so the first command an
+   * engineer sees is about the thing that breached.
+   */
+  private static vmwareCommands(
+    seriesLabels: JSONObject,
+  ): Array<SeriesDebugCommand> {
+    const commands: Array<SeriesDebugCommand> = [];
+
+    const vm: string = SeriesLabelDisplay.findLabelValue(seriesLabels, [
+      "vcenter.vm.name",
+    ]);
+    const vmTemplate: string = SeriesLabelDisplay.findLabelValue(seriesLabels, [
+      "vcenter.vm_template.name",
+    ]);
+    const host: string = SeriesLabelDisplay.findLabelValue(seriesLabels, [
+      "vcenter.host.name",
+    ]);
+    const datastore: string = SeriesLabelDisplay.findLabelValue(seriesLabels, [
+      "vcenter.datastore.name",
+    ]);
+    const cluster: string = SeriesLabelDisplay.findLabelValue(seriesLabels, [
+      "vcenter.cluster.name",
+    ]);
+    const datacenter: string = SeriesLabelDisplay.findLabelValue(seriesLabels, [
+      "vcenter.datacenter.name",
+    ]);
+    const resourcePoolPath: string = SeriesLabelDisplay.findLabelValue(
+      seriesLabels,
+      ["vcenter.resource_pool.inventory_path"],
+    );
+    const vcenter: string = SeriesLabelDisplay.findLabelValue(seriesLabels, [
+      "vmware.vcenter.name",
+    ]);
+
+    if (vm) {
+      const quoted: string = SeriesDebugHints.quoteForShell(vm);
+
+      commands.push({
+        purpose:
+          "Power state, host, resource pool, datastores and networks of the VM",
+        command: `govc vm.info -r ${quoted}`,
+      });
+      commands.push({
+        purpose:
+          "The VM's virtual disks and NICs (for a per-object latency or drop)",
+        command: `govc device.info -vm ${quoted}`,
+      });
+    }
+
+    if (vmTemplate) {
+      commands.push({
+        purpose: "Datastore placement and size of the VM template",
+        command: `govc vm.info -r ${SeriesDebugHints.quoteForShell(
+          vmTemplate,
+        )}`,
+      });
+    }
+
+    if (host) {
+      const quoted: string = SeriesDebugHints.quoteForShell(host);
+
+      commands.push({
+        purpose:
+          "Connection state, CPU/memory usage, uptime and VM count of the ESXi host",
+        command: `govc host.info ${quoted}`,
+      });
+      /*
+       * esxtop is the host-local view: per-VM %RDY, ballooning, swapping
+       * and per-NIC/per-disk counters that vCenter only rolls up. Run over
+       * SSH on the host itself; it is interactive and read-only.
+       */
+      commands.push({
+        purpose:
+          "Live per-VM CPU ready, memory and disk/network counters on the host (over SSH; c/m/d/n switch views)",
+        command: `esxtop`,
+      });
+    }
+
+    if (datastore) {
+      commands.push({
+        purpose:
+          "Capacity, free space, type and the hosts mounting the datastore",
+        command: `govc datastore.info ${SeriesDebugHints.quoteForShell(
+          datastore,
+        )}`,
+      });
+    }
+
+    if (cluster) {
+      const quotedCluster: string = SeriesDebugHints.quoteForShell(cluster);
+
+      commands.push({
+        purpose: "Effective vs. total CPU and memory of the cluster",
+        command: `govc cluster.usage ${quotedCluster}`,
+      });
+
+      /*
+       * The host folder path needs the datacenter; without it govc's
+       * default datacenter applies and a multi-DC vCenter would list the
+       * wrong cluster, so the listing is only offered when both are known.
+       */
+      if (datacenter) {
+        commands.push({
+          purpose:
+            "The hosts in the cluster with their connection and power state",
+          command: `govc ls -l /${SeriesDebugHints.quoteForShell(
+            datacenter,
+          )}/host/${quotedCluster}`,
+        });
+      }
+    }
+
+    if (resourcePoolPath) {
+      commands.push({
+        purpose:
+          "Reservation, limit, shares and current usage of the resource pool",
+        command: `govc pool.info ${SeriesDebugHints.quoteForShell(
+          resourcePoolPath,
+        )}`,
+      });
+    }
+
+    if (datacenter) {
+      commands.push({
+        purpose: "Host, VM, cluster and datastore counts for the datacenter",
+        command: `govc datacenter.info ${SeriesDebugHints.quoteForShell(
+          datacenter,
+        )}`,
+      });
+    }
+
+    /*
+     * A series that names only the vCenter (an ungrouped monitor whose
+     * labels happen to carry the agent's identity attribute) still gets a
+     * first command: is the endpoint even answering, and as what?
+     */
+    if (commands.length === 0 && vcenter) {
+      commands.push({
+        purpose: "vCenter / ESXi version and whether the SDK endpoint answers",
+        command: `govc about`,
+      });
+    }
+
+    return commands;
+  }
+
   private static cephCommands(
     seriesLabels: JSONObject,
   ): Array<SeriesDebugCommand> {
@@ -548,6 +703,9 @@ export default class SeriesDebugHints {
       case MonitorType.Proxmox:
         return SeriesDebugHints.proxmoxCommands(seriesLabels);
 
+      case MonitorType.VMware:
+        return SeriesDebugHints.vmwareCommands(seriesLabels);
+
       case MonitorType.Ceph:
         return SeriesDebugHints.cephCommands(seriesLabels);
 

package/Types/Monitor/SeriesContext/SeriesLabelDisplay.ts

@@ -105,6 +105,39 @@ const FriendlyLabelNames: Record<string, string> = {
   node: "Node",
   storage: "Storage",
 
+  /*
+   * --- VMware ---
+   *
+   * The OTel `vcenter` receiver stamps identity as RESOURCE attributes
+   * (`vcenter.host.name`, `vcenter.vm.name`, ...), which arrive here
+   * `resource.`-prefixed; the agent adds `vmware.vcenter.name` on top.
+   * The unprefixed spelling is registered once and covers both. The
+   * second block is the receiver's DATAPOINT attributes, which a user's
+   * own monitor may group by (`power_state`, `status`, `object`, ...).
+   */
+  "vmware.vcenter.name": "vCenter",
+  "vcenter.datacenter.name": "Datacenter",
+  "vcenter.cluster.name": "vSphere Cluster",
+  "vcenter.host.name": "ESXi Host",
+  "vcenter.vm.name": "Virtual Machine",
+  "vcenter.vm.id": "VM Instance UUID",
+  "vcenter.vm_template.name": "VM Template",
+  "vcenter.vm_template.id": "VM Template UUID",
+  "vcenter.datastore.name": "Datastore",
+  "vcenter.resource_pool.name": "Resource Pool",
+  "vcenter.resource_pool.inventory_path": "Resource Pool Path",
+  "vcenter.virtual_app.name": "vApp",
+  "vcenter.virtual_app.inventory_path": "vApp Path",
+  power_state: "Power State",
+  status: "Status",
+  effective: "Effective",
+  disk_state: "Disk State",
+  disk_type: "Disk Type",
+  object: "Object",
+  type: "Type",
+  cpu_reservation_type: "CPU Reservation Type",
+  cpu_state: "CPU State",
+
   // --- Ceph ---
   "ceph.cluster.name": "Ceph Cluster",
   ceph_daemon: "Ceph Daemon",
@@ -172,6 +205,34 @@ const LabelPriority: Record<string, number> = {
   "device.name": 25,
   "proxmox.vm.name": 25,
   vmid: 25,
+  /*
+   * VMware: the object that breached first (VM / template / datastore /
+   * resource pool / NIC-or-disk instance), then the host it runs on, then
+   * the cluster, datacenter and vCenter that merely scope it. The instance
+   * UUIDs are pushed to the end — correct, but not what a human scans for.
+   */
+  "vcenter.vm.name": 25,
+  "vcenter.vm_template.name": 25,
+  object: 26,
+  "vcenter.datastore.name": 30,
+  "vcenter.resource_pool.name": 30,
+  "vcenter.resource_pool.inventory_path": 32,
+  "vcenter.virtual_app.name": 34,
+  "vcenter.virtual_app.inventory_path": 36,
+  power_state: 55,
+  status: 55,
+  effective: 55,
+  disk_state: 56,
+  disk_type: 56,
+  cpu_reservation_type: 56,
+  cpu_state: 56,
+  type: 57,
+  "vcenter.host.name": 60,
+  "vcenter.cluster.name": 75,
+  "vcenter.datacenter.name": 78,
+  "vmware.vcenter.name": 80,
+  "vcenter.vm.id": 95,
+  "vcenter.vm_template.id": 95,
   id: 30,
   "pve.id": 32,
   "pve.type": 55,

package/Types/Monitor/SnmpMonitor/NetworkTopology.ts

@@ -237,6 +237,19 @@ export interface NetworkTopologyEdge {
    * absent is "not stated", never "these are peers".
    */
   parentNodeId?: string | undefined;
+  /*
+   * On an "fdb" edge, the end whose forwarding table LEARNED the other
+   * end's MAC — the switch. Always one of `fromNodeId`/`toNodeId`.
+   *
+   * Needed because the pair may already have been joined the other way
+   * round: a hand-drawn link stored device→switch, or an LLDP edge read
+   * from the device's side, keeps its ends when the attachment merges in,
+   * so "the switch is the from end" is true of a fresh attachment and
+   * false of a merged one. Readers that need to know which end learned
+   * (the drawer's "Connected to", the link panel's sentence) read this,
+   * and fall back to `fromNodeId` on a payload that predates it.
+   */
+  learnedByNodeId?: string | undefined;
 }
 
 export default interface NetworkTopology {