@oneuptime/common 10.0.38 → 10.0.40

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;

package/Server/Utils/Profile/PprofEncoder.ts

@@ -0,0 +1,225 @@
+import { JSONObject } from "../../../Types/JSON";
+import zlib from "zlib";
+
+/**
+ * Encodes profile data into a simplified pprof-compatible JSON format.
+ * This produces a gzipped JSON representation that captures the essential
+ * profile information (stacktraces, values, metadata) in a format that
+ * can be consumed by tools that support pprof JSON.
+ *
+ * For full protobuf pprof support, a protobuf serializer (e.g., protobufjs
+ * with the pprof proto) would be needed. This implementation provides a
+ * practical export format.
+ */
+
+export interface PprofSample {
+  stacktrace: Array<string>;
+  value: number;
+  labels: JSONObject | undefined;
+}
+
+export interface PprofProfile {
+  profileId: string;
+  profileType: string;
+  unit: string;
+  periodType: string;
+  period: number;
+  startTimeNanos: number;
+  endTimeNanos: number;
+  durationNanos: number;
+  samples: Array<PprofSample>;
+}
+
+export interface PprofFunction {
+  id: number;
+  name: number; // string table index
+  filename: number; // string table index
+}
+
+export interface PprofLocation {
+  id: number;
+  line: Array<{
+    functionId: number;
+    line: number;
+  }>;
+}
+
+export interface PprofProto {
+  stringTable: Array<string>;
+  functions: Array<PprofFunction>;
+  locations: Array<PprofLocation>;
+  samples: Array<{
+    locationId: Array<number>;
+    value: Array<number>;
+    label: Array<{ key: number; str: number }>;
+  }>;
+  sampleType: Array<{ type: number; unit: number }>;
+  periodType: { type: number; unit: number };
+  period: number;
+  timeNanos: number;
+  durationNanos: number;
+}
+
+export default class PprofEncoder {
+  /**
+   * Build a pprof-like JSON structure from denormalized profile data.
+   * The output is a JSON object that mirrors the pprof proto structure,
+   * using string table indirection for compact representation.
+   */
+  public static encode(profile: PprofProfile): PprofProto {
+    const stringTable: Array<string> = [""];
+    const stringIndex: Map<string, number> = new Map([["", 0]]);
+
+    const getStringIndex: (s: string) => number = (s: string): number => {
+      const existing: number | undefined = stringIndex.get(s);
+      if (existing !== undefined) {
+        return existing;
+      }
+      const idx: number = stringTable.length;
+      stringTable.push(s);
+      stringIndex.set(s, idx);
+      return idx;
+    };
+
+    const functions: Array<PprofFunction> = [];
+    const functionIndex: Map<string, number> = new Map();
+    const locations: Array<PprofLocation> = [];
+    const locationIndex: Map<string, number> = new Map();
+
+    const getOrCreateFunction: (name: string, fileName: string) => number = (
+      name: string,
+      fileName: string,
+    ): number => {
+      const key: string = `${name}@${fileName}`;
+      const existing: number | undefined = functionIndex.get(key);
+      if (existing !== undefined) {
+        return existing;
+      }
+      const id: number = functions.length + 1;
+      functions.push({
+        id,
+        name: getStringIndex(name),
+        filename: getStringIndex(fileName),
+      });
+      functionIndex.set(key, id);
+      return id;
+    };
+
+    const getOrCreateLocation: (
+      functionName: string,
+      fileName: string,
+      lineNumber: number,
+    ) => number = (
+      functionName: string,
+      fileName: string,
+      lineNumber: number,
+    ): number => {
+      const key: string = `${functionName}@${fileName}:${lineNumber}`;
+      const existing: number | undefined = locationIndex.get(key);
+      if (existing !== undefined) {
+        return existing;
+      }
+      const funcId: number = getOrCreateFunction(functionName, fileName);
+      const id: number = locations.length + 1;
+      locations.push({
+        id,
+        line: [{ functionId: funcId, line: lineNumber }],
+      });
+      locationIndex.set(key, id);
+      return id;
+    };
+
+    // Build samples
+    const pprofSamples: Array<{
+      locationId: Array<number>;
+      value: Array<number>;
+      label: Array<{ key: number; str: number }>;
+    }> = [];
+
+    for (const sample of profile.samples) {
+      const locationIds: Array<number> = [];
+
+      // Parse each frame in the stacktrace
+      for (const frame of sample.stacktrace) {
+        const atIndex: number = frame.indexOf("@");
+        let functionName: string = frame;
+        let fileName: string = "";
+        let lineNumber: number = 0;
+
+        if (atIndex !== -1) {
+          functionName = frame.substring(0, atIndex);
+          const rest: string = frame.substring(atIndex + 1);
+          const lastColon: number = rest.lastIndexOf(":");
+          if (lastColon !== -1) {
+            fileName = rest.substring(0, lastColon);
+            lineNumber = parseInt(rest.substring(lastColon + 1), 10) || 0;
+          } else {
+            fileName = rest;
+          }
+        }
+
+        locationIds.push(
+          getOrCreateLocation(functionName, fileName, lineNumber),
+        );
+      }
+
+      // Build labels
+      const labels: Array<{ key: number; str: number }> = [];
+      if (sample.labels) {
+        for (const [key, value] of Object.entries(sample.labels)) {
+          labels.push({
+            key: getStringIndex(key),
+            str: getStringIndex(String(value)),
+          });
+        }
+      }
+
+      pprofSamples.push({
+        locationId: locationIds,
+        value: [sample.value],
+        label: labels,
+      });
+    }
+
+    // Build sample type
+    const typeIdx: number = getStringIndex(profile.profileType);
+    const unitIdx: number = getStringIndex(profile.unit || "count");
+    const periodTypeIdx: number = getStringIndex(
+      profile.periodType || profile.profileType,
+    );
+
+    return {
+      stringTable,
+      functions,
+      locations,
+      samples: pprofSamples,
+      sampleType: [{ type: typeIdx, unit: unitIdx }],
+      periodType: { type: periodTypeIdx, unit: unitIdx },
+      period: profile.period,
+      timeNanos: profile.startTimeNanos,
+      durationNanos: profile.durationNanos,
+    };
+  }
+
+  /**
+   * Encode and gzip the pprof JSON for download.
+   */
+  public static async encodeAndCompress(
+    profile: PprofProfile,
+  ): Promise<Buffer> {
+    const pprofData: PprofProto = PprofEncoder.encode(profile);
+    const jsonString: string = JSON.stringify(pprofData);
+
+    return new Promise<Buffer>(
+      (resolve: (value: Buffer) => void, reject: (reason: Error) => void) => {
+        zlib.gzip(jsonString, (err: Error | null, result: Buffer) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(result);
+          }
+        });
+      },
+    );
+  }
+}

