@oneuptime/common 12.0.34 → 13.0.1

package/Server/Utils/Monitor/MonitorCriteriaEvaluator.ts

@@ -83,6 +83,8 @@ import MetricMonitorResponse, {
   KubernetesResourceBreakdown,
   ProxmoxAffectedResource,
   ProxmoxResourceBreakdown,
+  VMwareAffectedResource,
+  VMwareResourceBreakdown,
   CephAffectedResource,
   CephResourceBreakdown,
   DockerSwarmAffectedResource,
@@ -98,8 +100,15 @@ import MonitorStepDockerMonitor from "../../../Types/Monitor/MonitorStepDockerMo
 import MonitorStepHostMonitor from "../../../Types/Monitor/MonitorStepHostMonitor";
 import MonitorStepPodmanMonitor from "../../../Types/Monitor/MonitorStepPodmanMonitor";
 import MonitorStepProxmoxMonitor from "../../../Types/Monitor/MonitorStepProxmoxMonitor";
+import MonitorStepVMwareMonitor from "../../../Types/Monitor/MonitorStepVMwareMonitor";
 import MonitorStepCephMonitor from "../../../Types/Monitor/MonitorStepCephMonitor";
 import MonitorStepDockerSwarmMonitor from "../../../Types/Monitor/MonitorStepDockerSwarmMonitor";
+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";
 
 /**
  * A cross-signal deep link into a telemetry explorer, plus the scope
@@ -477,7 +486,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
@@ -1098,6 +1107,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
     ) {
@@ -1277,6 +1287,11 @@ ${contextBlock}
       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);
@@ -1356,6 +1371,15 @@ ${contextBlock}
       );
     }
 
+    /*
+     * 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?.totalAttempts !== undefined) {
+      responseDetails.push(`- Attempts: ${probeResponse.totalAttempts}`);
+    }
+
     // Add Request Failed Details if available
     if (probeResponse?.requestFailedDetails) {
       const requestFailedDetails: RequestFailedDetails =
@@ -1433,13 +1457,28 @@ ${contextBlock}
       return null;
     }
 
+    const unitHeuristicMetricName: string | undefined =
+      MonitorCriteriaEvaluator.metricNameForUnitHeuristics({
+        metricName: ctx.metricName,
+        isFormula: ctx.isFormula,
+      });
+
     const lines: Array<string> = [];
     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: string | null = MetricValueFormatter.getReadableUnit(
+      ctx.unit,
+      unitHeuristicMetricName,
+    );
+    if (readableUnit) {
+      lines.push(`- Unit: ${readableUnit}`);
     }
     if (ctx.aggregationType) {
       lines.push(`- Aggregation: ${ctx.aggregationType}`);
@@ -1459,8 +1498,16 @@ ${contextBlock}
     if (ctx.components && ctx.components.length > 0) {
       const componentLines: Array<string> = ctx.components.map(
         (component: MetricComponent) => {
-          const unitSuffix: string = component.unit
-            ? ` — unit: ${component.unit}`
+          const componentUnit: string | null =
+            MetricValueFormatter.getReadableUnit(
+              component.unit,
+              MonitorCriteriaEvaluator.metricNameForUnitHeuristics({
+                metricName: component.name,
+                isFormula: component.isFormula,
+              }),
+            );
+          const unitSuffix: string = componentUnit
+            ? ` — unit: ${componentUnit}`
             : "";
           const typeSuffix: string = component.isFormula ? " (formula)" : "";
           return `  - \`${component.alias}\` = \`${component.name}\`${typeSuffix}${unitSuffix}`;
@@ -1504,6 +1551,7 @@ ${contextBlock}
           totalSamples: ctx.totalSamplesInWindow,
           unit: ctx.unit,
           metricName: ctx.metricName,
+          unitHeuristicMetricName: unitHeuristicMetricName,
           alias: ctx.alias,
           components: ctx.components || [],
         })}`,
@@ -1575,6 +1623,11 @@ ${contextBlock}
     totalSamples?: number | undefined;
     unit: string | null;
     metricName: string;
+    /**
+     * The metric name to reason about, or undefined for a formula.
+     * See MonitorCriteriaEvaluator.metricNameForUnitHeuristics.
+     */
+    unitHeuristicMetricName: string | undefined;
     alias: string;
     components: Array<MetricComponent>;
   }): string {
@@ -1628,17 +1681,20 @@ ${contextBlock}
       "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: string = component.unit
-        ? `${component.alias} (${component.unit})`
-        : component.alias;
-      headerCells.push(label);
+      headerCells.push(component.alias);
     }
 
     headerCells.push(...attrKeys);
 
