@oneuptime/common 13.0.8 → 14.0.0

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

@@ -26,6 +26,7 @@ import ExternalStatusPageMonitorCriteria from "./Criteria/ExternalStatusPageMoni
 import MonitorCriteriaMessageBuilder from "./MonitorCriteriaMessageBuilder";
 import MonitorCriteriaDataExtractor from "./MonitorCriteriaDataExtractor";
 import MonitorCriteriaMessageFormatter from "./MonitorCriteriaMessageFormatter";
+import AffectedResourceList from "./AffectedResourceList";
 import MonitorCriteriaInstance from "../../../Types/Monitor/MonitorCriteriaInstance";
 import MonitorStep from "../../../Types/Monitor/MonitorStep";
 import FilterCondition from "../../../Types/Filter/FilterCondition";
@@ -1436,7 +1437,7 @@ ${contextBlock}
         return ` _(scope partially carried — not applied: ${dropped.join(", ")})_`;
     }
     /**
-     * The unit for a value in a per-platform "Affected Resources" table.
+     * The unit for a value in a per-platform "Affected Resources" list.
      *
      * These rows are NOT the same numbers as the criteria's breaching
      * samples: the worker collects them with a raw `MetricService.findBy`
@@ -1475,10 +1476,11 @@ ${contextBlock}
         }
     }
     /**
-     * Render one cell of a platform breakdown table's Value column.
+     * Render the value of one resource in a platform "Affected Resources"
+     * list.
      *
-     * Bold, because that is how these tables have always drawn the value —
-     * it is the one number in the row a reader scans for.
+     * Bold, because that is how the breakdown has always drawn the value —
+     * it is the one number on the line a reader scans for.
      */
     static formatPlatformResourceValue(input) {
         return `**${MetricValueFormatter.format({
@@ -1490,6 +1492,78 @@ ${contextBlock}
             metricName: input.metricName,
         })}**`;
     }
