@oneuptime/common 10.0.39 → 10.0.41

package/Server/Services/TelemetryUsageBillingService.ts

@@ -16,6 +16,8 @@ import SpanService from "./SpanService";
 import LogService from "./LogService";
 import MetricService from "./MetricService";
 import ExceptionInstanceService from "./ExceptionInstanceService";
+import ProfileService from "./ProfileService";
+import ProfileSampleService from "./ProfileSampleService";
 import AnalyticsQueryHelper from "../Types/AnalyticsDatabase/QueryHelper";
 import DiskSize from "../../Types/DiskSize";
 import logger from "../Utils/Logger";
@@ -26,6 +28,8 @@ import {
   AverageLogRowSizeInBytes,
   AverageMetricRowSizeInBytes,
   AverageExceptionRowSizeInBytes,
+  AverageProfileRowSizeInBytes,
+  AverageProfileSampleRowSizeInBytes,
   IsBillingEnabled,
 } from "../EnvironmentConfig";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
@@ -81,7 +85,14 @@ export class Service extends DatabaseService<Model> {
     const averageExceptionRowSizeInBytes: number =
       this.getAverageExceptionRowSize();
 
-    if (data.productType !== ProductType.Traces && averageRowSizeInBytes <= 0) {
+    const averageProfileSampleRowSizeInBytes: number =
+      this.getAverageProfileSampleRowSize();
+
+    if (
+      data.productType !== ProductType.Traces &&
+      data.productType !== ProductType.Profiles &&
+      averageRowSizeInBytes <= 0
+    ) {
       return;
     }
 
@@ -93,6 +104,14 @@ export class Service extends DatabaseService<Model> {
       return;
     }
 
+    if (
+      data.productType === ProductType.Profiles &&
+      averageRowSizeInBytes <= 0 &&
+      averageProfileSampleRowSizeInBytes <= 0
+    ) {
+      return;
+    }
+
     const usageDayString: string = OneUptimeDate.getDateString(usageDate);
     const startOfDay: Date = OneUptimeDate.getStartOfDay(usageDate);
     const endOfDay: Date = OneUptimeDate.getEndOfDay(usageDate);
@@ -223,6 +242,44 @@ export class Service extends DatabaseService<Model> {
           }
 
           estimatedBytes = totalRowCount * averageRowSizeInBytes;
+        } else if (data.productType === ProductType.Profiles) {
+          const profileCount: PositiveNumber = await ProfileService.countBy({
+            query: {
+              projectId: data.projectId,
+              serviceId: service.id,
+              startTime: AnalyticsQueryHelper.inBetween(startOfDay, endOfDay),
+            },
+            skip: 0,
+            limit: LIMIT_INFINITY,
+            props: {
+              isRoot: true,
+            },
+          });
+
+          const profileSampleCount: PositiveNumber =
+            await ProfileSampleService.countBy({
+              query: {
+                projectId: data.projectId,
+                serviceId: service.id,
+                time: AnalyticsQueryHelper.inBetween(startOfDay, endOfDay),
+              },
+              skip: 0,
+              limit: LIMIT_INFINITY,
+              props: {
+                isRoot: true,
+              },
+            });
+
+          const totalProfileCount: number = profileCount.toNumber();
+          const totalProfileSampleCount: number = profileSampleCount.toNumber();
+
+          if (totalProfileCount <= 0 && totalProfileSampleCount <= 0) {
+            continue;
+          }
+
+          estimatedBytes =
+            totalProfileCount * averageRowSizeInBytes +
+            totalProfileSampleCount * averageProfileSampleRowSizeInBytes;
         }
       } catch (error) {
         logger.error(
@@ -268,7 +325,8 @@ export class Service extends DatabaseService<Model> {
     if (
       data.productType !== ProductType.Traces &&
       data.productType !== ProductType.Metrics &&
-      data.productType !== ProductType.Logs
+      data.productType !== ProductType.Logs &&
+      data.productType !== ProductType.Profiles
     ) {
       throw new BadDataException(
         "This product type is not a telemetry product type.",
@@ -370,7 +428,8 @@ export class Service extends DatabaseService<Model> {
     if (
       productType !== ProductType.Traces &&
       productType !== ProductType.Logs &&
-      productType !== ProductType.Metrics
+      productType !== ProductType.Metrics &&
+      productType !== ProductType.Profiles
     ) {
       return fallbackSize;
     }
@@ -380,6 +439,7 @@ export class Service extends DatabaseService<Model> {
         [ProductType.Traces]: AverageSpanRowSizeInBytes,
         [ProductType.Logs]: AverageLogRowSizeInBytes,
         [ProductType.Metrics]: AverageMetricRowSizeInBytes,
+        [ProductType.Profiles]: AverageProfileRowSizeInBytes,
       }[productType] ?? fallbackSize;
 
     if (!Number.isFinite(value) || value <= 0) {
@@ -402,6 +462,20 @@ export class Service extends DatabaseService<Model> {
 
     return AverageExceptionRowSizeInBytes;
   }
+
+  private getAverageProfileSampleRowSize(): number {
+    const fallbackSize: number = 512;
+
+    if (!Number.isFinite(AverageProfileSampleRowSizeInBytes)) {
+      return fallbackSize;
+    }
+
+    if (AverageProfileSampleRowSizeInBytes <= 0) {
+      return fallbackSize;
+    }
+
+    return AverageProfileSampleRowSizeInBytes;
+  }
 }
 
 export default new Service();

package/Server/Services/WorkspaceNotificationSummaryService.ts

@@ -241,6 +241,9 @@ export class Service extends DatabaseService<WorkspaceNotificationSummary> {
     items: Array<WorkspaceNotificationSummaryItem>,
     item: WorkspaceNotificationSummaryItem,
   ): boolean {
+    if (items.includes(WorkspaceNotificationSummaryItem.All)) {
+      return true;
+    }
     return items.includes(item);
   }
 
@@ -822,6 +825,11 @@ export class Service extends DatabaseService<WorkspaceNotificationSummary> {
             ackResolve.push(
               `Ack: ${Service.bold(td.ackBy)} in ${Service.formatDuration(OneUptimeDate.getMinutesBetweenTwoDates(td.declaredAt || inc.createdAt!, td.ackAt))}`,
             );
+          } else if (td?.resolvedBy && td?.resolvedAt) {
+            // If not explicitly acknowledged but resolved, ack time = resolve time
+            ackResolve.push(
+              `Ack: ${Service.bold(td.resolvedBy)} in ${Service.formatDuration(OneUptimeDate.getMinutesBetweenTwoDates(td.declaredAt || inc.createdAt!, td.resolvedAt))}`,
+            );
           } else {
             ackResolve.push(`_Not yet acknowledged_`);
           }
@@ -1251,6 +1259,11 @@ export class Service extends DatabaseService<WorkspaceNotificationSummary> {
             ackResolve.push(
               `Ack: ${Service.bold(td.ackBy)} in ${Service.formatDuration(OneUptimeDate.getMinutesBetweenTwoDates(td.declaredAt || a.createdAt!, td.ackAt))}`,
             );
+          } else if (td?.resolvedBy && td?.resolvedAt) {
+            // If not explicitly acknowledged but resolved, ack time = resolve time
+            ackResolve.push(
+              `Ack: ${Service.bold(td.resolvedBy)} in ${Service.formatDuration(OneUptimeDate.getMinutesBetweenTwoDates(td.declaredAt || a.createdAt!, td.resolvedAt))}`,
+            );
           } else {
             ackResolve.push(`_Not yet acknowledged_`);
           }
@@ -1433,8 +1446,9 @@ export class Service extends DatabaseService<WorkspaceNotificationSummary> {
     let total: number = 0;
     let count: number = 0;
     for (const [, td] of tlMap) {
+      // For ack: if not explicitly acknowledged but resolved, use resolve time as ack time
       const eventTime: Date | undefined =
-        kind === "ack" ? td.ackAt : td.resolvedAt;
+        kind === "ack" ? td.ackAt || td.resolvedAt : td.resolvedAt;
       if (eventTime && td.declaredAt) {
         total += OneUptimeDate.getMinutesBetweenTwoDates(
           td.declaredAt,

package/Server/Types/Billing/MeteredPlan/AllMeteredPlans.ts

@@ -26,11 +26,18 @@ export const TracesDataIngestMetredPlan: TelemetryMeteredPlanType =
     unitCostInUSD: 0.1 / 15, // 0.10 per 15 days per GB
   });
 
+export const ProfilesDataIngestMeteredPlan: TelemetryMeteredPlanType =
+  new TelemetryMeteredPlanType({
+    productType: ProductType.Profiles,
+    unitCostInUSD: 0.1 / 15, // 0.10 per 15 days per GB
+  });
+
 const AllMeteredPlans: Array<ServerMeteredPlan> = [
   ActiveMonitoringMeteredPlan,
   LogDataIngestMeteredPlan,
   MetricsDataIngestMeteredPlan,
   TracesDataIngestMetredPlan,
+  ProfilesDataIngestMeteredPlan,
 ];
 
 export class MeteredPlanUtil {
@@ -44,6 +51,8 @@ export class MeteredPlanUtil {
       return MetricsDataIngestMeteredPlan;
     } else if (productType === ProductType.Traces) {
       return TracesDataIngestMetredPlan;
+    } else if (productType === ProductType.Profiles) {
+      return ProfilesDataIngestMeteredPlan;
     } else if (productType === ProductType.ActiveMonitoring) {
       return ActiveMonitoringMeteredPlan;
     }

package/Server/Utils/Cookie.ts

@@ -12,6 +12,10 @@ import {
   MASTER_PASSWORD_COOKIE_IDENTIFIER,
   MASTER_PASSWORD_COOKIE_MAX_AGE_IN_DAYS,
 } from "../../Types/StatusPage/MasterPassword";
+import {
+  DASHBOARD_MASTER_PASSWORD_COOKIE_IDENTIFIER,
+  DASHBOARD_MASTER_PASSWORD_COOKIE_MAX_AGE_IN_DAYS,
+} from "../../Types/Dashboard/MasterPassword";
 import CaptureSpan from "./Telemetry/CaptureSpan";
 
 export default class CookieUtil {
@@ -323,6 +327,50 @@ export default class CookieUtil {
     );
   }
 
+  @CaptureSpan()
+  public static setDashboardMasterPasswordCookie(data: {
+    expressResponse: ExpressResponse;
+    dashboardId: ObjectID;
+  }): void {
+    const expiresInDays: PositiveNumber = new PositiveNumber(
+      DASHBOARD_MASTER_PASSWORD_COOKIE_MAX_AGE_IN_DAYS,
+    );
+
+    const token: string = JSONWebToken.signJsonPayload(
+      {
+        dashboardId: data.dashboardId.toString(),
+        type: DASHBOARD_MASTER_PASSWORD_COOKIE_IDENTIFIER,
+      },
+      OneUptimeDate.getSecondsInDays(expiresInDays),
+    );
+
+    CookieUtil.setCookie(
+      data.expressResponse,
+      CookieUtil.getDashboardMasterPasswordKey(data.dashboardId),
+      token,
+      {
+        maxAge: OneUptimeDate.getMillisecondsInDays(expiresInDays),
+        httpOnly: true,
+      },
+    );
+  }
+
+  @CaptureSpan()
+  public static removeDashboardMasterPasswordCookie(
+    res: ExpressResponse,
+    dashboardId: ObjectID,
+  ): void {
+    CookieUtil.removeCookie(
+      res,
+      CookieUtil.getDashboardMasterPasswordKey(dashboardId),
+    );
+  }
+
+  @CaptureSpan()
+  public static getDashboardMasterPasswordKey(id: ObjectID): string {
+    return `${CookieName.DashboardMasterPassword}-${id.toString()}`;
+  }
+
   // get all cookies with express request
   @CaptureSpan()
   public static getAllCookies(req: ExpressRequest): Dictionary<string> {

package/Server/Utils/Monitor/Criteria/ProfileMonitorCriteria.ts

@@ -0,0 +1,34 @@
+import ProfileMonitorResponse from "../../../../Types/Monitor/ProfileMonitor/ProfileMonitorResponse";
+import CaptureSpan from "../../Telemetry/CaptureSpan";
+import DataToProcess from "../DataToProcess";
+import CompareCriteria from "./CompareCriteria";
+import {
+  CheckOn,
+  CriteriaFilter,
+} from "../../../../Types/Monitor/CriteriaFilter";
+
+export default class ProfileMonitorCriteria {
+  @CaptureSpan()
+  public static async isMonitorInstanceCriteriaFilterMet(input: {
+    dataToProcess: DataToProcess;
+    criteriaFilter: CriteriaFilter;
+  }): Promise<string | null> {
+    let threshold: number | string | undefined | null =
+      input.criteriaFilter.value;
+
+    if (input.criteriaFilter.checkOn === CheckOn.ProfileCount) {
+      threshold = CompareCriteria.convertToNumber(threshold);
+
+      const currentProfileCount: number =
+        (input.dataToProcess as ProfileMonitorResponse).profileCount || 0;
+
+      return CompareCriteria.compareCriteriaNumbers({
+        value: currentProfileCount,
+        threshold: threshold as number,
+        criteriaFilter: input.criteriaFilter,
+      });
+    }
+
+    return null;
+  }
+}

package/Server/Utils/Monitor/DataToProcess.ts

@@ -6,6 +6,7 @@ import LogMonitorResponse from "../../../Types/Monitor/LogMonitor/LogMonitorResp
 import TraceMonitorResponse from "../../../Types/Monitor/TraceMonitor/TraceMonitorResponse";
 import MetricMonitorResponse from "../../../Types/Monitor/MetricMonitor/MetricMonitorResponse";
 import ExceptionMonitorResponse from "../../../Types/Monitor/ExceptionMonitor/ExceptionMonitorResponse";
+import ProfileMonitorResponse from "../../../Types/Monitor/ProfileMonitor/ProfileMonitorResponse";
 
 type DataToProcess =
   | ProbeMonitorResponse
@@ -15,6 +16,7 @@ type DataToProcess =
   | LogMonitorResponse
   | TraceMonitorResponse
   | MetricMonitorResponse
-  | ExceptionMonitorResponse;
+  | ExceptionMonitorResponse
+  | ProfileMonitorResponse;
 
 export default DataToProcess;

package/Server/Utils/Monitor/MonitorCriteriaEvaluator.ts

@@ -11,6 +11,7 @@ import LogMonitorCriteria from "./Criteria/LogMonitorCriteria";
 import MetricMonitorCriteria from "./Criteria/MetricMonitorCriteria";
 import TraceMonitorCriteria from "./Criteria/TraceMonitorCriteria";
 import ExceptionMonitorCriteria from "./Criteria/ExceptionMonitorCriteria";
+import ProfileMonitorCriteria from "./Criteria/ProfileMonitorCriteria";
 import SnmpMonitorCriteria from "./Criteria/SnmpMonitorCriteria";
 import DnsMonitorCriteria from "./Criteria/DnsMonitorCriteria";
 import DomainMonitorCriteria from "./Criteria/DomainMonitorCriteria";
@@ -43,6 +44,10 @@ import URL from "../../../Types/API/URL";
 import IP from "../../../Types/IP/IP";
 import Hostname from "../../../Types/API/Hostname";
 import Port from "../../../Types/Port";
+import MetricMonitorResponse, {
+  KubernetesAffectedResource,
+  KubernetesResourceBreakdown,
+} from "../../../Types/Monitor/MetricMonitor/MetricMonitorResponse";
 
 export default class MonitorCriteriaEvaluator {
   public static async processMonitorStep(input: {
@@ -487,6 +492,18 @@ ${contextBlock}
       }
     }
 
+    if (input.monitor.monitorType === MonitorType.Profiles) {
+      const profileMonitorResult: string | null =
+        await ProfileMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+          dataToProcess: input.dataToProcess,
+          criteriaFilter: input.criteriaFilter,
+        });
+
+      if (profileMonitorResult) {
+        return profileMonitorResult;
+      }
+    }
+
     if (input.monitor.monitorType === MonitorType.SNMP) {
       const snmpMonitorResult: string | null =
         await SnmpMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
@@ -545,6 +562,11 @@ ${contextBlock}
     monitorStep: MonitorStep;
     monitor: Monitor;
   }): string | null {
+    // Handle Kubernetes monitors with rich resource context
+    if (input.monitor.monitorType === MonitorType.Kubernetes) {
+      return MonitorCriteriaEvaluator.buildKubernetesRootCauseContext(input);
+    }
+
     const requestDetails: Array<string> = [];
     const responseDetails: Array<string> = [];
     const failureDetails: Array<string> = [];
@@ -653,6 +675,283 @@ ${contextBlock}
     return sections.join("\n");
   }
 
+  private static buildKubernetesRootCauseContext(input: {
+    dataToProcess: DataToProcess;
+    monitorStep: MonitorStep;
+    monitor: Monitor;
+  }): string | null {
+    const metricResponse: MetricMonitorResponse =
+      input.dataToProcess as MetricMonitorResponse;
+
+    const breakdown: KubernetesResourceBreakdown | undefined =
+      metricResponse.kubernetesResourceBreakdown;
+
+    if (!breakdown) {
+      return null;
+    }
+
+    const sections: Array<string> = [];
+
+    // Cluster context
+    const clusterDetails: Array<string> = [];
+    clusterDetails.push(`- Cluster: ${breakdown.clusterName}`);
+    clusterDetails.push(
+      `- Metric: ${breakdown.metricFriendlyName} (\`${breakdown.metricName}\`)`,
+    );
+
+    if (breakdown.attributes["k8s.namespace.name"]) {
+      clusterDetails.push(
+        `- Namespace: ${breakdown.attributes["k8s.namespace.name"]}`,
+      );
+    }
+
+    sections.push(
+      `**Kubernetes Cluster Details**\n${clusterDetails.join("\n")}`,
+    );
+
+    // Affected resources
+    if (breakdown.affectedResources && breakdown.affectedResources.length > 0) {
+      const resourceLines: Array<string> = [];
+
+      // Sort by metric value descending (worst first)
+      const sortedResources: Array<KubernetesAffectedResource> = [
+        ...breakdown.affectedResources,
+      ].sort((a: KubernetesAffectedResource, b: KubernetesAffectedResource) => {
+        return b.metricValue - a.metricValue;
+      });
+
+      // Show top 10 affected resources
+      const resourcesToShow: Array<KubernetesAffectedResource> =
+        sortedResources.slice(0, 10);
+
+      for (const resource of resourcesToShow) {
+        const details: Array<string> = [];
+
+        if (resource.namespace) {
+          details.push(`Namespace: \`${resource.namespace}\``);
+        }
+        if (resource.workloadType && resource.workloadName) {
+          details.push(
+            `${resource.workloadType}: \`${resource.workloadName}\``,
+          );
+        }
+        if (resource.podName) {
+          details.push(`Pod: \`${resource.podName}\``);
+        }
+        if (resource.containerName) {
+          details.push(`Container: \`${resource.containerName}\``);
+        }
+        if (resource.nodeName) {
+          details.push(`Node: \`${resource.nodeName}\``);
+        }
+
+        details.push(`Value: **${resource.metricValue}**`);
+
+        resourceLines.push(`- ${details.join(" | ")}`);
+      }
+
+      if (sortedResources.length > 10) {
+        resourceLines.push(
+          `- ... and ${sortedResources.length - 10} more affected resources`,
+        );
+      }
+
+      sections.push(
+        `\n\n**Affected Resources** (${sortedResources.length} total)\n${resourceLines.join("\n")}`,
+      );
+
+      // Add root cause analysis based on metric type
+      const analysis: string | null =
+        MonitorCriteriaEvaluator.buildKubernetesRootCauseAnalysis({
+          breakdown: breakdown,
+          topResource: resourcesToShow[0]!,
+        });
+
+      if (analysis) {
+        sections.push(`\n\n**Root Cause Analysis**\n${analysis}`);
+      }
+    }
+
+    return sections.join("\n");
+  }
+
+  private static buildKubernetesRootCauseAnalysis(input: {
+    breakdown: KubernetesResourceBreakdown;
+    topResource: KubernetesAffectedResource;
+  }): string | null {
+    const { breakdown, topResource } = input;
+    const metricName: string = breakdown.metricName;
+    const lines: Array<string> = [];
+
+    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(
+        `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"
+    ) {
+      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) {
+        lines.push(
+          `Recommended actions: Check scheduling events with \`kubectl describe pod ${topResource.podName}\` and verify node resources with \`kubectl describe nodes\`.`,
+        );
+      }
+    } else if (
+      metricName === "k8s.node.condition_ready" ||
+      (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(
+        `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"))
+    ) {
+      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(
+        `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"))
+    ) {
+      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(
+        `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.`,
+      );
+    } else if (
+      metricName === "k8s.deployment.unavailable_replicas" ||
+      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(
+        `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.`,
+      );
+    } else if (
+      metricName === "k8s.job.failed_pods" ||
+      (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(
+        `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).`,
+      );
+    } else if (
+      metricName === "k8s.node.filesystem.usage" ||
+      metricName.includes("disk") ||
+      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(
+        `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.`,
+      );
+    } else if (
+      metricName === "k8s.daemonset.misscheduled_nodes" ||
+      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(
+        `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.`,
+      );
+    } else {
+      // Generic Kubernetes context
+      lines.push(
+        `Kubernetes metric \`${metricName}\` (${breakdown.metricFriendlyName}) has breached the configured threshold.`,
+      );
+      if (topResource.podName) {
+        lines.push(`Most affected pod: \`${topResource.podName}\``);
+      }
+      if (topResource.nodeName) {
+        lines.push(`Most affected node: \`${topResource.nodeName}\``);
+      }
+      lines.push(
+        `Recommended actions: Investigate the affected resources using \`kubectl describe\` and \`kubectl logs\` commands.`,
+      );
+    }
+
+    return lines.join("\n");
+  }
+
   private static getMonitorDestinationString(input: {
     monitorStep: MonitorStep;
     probeResponse: ProbeMonitorResponse | null;