@oneuptime/common 12.0.34 → 13.0.1

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

@@ -41,6 +41,12 @@ import IP from "../../../Types/IP/IP";
 import Hostname from "../../../Types/API/Hostname";
 import Port from "../../../Types/Port";
 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 {
     static async processMonitorStep(input) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
@@ -330,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
@@ -790,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({
@@ -920,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);
@@ -972,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;
@@ -1020,13 +1039,23 @@ ${contextBlock}
         if (!ctx) {
             return null;
         }
+        const unitHeuristicMetricName = MonitorCriteriaEvaluator.metricNameForUnitHeuristics({
+            metricName: ctx.metricName,
+            isFormula: ctx.isFormula,
+        });
         const lines = [];
         lines.push(`- Metric: \`${ctx.metricName}\``);
         if (ctx.alias) {
             lines.push(`- Alias: \`${ctx.alias}\``);
         }
-        if (ctx.unit) {
-            lines.push(`- Unit: ${ctx.unit}`);
+        /*
+         * Spell the unit out — "Bytes", not the UCUM "By" the exporter wrote —
+         * and drop the line entirely for units that name no dimension, so a
+         * ratio metric no longer reports the bare "Unit: 1".
+         */
+        const readableUnit = MetricValueFormatter.getReadableUnit(ctx.unit, unitHeuristicMetricName);
+        if (readableUnit) {
+            lines.push(`- Unit: ${readableUnit}`);
         }
         if (ctx.aggregationType) {
             lines.push(`- Aggregation: ${ctx.aggregationType}`);
@@ -1044,8 +1073,12 @@ ${contextBlock}
          */
         if (ctx.components && ctx.components.length > 0) {
             const componentLines = ctx.components.map((component) => {
-                const unitSuffix = component.unit
-                    ? ` — unit: ${component.unit}`
+                const componentUnit = MetricValueFormatter.getReadableUnit(component.unit, MonitorCriteriaEvaluator.metricNameForUnitHeuristics({
+                    metricName: component.name,
+                    isFormula: component.isFormula,
+                }));
+                const unitSuffix = componentUnit
+                    ? ` — unit: ${componentUnit}`
                     : "";
                 const typeSuffix = component.isFormula ? " (formula)" : "";
                 return `  - \`${component.alias}\` = \`${component.name}\`${typeSuffix}${unitSuffix}`;
@@ -1079,6 +1112,7 @@ ${contextBlock}
                 totalSamples: ctx.totalSamplesInWindow,
                 unit: ctx.unit,
                 metricName: ctx.metricName,
+                unitHeuristicMetricName: unitHeuristicMetricName,
                 alias: ctx.alias,
                 components: ctx.components || [],
             })}`);
@@ -1163,14 +1197,18 @@ ${contextBlock}
             "Alias",
             "Value",
         ];
+        /*
+         * The component columns carry no unit in their header any more. Each
+         * cell now names the unit it actually landed on, and auto-scaling
+         * means neighbouring rows can land on different ones — a header that
+         * read "a (By)" over cells reading "900 KB" and "1.2 MB" states a
+         * unit that neither row uses. The configured unit is not lost: the
+         * Components bullet list above the table still records it.
+         */
         for (const component of input.components) {
-            const label = component.unit
-                ? `${component.alias} (${component.unit})`
-                : component.alias;
-            headerCells.push(label);
+            headerCells.push(component.alias);
         }
         headerCells.push(...attrKeys);
-        const unitSuffix = input.unit ? ` ${input.unit}` : "";
         const headerRow = `| ${headerCells.join(" | ")} |`;
         const dividerRow = `| ${headerCells
             .map(() => {
@@ -1187,17 +1225,33 @@ ${contextBlock}
                 `\`${timestampIso}\``,
                 metricCell,
                 aliasCell,
-                `${MonitorCriteriaEvaluator.formatNumberForDisplay(s.value)}${unitSuffix}`,
+                MetricValueFormatter.format({
+                    value: s.value,
+                    unit: input.unit,
+                    metricName: input.unitHeuristicMetricName,
+                }),
             ];
             for (const component of input.components) {
                 const match = (s.componentValues || []).find((cv) => {
                     return cv.alias === component.alias;
                 });
                 if (match && typeof match.value === "number") {
-                    const componentUnitSuffix = component.unit
-                        ? ` ${component.unit}`
-                        : "";
-                    cells.push(`${MonitorCriteriaEvaluator.formatNumberForDisplay(match.value)}${componentUnitSuffix}`);
+                    /*
+                     * Each component keeps its OWN unit. Component values are
+                     * indexed off the per-query series and never go through the
+                     * sample→threshold-unit conversion the main Value column
+                     * does, so they are in the component's legendUnit — mixing
+                     * units across the row is deliberate, and is why every cell
+                     * has to say which one it is in.
+                     */
+                    cells.push(MetricValueFormatter.format({
+                        value: match.value,
+                        unit: component.unit,
+                        metricName: MonitorCriteriaEvaluator.metricNameForUnitHeuristics({
+                            metricName: component.name,
+                            isFormula: component.isFormula,
+                        }),
+                    }));
                 }
                 else {
                     cells.push("-");
@@ -1233,15 +1287,6 @@ ${contextBlock}
         }
         return `${input.breachingCount} sample${input.breachingCount === 1 ? "" : "s"} breached the threshold.`;
     }
-    static formatNumberForDisplay(value) {
-        if (!Number.isFinite(value)) {
-            return String(value);
-        }
-        if (Number.isInteger(value)) {
-            return value.toString();
-        }
-        return Number(value.toFixed(2)).toString();
-    }
     static buildMetricExplorerDeepLink(input) {
         var _a;
         const projectId = (_a = input.monitor.projectId) === null || _a === void 0 ? void 0 : _a.toString();
@@ -1365,12 +1410,84 @@ ${contextBlock}
             dropped: queryParams.dropped,
         };
     }
+    /**
+     * The metric name to hand a unit heuristic, or undefined when there
+     * isn't one.
+     *
+     * `MetricCriteriaContext.metricName` and `MetricComponent.name` are the
+     * FORMULA EXPRESSION when the criteria (or the component) targets a
+     * formula — MetricMonitorCriteria.buildContext falls back to
+     * `metricFormula`. The only thing a name is used for downstream is
+     * ValueFormatter.isFractionMetric, which asks whether the name ends in
+     * `.utilization` / `_ratio` / `_percent` and multiplies a "1"-unit value
+     * by 100 when it does. A formula written as `a / b_ratio` ends in
+     * `_ratio` and would silently be reported at 100× its real value, so a
+     * formula gets no name at all.
+     */
+    static metricNameForUnitHeuristics(input) {
+        return input.isFormula ? undefined : input.metricName;
+    }
     static formatScopeDroppedHint(dropped) {
         if (dropped.length === 0) {
             return "";
         }
         return ` _(scope partially carried — not applied: ${dropped.join(", ")})_`;
     }
+    /**
+     * The unit for a value in a per-platform "Affected Resources" table.
+     *
+     * These rows are NOT the same numbers as the criteria's breaching
+     * samples: the worker collects them with a raw `MetricService.findBy`
+     * scan and never runs them through MetricResultUnitConverter, so they
+     * are in the metric's NATIVE unit while the criteria threshold was
+     * compared in the user's chosen display unit. Labelling them with the
+     * query's legendUnit would therefore attach a confidently wrong unit to
+     * a correct number.
+     *
+     * The catalog is the right source precisely because it also declares
+     * the native unit. It is the same lookup, on the same metric name, that
+     * the worker already ran to resolve `metricFriendlyName`, so the unit
+     * shown here can never disagree with the metric name shown beside it.
+     */
+    static getPlatformMetricUnit(input) {
+        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 (_d = getDockerSwarmMetricByMetricName(input.metricName)) === null || _d === void 0 ? void 0 : _d.unit;
+            case "ceph":
+                return (_e = getCephMetricByMetricName(input.metricName)) === null || _e === void 0 ? void 0 : _e.unit;
+            default:
+                return undefined;
+        }
+    }
+    /**
+     * Render one cell of a platform breakdown table's Value column.
+     *
+     * Bold, because that is how these tables have always drawn the value —
+     * it is the one number in the row a reader scans for.
+     */
+    static formatPlatformResourceValue(input) {
+        return `**${MetricValueFormatter.format({
+            value: input.value,
+            unit: MonitorCriteriaEvaluator.getPlatformMetricUnit({
+                platform: input.platform,
+                metricName: input.metricName,
+            }),
+            metricName: input.metricName,
+        })}**`;
+    }
     static async buildKubernetesRootCauseContext(input) {
         var _a;
         const metricResponse = input.dataToProcess;
@@ -1466,7 +1583,11 @@ ${contextBlock}
                 if (hasNode) {
                     cells.push(resource.nodeName ? `\`${resource.nodeName}\`` : "-");
                 }
-                cells.push(`**${resource.metricValue}**`);
+                cells.push(MonitorCriteriaEvaluator.formatPlatformResourceValue({
+                    platform: "kubernetes",
+                    metricName: breakdown.metricName,
+                    value: resource.metricValue,
+                }));
                 resourceLines.push(`| ${cells.join(" | ")} |`);
             }
             if (sortedResources.length > 10) {
@@ -1730,7 +1851,204 @@ ${contextBlock}
                     const nodeCell = resource.nodeName
                         ? `\`${resource.nodeName}\``
                         : "-";
-                    resourceLines.push(`| ${resourceCell} | ${typeCell} | ${nodeCell} | **${resource.metricValue}** |`);
+                    resourceLines.push(`| ${resourceCell} | ${typeCell} | ${nodeCell} | ${MonitorCriteriaEvaluator.formatPlatformResourceValue({
+                        platform: "proxmox",
+                        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;
+    }
+    /*
+     * 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*`);
@@ -1832,7 +2150,11 @@ ${contextBlock}
                     const nodeCell = resource.nodeName
                         ? `\`${resource.nodeName}\``
                         : "-";
-                    resourceLines.push(`| ${taskCell} | ${serviceCell} | ${nodeCell} | **${resource.metricValue}** |`);
+                    resourceLines.push(`| ${taskCell} | ${serviceCell} | ${nodeCell} | ${MonitorCriteriaEvaluator.formatPlatformResourceValue({
+                        platform: "dockerSwarm",
+                        metricName: breakdown.metricName,
+                        value: resource.metricValue,
+                    })} |`);
                 }
                 if (sortedResources.length > 10) {
                     resourceLines.push(`\n*... and ${sortedResources.length - 10} more affected tasks*`);
@@ -1989,7 +2311,11 @@ ${contextBlock}
                     const hostCell = resource.hostname
                         ? `\`${resource.hostname}\``
                         : "-";
-                    resourceLines.push(`| ${daemonCell} | ${poolCell} | ${hostCell} | **${resource.metricValue}** |`);
+                    resourceLines.push(`| ${daemonCell} | ${poolCell} | ${hostCell} | ${MonitorCriteriaEvaluator.formatPlatformResourceValue({
+                        platform: "ceph",
+                        metricName: breakdown.metricName,
+                        value: resource.metricValue,
+                    })} |`);
                 }
                 if (sortedResources.length > 10) {
                     resourceLines.push(`\n*... and ${sortedResources.length - 10} more affected resources*`);
@@ -2018,11 +2344,31 @@ ${contextBlock}
         const { breakdown, topResource } = input;
         const metricName = breakdown.metricName;
         const lines = [];
+        /*
+         * The top resource's value, in the unit the catalog says the metric
+         * is actually reported in.
+         *
+         * The three "is at N%" sentences below used to hardcode that percent
+         * sign. Two of the three metrics they fire for are not percentages at
+         * all — k8s.node.memory.usage and k8s.node.filesystem.usage are
+         * `bytes`, so a node holding 8 GiB reported "memory usage is at
+         * 8589934592.0%" — and the third, k8s.node.cpu.utilization, is the
+         * kubeletstats cores gauge that four other places in this repo warn
+         * is misnamed, so 1.4 cores in use read as "1.4% CPU utilization".
+         */
+        const topResourceValue = MetricValueFormatter.format({
+            value: topResource.metricValue,
+            unit: MonitorCriteriaEvaluator.getPlatformMetricUnit({
+                platform: "kubernetes",
+                metricName: metricName,
+            }),
+            metricName: metricName,
+        });
         if (metricName === "k8s.container.restarts" ||
             metricName.includes("restart")) {
             lines.push(`Container restart count is elevated, indicating a potential CrashLoopBackOff condition.`);
             if (topResource.containerName) {
-                lines.push(`The container \`${topResource.containerName}\` in pod \`${topResource.podName || "unknown"}\` has restarted **${topResource.metricValue}** times.`);
+                lines.push(`The container \`${topResource.containerName}\` in pod \`${topResource.podName || "unknown"}\` has restarted **${topResourceValue}** times.`);
             }
             lines.push(`Common causes: application crash on startup, misconfigured environment variables, missing dependencies, OOM (Out of Memory) kills, failed health checks, or missing config maps/secrets.`);
             lines.push(`Recommended actions: Check container logs with \`kubectl logs ${topResource.podName || "<pod-name>"} -c ${topResource.containerName || "<container>"} --previous\` and inspect events with \`kubectl describe pod ${topResource.podName || "<pod-name>"}\`.`);
@@ -2048,7 +2394,7 @@ ${contextBlock}
             (metricName.includes("node") && metricName.includes("condition"))) {
             lines.push(`One or more nodes have transitioned to a NotReady state.`);
             if (topResource.nodeName) {
-                lines.push(`Node \`${topResource.nodeName}\` is reporting NotReady (value: ${topResource.metricValue}).`);
+                lines.push(`Node \`${topResource.nodeName}\` is reporting NotReady (value: ${topResourceValue}).`);
             }
             lines.push(`Common causes: kubelet process failure, node resource exhaustion (disk pressure, memory pressure, PID pressure), network connectivity issues, or underlying VM/hardware failure.`);
             lines.push(`Recommended actions: Check node conditions with \`kubectl describe node ${topResource.nodeName || "<node-name>"}\` and verify kubelet status on the node.`);
@@ -2068,7 +2414,7 @@ ${contextBlock}
                 metricName.includes("utilization"))) {
             lines.push(`Node CPU utilization has exceeded the configured threshold.`);
             if (topResource.nodeName) {
-                lines.push(`Node \`${topResource.nodeName}\` is at **${topResource.metricValue.toFixed(1)}%** CPU utilization.`);
+                lines.push(`Node \`${topResource.nodeName}\` is at **${topResourceValue}** CPU utilization.`);
             }
             lines.push(`Common causes: resource-intensive workloads, insufficient resource limits on pods, noisy neighbor pods consuming excessive CPU, or insufficient cluster capacity.`);
             lines.push(`Recommended actions: Identify top CPU consumers with \`kubectl top pods --all-namespaces --sort-by=cpu\` and consider scaling the cluster or adjusting pod resource limits.`);
@@ -2080,7 +2426,7 @@ ${contextBlock}
                 metricName.includes("usage"))) {
             lines.push(`Node memory utilization has exceeded the configured threshold.`);
             if (topResource.nodeName) {
-                lines.push(`Node \`${topResource.nodeName}\` memory usage is at **${topResource.metricValue.toFixed(1)}%**.`);
+                lines.push(`Node \`${topResource.nodeName}\` memory usage is at **${topResourceValue}**.`);
             }
             lines.push(`Common causes: memory leaks in applications, insufficient memory limits on pods, too many pods scheduled on the node, or growing dataset sizes.`);
             lines.push(`Recommended actions: Check memory consumers with \`kubectl top pods --all-namespaces --sort-by=memory\` and review pod memory limits. Consider scaling the cluster or adding nodes with more memory.`);
@@ -2089,7 +2435,7 @@ ${contextBlock}
             metricName.includes("unavailable")) {
             lines.push(`Deployment has unavailable replicas, indicating a mismatch between desired and available replicas.`);
             if (topResource.workloadName) {
-                lines.push(`${topResource.workloadType || "Deployment"} \`${topResource.workloadName}\` has **${topResource.metricValue}** unavailable replica(s).`);
+                lines.push(`${topResource.workloadType || "Deployment"} \`${topResource.workloadName}\` has **${topResourceValue}** unavailable replica(s).`);
             }
             lines.push(`Common causes: failed rolling update, image pull errors (wrong image tag or missing registry credentials), pod crash loops, insufficient cluster resources to schedule new pods, or PodDisruptionBudget blocking updates.`);
             lines.push(`Recommended actions: Check deployment rollout status with \`kubectl rollout status deployment/${topResource.workloadName || "<deployment>"}\` and inspect pod events.`);
@@ -2098,7 +2444,7 @@ ${contextBlock}
             (metricName.includes("job") && metricName.includes("fail"))) {
             lines.push(`Kubernetes Job has failed pods.`);
             if (topResource.workloadName) {
-                lines.push(`Job \`${topResource.workloadName}\` has **${topResource.metricValue}** failed pod(s).`);
+                lines.push(`Job \`${topResource.workloadName}\` has **${topResourceValue}** failed pod(s).`);
             }
             lines.push(`Common causes: application error or non-zero exit code, resource limits exceeded (OOMKilled), misconfigured command or arguments, missing environment variables, or timeout exceeded.`);
             lines.push(`Recommended actions: Check job status with \`kubectl describe job ${topResource.workloadName || "<job-name>"}\` and review pod logs for the failed pod(s).`);
@@ -2108,7 +2454,7 @@ ${contextBlock}
             metricName.includes("filesystem")) {
             lines.push(`Node disk/filesystem usage has exceeded the configured threshold.`);
             if (topResource.nodeName) {
-                lines.push(`Node \`${topResource.nodeName}\` filesystem usage is at **${topResource.metricValue.toFixed(1)}%**.`);
+                lines.push(`Node \`${topResource.nodeName}\` filesystem usage is at **${topResourceValue}**.`);
             }
             lines.push(`Common causes: container image layers consuming disk space, excessive logging, large emptyDir volumes, or accumulation of unused container images.`);
             lines.push(`Recommended actions: Clean up unused images with \`docker system prune\` or \`crictl rmi --prune\`, check for large log files, and review PersistentVolumeClaim usage.`);
@@ -2117,7 +2463,7 @@ ${contextBlock}
             metricName.includes("daemonset")) {
             lines.push(`DaemonSet has misscheduled or unavailable nodes.`);
             if (topResource.workloadName) {
-                lines.push(`DaemonSet \`${topResource.workloadName}\` has **${topResource.metricValue}** misscheduled node(s).`);
+                lines.push(`DaemonSet \`${topResource.workloadName}\` has **${topResourceValue}** misscheduled node(s).`);
             }
             lines.push(`Common causes: node taints preventing scheduling, incorrect node selectors, or node affinity rules excluding certain nodes.`);
             lines.push(`Recommended actions: Check DaemonSet status with \`kubectl describe daemonset ${topResource.workloadName || "<daemonset>"}\` and verify node labels and taints.`);