+    /*
+     * One Kubernetes resource as an "Affected Resources" list item.
+     *
+     * The item is titled by the most specific object the series names —
+     * container, then pod, then workload, then node, then namespace — because
+     * that is the thing that is actually breaching; everything above it in
+     * the hierarchy is listed underneath as context. A series with no
+     * Kubernetes identity at all is a cluster-level series, so it is titled
+     * by the cluster.
+     *
+     * A container is titled together with its pod. Every replica of a
+     * workload runs a container of the same name, so "Container `checkout`"
+     * alone would title three crash-looping replicas identically and leave
+     * the pod that tells them apart buried in the bullets.
+     */
+    static getKubernetesAffectedResourceEntry(input) {
+        const resource = input.resource;
+        // "Deployment", "StatefulSet", ... — the worker only ever sets one of those.
+        const workloadLabel = resource.workloadType || "Workload";
+        let kind = "Cluster";
+        let name = AffectedResourceList.code(input.clusterName);
+        if (resource.containerName) {
+            kind = "Container";
+            name = resource.podName
+                ? `${AffectedResourceList.code(resource.containerName)} in pod ${AffectedResourceList.code(resource.podName)}`
+                : AffectedResourceList.code(resource.containerName);
+        }
+        else if (resource.podName) {
+            kind = "Pod";
+            name = AffectedResourceList.code(resource.podName);
+        }
+        else if (resource.workloadName) {
+            kind = workloadLabel;
+            name = AffectedResourceList.code(resource.workloadName);
+        }
+        else if (resource.nodeName) {
+            kind = "Node";
+            name = AffectedResourceList.code(resource.nodeName);
+        }
+        else if (resource.namespace) {
+            kind = "Namespace";
+            name = AffectedResourceList.code(resource.namespace);
+        }
+        const details = [];
+        if (resource.namespace && kind !== "Namespace") {
+            details.push({
+                label: "Namespace",
+                value: AffectedResourceList.code(resource.namespace),
+            });
+        }
+        const titledByWorkload = !resource.containerName &&
+            !resource.podName &&
+            Boolean(resource.workloadName);
+        if (resource.workloadName && !titledByWorkload) {
+            details.push({
+                label: workloadLabel,
+                value: AffectedResourceList.code(resource.workloadName),
+            });
+        }
+        if (resource.nodeName && kind !== "Node") {
+            details.push({
+                label: "Node",
+                value: AffectedResourceList.code(resource.nodeName),
+            });
+        }
+        return {
+            kind: kind,
+            name: name,
+            value: input.value,
+            details: details,
+        };
+    }
     static async buildKubernetesRootCauseContext(input) {
         var _a;
         const metricResponse = input.dataToProcess;
@@ -1508,7 +1582,6 @@ ${contextBlock}
         sections.push(`**Kubernetes Cluster Details**\n${clusterDetails.join("\n")}`);
         // Affected resources
         if (breakdown.affectedResources && breakdown.affectedResources.length > 0) {
-            const resourceLines = [];
             // Sort by metric value descending (worst first) and filter out zero-value resources
             const sortedResources = [
                 ...breakdown.affectedResources,
@@ -1523,79 +1596,23 @@ ${contextBlock}
                 return sections.join("\n");
             }
             // Show top 10 affected resources
-            const resourcesToShow = sortedResources.slice(0, 10);
-            // Determine which columns are present across all resources
-            const hasNamespace = resourcesToShow.some((r) => {
-                return r.namespace;
-            });
-            const hasWorkload = resourcesToShow.some((r) => {
-                return r.workloadType && r.workloadName;
-            });
-            const hasPod = resourcesToShow.some((r) => {
-                return r.podName;
-            });
-            const hasContainer = resourcesToShow.some((r) => {
-                return r.containerName;
-            });
-            const hasNode = resourcesToShow.some((r) => {
-                return r.nodeName;
-            });
-            // Build table header
-            const headerCells = [];
-            if (hasNamespace) {
-                headerCells.push("Namespace");
-            }
-            if (hasWorkload) {
-                headerCells.push("Workload Type");
-                headerCells.push("Workload");
-            }
-            if (hasPod) {
-                headerCells.push("Pod");
-            }
-            if (hasContainer) {
-                headerCells.push("Container");
-            }
-            if (hasNode) {
-                headerCells.push("Node");
-            }
-            headerCells.push("Value");
-            const headerRow = `| ${headerCells.join(" | ")} |`;
-            const separatorRow = `| ${headerCells
-                .map(() => {
-                return "---";
-            })
-                .join(" | ")} |`;
-            resourceLines.push(headerRow);
-            resourceLines.push(separatorRow);
-            for (const resource of resourcesToShow) {
-                const cells = [];
-                if (hasNamespace) {
-                    cells.push(resource.namespace ? `\`${resource.namespace}\`` : "-");
-                }
-                if (hasWorkload) {
-                    cells.push(resource.workloadType ? `${resource.workloadType}` : "-");
-                    cells.push(resource.workloadName ? `\`${resource.workloadName}\`` : "-");
-                }
-                if (hasPod) {
-                    cells.push(resource.podName ? `\`${resource.podName}\`` : "-");
-                }
-                if (hasContainer) {
-                    cells.push(resource.containerName ? `\`${resource.containerName}\`` : "-");
-                }
-                if (hasNode) {
-                    cells.push(resource.nodeName ? `\`${resource.nodeName}\`` : "-");
-                }
-                cells.push(MonitorCriteriaEvaluator.formatPlatformResourceValue({
-                    platform: "kubernetes",
-                    metricName: breakdown.metricName,
-                    value: resource.metricValue,
-                }));
-                resourceLines.push(`| ${cells.join(" | ")} |`);
-            }
-            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")}`);
+            const resourcesToShow = sortedResources.slice(0, AffectedResourceList.MAX_ENTRIES);
+            sections.push(AffectedResourceList.render({
+                heading: "Affected Resources",
+                overflowNoun: "affected resources",
+                totalCount: sortedResources.length,
+                entries: resourcesToShow.map((resource) => {
+                    return MonitorCriteriaEvaluator.getKubernetesAffectedResourceEntry({
+                        resource: resource,
+                        clusterName: breakdown.clusterName,
+                        value: MonitorCriteriaEvaluator.formatPlatformResourceValue({
+                            platform: "kubernetes",
+                            metricName: breakdown.metricName,
+                            value: resource.metricValue,
+                        }),
+                    });
+                }),
+            }));
             // Add root cause analysis based on metric type
             const analysis = MonitorCriteriaEvaluator.buildKubernetesRootCauseAnalysis({
                 breakdown: breakdown,
@@ -1771,6 +1788,75 @@ ${contextBlock}
         }
         return sections.length > 0 ? sections.join("\n") : null;
     }
+    /*
+     * What a Proxmox resource is, from the `pve.type` / `pve.scope` the
+     * agent's transform/pve-identity processor derives from its `id`
+     * (node/…, qemu/…, lxc/…, storage/…, cluster/…). A value that processor
+     * does not produce is shown as it arrived rather than guessed at.
+     */
+    static getProxmoxAffectedResourceKind(resource) {
+        switch (resource.resourceType) {
+            case "qemu":
+                return "Virtual Machine";
+            case "lxc":
+                return "Container";
+            case "node":
+                return "Node";
+            case "storage":
+                return "Storage";
+            default:
+                break;
+        }
+        switch (resource.scope) {
+            case "guest":
+                return "Guest";
+            case "node":
+                return "Node";
+            case "storage":
+                return "Storage";
+            case "cluster":
+                return "Cluster";
+            default:
+                break;
+        }
+        return resource.resourceType || resource.scope || "Resource";
+    }
+    /*
+     * One Proxmox resource as an "Affected Resources" list item: its kind,
+     * its name next to its `qemu/100`-style id, and the node it runs on.
+     */
+    static getProxmoxAffectedResourceEntry(input) {
+        const resource = input.resource;
+        let kind = MonitorCriteriaEvaluator.getProxmoxAffectedResourceKind(resource);
+        let name = AffectedResourceList.codeWithId({
+            name: resource.resourceName,
+            id: resource.resourceId,
+        });
+        if (!name && resource.nodeName) {
+            // A per-node series that carries no id of its own.
+            kind = "Node";
+            name = AffectedResourceList.code(resource.nodeName);
+        }
+        if (!name) {
+            // Nothing narrower than the cluster — a cluster-wide series.
+            kind = "Cluster";
+            name = AffectedResourceList.code(input.clusterName);
+        }
+        const details = [];
+        // A node's own row would only repeat its name as "Node: …".
+        if (resource.nodeName && kind !== "Node") {
+            details.push({
+                label: "Node",
+                value: AffectedResourceList.code(resource.nodeName),
+            });
+        }
+        return {
+            kind: kind,
+            name: name,
+            value: input.value,
+            details: details,
+        };
+    }
     static buildProxmoxRootCauseContext(input) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j;
         const metricResponse = input.dataToProcess;
@@ -1807,15 +1893,15 @@ ${contextBlock}
             }
             sections.push(`**Proxmox Cluster Details**\n${clusterDetails.join("\n")}`);
         }