package/Server/Utils/Workspace/MicrosoftTeams/MicrosoftTeams.ts

@@ -1023,12 +1023,43 @@ export default class MicrosoftTeamsUtil extends WorkspaceBase {
     logger.debug("Sending message to Microsoft Teams with data:");
     logger.debug(data);
 
-    const adaptiveCard: JSONObject = this.buildAdaptiveCardFromMessageBlocks({
-      messageBlocks: data.workspaceMessagePayload.messageBlocks,
-    });
+    /*
+     * Teams adaptive cards have a ~28KB payload limit.
+     * Split message blocks into chunks of 40 to avoid hitting the limit.
+     */
+    const maxBlocksPerCard: number = 40;
+    const allMessageBlocks: Array<WorkspaceMessageBlock> =
+      data.workspaceMessagePayload.messageBlocks;
 
-    logger.debug("Adaptive card built successfully:");
-    logger.debug(JSON.stringify(adaptiveCard, null, 2));
+    const adaptiveCards: Array<JSONObject> = [];
+
+    if (allMessageBlocks.length <= maxBlocksPerCard) {
+      adaptiveCards.push(
+        this.buildAdaptiveCardFromMessageBlocks({
+          messageBlocks: allMessageBlocks,
+        }),
+      );
+    } else {
+      for (
+        let i: number = 0;
+        i < allMessageBlocks.length;
+        i += maxBlocksPerCard
+      ) {
+        const chunk: Array<WorkspaceMessageBlock> = allMessageBlocks.slice(
+          i,
+          i + maxBlocksPerCard,
+        );
+        adaptiveCards.push(
+          this.buildAdaptiveCardFromMessageBlocks({
+            messageBlocks: chunk,
+          }),
+        );
+      }
+    }
+
+    logger.debug(
+      `Built ${adaptiveCards.length} adaptive card(s) from ${allMessageBlocks.length} message blocks`,
+    );
 
     const workspaceChannelsToPostTo: Array<WorkspaceChannel> = [];
 
@@ -1122,18 +1153,24 @@ export default class MicrosoftTeamsUtil extends WorkspaceBase {
           );
         }
 