-    const unitSuffix: string = input.unit ? ` ${input.unit}` : "";
-
     const headerRow: string = `| ${headerCells.join(" | ")} |`;
     const dividerRow: string = `| ${headerCells
       .map(() => {
@@ -1658,7 +1714,11 @@ ${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) {
@@ -1668,11 +1728,24 @@ ${contextBlock}
             return cv.alias === component.alias;
           });
           if (match && typeof match.value === "number") {
-            const componentUnitSuffix: string = component.unit
-              ? ` ${component.unit}`
-              : "";
+            /*
+             * 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(
-              `${MonitorCriteriaEvaluator.formatNumberForDisplay(match.value)}${componentUnitSuffix}`,
+              MetricValueFormatter.format({
+                value: match.value,
+                unit: component.unit,
+                metricName:
+                  MonitorCriteriaEvaluator.metricNameForUnitHeuristics({
+                    metricName: component.name,
+                    isFormula: component.isFormula,
+                  }),
+              }),
             );
           } else {
             cells.push("-");
@@ -1722,16 +1795,6 @@ ${contextBlock}
     return `${input.breachingCount} sample${input.breachingCount === 1 ? "" : "s"} breached the threshold.`;
   }
 
-  private static formatNumberForDisplay(value: number): string {
-    if (!Number.isFinite(value)) {
-      return String(value);
-    }
-    if (Number.isInteger(value)) {
-      return value.toString();
-    }
-    return Number(value.toFixed(2)).toString();
-  }
-
   private static buildMetricExplorerDeepLink(input: {
     monitor: Monitor;
     ctx: MetricCriteriaContext;
@@ -1923,6 +1986,27 @@ ${contextBlock}
     };
   }
 
+  /**
+   * 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.
+   */
+  private static metricNameForUnitHeuristics(input: {
+    metricName: string | undefined;
+    isFormula: boolean | undefined;
+  }): string | undefined {
+    return input.isFormula ? undefined : input.metricName;
+  }
+
   private static formatScopeDroppedHint(dropped: Array<string>): string {
     if (dropped.length === 0) {
       return "";
@@ -1931,6 +2015,69 @@ ${contextBlock}
     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.
+   */
+  private static getPlatformMetricUnit(input: {
+    platform: "kubernetes" | "proxmox" | "vmware" | "dockerSwarm" | "ceph";
+    metricName: string;
+  }): string | undefined {
+    switch (input.platform) {
+      case "kubernetes":
+        return getKubernetesMetricByMetricName(input.metricName)?.unit;
+      case "proxmox":
+        return getProxmoxMetricByMetricName(input.metricName)?.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 getVMwareMetricByMetricName(input.metricName)?.unit;
+      case "dockerSwarm":
+        return getDockerSwarmMetricByMetricName(input.metricName)?.unit;
+      case "ceph":
+        return getCephMetricByMetricName(input.metricName)?.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.
+   */
+  private static formatPlatformResourceValue(input: {
+    platform: "kubernetes" | "proxmox" | "vmware" | "dockerSwarm" | "ceph";
+    metricName: string;
+    value: number;
+  }): string {
+    return `**${MetricValueFormatter.format({
+      value: input.value,
+      unit: MonitorCriteriaEvaluator.getPlatformMetricUnit({
+        platform: input.platform,
+        metricName: input.metricName,
+      }),
+      metricName: input.metricName,
+    })}**`;
+  }
+
   private static async buildKubernetesRootCauseContext(input: {
     dataToProcess: DataToProcess;
     monitorStep: MonitorStep;
@@ -2071,7 +2218,13 @@ ${contextBlock}
           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(" | ")} |`);
       }
