@oneuptime/common 10.0.10 → 10.0.14

package/Models/AnalyticsModels/ExceptionInstance.ts

@@ -311,6 +311,77 @@ export default class ExceptionInstance extends AnalyticsBaseModel {
       },
     });
 
+    const releaseColumn: AnalyticsTableColumn = new AnalyticsTableColumn({
+      key: "release",
+      title: "Release",
+      description:
+        "Service version / release from service.version resource attribute",
+      required: false,
+      type: TableColumnType.Text,
+      accessControl: {
+        read: [
+          Permission.ProjectOwner,
+          Permission.ProjectAdmin,
+          Permission.ProjectMember,
+          Permission.ReadTelemetryException,
+        ],
+        create: [
+          Permission.ProjectOwner,
+          Permission.ProjectAdmin,
+          Permission.ProjectMember,
+          Permission.CreateTelemetryException,
+        ],
+        update: [],
+      },
+    });
+
+    const environmentColumn: AnalyticsTableColumn = new AnalyticsTableColumn({
+      key: "environment",
+      title: "Environment",
+      description:
+        "Deployment environment from deployment.environment resource attribute",
+      required: false,
+      type: TableColumnType.Text,
+      accessControl: {
+        read: [
+          Permission.ProjectOwner,
+          Permission.ProjectAdmin,
+          Permission.ProjectMember,
+          Permission.ReadTelemetryException,
+        ],
+        create: [
+          Permission.ProjectOwner,
+          Permission.ProjectAdmin,
+          Permission.ProjectMember,
+          Permission.CreateTelemetryException,
+        ],
+        update: [],
+      },
+    });
+
+    const parsedFramesColumn: AnalyticsTableColumn = new AnalyticsTableColumn({
+      key: "parsedFrames",
+      title: "Parsed Stack Frames",
+      description: "Stack trace parsed into structured frames (JSON array)",
+      required: false,
+      type: TableColumnType.Text,
+      accessControl: {
+        read: [
+          Permission.ProjectOwner,
+          Permission.ProjectAdmin,
+          Permission.ProjectMember,
+          Permission.ReadTelemetryException,
+        ],
+        create: [
+          Permission.ProjectOwner,
+          Permission.ProjectAdmin,
+          Permission.ProjectMember,
+          Permission.CreateTelemetryException,
+        ],
+        update: [],
+      },
+    });
+
     const attributesColumn: AnalyticsTableColumn = new AnalyticsTableColumn({
       key: "attributes",
       title: "Attributes",
@@ -384,6 +455,9 @@ export default class ExceptionInstance extends AnalyticsBaseModel {
         spanIdColumn,
         fingerprintColumn,
         spanNameColumn,
+        releaseColumn,
+        environmentColumn,
+        parsedFramesColumn,
         attributesColumn,
       ],
       projections: [],
@@ -504,4 +578,28 @@ export default class ExceptionInstance extends AnalyticsBaseModel {
   public set spanName(v: string | undefined) {
     this.setColumnValue("spanName", v);
   }
+
+  public get release(): string | undefined {
+    return this.getColumnValue("release") as string | undefined;
+  }
+
+  public set release(v: string | undefined) {
+    this.setColumnValue("release", v);
+  }
+
+  public get environment(): string | undefined {
+    return this.getColumnValue("environment") as string | undefined;
+  }
+
+  public set environment(v: string | undefined) {
+    this.setColumnValue("environment", v);
+  }
+
+  public get parsedFrames(): string | undefined {
+    return this.getColumnValue("parsedFrames") as string | undefined;
+  }
+
+  public set parsedFrames(v: string | undefined) {
+    this.setColumnValue("parsedFrames", v);
+  }
 }

package/Models/DatabaseModels/TelemetryException.ts

@@ -1026,4 +1026,109 @@ export default class TelemetryException extends DatabaseBaseModel {
     default: 1,
   })
   public occuranceCount?: number = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateTelemetryException,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadTelemetryException,
+      Permission.ReadAllProjectResources,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditTelemetryException,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.LongText,
+    canReadOnRelationQuery: true,
+    title: "First Seen In Release",
+    description:
+      "The service version / release in which this exception was first observed",
+    example: "v1.2.3",
+  })
+  @Column({
+    nullable: true,
+    type: ColumnType.LongText,
+    length: ColumnLength.LongText,
+  })
+  public firstSeenInRelease?: string = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateTelemetryException,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadTelemetryException,
+      Permission.ReadAllProjectResources,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditTelemetryException,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.LongText,
+    canReadOnRelationQuery: true,
+    title: "Last Seen In Release",
+    description:
+      "The most recent service version / release in which this exception was observed",
+    example: "v1.4.0",
+  })
+  @Column({
+    nullable: true,
+    type: ColumnType.LongText,
+    length: ColumnLength.LongText,
+  })
+  public lastSeenInRelease?: string = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateTelemetryException,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadTelemetryException,
+      Permission.ReadAllProjectResources,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditTelemetryException,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.LongText,
+    canReadOnRelationQuery: true,
+    title: "Environment",
+    description:
+      "Deployment environment from deployment.environment resource attribute",
+    example: "production",
+  })
+  @Column({
+    nullable: true,
+    type: ColumnType.LongText,
+    length: ColumnLength.LongText,
+  })
+  public environment?: string = undefined;
 }

