@oneuptime/common 12.0.33 → 13.0.0

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

@@ -30,7 +30,7 @@ import MonitorCriteriaInstance from "../../../Types/Monitor/MonitorCriteriaInsta
 import MonitorStep from "../../../Types/Monitor/MonitorStep";
 import FilterCondition from "../../../Types/Filter/FilterCondition";
 import MonitorType from "../../../Types/Monitor/MonitorType";
-import { CheckOn } from "../../../Types/Monitor/CriteriaFilter";
+import { CheckOn, FilterType, } from "../../../Types/Monitor/CriteriaFilter";
 import OneUptimeDate from "../../../Types/Date";
 import InBetween from "../../../Types/BaseDatabase/InBetween";
 import MetricExplorerUrl from "../../../Utils/Metrics/MetricExplorerUrl";
@@ -41,6 +41,11 @@ 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 { 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;
@@ -1020,13 +1025,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 +1059,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 +1098,7 @@ ${contextBlock}
                 totalSamples: ctx.totalSamplesInWindow,
                 unit: ctx.unit,
                 metricName: ctx.metricName,
+                unitHeuristicMetricName: unitHeuristicMetricName,
                 alias: ctx.alias,
                 components: ctx.components || [],
             })}`);
@@ -1163,14 +1183,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 +1211,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 +1273,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 +1396,76 @@ ${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;
+        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 "dockerSwarm":
+                return (_c = getDockerSwarmMetricByMetricName(input.metricName)) === null || _c === void 0 ? void 0 : _c.unit;
+            case "ceph":
+                return (_d = getCephMetricByMetricName(input.metricName)) === null || _d === void 0 ? void 0 : _d.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 +1561,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 +1829,11 @@ ${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*`);
@@ -1832,7 +1935,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*`);
@@ -1857,6 +1964,57 @@ ${contextBlock}
         }
         return sections.length > 0 ? sections.join("\n") : null;
     }
+    /*
+     * Which rows of the Ceph affected-resources table actually BREACHED.
+     *
+     * The blanket `metricValue > 0` below is right for every count- or
+     * level-style criteria ("> 0 active health checks", "> 85 % used"), but
+     * it is exactly backwards for the availability signals: the OSD Down /
+     * OSD Out / Quorum Degraded criteria fire on `< 1` over ceph_osd_up /
+     * ceph_osd_in / ceph_mon_quorum_status, so the ZERO rows are the down
+     * daemons. Dropping them rendered a table of the HEALTHY daemons under
+     * an incident that tells the reader to "check the root cause for the
+     * affected ceph_daemon label".
+     *
+     * Invert only for a criteria that fires when the metric FALLS.
+     * Everything else — every `> 0` health check, PG count, latency and
+     * capacity ratio, and every `= 0` recovery criteria — keeps the
+     * existing `> 0`, worst-highest-first table byte for byte.
+     */
+    static getCephBreachPredicate(criteriaInstance) {
+        var _a;
+        const metricFilters = (((_a = criteriaInstance === null || criteriaInstance === void 0 ? void 0 : criteriaInstance.data) === null || _a === void 0 ? void 0 : _a.filters) || []).filter((f) => {
+            return f.checkOn === CheckOn.MetricValue && typeof f.value === "number";
+        });
+        const firesWhenMetricFalls = metricFilters.length > 0 &&
+            metricFilters.every((f) => {
+                return (f.filterType === FilterType.LessThan ||
+                    f.filterType === FilterType.LessThanOrEqualTo);
+            });
+        if (!firesWhenMetricFalls) {
+            return {
+                matches: (value) => {
+                    return value > 0;
+                },
+                worstIsLowest: false,
+            };
+        }
+        return {
+            matches: (value) => {
+                return metricFilters.some((f) => {
+                    const threshold = f.value;
+                    return f.filterType === FilterType.LessThan
+                        ? value < threshold
+                        : value <= threshold;
+                });
+            },
+            /*
+             * A criteria that fires when the metric falls ranks the smallest
+             * value worst, so "worst first" is ascending here.
+             */
+            worstIsLowest: true,
+        };
+    }
     static buildCephRootCauseContext(input) {
         var _a, _b, _c, _d, _e, _f, _g;
         const metricResponse = input.dataToProcess;
@@ -1891,21 +2049,22 @@ ${contextBlock}
         let renderedBreakdownTable = false;
         if (breakdown && breakdown.affectedResources.length > 0) {
             /*
-             * K8s-parity render: drop zero-value rows, worst (highest)
-             * first, top 10. Note that for availability metrics
-             * (ceph_osd_up / ceph_osd_in / ceph_mon_quorum_status)
-             * zero-valued rows ARE the down resources — those still drive
-             * alerting through the per-series criteria evaluation; this
-             * table is supplementary context only.
+             * Keep the rows that satisfy the criteria that just matched, worst
+             * first, top 10 — NOT simply the non-zero rows. For ceph_osd_up /
+             * ceph_osd_in / ceph_mon_quorum_status the criteria is `< 1`, so
+             * the zero rows are the whole point of the incident.
              */
+            const breach = MonitorCriteriaEvaluator.getCephBreachPredicate(input.criteriaInstance);
             const sortedResources = [
                 ...breakdown.affectedResources,
             ]
                 .filter((r) => {
-                return r.metricValue > 0;
+                return breach.matches(r.metricValue);
             })
                 .sort((a, b) => {
-                return b.metricValue - a.metricValue;
+                return breach.worstIsLowest
+                    ? a.metricValue - b.metricValue
+                    : b.metricValue - a.metricValue;
             });
             /*
              * Skip the table when no row carries any identity label
@@ -1937,7 +2096,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*`);
@@ -1966,17 +2129,46 @@ ${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>"}\`.`);
         }
