@oneuptime/common 10.0.39 → 10.0.40

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");

package/Types/AnalyticsDatabase/AnalyticsTableName.ts

@@ -4,6 +4,8 @@ enum AnalyticsTableName {
   ExceptionInstance = "ExceptionItemV2",
   Span = "SpanItemV2",
   MonitorLog = "MonitorLogV2",
+  Profile = "ProfileItemV2",
+  ProfileSample = "ProfileSampleItemV2",
 }
 
 export default AnalyticsTableName;

package/Types/CookieName.ts

@@ -8,6 +8,7 @@ enum CookieName {
   IsMasterAdmin = "user-is-master-admin",
   ProfilePicID = "user-profile-pic-id",
   StatusPageMasterPassword = "status-page-master-password",
+  DashboardMasterPassword = "dashboard-master-password",
 }
 
 export default CookieName;

package/Types/Dashboard/Chart/ChartType.ts

@@ -1,6 +1,11 @@
 enum DashboardChartType {
   Line = "Line",
   Bar = "Bar",
+  Area = "Area",
+  StackedArea = "Stacked Area",
+  Pie = "Pie",
+  Heatmap = "Heatmap",
+  Histogram = "Histogram",
 }
 
 export default DashboardChartType;

package/Types/Dashboard/DashboardComponentType.ts

@@ -2,6 +2,10 @@ enum DashboardComponentType {
   Chart = `Chart`,
   Value = `Value`,
   Text = `Text`,
+  Table = `Table`,
+  Gauge = `Gauge`,
+  LogStream = `LogStream`,
+  TraceList = `TraceList`,
 }
 
 export default DashboardComponentType;

package/Types/Dashboard/DashboardComponents/ComponentArgument.ts

@@ -9,10 +9,19 @@ export enum ComponentInputType {
   Number = "Number",
   Decimal = "Decimal",
   MetricsQueryConfig = "MetricsQueryConfig",
+  MetricsQueryConfigs = "MetricsQueryConfigs",
   LongText = "Long Text",
   Dropdown = "Dropdown",
 }
 
+export interface ComponentArgumentSection {
+  name: string;
+  description?: string | undefined;
+  icon?: string | undefined;
+  defaultCollapsed?: boolean | undefined;
+  order: number;
+}
+
 export interface ComponentArgument<T extends DashboardBaseComponent> {
   name: string;
   description: string;
@@ -22,4 +31,5 @@ export interface ComponentArgument<T extends DashboardBaseComponent> {
   isAdvanced?: boolean | undefined;
   placeholder?: string | undefined;
   dropdownOptions?: Array<DropdownOption> | undefined;
+  section?: ComponentArgumentSection | undefined;
 }

package/Types/Dashboard/DashboardComponents/DashboardChartComponent.ts

@@ -9,10 +9,9 @@ export default interface DashboardChartComponent extends BaseComponent {
   componentId: ObjectID;
   arguments: {
     metricQueryConfig?: MetricQueryConfigData | undefined;
+    metricQueryConfigs?: Array<MetricQueryConfigData> | undefined;
     chartTitle?: string | undefined;
     chartDescription?: string | undefined;
-    legendText?: string | undefined;
-    legendUnit?: string | undefined;
     chartType?: DashboardChartType | undefined;
   };
 }

package/Types/Dashboard/DashboardComponents/DashboardGaugeComponent.ts

@@ -0,0 +1,17 @@
+import MetricQueryConfigData from "../../Metrics/MetricQueryConfigData";
+import ObjectID from "../../ObjectID";
+import DashboardComponentType from "../DashboardComponentType";
+import BaseComponent from "./DashboardBaseComponent";
+
+export default interface DashboardGaugeComponent extends BaseComponent {
+  componentType: DashboardComponentType.Gauge;
+  componentId: ObjectID;
+  arguments: {
+    metricQueryConfig?: MetricQueryConfigData | undefined;
+    gaugeTitle?: string | undefined;
+    minValue?: number | undefined;
+    maxValue?: number | undefined;
+    warningThreshold?: number | undefined;
+    criticalThreshold?: number | undefined;
+  };
+}

package/Types/Dashboard/DashboardComponents/DashboardLogStreamComponent.ts

@@ -0,0 +1,15 @@
+import ObjectID from "../../ObjectID";
+import DashboardComponentType from "../DashboardComponentType";
+import BaseComponent from "./DashboardBaseComponent";
+
+export default interface DashboardLogStreamComponent extends BaseComponent {
+  componentType: DashboardComponentType.LogStream;
+  componentId: ObjectID;
+  arguments: {
+    title?: string | undefined;
+    severityFilter?: string | undefined;
+    bodyContains?: string | undefined;
+    attributeFilterQuery?: string | undefined;
+    maxRows?: number | undefined;
+  };
+}

package/Types/Dashboard/DashboardComponents/DashboardTableComponent.ts

@@ -0,0 +1,14 @@
+import MetricQueryConfigData from "../../Metrics/MetricQueryConfigData";
+import ObjectID from "../../ObjectID";
+import DashboardComponentType from "../DashboardComponentType";
+import BaseComponent from "./DashboardBaseComponent";
+
+export default interface DashboardTableComponent extends BaseComponent {
+  componentType: DashboardComponentType.Table;
+  componentId: ObjectID;
+  arguments: {
+    metricQueryConfig?: MetricQueryConfigData | undefined;
+    tableTitle?: string | undefined;
+    maxRows?: number | undefined;
+  };
+}

package/Types/Dashboard/DashboardComponents/DashboardTextComponent.ts

@@ -10,5 +10,6 @@ export default interface DashboardTextComponent extends BaseComponent {
     isBold: boolean;
     isItalic: boolean;
     isUnderline: boolean;
+    isMarkdown?: boolean | undefined;
   };
 }

package/Types/Dashboard/DashboardComponents/DashboardTraceListComponent.ts

@@ -0,0 +1,13 @@
+import ObjectID from "../../ObjectID";
+import DashboardComponentType from "../DashboardComponentType";
+import BaseComponent from "./DashboardBaseComponent";
+
+export default interface DashboardTraceListComponent extends BaseComponent {
+  componentType: DashboardComponentType.TraceList;
+  componentId: ObjectID;
+  arguments: {
+    title?: string | undefined;
+    statusFilter?: string | undefined;
+    maxRows?: number | undefined;
+  };
+}

package/Types/Dashboard/DashboardComponents/DashboardValueComponent.ts

@@ -9,5 +9,7 @@ export default interface DashboardValueComponent extends BaseComponent {
   arguments: {
     metricQueryConfig?: MetricQueryConfigData | undefined;
     title: string;
+    warningThreshold?: number | undefined;
+    criticalThreshold?: number | undefined;
   };
 }