-        const thread: WorkspaceThread = await this.sendAdaptiveCardToChannel({
-          authToken: data.authToken,
-          teamId: data.workspaceMessagePayload.teamId!,
-          workspaceChannel: channel,
-          adaptiveCard: adaptiveCard,
-          projectId: data.projectId,
-        });
+        // Send each adaptive card chunk to the channel
+        let lastThread: WorkspaceThread | undefined;
+        for (const adaptiveCard of adaptiveCards) {
+          lastThread = await this.sendAdaptiveCardToChannel({
+            authToken: data.authToken,
+            teamId: data.workspaceMessagePayload.teamId!,
+            workspaceChannel: channel,
+            adaptiveCard: adaptiveCard,
+            projectId: data.projectId,
+          });
+        }
 
-        logger.debug(
-          `Message sent successfully to channel ${channel.name}, thread: ${JSON.stringify(thread)}`,
-        );
-        workspaceMessageResponse.threads.push(thread);
+        if (lastThread) {
+          logger.debug(
+            `Message sent successfully to channel ${channel.name}, thread: ${JSON.stringify(lastThread)}`,
+          );
+          workspaceMessageResponse.threads.push(lastThread);
+        }
       } catch (e) {
         logger.error(`Error sending message to channel ID ${channel.id}:`);
         logger.error(e);

package/Server/Utils/Workspace/Slack/Slack.ts

@@ -1129,13 +1129,33 @@ export default class SlackUtil extends WorkspaceBase {
           }
         }
 
-        const thread: WorkspaceThread = await this.sendPayloadBlocksToChannel({
-          authToken: data.authToken,
-          workspaceChannel: channel,
-          blocks: blocks,
-        });
+        // Slack has a limit of 50 blocks per message. Split into batches if needed.
+        const maxBlocksPerMessage: number = 50;
+        let lastThread: WorkspaceThread | undefined;
 
-        workspaspaceMessageResponse.threads.push(thread);
+        if (blocks.length <= maxBlocksPerMessage) {
+          lastThread = await this.sendPayloadBlocksToChannel({
+            authToken: data.authToken,
+            workspaceChannel: channel,
+            blocks: blocks,
+          });
+        } else {
+          for (let i: number = 0; i < blocks.length; i += maxBlocksPerMessage) {
+            const chunk: Array<JSONObject> = blocks.slice(
+              i,
+              i + maxBlocksPerMessage,
+            );
+            lastThread = await this.sendPayloadBlocksToChannel({
+              authToken: data.authToken,
+              workspaceChannel: channel,
+              blocks: chunk,
+            });
+          }
+        }
+
+        if (lastThread) {
+          workspaspaceMessageResponse.threads.push(lastThread);
+        }
 
         logger.debug(`Message sent to channel ID ${channel.id} successfully.`);
       } catch (e) {

package/ServiceRoute.ts

@@ -35,3 +35,5 @@ export const RealtimeRoute: Route = new Route("/realtime/socket");
 export const DocsRoute: Route = new Route("/docs");
 
 export const StatusPageApiRoute: Route = new Route("/status-page-api");
+
+export const PublicDashboardRoute: Route = new Route("/public-dashboard");