@oneuptime/common 10.0.11 → 10.0.15

package/Server/Utils/Memory.ts

@@ -0,0 +1,81 @@
+import fs from "fs";
+import os from "os";
+
+const UNLIMITED_CGROUP_THRESHOLD_BYTES: number = 1 << 60; // treat absurdly large cgroup limit as "unlimited"
+
+export default class MemoryUtil {
+  public static getHostFreeMemoryInBytes(): number {
+    return os.freemem();
+  }
+
+  public static getContainerAwareAvailableMemoryInBytes(): number {
+    const hostFreeMemory: number = this.getHostFreeMemoryInBytes();
+    const cgroupAvailableMemory: number | null =
+      this.getCgroupAvailableMemoryInBytes();
+
+    if (cgroupAvailableMemory === null) {
+      return hostFreeMemory;
+    }
+
+    // Be conservative: never exceed container-available memory.
+    return Math.min(hostFreeMemory, cgroupAvailableMemory);
+  }
+
+  public static getCgroupAvailableMemoryInBytes(): number | null {
+    // cgroup v2
+    const v2Limit: number | null = this.readNumericFile(
+      "/sys/fs/cgroup/memory.max",
+    );
+    const v2Usage: number | null = this.readNumericFile(
+      "/sys/fs/cgroup/memory.current",
+    );
+
+    if (
+      v2Limit &&
+      v2Usage !== null &&
+      v2Limit > 0 &&
+      v2Limit < UNLIMITED_CGROUP_THRESHOLD_BYTES
+    ) {
+      return Math.max(v2Limit - v2Usage, 0);
+    }
+
+    // cgroup v1
+    const v1Limit: number | null = this.readNumericFile(
+      "/sys/fs/cgroup/memory/memory.limit_in_bytes",
+    );
+    const v1Usage: number | null = this.readNumericFile(
+      "/sys/fs/cgroup/memory/memory.usage_in_bytes",
+    );
+
+    if (
+      v1Limit &&
+      v1Usage !== null &&
+      v1Limit > 0 &&
+      v1Limit < UNLIMITED_CGROUP_THRESHOLD_BYTES
+    ) {
+      return Math.max(v1Limit - v1Usage, 0);
+    }
+
+    return null;
+  }
+
+  private static readNumericFile(path: string): number | null {
+    try {
+      const rawValue: string = fs.readFileSync(path, "utf8").trim();
+
+      if (!rawValue || rawValue === "max") {
+        return null;
+      }
+
+      const value: number = Number(rawValue);
+
+      if (!Number.isFinite(value) || value <= 0) {
+        return null;
+      }
+
+      return value;
+    } catch {
+      return null;
+    }
+  }
+}

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