package/Server/Infrastructure/Postgres/SchemaMigrations/1772111896988-MigrationName.ts

@@ -0,0 +1,41 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1772111896988 implements MigrationInterface {
+  public name = "MigrationName1772111896988";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "TelemetryException" ADD "firstSeenInRelease" character varying(500)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "TelemetryException" ADD "lastSeenInRelease" character varying(500)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "rotation" SET DEFAULT '{"_type":"Recurring","value":{"intervalType":"Day","intervalCount":{"_type":"PositiveNumber","value":1}}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "restrictionTimes" SET DEFAULT '{"_type":"RestrictionTimes","value":{"restictionType":"None","dayRestrictionTimes":null,"weeklyRestrictionTimes":[]}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "TelemetryException" ADD "environment" character varying(500)`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "TelemetryException" DROP COLUMN "environment"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "restrictionTimes" SET DEFAULT '{"_type": "RestrictionTimes", "value": {"restictionType": "None", "dayRestrictionTimes": null, "weeklyRestrictionTimes": []}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "rotation" SET DEFAULT '{"_type": "Recurring", "value": {"intervalType": "Day", "intervalCount": {"_type": "PositiveNumber", "value": 1}}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "TelemetryException" DROP COLUMN "lastSeenInRelease"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "TelemetryException" DROP COLUMN "firstSeenInRelease"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/Index.ts

@@ -259,6 +259,7 @@ import { MigrationName1770732721195 } from "./1770732721195-MigrationName";
 import { MigrationName1770833704656 } from "./1770833704656-MigrationName";
 import { MigrationName1770834237090 } from "./1770834237090-MigrationName";
 import { MigrationName1770834237091 } from "./1770834237091-MigrationName";
+import { MigrationName1772111896988 } from "./1772111896988-MigrationName";
 
 export default [
   InitialMigration,
@@ -522,4 +523,5 @@ export default [
   MigrationName1770833704656,
   MigrationName1770834237090,
   MigrationName1770834237091,
+  MigrationName1772111896988,
 ];

package/Server/Utils/Browser.ts

@@ -16,7 +16,7 @@ export type Page = PlaywrightPage;
 export type Browser = PlaywrightBrowser;
 
 export default class BrowserUtil {
-  // Chromium arguments for stability in containerized environments
+  // Chromium arguments for stability and memory optimization in containerized environments
   public static chromiumStabilityArgs: string[] = [
     "--no-sandbox",
     "--disable-setuid-sandbox",
@@ -26,9 +26,32 @@ export default class BrowserUtil {
     "--disable-dbus", // no D-Bus daemon in containers
     "--disable-features=dbus", // additional D-Bus feature gate
     "--no-zygote", // skip zygote process that fails OOM score adjustments in containers
+    // Memory optimization flags
+    "--single-process", // run browser in single process to reduce memory overhead
+    "--disable-extensions", // no extensions needed for monitoring
+    "--disable-background-networking", // disable background network requests
+    "--disable-default-apps", // don't load default apps
+    "--disable-sync", // no sync needed
+    "--disable-translate", // no translation needed
+    "--disable-backgrounding-occluded-windows", // don't throttle hidden windows
+    "--disable-renderer-backgrounding", // don't background renderers
+    "--disable-background-timer-throttling", // don't throttle timers
+    "--disable-ipc-flooding-protection", // allow high IPC throughput
+    "--memory-pressure-off", // disable memory pressure signals that cause GC
+    "--js-flags=--max-old-space-size=256", // limit V8 heap to 256MB
+    "--disable-features=TranslateUI,BlinkGenPropertyTrees", // disable unused features
+    "--disable-component-update", // don't update components
+    "--disable-domain-reliability", // no domain reliability monitoring
+    "--disable-client-side-phishing-detection", // no phishing detection
+    "--no-first-run", // skip first run experience
+    "--disable-hang-monitor", // no hang monitor
+    "--disable-popup-blocking", // allow popups for testing
+    "--disable-prompt-on-repost", // no repost prompts
+    "--metrics-recording-only", // disable metrics uploading
+    "--safebrowsing-disable-auto-update", // no safe browsing updates
   ];
 
-  // Firefox preferences for stability in containerized environments
+  // Firefox preferences for stability and memory optimization in containerized environments
   public static firefoxStabilityPrefs: Record<
     string,
     string | number | boolean
@@ -37,6 +60,21 @@ export default class BrowserUtil {
     "media.hardware-video-decoding.enabled": false, // disable hardware video decoding
     "layers.acceleration.disabled": true, // disable GPU-accelerated layers
     "network.http.spdy.enabled.http2": true, // keep HTTP/2 enabled
+    // Memory optimization preferences
+    "javascript.options.mem.max": 256 * 1024, // limit JS memory to 256MB in KB
+    "javascript.options.mem.high_water_mark": 128, // GC high water mark in MB
+    "browser.cache.memory.capacity": 16384, // limit memory cache to 16MB
+    "browser.cache.disk.enable": false, // disable disk cache
+    "browser.sessionhistory.max_entries": 3, // limit session history
+    "browser.sessionhistory.max_total_viewers": 0, // don't keep pages in bfcache
+    "dom.ipc.processCount": 1, // single content process
+    "extensions.update.enabled": false, // no extension updates
+    "network.prefetch-next": false, // no prefetching
+    "network.dns.disablePrefetch": true, // no DNS prefetch
+    "network.http.speculative-parallel-limit": 0, // no speculative connections
+    "browser.tabs.remote.autostart": false, // disable multi-process
+    "media.peerconnection.enabled": false, // disable WebRTC
+    "media.navigator.enabled": false, // disable getUserMedia
   };
 
   @CaptureSpan()

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

@@ -159,11 +159,7 @@ export default class IncomingRequestCriteria {
       }
     }
 
-    if (
-      input.criteriaFilter.checkOn === CheckOn.RequestBody &&
-      !(input.dataToProcess as IncomingMonitorRequest)
-        .onlyCheckForIncomingRequestReceivedAt
-    ) {
+    if (input.criteriaFilter.checkOn === CheckOn.RequestBody) {
       let responseBody: string | JSONObject | undefined = (
         input.dataToProcess as IncomingMonitorRequest
       ).requestBody;
@@ -200,11 +196,7 @@ export default class IncomingRequestCriteria {
       }
     }
 
-    if (
-      input.criteriaFilter.checkOn === CheckOn.RequestHeader &&
-      !(input.dataToProcess as IncomingMonitorRequest)
-        .onlyCheckForIncomingRequestReceivedAt
-    ) {
+    if (input.criteriaFilter.checkOn === CheckOn.RequestHeader) {
       const headerKeys: Array<string> = Object.keys(
         (input.dataToProcess as IncomingMonitorRequest).requestHeaders || {},
       ).map((key: string) => {
@@ -227,11 +219,7 @@ export default class IncomingRequestCriteria {
       }
     }
 
-    if (
-      input.criteriaFilter.checkOn === CheckOn.RequestHeaderValue &&
-      !(input.dataToProcess as IncomingMonitorRequest)
-        .onlyCheckForIncomingRequestReceivedAt
-    ) {
+    if (input.criteriaFilter.checkOn === CheckOn.RequestHeaderValue) {
       const headerValues: Array<string> = Object.values(
         (input.dataToProcess as IncomingMonitorRequest).requestHeaders || {},
       ).map((key: string) => {

package/Server/Utils/Telemetry.ts

@@ -34,10 +34,13 @@ import {
 import type { PushMetricExporter } from "@opentelemetry/sdk-metrics/build/src/export/MetricExporter";
 import * as opentelemetry from "@opentelemetry/sdk-node";
 import { SpanExporter } from "@opentelemetry/sdk-trace-base";
-import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
+import {
+  ATTR_SERVICE_NAME,
+  ATTR_SERVICE_VERSION,
+} from "@opentelemetry/semantic-conventions";
 import URL from "../../Types/API/URL";
 import Dictionary from "../../Types/Dictionary";
-import { DisableTelemetry } from "../EnvironmentConfig";
+import { AppVersion, Env, DisableTelemetry } from "../EnvironmentConfig";
 import logger from "./Logger";
 
 type ResourceWithRawAttributes = LogsResource & {
@@ -141,6 +144,8 @@ export default class Telemetry {
   public static getResource(data: { serviceName: string }): Resource {
     return new Resource({
       [ATTR_SERVICE_NAME]: data.serviceName,
+      [ATTR_SERVICE_VERSION]: AppVersion,
+      ["deployment.environment"]: Env,
     });
   }
 

package/Server/Utils/VM/VMAPI.ts

@@ -69,6 +69,14 @@ export default class VMUtil {
       valueToReplaceInPlace.toString().includes("}}")
     ) {
       let valueToReplaceInPlaceCopy: string = valueToReplaceInPlace.toString();
+
+      // First, expand {{#each path}}...{{/each}} loops before variable substitution
+      valueToReplaceInPlaceCopy = VMUtil.expandEachLoops(
+        storageMap,
+        valueToReplaceInPlaceCopy,
+        isJSON,
+      );
+
       const variablesInArgument: Array<string> = [];
 
       const regex: RegExp = /{{(.*?)}}/g; // Find all matches of the regular expression and capture the word between the braces {{x}} => x
@@ -128,6 +136,202 @@ export default class VMUtil {
     return valueToReplaceInPlace;
   }
 
+  /**
+   * Expand {{#each path}}...{{/each}} loop blocks by iterating over arrays.
+   *
+   * Supports:
+   *  - {{variableName}} inside the loop body resolves relative to the current array element
+   *  - {{@index}} resolves to the 0-based index of the current iteration
+   *  - {{this}} resolves to the current element value (useful for primitive arrays)
+   *  - Nested {{#each}} blocks for multi-level array traversal
+   *  - If the resolved path is not an array, the block is removed (replaced with empty string)
+   *
+   * Example:
+   *   {{#each requestBody.alerts}}
+   *     Alert {{@index}}: {{labels.label}} - {{status}}
+   *   {{/each}}
+   */
+  @CaptureSpan()
+  public static expandEachLoops(
+    storageMap: JSONObject,
+    template: string,
+    isJSON: boolean | undefined,
+  ): string {
+    let result: string = template;
+    const maxIterations: number = 100; // safety limit to prevent infinite loops
+    let iterations: number = 0;
+
+    while (iterations < maxIterations) {
+      iterations++;
+
+      // Find the first (outermost) {{#each ...}} tag
+      const openTag: RegExp = /\{\{#each\s+(.*?)\}\}/;
+      const openMatch: RegExpExecArray | null = openTag.exec(result);
+
+      if (!openMatch) {
+        break; // no more {{#each}} blocks
+      }
+
+      const blockStart: number = openMatch.index!;
+      const arrayPath: string = openMatch[1]!.trim();
+      const bodyStart: number = blockStart + openMatch[0]!.length;
+
+      // Find the matching {{/each}} by counting nesting depth
+      let depth: number = 1;
+      let searchPos: number = bodyStart;
+      let matchEnd: number = -1;
+      let bodyEnd: number = -1;
+
+      while (depth > 0 && searchPos < result.length) {
+        const nextOpen: number = result.indexOf("{{#each ", searchPos);
+        const nextClose: number = result.indexOf("{{/each}}", searchPos);
+
+        if (nextClose === -1) {
+          // Unmatched {{#each}} — break out to avoid infinite loop
+          break;
+        }
+
+        if (nextOpen !== -1 && nextOpen < nextClose) {
+          // Found a nested {{#each}} before the next {{/each}}
+          depth++;
+          searchPos = nextOpen + 8; // skip past "{{#each "
+        } else {
+          // Found {{/each}}
+          depth--;
+          if (depth === 0) {
+            bodyEnd = nextClose;
+            matchEnd = nextClose + "{{/each}}".length;
+          }
+          searchPos = nextClose + "{{/each}}".length;
+        }
+      }
+
+      if (matchEnd === -1 || bodyEnd === -1) {
+        // Unmatched {{#each}} — remove it to prevent infinite loop
+        result =
+          result.slice(0, blockStart) +
+          result.slice(blockStart + openMatch[0]!.length);
+        continue;
+      }
+
+      const loopBody: string = result.slice(bodyStart, bodyEnd);
+
+      // Resolve the array from the storage map
+      const arrayValue: JSONValue = VMUtil.deepFind(storageMap, arrayPath);
+
+      if (!Array.isArray(arrayValue)) {
+        // Not an array — remove the block entirely
+        result = result.slice(0, blockStart) + result.slice(matchEnd);
+        continue;
+      }
+
+      // Expand the loop body for each element in the array
+      const expandedParts: Array<string> = [];
+
+      for (let i: number = 0; i < arrayValue.length; i++) {
+        const element: JSONValue = arrayValue[i]!;
+        let iterationBody: string = loopBody;
+
+        // Replace {{@index}} with the current index
+        iterationBody = iterationBody.replace(/\{\{@index\}\}/g, i.toString());
+
+        if (typeof element === "object" && element !== null) {
+          /*
+           * Merge element properties into a scoped storageMap so that:
+           * 1. Element properties can be accessed directly (e.g., {{status}})
+           * 2. Parent storageMap properties are still accessible (e.g., {{requestBody.receiver}})
+           */
+          const scopedStorageMap: JSONObject = {
+            ...storageMap,
+            ...(element as JSONObject),
+          };
+
+          // Recursively expand any nested {{#each}} blocks within the iteration body
+          iterationBody = VMUtil.expandEachLoops(
+            scopedStorageMap,
+            iterationBody,
+            isJSON,
+          );
+
+          // Replace remaining {{variable}} placeholders
+          iterationBody = VMUtil.replaceLoopVariables(
+            element as JSONObject,
+            storageMap,
+            iterationBody,
+            isJSON,
+          );
+        } else {
+          // For primitive array elements, replace {{this}} with the value
+          iterationBody = iterationBody.replace(
+            /\{\{this\}\}/g,
+            isJSON ? VMUtil.serializeValueForJSON(`${element}`) : `${element}`,
+          );
+        }
+
+        expandedParts.push(iterationBody);
+      }
+
+      result =
+        result.slice(0, blockStart) +
+        expandedParts.join("") +
+        result.slice(matchEnd);
+    }
+
+    return result;
+  }
+
+  /**
+   * Replace {{variable}} placeholders inside a loop body.
+   * Variables are resolved first against the current element (scoped),
+   * then fall back to the parent storageMap.
+   */
+  @CaptureSpan()
+  private static replaceLoopVariables(
+    element: JSONObject,
+    parentStorageMap: JSONObject,
+    body: string,
+    isJSON: boolean | undefined,
+  ): string {
+    const variableRegex: RegExp = /\{\{((?!#each\b|\/each\b|@index\b).*?)\}\}/g;
+    let match: RegExpExecArray | null = null;
+    const variables: Array<string> = [];
+
+    while ((match = variableRegex.exec(body)) !== null) {
+      if (match[1]) {
+        variables.push(match[1]);
+      }
+    }
+
+    for (const variable of variables) {
+      // First try resolving relative to the current element
+      let foundValue: JSONValue = VMUtil.deepFind(element, variable.trim());
+
+      // Fall back to the parent storage map (for absolute paths)
+      if (foundValue === undefined) {
+        foundValue = VMUtil.deepFind(parentStorageMap, variable.trim());
+      }
+
+      if (foundValue === undefined) {
+        continue; // leave unresolved
+      }
+
+      let replacement: string;
+
+      if (typeof foundValue === "object" && foundValue !== null) {
+        replacement = JSON.stringify(foundValue, null, 2);
+      } else {
+        replacement = `${foundValue}`;
+      }
+
+      body = body.replace(
+        "{{" + variable + "}}",
+        isJSON ? VMUtil.serializeValueForJSON(replacement) : replacement,
+      );
+    }
+
+    return body;
+  }
+
   @CaptureSpan()
   public static serializeValueForJSON(value: string): string {
     if (!value) {