@@ -2478,7 +2631,285 @@ ${contextBlock}
             : "-";
 
           resourceLines.push(
-            `| ${resourceCell} | ${typeCell} | ${nodeCell} | **${resource.metricValue}** |`,
+            `| ${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: Array<string> = [];
+
+      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.
+   */
+  private static getVMwareAffectedResourceKind(
+    resource: VMwareAffectedResource,
+  ): string | undefined {
+    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;
+  }
+
+  private static buildVMwareRootCauseContext(input: {
+    dataToProcess: DataToProcess;
+    monitorStep: MonitorStep;
+    monitor: Monitor;
+  }): string | null {
+    const metricResponse: MetricMonitorResponse =
+      input.dataToProcess as MetricMonitorResponse;
+
+    const breakdown: VMwareResourceBreakdown | undefined =
+      metricResponse.vmwareResourceBreakdown;
+
+    const sections: Array<string> = [];
+
+    // vCenter context
+    const vmwareMonitor: MonitorStepVMwareMonitor | undefined =
+      input.monitorStep.data?.vmwareMonitor;
+
+    if (vmwareMonitor || breakdown) {
+      const vcenterDetails: Array<string> = [];
+      vcenterDetails.push(
+        `- vCenter: ${breakdown?.vcenterName || vmwareMonitor?.vcenterIdentifier || "Unknown"}`,
+      );
+
+      if (breakdown) {
+        vcenterDetails.push(
+          `- Metric: ${breakdown.metricFriendlyName} (\`${breakdown.metricName}\`)`,
+        );
+      } else if (
+        vmwareMonitor &&
+        vmwareMonitor.metricViewConfig?.queryConfigs?.length > 0 &&
+        vmwareMonitor.metricViewConfig.queryConfigs[0]
+      ) {
+        const metricName: string = vmwareMonitor.metricViewConfig
+          .queryConfigs[0].metricQueryData?.filterData?.metricName as string;
+        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 (vmwareMonitor?.resourceFilters?.datacenterName) {
+        vcenterDetails.push(
+          `- Datacenter Filter: ${vmwareMonitor.resourceFilters.datacenterName}`,
+        );
+      }
+
+      if (vmwareMonitor?.resourceFilters?.clusterName) {
+        vcenterDetails.push(
+          `- Cluster Filter: ${vmwareMonitor.resourceFilters.clusterName}`,
+        );
+      }
+
+      if (vmwareMonitor?.resourceFilters?.hostName) {
+        vcenterDetails.push(
+          `- Host Filter: ${vmwareMonitor.resourceFilters.hostName}`,
+        );
+      }
+
+      if (vmwareMonitor?.resourceFilters?.vmName) {
+        vcenterDetails.push(
+          `- Virtual Machine Filter: ${vmwareMonitor.resourceFilters.vmName}`,
+        );
+      }
+
+      if (vmwareMonitor?.resourceFilters?.datastoreName) {
+        vcenterDetails.push(
+          `- Datastore Filter: ${vmwareMonitor.resourceFilters.datastoreName}`,
+        );
+      }
+
+      if (vmwareMonitor?.resourceFilters?.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: boolean = 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: Array<VMwareAffectedResource> = [
+        ...breakdown.affectedResources,
+      ]
+        .filter((r: VMwareAffectedResource) => {
+          return r.metricValue > 0;
+        })
+        .sort((a: VMwareAffectedResource, b: VMwareAffectedResource) => {
+          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: boolean = sortedResources.some(
+        (r: VMwareAffectedResource) => {
+          return Boolean(
+            MonitorCriteriaEvaluator.getVMwareAffectedResourceKind(r),
+          );
+        },
+      );
+
+      if (sortedResources.length > 0 && hasIdentity) {
+        const resourcesToShow: Array<VMwareAffectedResource> =
+          sortedResources.slice(0, 10);
+
+        const resourceLines: Array<string> = [];
+        resourceLines.push(`| Resource | Kind | Host | Cluster | Value |`);
+        resourceLines.push(`| --- | --- | --- | --- | --- |`);
+
+        for (const resource of resourcesToShow) {
+          const kind: string | undefined =
+            MonitorCriteriaEvaluator.getVMwareAffectedResourceKind(resource);
+
+          let resourceCell: string = "-";
+          let hostCell: string = "-";
+
+          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: string = kind || "-";
+          const clusterCell: string =
+            kind !== "Cluster" && resource.clusterName
+              ? `\`${resource.clusterName}\``
+              : "-";
+
+          resourceLines.push(
+            `| ${resourceCell} | ${kindCell} | ${hostCell} | ${clusterCell} | ${MonitorCriteriaEvaluator.formatPlatformResourceValue(
+              {
+                platform: "vmware",
+                metricName: breakdown.metricName,
+                value: resource.metricValue,
+              },
+            )} |`,
           );
         }
 
@@ -2640,7 +3071,13 @@ ${contextBlock}
             : "-";
 
           resourceLines.push(
-            `| ${taskCell} | ${serviceCell} | ${nodeCell} | **${resource.metricValue}** |`,
+            `| ${taskCell} | ${serviceCell} | ${nodeCell} | ${MonitorCriteriaEvaluator.formatPlatformResourceValue(
+              {
+                platform: "dockerSwarm",
+                metricName: breakdown.metricName,
+                value: resource.metricValue,
+              },
+            )} |`,
           );
         }
 
@@ -2865,7 +3302,13 @@ ${contextBlock}
             : "-";
 
           resourceLines.push(
-            `| ${daemonCell} | ${poolCell} | ${hostCell} | **${resource.metricValue}** |`,
+            `| ${daemonCell} | ${poolCell} | ${hostCell} | ${MonitorCriteriaEvaluator.formatPlatformResourceValue(
+              {
+                platform: "ceph",
+                metricName: breakdown.metricName,
+                value: resource.metricValue,
+              },
+            )} |`,
           );
         }
 
@@ -2914,6 +3357,27 @@ ${contextBlock}
     const metricName: string = breakdown.metricName;
     const lines: Array<string> = [];
 
+    /*
+     * 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: string = MetricValueFormatter.format({
+      value: topResource.metricValue,
+      unit: MonitorCriteriaEvaluator.getPlatformMetricUnit({
+        platform: "kubernetes",
+        metricName: metricName,
+      }),
+      metricName: metricName,
+    });
+
     if (
       metricName === "k8s.container.restarts" ||
       metricName.includes("restart")
@@ -2923,7 +3387,7 @@ ${contextBlock}
       );
       if (topResource.containerName) {
         lines.push(
-          `The container \`${topResource.containerName}\` in pod \`${topResource.podName || "unknown"}\` has restarted **${topResource.metricValue}** times.`,
+          `The container \`${topResource.containerName}\` in pod \`${topResource.podName || "unknown"}\` has restarted **${topResourceValue}** times.`,
         );
       }
       lines.push(
@@ -2959,7 +3423,7 @@ ${contextBlock}
       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}).`,
+          `Node \`${topResource.nodeName}\` is reporting NotReady (value: ${topResourceValue}).`,
         );
       }
       lines.push(
@@ -2986,7 +3450,7 @@ ${contextBlock}
       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.`,
+          `Node \`${topResource.nodeName}\` is at **${topResourceValue}** CPU utilization.`,
         );
       }
       lines.push(
@@ -3007,7 +3471,7 @@ ${contextBlock}
       );
       if (topResource.nodeName) {
         lines.push(
-          `Node \`${topResource.nodeName}\` memory usage is at **${topResource.metricValue.toFixed(1)}%**.`,
+          `Node \`${topResource.nodeName}\` memory usage is at **${topResourceValue}**.`,
         );
       }
       lines.push(
@@ -3025,7 +3489,7 @@ ${contextBlock}
       );
       if (topResource.workloadName) {
         lines.push(
-          `${topResource.workloadType || "Deployment"} \`${topResource.workloadName}\` has **${topResource.metricValue}** unavailable replica(s).`,
+          `${topResource.workloadType || "Deployment"} \`${topResource.workloadName}\` has **${topResourceValue}** unavailable replica(s).`,
         );
       }
       lines.push(
@@ -3041,7 +3505,7 @@ ${contextBlock}
       lines.push(`Kubernetes Job has failed pods.`);
       if (topResource.workloadName) {
         lines.push(
-          `Job \`${topResource.workloadName}\` has **${topResource.metricValue}** failed pod(s).`,
+          `Job \`${topResource.workloadName}\` has **${topResourceValue}** failed pod(s).`,
         );
       }
       lines.push(
@@ -3060,7 +3524,7 @@ ${contextBlock}
       );
       if (topResource.nodeName) {
         lines.push(
-          `Node \`${topResource.nodeName}\` filesystem usage is at **${topResource.metricValue.toFixed(1)}%**.`,
+          `Node \`${topResource.nodeName}\` filesystem usage is at **${topResourceValue}**.`,
         );
       }
       lines.push(
@@ -3076,7 +3540,7 @@ ${contextBlock}
       lines.push(`DaemonSet has misscheduled or unavailable nodes.`);
       if (topResource.workloadName) {
         lines.push(
-          `DaemonSet \`${topResource.workloadName}\` has **${topResource.metricValue}** misscheduled node(s).`,
+          `DaemonSet \`${topResource.workloadName}\` has **${topResourceValue}** misscheduled node(s).`,
         );
       }
       lines.push(