-        // Affected resources (Resource / Type / Node / Value)
-        let renderedBreakdownTable = false;
+        // Affected resources: a ranked list of kind, name and node
+        let renderedBreakdownList = false;
         if (breakdown && breakdown.affectedResources.length > 0) {
             /*
              * K8s-parity render: drop zero-value rows, worst (highest)
              * first, top 10. Note that for availability metrics (pve_up)
              * zero-valued rows ARE the down resources — those still drive
              * alerting through the per-series criteria evaluation; this
-             * table is supplementary context only.
+             * list is supplementary context only.
              */
             const sortedResources = [
                 ...breakdown.affectedResources,
@@ -1827,47 +1913,35 @@ ${contextBlock}
                 return b.metricValue - a.metricValue;
             });
             /*
-             * Skip the table when no row carries any identity label
+             * Skip the list when no row carries any identity label
              * (cluster-wide series) — it would add nothing.
              */
             const hasIdentity = sortedResources.some((r) => {
                 return r.resourceId || r.resourceName || r.nodeName;
             });
             if (sortedResources.length > 0 && hasIdentity) {
-                const resourcesToShow = sortedResources.slice(0, 10);
-                const resourceLines = [];
-                resourceLines.push(`| Resource | Type | Node | Value |`);
-                resourceLines.push(`| --- | --- | --- | --- |`);
-                for (const resource of resourcesToShow) {
-                    let resourceCell = "-";
-                    if (resource.resourceName && resource.resourceId) {
-                        resourceCell = `\`${resource.resourceName}\` (\`${resource.resourceId}\`)`;
-                    }
-                    else if (resource.resourceId) {
-                        resourceCell = `\`${resource.resourceId}\``;
-                    }
-                    else if (resource.resourceName) {
-                        resourceCell = `\`${resource.resourceName}\``;
-                    }
-                    const typeCell = resource.resourceType || resource.scope || "-";
-                    const nodeCell = resource.nodeName
-                        ? `\`${resource.nodeName}\``
-                        : "-";
-                    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;
+                const resourcesToShow = sortedResources.slice(0, AffectedResourceList.MAX_ENTRIES);
+                sections.push(AffectedResourceList.render({
+                    heading: "Affected Resources",
+                    overflowNoun: "affected resources",
+                    totalCount: sortedResources.length,
+                    entries: resourcesToShow.map((resource) => {
+                        return MonitorCriteriaEvaluator.getProxmoxAffectedResourceEntry({
+                            resource: resource,
+                            clusterName: breakdown.clusterName,
+                            value: MonitorCriteriaEvaluator.formatPlatformResourceValue({
+                                platform: "proxmox",
+                                metricName: breakdown.metricName,
+                                value: resource.metricValue,
+                            }),
+                        });
+                    }),
+                }));
+                renderedBreakdownList = true;
             }
         }
