@oneuptime/common 13.0.0 → 13.0.1

package/build/dist/Server/Utils/Monitor/MonitorCriteriaEvaluator.js

@@ -44,6 +44,7 @@ import { DashboardClientUrl } from "../../EnvironmentConfig";
 import MetricValueFormatter from "../../../Utils/Monitor/MetricValueFormatter";
 import { getKubernetesMetricByMetricName } from "../../../Types/Monitor/KubernetesMetricCatalog";
 import { getProxmoxMetricByMetricName } from "../../../Types/Monitor/ProxmoxMetricCatalog";
+import { getVMwareMetricByMetricName } from "../../../Types/Monitor/VMwareMetricCatalog";
 import { getCephMetricByMetricName } from "../../../Types/Monitor/CephMetricCatalog";
 import { getDockerSwarmMetricByMetricName } from "../../../Types/Monitor/DockerSwarmMetricCatalog";
 export default class MonitorCriteriaEvaluator {
@@ -335,7 +336,7 @@ ${contextBlock}
         });
     }
     /**
-     * For metric-backed monitors (Metrics/Kubernetes/Docker/Proxmox/Ceph)
+     * For metric-backed monitors (Metrics/Kubernetes/Docker/Proxmox/VMware/Ceph)
      * with per-series aggregated results, re-evaluate the matched criteria
      * once per series and return one entry per series that breached.
      * Returns an empty array when the monitor is not series-aware or
@@ -795,6 +796,7 @@ ${contextBlock}
             input.monitor.monitorType === MonitorType.Podman ||
             input.monitor.monitorType === MonitorType.DockerSwarm ||
             input.monitor.monitorType === MonitorType.Proxmox ||
+            input.monitor.monitorType === MonitorType.VMware ||
             input.monitor.monitorType === MonitorType.Ceph ||
             input.monitor.monitorType === MonitorType.IoTDevice) {
             const metricMonitorResult = await MetricMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
@@ -925,6 +927,10 @@ ${contextBlock}
         if (input.monitor.monitorType === MonitorType.Proxmox) {
             return MonitorCriteriaEvaluator.buildProxmoxRootCauseContext(input);
         }
+        // Handle VMware monitors with vCenter resource context
+        if (input.monitor.monitorType === MonitorType.VMware) {
+            return MonitorCriteriaEvaluator.buildVMwareRootCauseContext(input);
+        }
         // Handle Docker Swarm monitors with resource context
         if (input.monitor.monitorType === MonitorType.DockerSwarm) {
             return MonitorCriteriaEvaluator.buildDockerSwarmRootCauseContext(input);
@@ -977,6 +983,14 @@ ${contextBlock}
         if ((probeResponse === null || probeResponse === void 0 ? void 0 : probeResponse.isTimeout) !== undefined) {
             responseDetails.push(`- Timed Out: ${probeResponse.isTimeout ? "Yes" : "No"}`);
         }
+        /*
+         * How many times the probe actually tried matters when reading a failure:
+         * "tried once" and "tried three times" describe very different levels of
+         * confidence, and the count was already collected but never shown.
+         */
+        if ((probeResponse === null || probeResponse === void 0 ? void 0 : probeResponse.totalAttempts) !== undefined) {
+            responseDetails.push(`- Attempts: ${probeResponse.totalAttempts}`);
+        }
         // Add Request Failed Details if available
         if (probeResponse === null || probeResponse === void 0 ? void 0 : probeResponse.requestFailedDetails) {
             const requestFailedDetails = probeResponse.requestFailedDetails;
@@ -1436,16 +1450,24 @@ ${contextBlock}
      * shown here can never disagree with the metric name shown beside it.
      */
     static getPlatformMetricUnit(input) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e;
         switch (input.platform) {
             case "kubernetes":
                 return (_a = getKubernetesMetricByMetricName(input.metricName)) === null || _a === void 0 ? void 0 : _a.unit;
             case "proxmox":
                 return (_b = getProxmoxMetricByMetricName(input.metricName)) === null || _b === void 0 ? void 0 : _b.unit;
+            case "vmware":
+                /*
+                 * The vcenter receiver's utilization metrics are already 0–100
+                 * percentages (unit "%"), never [0, 1] ratios — the catalog
+                 * says "%" and the formatter renders it as-is, so 92.5 reads
+                 * "92.50%" and never "9250.00%".
+                 */
+                return (_c = getVMwareMetricByMetricName(input.metricName)) === null || _c === void 0 ? void 0 : _c.unit;
             case "dockerSwarm":
-                return (_c = getDockerSwarmMetricByMetricName(input.metricName)) === null || _c === void 0 ? void 0 : _c.unit;
+                return (_d = getDockerSwarmMetricByMetricName(input.metricName)) === null || _d === void 0 ? void 0 : _d.unit;
             case "ceph":
-                return (_d = getCephMetricByMetricName(input.metricName)) === null || _d === void 0 ? void 0 : _d.unit;
+                return (_e = getCephMetricByMetricName(input.metricName)) === null || _e === void 0 ? void 0 : _e.unit;
             default:
                 return undefined;
         }
@@ -1858,6 +1880,199 @@ ${contextBlock}
         }
         return sections.length > 0 ? sections.join("\n") : null;
     }
