@oneuptime/common 11.0.2 → 11.0.4

package/Server/Types/Database/Permissions/OwnerTableRegistry.ts

@@ -18,6 +18,8 @@ import HostOwnerTeamService from "../../../Services/HostOwnerTeamService";
 import HostOwnerUserService from "../../../Services/HostOwnerUserService";
 import DockerHostOwnerTeamService from "../../../Services/DockerHostOwnerTeamService";
 import DockerHostOwnerUserService from "../../../Services/DockerHostOwnerUserService";
+import PodmanHostOwnerTeamService from "../../../Services/PodmanHostOwnerTeamService";
+import PodmanHostOwnerUserService from "../../../Services/PodmanHostOwnerUserService";
 import KubernetesClusterOwnerTeamService from "../../../Services/KubernetesClusterOwnerTeamService";
 import KubernetesClusterOwnerUserService from "../../../Services/KubernetesClusterOwnerUserService";
 import ServerlessFunctionOwnerTeamService from "../../../Services/ServerlessFunctionOwnerTeamService";
@@ -40,6 +42,7 @@ import ServiceService from "../../../Services/ServiceService";
 import MonitorService from "../../../Services/MonitorService";
 import HostService from "../../../Services/HostService";
 import DockerHostService from "../../../Services/DockerHostService";
+import PodmanHostService from "../../../Services/PodmanHostService";
 import KubernetesClusterService from "../../../Services/KubernetesClusterService";
 import ServerlessFunctionService from "../../../Services/ServerlessFunctionService";
 import CloudResourceService from "../../../Services/CloudResourceService";
@@ -180,6 +183,16 @@ const ownerTableRegistry: Map<string, OwnerTablePair> = new Map<
       modelService: DockerHostService,
     },
   ],