-        // Metric results summary (fallback context when no table rendered)
-        if (!renderedBreakdownTable &&
+        // Metric results summary (fallback context when no list rendered)
+        if (!renderedBreakdownList &&
             metricResponse.metricResult &&
             metricResponse.metricResult.length > 0) {
             const resultDetails = [];
@@ -1886,8 +1960,8 @@ ${contextBlock}
      * 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
+     * uses, so the kind an Affected Resources item is titled with 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.
      */
@@ -1912,6 +1986,84 @@ ${contextBlock}
         }
         return undefined;
     }
+    /*
+     * One vSphere object as an "Affected Resources" list item, titled by
+     * the object itself, with the ESXi host and cluster it sits under
+     * listed beneath it.
+     */
+    static getVMwareAffectedResourceEntry(input) {
+        const resource = input.resource;
+        const kind = MonitorCriteriaEvaluator.getVMwareAffectedResourceKind(resource);
+        let name = "";
+        let showHost = false;
+        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
+                 * detail is the ESXi host the VM is running on.
+                 */
+                name = AffectedResourceList.code(resource.vmName || resource.vmId);
+                showHost = true;
+                break;
+            case "Resource Pool":
+                /*
+                 * Pool names are only unique within a parent, so the inventory
+                 * path is shown next to the name. The Host detail is the owner
+                 * host for a pool on a standalone ESXi host (pools under a
+                 * cluster show the cluster).
+                 */
+                name = AffectedResourceList.codeWithId({
+                    name: resource.resourcePoolName,
+                    id: resource.resourcePoolPath,
+                });
+                showHost = true;
+                break;
+            case "Host":
+                // The host IS the resource; a "Host:" detail would repeat it.
+                name = AffectedResourceList.code(resource.hostName);
+                break;
+            case "Datastore":
+                name = AffectedResourceList.code(resource.datastoreName);
+                break;
+            case "Cluster":
+                name = AffectedResourceList.code(resource.clusterName);
+                break;
+            case "Datacenter":
+                name = AffectedResourceList.code(resource.datacenterName);
+                break;
+            default:
+                break;
+        }
+        const details = [];
+        if (showHost && resource.hostName) {
+            details.push({
+                label: "Host",
+                value: AffectedResourceList.code(resource.hostName),
+            });
+        }
+        if (kind !== "Cluster" && resource.clusterName) {
+            details.push({
+                label: "Cluster",
+                value: AffectedResourceList.code(resource.clusterName),
+            });
+        }
+        if (!kind || !name) {
+            // No vSphere identity on the series — it describes the vCenter as a whole.
+            return {
+                kind: "vCenter",
+                name: AffectedResourceList.code(input.vcenterName),
+                value: input.value,
+                details: details,
+            };
+        }
+        return {
+            kind: kind,
+            name: name,
+            value: input.value,
+            details: details,
+        };
+    }
     static buildVMwareRootCauseContext(input) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
         const metricResponse = input.dataToProcess;