+    /*
+     * Which vSphere object one VMware breakdown row describes, resolved
+     * from the identity attributes the vcenter receiver stamped on it —
+     * most specific first, in the same order the ingest inventory scan
+     * uses, so the Kind column here and the inventory's `kind` never
+     * disagree about the same series. A VM row carries its parent host
+     * (and often a resource pool), so the VM check must run before the
+     * host and pool checks.
+     */
+    static getVMwareAffectedResourceKind(resource) {
+        if (resource.vmName || resource.vmId) {
+            return "Virtual Machine";
+        }
+        if (resource.resourcePoolPath || resource.resourcePoolName) {
+            return "Resource Pool";
+        }
+        if (resource.hostName) {
+            return "Host";
+        }
+        if (resource.datastoreName) {
+            return "Datastore";
+        }
+        if (resource.clusterName) {
+            return "Cluster";
+        }
+        if (resource.datacenterName) {
+            return "Datacenter";
+        }
+        return undefined;
+    }
+    static buildVMwareRootCauseContext(input) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        const metricResponse = input.dataToProcess;
+        const breakdown = metricResponse.vmwareResourceBreakdown;
+        const sections = [];
+        // vCenter context
+        const vmwareMonitor = (_a = input.monitorStep.data) === null || _a === void 0 ? void 0 : _a.vmwareMonitor;
+        if (vmwareMonitor || breakdown) {
+            const vcenterDetails = [];
+            vcenterDetails.push(`- vCenter: ${(breakdown === null || breakdown === void 0 ? void 0 : breakdown.vcenterName) || (vmwareMonitor === null || vmwareMonitor === void 0 ? void 0 : vmwareMonitor.vcenterIdentifier) || "Unknown"}`);
+            if (breakdown) {
+                vcenterDetails.push(`- Metric: ${breakdown.metricFriendlyName} (\`${breakdown.metricName}\`)`);
+            }
+            else if (vmwareMonitor &&
+                ((_c = (_b = vmwareMonitor.metricViewConfig) === null || _b === void 0 ? void 0 : _b.queryConfigs) === null || _c === void 0 ? void 0 : _c.length) > 0 &&
+                vmwareMonitor.metricViewConfig.queryConfigs[0]) {
+                const metricName = (_e = (_d = vmwareMonitor.metricViewConfig
+                    .queryConfigs[0].metricQueryData) === null || _d === void 0 ? void 0 : _d.filterData) === null || _e === void 0 ? void 0 : _e.metricName;
+                if (metricName) {
+                    vcenterDetails.push(`- Metric: \`${metricName}\``);
+                }
+            }
+            /*
+             * The worker maps each resource filter to an equality on the
+             * matching `resource.vcenter.*` attribute; surface the same
+             * filters so the incident shows WHAT was scoped.
+             */
+            if ((_f = vmwareMonitor === null || vmwareMonitor === void 0 ? void 0 : vmwareMonitor.resourceFilters) === null || _f === void 0 ? void 0 : _f.datacenterName) {
+                vcenterDetails.push(`- Datacenter Filter: ${vmwareMonitor.resourceFilters.datacenterName}`);
+            }
+            if ((_g = vmwareMonitor === null || vmwareMonitor === void 0 ? void 0 : vmwareMonitor.resourceFilters) === null || _g === void 0 ? void 0 : _g.clusterName) {
+                vcenterDetails.push(`- Cluster Filter: ${vmwareMonitor.resourceFilters.clusterName}`);
+            }
+            if ((_h = vmwareMonitor === null || vmwareMonitor === void 0 ? void 0 : vmwareMonitor.resourceFilters) === null || _h === void 0 ? void 0 : _h.hostName) {
+                vcenterDetails.push(`- Host Filter: ${vmwareMonitor.resourceFilters.hostName}`);
+            }
+            if ((_j = vmwareMonitor === null || vmwareMonitor === void 0 ? void 0 : vmwareMonitor.resourceFilters) === null || _j === void 0 ? void 0 : _j.vmName) {
+                vcenterDetails.push(`- Virtual Machine Filter: ${vmwareMonitor.resourceFilters.vmName}`);
+            }
+            if ((_k = vmwareMonitor === null || vmwareMonitor === void 0 ? void 0 : vmwareMonitor.resourceFilters) === null || _k === void 0 ? void 0 : _k.datastoreName) {
+                vcenterDetails.push(`- Datastore Filter: ${vmwareMonitor.resourceFilters.datastoreName}`);
+            }
+            if ((_l = vmwareMonitor === null || vmwareMonitor === void 0 ? void 0 : vmwareMonitor.resourceFilters) === null || _l === void 0 ? void 0 : _l.resourcePoolPath) {
+                vcenterDetails.push(`- Resource Pool Filter: ${vmwareMonitor.resourceFilters.resourcePoolPath}`);
+            }
+            sections.push(`**vCenter Details**\n${vcenterDetails.join("\n")}`);
+        }
+        // Affected resources (Resource / Kind / Host / Cluster / Value)
+        let renderedBreakdownTable = false;
+        if (breakdown && breakdown.affectedResources.length > 0) {
+            /*
+             * K8s/Proxmox-parity render: drop zero-value rows, worst (highest)
+             * first, top 10. For count metrics filtered to an unhealthy state
+             * (`vcenter.datacenter.host.count{status=red}`) the non-zero rows
+             * ARE the objects with a problem, so the table reads correctly;
+             * a zero row means "nothing in that state" and adds nothing. The
+             * per-series criteria evaluation is what actually alerts; this
+             * table is supplementary context only.
+             */
+            const sortedResources = [
+                ...breakdown.affectedResources,
+            ]
+                .filter((r) => {
+                return r.metricValue > 0;
+            })
+                .sort((a, b) => {
+                return b.metricValue - a.metricValue;
+            });
+            /*
+             * Skip the table when no row carries any identity attribute — it
+             * would add nothing. Every vcenter-receiver series carries at
+             * least `vcenter.datacenter.name`, so this only trips on a
+             * breakdown the worker could not attribute at all.
+             */
+            const hasIdentity = sortedResources.some((r) => {
+                return Boolean(MonitorCriteriaEvaluator.getVMwareAffectedResourceKind(r));
+            });
+            if (sortedResources.length > 0 && hasIdentity) {
+                const resourcesToShow = sortedResources.slice(0, 10);
+                const resourceLines = [];
+                resourceLines.push(`| Resource | Kind | Host | Cluster | Value |`);
+                resourceLines.push(`| --- | --- | --- | --- | --- |`);
+                for (const resource of resourcesToShow) {
+                    const kind = MonitorCriteriaEvaluator.getVMwareAffectedResourceKind(resource);
+                    let resourceCell = "-";
+                    let hostCell = "-";
+                    switch (kind) {
+                        case "Virtual Machine":
+                            /*
+                             * The VM's display name, falling back to its instance
+                             * UUID (`vcenter.vm.id`) when the receiver stamped no
+                             * name. The Host column carries the ESXi host the VM is
+                             * running on.
+                             */
+                            resourceCell = resource.vmName
+                                ? `\`${resource.vmName}\``
+                                : `\`${resource.vmId}\``;
+                            hostCell = resource.hostName ? `\`${resource.hostName}\`` : "-";
+                            break;
+                        case "Resource Pool":
+                            /*
+                             * Pool names are only unique within a parent, so the
+                             * inventory path is shown next to the name. The Host
+                             * column is the owner host for a pool on a standalone
+                             * ESXi host (pools under a cluster show the cluster).
+                             */
+                            if (resource.resourcePoolName && resource.resourcePoolPath) {
+                                resourceCell = `\`${resource.resourcePoolName}\` (\`${resource.resourcePoolPath}\`)`;
+                            }
+                            else {
+                                resourceCell = `\`${resource.resourcePoolPath || resource.resourcePoolName}\``;
+                            }
+                            hostCell = resource.hostName ? `\`${resource.hostName}\`` : "-";
+                            break;
+                        case "Host":
+                            // The host IS the resource; repeating it in the Host column adds nothing.
+                            resourceCell = `\`${resource.hostName}\``;
+                            break;
+                        case "Datastore":
+                            resourceCell = `\`${resource.datastoreName}\``;
+                            break;
+                        case "Cluster":
+                            resourceCell = `\`${resource.clusterName}\``;
+                            break;
+                        case "Datacenter":
+                            resourceCell = `\`${resource.datacenterName}\``;
+                            break;
+                        default:
+                            break;
+                    }
+                    const kindCell = kind || "-";
+                    const clusterCell = kind !== "Cluster" && resource.clusterName
+                        ? `\`${resource.clusterName}\``
+                        : "-";
+                    resourceLines.push(`| ${resourceCell} | ${kindCell} | ${hostCell} | ${clusterCell} | ${MonitorCriteriaEvaluator.formatPlatformResourceValue({
+                        platform: "vmware",
+                        metricName: breakdown.metricName,
+                        value: resource.metricValue,
+                    })} |`);
+                }
+                if (sortedResources.length > 10) {
+                    resourceLines.push(`\n*... and ${sortedResources.length - 10} more affected resources*`);
+                }
+                sections.push(`\n\n**Affected Resources** (${sortedResources.length} total)\n\n${resourceLines.join("\n")}`);
+                renderedBreakdownTable = true;
+            }
+        }
+        // Metric results summary (fallback context when no table rendered)
+        if (!renderedBreakdownTable &&
+            metricResponse.metricResult &&
+            metricResponse.metricResult.length > 0) {
+            const resultDetails = [];
+            for (const result of metricResponse.metricResult) {
+                if (result.data && result.data.length > 0) {
+                    resultDetails.push(`- ${result.data.length} metric data point(s) returned`);
+                }
+            }
+            if (resultDetails.length > 0) {
+                sections.push(`\n\n**Metric Summary**\n${resultDetails.join("\n")}`);
+            }
+        }
+        return sections.length > 0 ? sections.join("\n") : null;
+    }
     static buildDockerSwarmRootCauseContext(input) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j;
         const metricResponse = input.dataToProcess;