+  [
+    "PodmanHost",
+    {
+      ownerUserService: PodmanHostOwnerUserService,
+      ownerTeamService: PodmanHostOwnerTeamService,
+      fkColumn: "podmanHostId",
+      canOwnTelemetry: true,
+      modelService: PodmanHostService,
+    },
+  ],
   [
     "KubernetesCluster",
     {

package/Server/Utils/Cookie.ts

@@ -8,6 +8,7 @@ import StatusPagePrivateUser from "../../Models/DatabaseModels/StatusPagePrivate
 import OneUptimeDate from "../../Types/Date";
 import PositiveNumber from "../../Types/PositiveNumber";
 import CookieName from "../../Types/CookieName";
+import SsoProviderType from "../../Types/SSO/SsoProviderType";
 import {
   MASTER_PASSWORD_COOKIE_IDENTIFIER,
   MASTER_PASSWORD_COOKIE_MAX_AGE_IN_DAYS,
@@ -38,15 +39,24 @@ export default class CookieUtil {
     return cookies;
   }
 
+  /*
+   * Builds a per-project SSO token. The optional `ssoProviderId` /
+   * `ssoProviderType` discriminator records WHICH identity provider issued the
+   * token, so a project that enforces SSO can require a specific provider
+   * (e.g. its own Project SSO, or an instance-wide Global SSO). Used by both
+   * the cookie flow (web) and the deep-link flow (mobile) so the token shape
+   * stays identical.
+   */
   @CaptureSpan()
-  public static setSSOCookie(data: {
+  public static getSSOToken(data: {
     user: User;
     projectId: ObjectID;
-    expressResponse: ExpressResponse;
-  }): void {
-    const { user, projectId, expressResponse: res } = data;
+    ssoProviderId?: ObjectID | undefined;
+    ssoProviderType?: SsoProviderType | undefined;
+  }): string {
+    const { user, projectId } = data;
 
-    const ssoToken: string = JSONWebToken.sign({
+    return JSONWebToken.sign({
       data: {
         userId: user.id!,
         projectId: projectId,
@@ -54,9 +64,33 @@ export default class CookieUtil {
         email: user.email,
         isMasterAdmin: false,
         isGeneralLogin: false,
+        ssoProviderId: data.ssoProviderId
+          ? data.ssoProviderId.toString()
+          : undefined,
+        ssoProviderType: data.ssoProviderType
+          ? data.ssoProviderType.toString()
+          : undefined,
       },
       expiresInSeconds: OneUptimeDate.getSecondsInDays(new PositiveNumber(30)),
     });
+  }
+
+  @CaptureSpan()
+  public static setSSOCookie(data: {
+    user: User;
+    projectId: ObjectID;
+    expressResponse: ExpressResponse;
+    ssoProviderId?: ObjectID | undefined;
+    ssoProviderType?: SsoProviderType | undefined;
+  }): void {
+    const { projectId, expressResponse: res } = data;
+
+    const ssoToken: string = CookieUtil.getSSOToken({
+      user: data.user,
+      projectId: projectId,
+      ssoProviderId: data.ssoProviderId,
+      ssoProviderType: data.ssoProviderType,
+    });
 
     CookieUtil.setCookie(res, CookieUtil.getUserSSOKey(projectId), ssoToken, {
       maxAge: OneUptimeDate.getMillisecondsInDays(new PositiveNumber(30)),

package/Server/Utils/JsonWebToken.ts

@@ -6,6 +6,7 @@ import JSONFunctions from "../../Types/JSONFunctions";
 import JSONWebTokenData from "../../Types/JsonWebTokenData";
 import Name from "../../Types/Name";
 import ObjectID from "../../Types/ObjectID";
+import SsoProviderType from "../../Types/SSO/SsoProviderType";
 import Timezone from "../../Types/Timezone";
 import StatusPagePrivateUser from "../../Models/DatabaseModels/StatusPagePrivateUser";
 import User from "../../Models/DatabaseModels/User";
@@ -139,6 +140,12 @@ class JSONWebToken {
         sessionId: decoded["sessionId"]
           ? new ObjectID(decoded["sessionId"] as string)
           : undefined,
+        ssoProviderId: decoded["ssoProviderId"]
+          ? new ObjectID(decoded["ssoProviderId"] as string)
+          : undefined,
+        ssoProviderType: decoded["ssoProviderType"]
+          ? (decoded["ssoProviderType"] as SsoProviderType)
+          : undefined,
       };
     } catch (e) {
       logger.error(e);

package/Server/Utils/Monitor/MonitorAlert.ts

@@ -2,6 +2,7 @@ import Alert from "../../../Models/DatabaseModels/Alert";
 import AlertSeverity from "../../../Models/DatabaseModels/AlertSeverity";
 import AlertStateTimeline from "../../../Models/DatabaseModels/AlertStateTimeline";
 import CephCluster from "../../../Models/DatabaseModels/CephCluster";
+import DockerSwarmCluster from "../../../Models/DatabaseModels/DockerSwarmCluster";
 import Host from "../../../Models/DatabaseModels/Host";
 import Label from "../../../Models/DatabaseModels/Label";
 import Monitor from "../../../Models/DatabaseModels/Monitor";
@@ -420,6 +421,15 @@ export default class MonitorAlert {
             },
           );
         }
+        if (clusterContext.dockerSwarmClusterIds.length > 0) {
+          alert.dockerSwarmClusters = clusterContext.dockerSwarmClusterIds.map(
+            (id: string): DockerSwarmCluster => {
+              const cluster: DockerSwarmCluster = new DockerSwarmCluster();
+              cluster._id = id;
+              return cluster;
+            },
+          );
+        }
 
         alert.onCallDutyPolicies =
           criteriaAlert.onCallPolicyIds?.map((id: ObjectID) => {

package/Server/Utils/Monitor/MonitorClusterContext.ts

@@ -1,9 +1,11 @@
 import CephCluster from "../../../Models/DatabaseModels/CephCluster";
+import DockerSwarmCluster from "../../../Models/DatabaseModels/DockerSwarmCluster";
 import Monitor from "../../../Models/DatabaseModels/Monitor";
 import ProxmoxCluster from "../../../Models/DatabaseModels/ProxmoxCluster";
 import MonitorStep from "../../../Types/Monitor/MonitorStep";
 import MonitorType from "../../../Types/Monitor/MonitorType";
 import CephClusterService from "../../Services/CephClusterService";
+import DockerSwarmClusterService from "../../Services/DockerSwarmClusterService";
 import ProxmoxClusterService from "../../Services/ProxmoxClusterService";
 import QueryHelper from "../../Types/Database/QueryHelper";
 import logger from "../Logger";
@@ -23,6 +25,7 @@ import logger from "../Logger";
 export interface MonitorClusterContext {
   proxmoxClusterIds: Array<string>;
   cephClusterIds: Array<string>;
+  dockerSwarmClusterIds: Array<string>;
 }
 
 export default class MonitorClusterContextUtil {
@@ -42,13 +45,15 @@ export default class MonitorClusterContextUtil {
     const context: MonitorClusterContext = {
       proxmoxClusterIds: [],
       cephClusterIds: [],
+      dockerSwarmClusterIds: [],
     };
 
     const monitorType: MonitorType | undefined = input.monitor.monitorType;
 
     if (
       monitorType !== MonitorType.Proxmox &&
-      monitorType !== MonitorType.Ceph
+      monitorType !== MonitorType.Ceph &&
+      monitorType !== MonitorType.DockerSwarm
     ) {
       return context;
     }
@@ -63,10 +68,16 @@ export default class MonitorClusterContextUtil {
     const clusterIdentifiers: Set<string> = new Set<string>();
 
     for (const monitorStep of monitorSteps) {
-      const clusterIdentifier: string | undefined =
-        monitorType === MonitorType.Proxmox
-          ? monitorStep.data?.proxmoxMonitor?.clusterIdentifier
-          : monitorStep.data?.cephMonitor?.clusterIdentifier;
+      let clusterIdentifier: string | undefined = undefined;
+
+      if (monitorType === MonitorType.Proxmox) {
+        clusterIdentifier = monitorStep.data?.proxmoxMonitor?.clusterIdentifier;
+      } else if (monitorType === MonitorType.Ceph) {
+        clusterIdentifier = monitorStep.data?.cephMonitor?.clusterIdentifier;
+      } else if (monitorType === MonitorType.DockerSwarm) {
+        clusterIdentifier =
+          monitorStep.data?.dockerSwarmMonitor?.clusterIdentifier;
+      }
 
       if (clusterIdentifier && clusterIdentifier.trim().length > 0) {
         clusterIdentifiers.add(clusterIdentifier.trim());
@@ -98,7 +109,7 @@ export default class MonitorClusterContextUtil {
           if (proxmoxCluster?._id) {
             context.proxmoxClusterIds.push(String(proxmoxCluster._id));
           }
-        } else {
+        } else if (monitorType === MonitorType.Ceph) {
           const cephCluster: CephCluster | null =
             await CephClusterService.findOneBy({
               query: {
@@ -116,6 +127,24 @@ export default class MonitorClusterContextUtil {
           if (cephCluster?._id) {
             context.cephClusterIds.push(String(cephCluster._id));
           }
+        } else {
+          const dockerSwarmCluster: DockerSwarmCluster | null =
+            await DockerSwarmClusterService.findOneBy({
+              query: {
+                projectId: input.monitor.projectId,
+                name: QueryHelper.findWithSameText(clusterIdentifier),
+              },
+              select: {
+                _id: true,
+              },
+              props: {
+                isRoot: true,
+              },
+            });
+
+          if (dockerSwarmCluster?._id) {
+            context.dockerSwarmClusterIds.push(String(dockerSwarmCluster._id));
+          }
         }
       } catch (err) {
         logger.error(

package/Server/Utils/Monitor/MonitorCriteriaEvaluator.ts

@@ -58,6 +58,8 @@ import MetricMonitorResponse, {
   ProxmoxResourceBreakdown,
   CephAffectedResource,
   CephResourceBreakdown,
+  DockerSwarmAffectedResource,
+  DockerSwarmResourceBreakdown,
 } from "../../../Types/Monitor/MetricMonitor/MetricMonitorResponse";
 import MetricSeriesResult from "../../../Types/Monitor/MetricMonitor/MetricSeriesResult";
 import MetricCriteriaContext, {
@@ -66,8 +68,11 @@ import MetricCriteriaContext, {
   MetricComponentValue,
 } from "../../../Types/Monitor/MetricMonitor/MetricCriteriaContext";
 import MonitorStepDockerMonitor from "../../../Types/Monitor/MonitorStepDockerMonitor";
+import MonitorStepHostMonitor from "../../../Types/Monitor/MonitorStepHostMonitor";
+import MonitorStepPodmanMonitor from "../../../Types/Monitor/MonitorStepPodmanMonitor";
 import MonitorStepProxmoxMonitor from "../../../Types/Monitor/MonitorStepProxmoxMonitor";
 import MonitorStepCephMonitor from "../../../Types/Monitor/MonitorStepCephMonitor";
+import MonitorStepDockerSwarmMonitor from "../../../Types/Monitor/MonitorStepDockerSwarmMonitor";
 
 export default class MonitorCriteriaEvaluator {
   public static async processMonitorStep(input: {
@@ -237,6 +242,9 @@ ${contextBlock}
       input.monitor.monitorType !== MonitorType.Metrics &&
       input.monitor.monitorType !== MonitorType.Kubernetes &&
       input.monitor.monitorType !== MonitorType.Docker &&
+      input.monitor.monitorType !== MonitorType.Host &&
+      input.monitor.monitorType !== MonitorType.Podman &&
+      input.monitor.monitorType !== MonitorType.DockerSwarm &&
       input.monitor.monitorType !== MonitorType.Proxmox &&
       input.monitor.monitorType !== MonitorType.Ceph
     ) {
@@ -685,6 +693,9 @@ ${contextBlock}
       input.monitor.monitorType === MonitorType.Metrics ||
       input.monitor.monitorType === MonitorType.Kubernetes ||
       input.monitor.monitorType === MonitorType.Docker ||
+      input.monitor.monitorType === MonitorType.Host ||
+      input.monitor.monitorType === MonitorType.Podman ||
+      input.monitor.monitorType === MonitorType.DockerSwarm ||
       input.monitor.monitorType === MonitorType.Proxmox ||
       input.monitor.monitorType === MonitorType.Ceph
     ) {
@@ -819,11 +830,26 @@ ${contextBlock}
       return MonitorCriteriaEvaluator.buildDockerRootCauseContext(input);
     }
 
+    // Handle Host monitors with resource context
+    if (input.monitor.monitorType === MonitorType.Host) {
+      return MonitorCriteriaEvaluator.buildHostRootCauseContext(input);
+    }
+
+    // Handle Podman monitors with resource context
+    if (input.monitor.monitorType === MonitorType.Podman) {
+      return MonitorCriteriaEvaluator.buildPodmanRootCauseContext(input);
+    }
+
     // Handle Proxmox monitors with resource context
     if (input.monitor.monitorType === MonitorType.Proxmox) {
       return MonitorCriteriaEvaluator.buildProxmoxRootCauseContext(input);
     }
 
+    // Handle Docker Swarm monitors with resource context
+    if (input.monitor.monitorType === MonitorType.DockerSwarm) {
+      return MonitorCriteriaEvaluator.buildDockerSwarmRootCauseContext(input);
+    }
+
     // Handle Ceph monitors with resource context
     if (input.monitor.monitorType === MonitorType.Ceph) {
       return MonitorCriteriaEvaluator.buildCephRootCauseContext(input);
@@ -1593,6 +1619,124 @@ ${contextBlock}
     return sections.length > 0 ? sections.join("\n") : null;
   }
 
+  private static buildHostRootCauseContext(input: {
+    dataToProcess: DataToProcess;
+    monitorStep: MonitorStep;
+    monitor: Monitor;
+  }): string | null {
+    const metricResponse: MetricMonitorResponse =
+      input.dataToProcess as MetricMonitorResponse;
+
+    const sections: Array<string> = [];
+
+    // Host context
+    const hostMonitor: MonitorStepHostMonitor | undefined =
+      input.monitorStep.data?.hostMonitor;
+
+    if (hostMonitor) {
+      const hostDetails: Array<string> = [];
+      hostDetails.push(`- Host: ${hostMonitor.hostIdentifier || "Unknown"}`);
+
+      // Add metric name from the query config
+      if (
+        hostMonitor.metricViewConfig?.queryConfigs?.length > 0 &&
+        hostMonitor.metricViewConfig.queryConfigs[0]
+      ) {
+        const metricName: string = hostMonitor.metricViewConfig.queryConfigs[0]
+          .metricQueryData?.filterData?.metricName as string;
+        if (metricName) {
+          hostDetails.push(`- Metric: \`${metricName}\``);
+        }
+      }
+
+      sections.push(`**Host Details**\n${hostDetails.join("\n")}`);
+    }
+
+    // Metric results summary
+    if (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;
+  }
+
+  private static buildPodmanRootCauseContext(input: {
+    dataToProcess: DataToProcess;
+    monitorStep: MonitorStep;
+    monitor: Monitor;
+  }): string | null {
+    const metricResponse: MetricMonitorResponse =
+      input.dataToProcess as MetricMonitorResponse;
+
+    const sections: Array<string> = [];
+
+    // Podman host context
+    const podmanMonitor: MonitorStepPodmanMonitor | undefined =
+      input.monitorStep.data?.podmanMonitor;
+
+    if (podmanMonitor) {
+      const hostDetails: Array<string> = [];
+      hostDetails.push(`- Host: ${podmanMonitor.hostIdentifier || "Unknown"}`);
+
+      if (podmanMonitor.containerFilters?.containerName) {
+        hostDetails.push(
+          `- Container Name Filter: ${podmanMonitor.containerFilters.containerName}`,
+        );
+      }
+
+      if (podmanMonitor.containerFilters?.containerImage) {
+        hostDetails.push(
+          `- Container Image Filter: ${podmanMonitor.containerFilters.containerImage}`,
+        );
+      }
+
+      // Add metric name from the query config
+      if (
+        podmanMonitor.metricViewConfig?.queryConfigs?.length > 0 &&
+        podmanMonitor.metricViewConfig.queryConfigs[0]
+      ) {
+        const metricName: string = podmanMonitor.metricViewConfig
+          .queryConfigs[0].metricQueryData?.filterData?.metricName as string;
+        if (metricName) {
+          hostDetails.push(`- Metric: \`${metricName}\``);
+        }
+      }
+
+      sections.push(`**Podman Host Details**\n${hostDetails.join("\n")}`);
+    }
+
+    // Metric results summary
+    if (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;
+  }
+
   private static buildProxmoxRootCauseContext(input: {
     dataToProcess: DataToProcess;
     monitorStep: MonitorStep;
@@ -1758,6 +1902,168 @@ ${contextBlock}
     return sections.length > 0 ? sections.join("\n") : null;
   }
 
+  private static buildDockerSwarmRootCauseContext(input: {
+    dataToProcess: DataToProcess;
+    monitorStep: MonitorStep;
+    monitor: Monitor;
+  }): string | null {
+    const metricResponse: MetricMonitorResponse =
+      input.dataToProcess as MetricMonitorResponse;
+
+    const breakdown: DockerSwarmResourceBreakdown | undefined =
+      metricResponse.dockerSwarmResourceBreakdown;
+
+    const sections: Array<string> = [];
+
+    // Docker Swarm cluster context
+    const dockerSwarmMonitor: MonitorStepDockerSwarmMonitor | undefined =
+      input.monitorStep.data?.dockerSwarmMonitor;
+
+    if (dockerSwarmMonitor || breakdown) {
+      const clusterDetails: Array<string> = [];
+      clusterDetails.push(
+        `- Cluster: ${breakdown?.clusterName || dockerSwarmMonitor?.clusterIdentifier || "Unknown"}`,
+      );
+
+      if (breakdown) {
+        clusterDetails.push(
+          `- Metric: ${breakdown.metricFriendlyName} (\`${breakdown.metricName}\`)`,
+        );
+      } else if (
+        dockerSwarmMonitor &&
+        dockerSwarmMonitor.metricViewConfig?.queryConfigs?.length > 0 &&
+        dockerSwarmMonitor.metricViewConfig.queryConfigs[0]
+      ) {
+        const metricName: string = dockerSwarmMonitor.metricViewConfig
+          .queryConfigs[0].metricQueryData?.filterData?.metricName as string;
+        if (metricName) {
+          clusterDetails.push(`- Metric: \`${metricName}\``);
+        }
+      }
+
+      if (dockerSwarmMonitor?.resourceFilters?.serviceName) {
+        clusterDetails.push(
+          `- Service Filter: ${dockerSwarmMonitor.resourceFilters.serviceName}`,
+        );
+      }
+
+      if (dockerSwarmMonitor?.resourceFilters?.nodeName) {
+        clusterDetails.push(
+          `- Node Filter: ${dockerSwarmMonitor.resourceFilters.nodeName}`,
+        );
+      }
+
+      if (dockerSwarmMonitor?.resourceFilters?.containerName) {
+        clusterDetails.push(
+          `- Container Name Filter: ${dockerSwarmMonitor.resourceFilters.containerName}`,
+        );
+      }
+
+      if (dockerSwarmMonitor?.resourceFilters?.containerImage) {
+        clusterDetails.push(
+          `- Container Image Filter: ${dockerSwarmMonitor.resourceFilters.containerImage}`,
+        );
+      }
+
+      sections.push(
+        `**Docker Swarm Cluster Details**\n${clusterDetails.join("\n")}`,
+      );
+    }
+
+    // Affected resources (Task / Service / Node / 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 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
+       * context only.
+       */
+      const sortedResources: Array<DockerSwarmAffectedResource> = [
+        ...breakdown.affectedResources,
+      ]
+        .filter((r: DockerSwarmAffectedResource) => {
+          return r.metricValue > 0;
+        })
+        .sort(
+          (a: DockerSwarmAffectedResource, b: DockerSwarmAffectedResource) => {
+            return b.metricValue - a.metricValue;
+          },
+        );
+
+      /*
+       * Skip the table when no row carries any identity label
+       * (cluster-wide series) — it would add nothing.
+       */
+      const hasIdentity: boolean = sortedResources.some(
+        (r: DockerSwarmAffectedResource) => {
+          return r.containerName || r.serviceName || r.nodeName;
+        },
+      );
+
+      if (sortedResources.length > 0 && hasIdentity) {
+        const resourcesToShow: Array<DockerSwarmAffectedResource> =
+          sortedResources.slice(0, 10);
+
+        const resourceLines: Array<string> = [];
+        resourceLines.push(`| Task / Container | Service | Node | Value |`);
+        resourceLines.push(`| --- | --- | --- | --- |`);
+
+        for (const resource of resourcesToShow) {
+          const taskCell: string = resource.containerName
+            ? `\`${resource.containerName}\``
+            : "-";
+          const serviceCell: string = resource.serviceName
+            ? `\`${resource.serviceName}\``
+            : "-";
+          const nodeCell: string = resource.nodeName
+            ? `\`${resource.nodeName}\``
+            : "-";
+
+          resourceLines.push(
+            `| ${taskCell} | ${serviceCell} | ${nodeCell} | **${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;
+      }
+    }
+
+    // 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;
+  }
+
   private static buildCephRootCauseContext(input: {
     dataToProcess: DataToProcess;
     monitorStep: MonitorStep;