@@ -1959,17 +2111,17 @@ ${contextBlock}
             }
             sections.push(`**vCenter Details**\n${vcenterDetails.join("\n")}`);
         }
-        // Affected resources (Resource / Kind / Host / Cluster / Value)
-        let renderedBreakdownTable = false;
+        // Affected resources: a ranked list of object, host and cluster
+        let renderedBreakdownList = 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;
+             * ARE the objects with a problem, so the list 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.
+             * list is supplementary context only.
              */
             const sortedResources = [
                 ...breakdown.affectedResources,
@@ -1981,7 +2133,7 @@ ${contextBlock}
                 return b.metricValue - a.metricValue;
             });
             /*
-             * Skip the table when no row carries any identity attribute — it
+             * Skip the list 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.
@@ -1990,77 +2142,28 @@ ${contextBlock}
                 return Boolean(MonitorCriteriaEvaluator.getVMwareAffectedResourceKind(r));
             });
             if (sortedResources.length > 0 && hasIdentity) {
-                const resourcesToShow = sortedResources.slice(0, 10);
-                const resourceLines = [];
-                resourceLines.push(`| Resource | Kind | Host | Cluster | Value |`);
-                resourceLines.push(`| --- | --- | --- | --- | --- |`);
-                for (const resource of resourcesToShow) {
-                    const kind = MonitorCriteriaEvaluator.getVMwareAffectedResourceKind(resource);
-                    let resourceCell = "-";
-                    let hostCell = "-";
-                    switch (kind) {
-                        case "Virtual Machine":
-                            /*
-                             * The VM's display name, falling back to its instance
-                             * UUID (`vcenter.vm.id`) when the receiver stamped no
-                             * name. The Host column carries the ESXi host the VM is
-                             * running on.
-                             */
-                            resourceCell = resource.vmName
-                                ? `\`${resource.vmName}\``
-                                : `\`${resource.vmId}\``;
-                            hostCell = resource.hostName ? `\`${resource.hostName}\`` : "-";
-                            break;
-                        case "Resource Pool":
-                            /*
-                             * Pool names are only unique within a parent, so the
-                             * inventory path is shown next to the name. The Host
-                             * column is the owner host for a pool on a standalone
-                             * ESXi host (pools under a cluster show the cluster).
-                             */
-                            if (resource.resourcePoolName && resource.resourcePoolPath) {
-                                resourceCell = `\`${resource.resourcePoolName}\` (\`${resource.resourcePoolPath}\`)`;
-                            }
-                            else {
-                                resourceCell = `\`${resource.resourcePoolPath || resource.resourcePoolName}\``;
-                            }
-                            hostCell = resource.hostName ? `\`${resource.hostName}\`` : "-";
-                            break;
-                        case "Host":
-                            // The host IS the resource; repeating it in the Host column adds nothing.
-                            resourceCell = `\`${resource.hostName}\``;
-                            break;
-                        case "Datastore":
-                            resourceCell = `\`${resource.datastoreName}\``;
-                            break;
-                        case "Cluster":
-                            resourceCell = `\`${resource.clusterName}\``;
-                            break;
-                        case "Datacenter":
-                            resourceCell = `\`${resource.datacenterName}\``;
-                            break;
-                        default:
-                            break;
-                    }
-                    const kindCell = kind || "-";
-                    const clusterCell = kind !== "Cluster" && resource.clusterName
-                        ? `\`${resource.clusterName}\``
-                        : "-";
-                    resourceLines.push(`| ${resourceCell} | ${kindCell} | ${hostCell} | ${clusterCell} | ${MonitorCriteriaEvaluator.formatPlatformResourceValue({
-                        platform: "vmware",
-                        metricName: breakdown.metricName,
-                        value: resource.metricValue,
-                    })} |`);
-                }
-                if (sortedResources.length > 10) {
-                    resourceLines.push(`\n*... and ${sortedResources.length - 10} more affected resources*`);
-                }
-                sections.push(`\n\n**Affected Resources** (${sortedResources.length} total)\n\n${resourceLines.join("\n")}`);
-                renderedBreakdownTable = true;
+                const resourcesToShow = sortedResources.slice(0, AffectedResourceList.MAX_ENTRIES);
+                sections.push(AffectedResourceList.render({
+                    heading: "Affected Resources",
+                    overflowNoun: "affected resources",
+                    totalCount: sortedResources.length,
+                    entries: resourcesToShow.map((resource) => {
+                        return MonitorCriteriaEvaluator.getVMwareAffectedResourceEntry({
+                            resource: resource,
+                            vcenterName: breakdown.vcenterName,
+                            value: MonitorCriteriaEvaluator.formatPlatformResourceValue({
+                                platform: "vmware",
+                                metricName: breakdown.metricName,
+                                value: resource.metricValue,
+                            }),
+                        });
+                    }),
+                }));
+                renderedBreakdownList = true;
             }
         }