@@ -235,7 +235,10 @@ export default class CompareCriteria {
 
     if (data.criteriaFilter.filterType === FilterType.IsNotEmpty) {
       if (data.value !== null && data.value !== undefined) {
-        return `${data.criteriaFilter.checkOn} is not empty.`;
+        const valueStr: string = String(data.value);
+        const truncatedValue: string =
+          valueStr.length > 500 ? valueStr.substring(0, 500) + "..." : valueStr;
+        return `${data.criteriaFilter.checkOn} is not empty. Value: ${truncatedValue}`;
       }
 
       return null;

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

@@ -238,7 +238,11 @@ export default class IncomingEmailCriteria {
 
     if (criteriaFilter.filterType === FilterType.IsNotEmpty) {
       if (fieldValue && fieldValue.trim() !== "") {
-        return `${fieldName} is not empty.`;
+        const truncatedValue: string =
+          fieldValue.length > 500
+            ? fieldValue.substring(0, 500) + "..."
+            : fieldValue;
+        return `${fieldName} is not empty. Value: ${truncatedValue}`;
       }
       return null;
     }

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) {

package/Tests/Server/Utils/VM/VMAPI.test.ts

@@ -0,0 +1,314 @@
+// Mock all heavy dependencies so the test focuses on template logic only
+jest.mock("../../../../Server/EnvironmentConfig", () => {
+  return {
+    IsolatedVMHostname: "localhost",
+  };
+});
+
+jest.mock("../../../../Server/Middleware/ClusterKeyAuthorization", () => {
+  return {
+    __esModule: true,
+    default: {
+      getClusterKeyHeaders: () => {
+        return {};
+      },
+    },
+  };
+});
+
+jest.mock("../../../../Utils/API", () => {
+  return {
+    __esModule: true,
+    default: { post: jest.fn() },
+  };
+});
+
+jest.mock("../../../../Server/Utils/Logger", () => {
+  return {
+    __esModule: true,
+    default: {
+      error: jest.fn(),
+      debug: jest.fn(),
+      info: jest.fn(),
+      warn: jest.fn(),
+    },
+  };
+});
+
+jest.mock("../../../../Server/Utils/Telemetry/CaptureSpan", () => {
+  return {
+    __esModule: true,
+    default: () => {
+      return (
+        _target: any,
+        _propertyKey: string,
+        descriptor: PropertyDescriptor,
+      ) => {
+        return descriptor;
+      };
+    },
+  };
+});
+
+import VMUtil from "../../../../Server/Utils/VM/VMAPI";
+import { describe, expect, it } from "@jest/globals";
+import { JSONObject } from "../../../../Types/JSON";
+
+describe("VMUtil", () => {
+  describe("deepFind", () => {
+    it("should find top-level keys", () => {
+      const obj: JSONObject = { status: "firing", receiver: "test" };
+      expect(VMUtil.deepFind(obj, "status")).toBe("firing");
+    });
+
+    it("should find nested keys with dot notation", () => {
+      const obj: JSONObject = { data: { nested: { value: 42 } } };
+      expect(VMUtil.deepFind(obj, "data.nested.value")).toBe(42);
+    });
+
+    it("should find array elements with bracket notation", () => {
+      const obj: JSONObject = { items: ["a", "b", "c"] };
+      expect(VMUtil.deepFind(obj, "items[0]")).toBe("a");
+      expect(VMUtil.deepFind(obj, "items[2]")).toBe("c");
+    });
+
+    it("should find last array element with [last]", () => {
+      const obj: JSONObject = { items: [1, 2, 3] };
+      expect(VMUtil.deepFind(obj, "items[last]")).toBe(3);
+    });
+
+    it("should return undefined for missing paths", () => {
+      const obj: JSONObject = { a: { b: 1 } };
+      expect(VMUtil.deepFind(obj, "a.c")).toBeUndefined();
+      expect(VMUtil.deepFind(obj, "x.y.z")).toBeUndefined();
+    });
+  });
+
+  describe("replaceValueInPlace", () => {
+    it("should replace simple variables", () => {
+      const storageMap: JSONObject = { name: "test", status: "firing" };
+      const result: string = VMUtil.replaceValueInPlace(
+        storageMap,
+        "Alert: {{name}} is {{status}}",
+        false,
+      );
+      expect(result).toBe("Alert: test is firing");
+    });
+
+    it("should replace nested dotted path variables", () => {
+      const storageMap: JSONObject = {
+        requestBody: { title: "My Alert", data: { severity: "high" } },
+      };
+      const result: string = VMUtil.replaceValueInPlace(
+        storageMap,
+        "Title: {{requestBody.title}}, Severity: {{requestBody.data.severity}}",
+        false,
+      );
+      expect(result).toBe("Title: My Alert, Severity: high");
+    });
+
+    it("should leave unresolved variables as-is", () => {
+      const storageMap: JSONObject = { name: "test" };
+      const result: string = VMUtil.replaceValueInPlace(
+        storageMap,
+        "{{name}} {{unknown}}",
+        false,
+      );
+      expect(result).toBe("test {{unknown}}");
+    });
+  });
+
+  describe("expandEachLoops", () => {
+    it("should expand a simple each loop over an array of objects", () => {
+      const storageMap: JSONObject = {
+        requestBody: {
+          alerts: [
+            { labels: { label: "Coralpay" }, status: "firing" },
+            { labels: { label: "capitecpay" }, status: "resolved" },
+          ],
+        },
+      };
+
+      const template: string =
+        "Alerts:{{#each requestBody.alerts}} {{labels.label}}({{status}}){{/each}}";
+      const result: string = VMUtil.expandEachLoops(
+        storageMap,
+        template,
+        false,
+      );
+      expect(result).toBe("Alerts: Coralpay(firing) capitecpay(resolved)");
+    });
+
+    it("should support {{@index}} in loops", () => {
+      const storageMap: JSONObject = {
+        items: [{ name: "a" }, { name: "b" }, { name: "c" }],
+      };
+
+      const template: string = "{{#each items}}{{@index}}: {{name}} {{/each}}";
+      const result: string = VMUtil.expandEachLoops(
+        storageMap,
+        template,
+        false,
+      );
+      expect(result).toBe("0: a 1: b 2: c ");
+    });
+
+    it("should support {{this}} for primitive arrays", () => {
+      const storageMap: JSONObject = {
+        tags: ["critical", "production", "api"],
+      };
+
+      const template: string = "Tags:{{#each tags}} {{this}}{{/each}}";
+      const result: string = VMUtil.expandEachLoops(
+        storageMap,
+        template,
+        false,
+      );
+      expect(result).toBe("Tags: critical production api");
+    });
+
+    it("should remove the block if the path is not an array", () => {
+      const storageMap: JSONObject = { notAnArray: "hello" };
+      const template: string = "Before {{#each notAnArray}}body{{/each}} After";
+      const result: string = VMUtil.expandEachLoops(
+        storageMap,
+        template,
+        false,
+      );
+      expect(result).toBe("Before  After");
+    });
+
+    it("should remove the block if the path does not exist", () => {
+      const storageMap: JSONObject = {};
+      const template: string =
+        "Before {{#each missing.path}}body{{/each}} After";
+      const result: string = VMUtil.expandEachLoops(
+        storageMap,
+        template,
+        false,
+      );
+      expect(result).toBe("Before  After");
+    });
+
+    it("should handle empty arrays", () => {
+      const storageMap: JSONObject = { items: [] };
+      const template: string = "Before {{#each items}}item{{/each}} After";
+      const result: string = VMUtil.expandEachLoops(
+        storageMap,
+        template,
+        false,
+      );
+      expect(result).toBe("Before  After");
+    });
+
+    it("should support nested each loops", () => {
+      const storageMap: JSONObject = {
+        groups: [
+          { name: "G1", members: [{ id: 1 }, { id: 2 }] },
+          { name: "G2", members: [{ id: 3 }] },
+        ],
+      };
+
+      const template: string =
+        "{{#each groups}}Group {{name}}: {{#each members}}{{id}} {{/each}}| {{/each}}";
+      const result: string = VMUtil.expandEachLoops(
+        storageMap,
+        template,
+        false,
+      );
+      expect(result).toBe("Group G1: 1 2 | Group G2: 3 | ");
+    });
+
+    it("should allow fallback to parent variables inside loops", () => {
+      const storageMap: JSONObject = {
+        globalTitle: "My Dashboard",
+        items: [{ name: "item1" }, { name: "item2" }],
+      };
+
+      const template: string =
+        "{{#each items}}{{name}} in {{globalTitle}} {{/each}}";
+      const result: string = VMUtil.expandEachLoops(
+        storageMap,
+        template,
+        false,
+      );
+      expect(result).toBe("item1 in My Dashboard item2 in My Dashboard ");
+    });
+  });
+
+  describe("replaceValueInPlace with each loops (end-to-end)", () => {
+    it("should expand loops and then replace remaining variables", () => {
+      const storageMap: JSONObject = {
+        requestBody: {
+          receiver: "Fundsflow",
+          alerts: [
+            {
+              status: "firing",
+              labels: { label: "Coralpay", alertname: "File Drop" },
+            },
+            {
+              status: "firing",
+              labels: { label: "capitecpay", alertname: "File Drop" },
+            },
+          ],
+        },
+      };
+
+      const template: string =
+        "Receiver: {{requestBody.receiver}}\n{{#each requestBody.alerts}}- {{labels.label}}: {{status}}\n{{/each}}";
+      const result: string = VMUtil.replaceValueInPlace(
+        storageMap,
+        template,
+        false,
+      );
+      expect(result).toBe(
+        "Receiver: Fundsflow\n- Coralpay: firing\n- capitecpay: firing\n",
+      );
+    });
+
+    it("should handle the Grafana alerts use case", () => {
+      const storageMap: JSONObject = {
+        requestBody: {
+          status: "firing",
+          alerts: [
+            {
+              status: "firing",
+              labels: {
+                alertname: "Fundsflow File Drop Update",
+                label: "Coralpay",
+              },
+              valueString: "A=0, C=1",
+            },
+            {
+              status: "firing",
+              labels: {
+                alertname: "Fundsflow File Drop Update",
+                label: "capitecpay",
+              },
+              valueString: "A=0, C=1",
+            },
+            {
+              status: "firing",
+              labels: {
+                alertname: "Fundsflow File Drop Update",
+                label: "capricorn",
+              },
+              valueString: "A=0, C=1",
+            },
+          ],
+        },
+      };
+
+      const template: string =
+        "Alert Labels:\n{{#each requestBody.alerts}}- {{labels.label}}\n{{/each}}";
+      const result: string = VMUtil.replaceValueInPlace(
+        storageMap,
+        template,
+        false,
+      );
+      expect(result).toBe(
+        "Alert Labels:\n- Coralpay\n- capitecpay\n- capricorn\n",
+      );
+    });
+  });
+});