-        else if (metricName === "k8s.pod.phase" &&
-            breakdown.attributes["k8s.pod.phase"] === "Pending") {
+        else if (metricName === "k8s.pod.phase") {
+            /*
+             * The second half of this condition used to be
+             * `breakdown.attributes["k8s.pod.phase"] === "Pending"`, which could
+             * never be true. `breakdown.attributes` is the QUERY's attribute map
+             * (MonitorTelemetryMonitor stamps `resource.`-prefixed keys into it),
+             * and no receiver or processor in the shipped agent emits a pod
+             * phase attribute at all — the phase is the metric's VALUE
+             * (1 = Pending ... 5 = Unknown). So this branch never ran and every
+             * pod-phase alert fell through to the generic Kubernetes text.
+             */
             lines.push(`Pods are stuck in Pending phase and unable to be scheduled.`);
             lines.push(`Common causes: insufficient CPU/memory resources on nodes, node affinity/taint restrictions preventing scheduling, PersistentVolumeClaim pending, or resource quota exceeded.`);
             if (topResource.podName) {
@@ -1987,25 +2179,39 @@ ${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.`);
         }
         else if (metricName === "k8s.node.cpu.utilization" ||
-            (metricName.includes("cpu") && metricName.includes("utilization"))) {
+            /*
+             * Node-scoped ONLY. The bare substring test used to swallow every
+             * pod- and container-scoped CPU metric — `k8s.pod.cpu.utilization`,
+             * and now `k8s.pod.cpu_limit_utilization` — and answer them with
+             * "Node X is at N% CPU utilization... consider scaling the cluster",
+             * directly contradicting the pod-limit template's own description,
+             * which tells the reader NOT to add replicas, and naming a node for
+             * a pod-scoped alert.
+             */
+            (metricName.startsWith("k8s.node.") &&
+                metricName.includes("cpu") &&
+                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.`);
         }
         else if (metricName === "k8s.node.memory.usage" ||
-            (metricName.includes("memory") && metricName.includes("usage"))) {
+            // Node-scoped only — see the CPU branch above.
+            (metricName.startsWith("k8s.node.") &&
+                metricName.includes("memory") &&
+                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.`);
@@ -2014,7 +2220,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.`);
@@ -2023,7 +2229,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).`);
@@ -2033,7 +2239,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.`);
@@ -2042,7 +2248,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.`);