-        // Metric results summary (fallback context when no table rendered)
-        if (!renderedBreakdownTable &&
+        // Metric results summary (fallback context when no list rendered)
+        if (!renderedBreakdownList &&
             metricResponse.metricResult &&
             metricResponse.metricResult.length > 0) {
             const resultDetails = [];
@@ -2075,6 +2178,46 @@ ${contextBlock}
         }
         return sections.length > 0 ? sections.join("\n") : null;
     }
+    /*
+     * One Docker Swarm task as an "Affected Tasks" list item, with the
+     * service it belongs to and the node it is scheduled on beneath it.
+     */
+    static getDockerSwarmAffectedResourceEntry(input) {
+        const resource = input.resource;
+        let kind = "Cluster";
+        let name = AffectedResourceList.code(input.clusterName);
+        if (resource.containerName) {
+            kind = "Task";
+            name = AffectedResourceList.code(resource.containerName);
+        }
+        else if (resource.serviceName) {
+            kind = "Service";
+            name = AffectedResourceList.code(resource.serviceName);
+        }
+        else if (resource.nodeName) {
+            kind = "Node";
+            name = AffectedResourceList.code(resource.nodeName);
+        }
+        const details = [];
+        if (resource.serviceName && kind !== "Service") {
+            details.push({
+                label: "Service",
+                value: AffectedResourceList.code(resource.serviceName),
+            });
+        }
+        if (resource.nodeName && kind !== "Node") {
+            details.push({
+                label: "Node",
+                value: AffectedResourceList.code(resource.nodeName),
+            });
+        }
+        return {
+            kind: kind,
+            name: name,
+            value: input.value,
+            details: details,
+        };
+    }
     static buildDockerSwarmRootCauseContext(input) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j;
         const metricResponse = input.dataToProcess;
@@ -2111,14 +2254,14 @@ ${contextBlock}
             }
             sections.push(`**Docker Swarm Cluster Details**\n${clusterDetails.join("\n")}`);
         }
-        // Affected resources (Task / Service / Node / Value)
-        let renderedBreakdownTable = false;
+        // Affected tasks: a ranked list of task, service and node
+        let renderedBreakdownList = false;
         if (breakdown && breakdown.affectedResources.length > 0) {
             /*
              * K8s/Proxmox-parity render: drop zero-value rows, worst (highest)
              * first, top 10. For the task-down template the breaching rows ARE
              * the zero-uptime ones — those still drive alerting through the
-             * per-series criteria evaluation; this table is supplementary
+             * per-series criteria evaluation; this list is supplementary
              * context only.
              */
             const sortedResources = [
@@ -2131,42 +2274,35 @@ ${contextBlock}
                 return b.metricValue - a.metricValue;
             });
             /*
-             * Skip the table when no row carries any identity label
+             * Skip the list when no row carries any identity label
              * (cluster-wide series) — it would add nothing.
              */
             const hasIdentity = sortedResources.some((r) => {
                 return r.containerName || r.serviceName || r.nodeName;
             });
             if (sortedResources.length > 0 && hasIdentity) {
-                const resourcesToShow = sortedResources.slice(0, 10);
-                const resourceLines = [];
-                resourceLines.push(`| Task / Container | Service | Node | Value |`);
-                resourceLines.push(`| --- | --- | --- | --- |`);
-                for (const resource of resourcesToShow) {
-                    const taskCell = resource.containerName
-                        ? `\`${resource.containerName}\``
-                        : "-";
-                    const serviceCell = resource.serviceName
-                        ? `\`${resource.serviceName}\``
-                        : "-";
-                    const nodeCell = resource.nodeName
-                        ? `\`${resource.nodeName}\``
-                        : "-";
-                    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*`);
-                }
-                sections.push(`\n\n**Affected Tasks** (${sortedResources.length} total)\n\n${resourceLines.join("\n")}`);
-                renderedBreakdownTable = true;
+                const resourcesToShow = sortedResources.slice(0, AffectedResourceList.MAX_ENTRIES);
+                sections.push(AffectedResourceList.render({
+                    heading: "Affected Tasks",
+                    overflowNoun: "affected tasks",
+                    totalCount: sortedResources.length,
+                    entries: resourcesToShow.map((resource) => {
+                        return MonitorCriteriaEvaluator.getDockerSwarmAffectedResourceEntry({
+                            resource: resource,
+                            clusterName: breakdown.clusterName,
+                            value: MonitorCriteriaEvaluator.formatPlatformResourceValue({
+                                platform: "dockerSwarm",
+                                metricName: breakdown.metricName,
+                                value: resource.metricValue,
+                            }),
+                        });
+                    }),
+                }));
+                renderedBreakdownList = true;
             }
         }
-        // Metric results summary (fallback context when no table rendered)
-        if (!renderedBreakdownTable &&
+        // Metric results summary (fallback context when no list rendered)
+        if (!renderedBreakdownList &&
             metricResponse.metricResult &&
             metricResponse.metricResult.length > 0) {
             const resultDetails = [];
@@ -2182,21 +2318,21 @@ ${contextBlock}
         return sections.length > 0 ? sections.join("\n") : null;
     }
     /*
-     * Which rows of the Ceph affected-resources table actually BREACHED.
+     * Which rows of the Ceph affected-resources list 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
+     * daemons. Dropping them rendered a list 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.
+     * existing `> 0`, worst-highest-first list byte for byte.
      */
     static getCephBreachPredicate(criteriaInstance) {
         var _a;
@@ -2232,6 +2368,71 @@ ${contextBlock}
             worstIsLowest: true,
         };
     }
+    /*
+     * One Ceph daemon or pool as an "Affected Resources" list item, with
+     * the pool and host it belongs to beneath it.
+     */
+    static getCephAffectedResourceEntry(input) {
+        const resource = input.resource;
+        /*
+         * The worker stores every series' `name` label as poolName, but only
+         * ceph_pool_metadata's `name` is a pool — and that series always
+         * carries pool_id too. On ceph_health_detail, `name` is the health
+         * check (RECENT_CRASH, OSD_NEARFULL, ...), and titling it "Pool" told
+         * the reader a pool called OSD_NEARFULL was the problem. So a name is
+         * treated as a pool only when it arrives with a pool id.
+         */
+        const pool = resource.poolId
+            ? AffectedResourceList.codeWithId({
+                name: resource.poolName,
+                id: resource.poolId,
+            })
+            : "";
+        const otherName = resource.poolId
+            ? ""
+            : AffectedResourceList.code(resource.poolName);
+        const otherNameKind = input.metricName === "ceph_health_detail" ? "Health Check" : "Resource";
+        let kind = "Cluster";
+        let name = AffectedResourceList.code(input.clusterName);
+        if (resource.daemon) {
+            kind = "Daemon";
+            name = AffectedResourceList.code(resource.daemon);
+        }
+        else if (pool) {
+            kind = "Pool";
+            name = pool;
+        }
+        else if (otherName) {
+            kind = otherNameKind;
+            name = otherName;
+        }
+        else if (resource.hostname) {
+            kind = "Host";
+            name = AffectedResourceList.code(resource.hostname);
+        }
+        const details = [];
+        if (pool && name !== pool) {
+            details.push({ label: "Pool", value: pool });
+        }
+        if (otherName && name !== otherName) {
+            details.push({
+                label: otherNameKind === "Resource" ? "Name" : otherNameKind,
+                value: otherName,
+            });
+        }
+        if (resource.hostname && kind !== "Host") {
+            details.push({
+                label: "Host",
+                value: AffectedResourceList.code(resource.hostname),
+            });
+        }
+        return {
+            kind: kind,
+            name: name,
+            value: input.value,
+            details: details,
+        };
+    }
     static buildCephRootCauseContext(input) {
         var _a, _b, _c, _d, _e, _f, _g;
         const metricResponse = input.dataToProcess;
@@ -2262,8 +2463,8 @@ ${contextBlock}
             }
             sections.push(`**Ceph Cluster Details**\n${clusterDetails.join("\n")}`);
         }
-        // Affected resources (Daemon / Pool / Host / Value)
-        let renderedBreakdownTable = false;
+        // Affected resources: a ranked list of daemon, pool and host
+        let renderedBreakdownList = false;
         if (breakdown && breakdown.affectedResources.length > 0) {
             /*
              * Keep the rows that satisfy the criteria that just matched, worst
@@ -2284,7 +2485,7 @@ ${contextBlock}
                     : b.metricValue - a.metricValue;
             });
             /*
-             * Skip the table when no row carries any identity label
+             * Skip the list when no row carries any identity label
              * (cluster-wide series like ceph_health_status) — it would add
              * nothing.
              */
@@ -2292,42 +2493,29 @@ ${contextBlock}
                 return r.daemon || r.poolId || r.poolName || r.hostname;
             });
             if (sortedResources.length > 0 && hasIdentity) {
-                const resourcesToShow = sortedResources.slice(0, 10);
-                const resourceLines = [];
-                resourceLines.push(`| Daemon | Pool | Host | Value |`);
-                resourceLines.push(`| --- | --- | --- | --- |`);
-                for (const resource of resourcesToShow) {
-                    const daemonCell = resource.daemon
-                        ? `\`${resource.daemon}\``
-                        : "-";
-                    let poolCell = "-";
-                    if (resource.poolName && resource.poolId) {
-                        poolCell = `\`${resource.poolName}\` (\`${resource.poolId}\`)`;
-                    }
-                    else if (resource.poolName) {
-                        poolCell = `\`${resource.poolName}\``;
-                    }
-                    else if (resource.poolId) {
-                        poolCell = `\`${resource.poolId}\``;
-                    }
-                    const hostCell = resource.hostname
-                        ? `\`${resource.hostname}\``
-                        : "-";
-                    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*`);
-                }
-                sections.push(`\n\n**Affected Resources** (${sortedResources.length} total)\n\n${resourceLines.join("\n")}`);
-                renderedBreakdownTable = true;
+                const resourcesToShow = sortedResources.slice(0, AffectedResourceList.MAX_ENTRIES);
+                sections.push(AffectedResourceList.render({
+                    heading: "Affected Resources",
+                    overflowNoun: "affected resources",
+                    totalCount: sortedResources.length,
+                    entries: resourcesToShow.map((resource) => {
+                        return MonitorCriteriaEvaluator.getCephAffectedResourceEntry({
+                            resource: resource,
+                            clusterName: breakdown.clusterName,
+                            metricName: breakdown.metricName,
+                            value: MonitorCriteriaEvaluator.formatPlatformResourceValue({
+                                platform: "ceph",
+                                metricName: breakdown.metricName,
+                                value: resource.metricValue,
+                            }),
+                        });
+                    }),
+                }));
+                renderedBreakdownList = true;
             }
         }
-        // Metric results summary (fallback context when no table rendered)
-        if (!renderedBreakdownTable &&
+        // Metric results summary (fallback context when no list rendered)
+        if (!renderedBreakdownList &&
             metricResponse.metricResult &&
             metricResponse.metricResult.length > 0) {
             const resultDetails = [];