@oneuptime/common 10.5.9 → 10.5.18

package/Server/Utils/Telemetry/SpanUtil.ts

@@ -1,5 +1,6 @@
-import OpenTelemetryAPI, { Span } from "@opentelemetry/api";
 import { DisableTelemetry } from "../../EnvironmentConfig";
+import TelemetryContext from "./TelemetryContext";
+import OpenTelemetryAPI, { Span } from "@opentelemetry/api";
 
 export interface SpanAttributes {
   userId?: string | undefined;
@@ -21,14 +22,26 @@ export interface SpanAttributes {
 
 export default class SpanUtil {
   /**
-   * Add attributes to the currently active span.
-   * Safe to call even when there is no active span or telemetry is disabled.
+   * Add attributes to the current unit of work.
+   *
+   * This does two things:
+   *  1. Merges the attributes into the ambient {@link TelemetryContext} so that
+   *     every span and log produced later in this request/job/check inherits
+   *     them (OTel span attributes do NOT propagate parent -> child on their
+   *     own, so this is what actually makes context flow downstream).
+   *  2. Tags the currently active span immediately, if there is one.
+   *
+   * Safe to call even when there is no active span or scope, or when telemetry
+   * is disabled.
    */
   public static addAttributesToCurrentSpan(attributes: SpanAttributes): void {
     if (DisableTelemetry) {
       return;
     }
 
+    // Propagate to all downstream spans + logs via the ambient context.
+    TelemetryContext.setAttributes(attributes);
+
     const span: Span | undefined = OpenTelemetryAPI.trace.getActiveSpan();
 
     if (!span) {
@@ -55,36 +68,4 @@ export default class SpanUtil {
       }
     }
   }
-
-  /**
-   * Build span attributes from a request-like object.
-   * Similar to getLogAttributesFromRequest in Logger but for spans.
-   */
-  public static getSpanAttributesFromRequest(
-    req?: {
-      requestId?: string;
-      tenantId?: { toString(): string };
-      userAuthorization?: { userId?: { toString(): string } };
-    } | null,
-  ): SpanAttributes {
-    if (!req) {
-      return {};
-    }
-
-    const attributes: SpanAttributes = {};
-
-    if (req.requestId) {
-      attributes["requestId"] = req.requestId;
-    }
-
-    if (req.tenantId) {
-      attributes["projectId"] = req.tenantId.toString();
-    }
-
-    if (req.userAuthorization?.userId) {
-      attributes["userId"] = req.userAuthorization.userId.toString();
-    }
-
-    return attributes;
-  }
 }

package/Server/Utils/Telemetry/StackTraceParser.ts

@@ -0,0 +1,423 @@
+/**
+ * Stack trace parser that transforms raw stack trace strings into structured frames.
+ * Supports JavaScript/Node.js, Python, Java, Go, Ruby, C#/.NET, and PHP stack traces.
+ */
+
+export interface StackFrame {
+  functionName: string;
+  fileName: string;
+  lineNumber: number;
+  columnNumber?: number;
+  inApp: boolean; // true if user code, false if library/framework code
+}
+
+export interface ParsedStackTrace {
+  frames: StackFrame[];
+  raw: string; // original raw stack trace string
+}
+
+// Known library/framework path patterns that indicate non-app code
+const LIBRARY_PATTERNS: Array<RegExp> = [
+  // Node.js internals
+  /^node:/,
+  /^internal\//,
+  /node_modules\//,
+  /^events\.js$/,
+  /^timers\.js$/,
+  /^util\.js$/,
+  /^net\.js$/,
+  /^stream\.js$/,
+  /^buffer\.js$/,
+  // Python
+  /\/site-packages\//,
+  /\/dist-packages\//,
+  /\/lib\/python\d+\.\d+\//,
+  /\/usr\/lib\//,
+  /\/usr\/local\/lib\//,
+  /\/venv\//,
+  /\/\.venv\//,
+  /\/virtualenv\//,
+  // Java
+  /^java\./,
+  /^javax\./,
+  /^sun\./,
+  /^com\.sun\./,
+  /^org\.springframework\./,
+  /^org\.apache\./,
+  /^org\.hibernate\./,
+  /^org\.eclipse\./,
+  /^io\.netty\./,
+  /^com\.google\./,
+  /^org\.junit\./,
+  // Go
+  /^runtime\//,
+  /^net\/http\//,
+  /^testing\//,
+  /\/vendor\//,
+  /\/pkg\/mod\//,
+  // Ruby
+  /\/gems\//,
+  /\/rubygems\//,
+  /\/ruby\/\d+\.\d+\.\d+\//,
+  // C#/.NET
+  /^System\./,
+  /^Microsoft\./,
+  /^Newtonsoft\./,
+  // PHP
+  /\/vendor\//,
+  /^phar:\/\//,
+];
+
+export default class StackTraceParser {
+  /**
+   * Parse a raw stack trace string into structured frames.
+   * Auto-detects the language and applies the appropriate parser.
+   */
+  public static parse(rawStackTrace: string): ParsedStackTrace {
+    if (!rawStackTrace || rawStackTrace.trim().length === 0) {
+      return { frames: [], raw: rawStackTrace || "" };
+    }
+
+    const lines: string[] = rawStackTrace.split("\n").map((l: string) => {
+      return l.trim();
+    });
+
+    // Try each parser and use the one that produces the most frames
+    const parsers: Array<(lines: string[]) => StackFrame[]> = [
+      StackTraceParser.parseJavaScript,
+      StackTraceParser.parsePython,
+      StackTraceParser.parseJava,
+      StackTraceParser.parseGo,
+      StackTraceParser.parseRuby,
+      StackTraceParser.parseCSharp,
+      StackTraceParser.parsePHP,
+    ];
+
+    let bestFrames: StackFrame[] = [];
+
+    for (const parser of parsers) {
+      try {
+        const frames: StackFrame[] = parser(lines);
+        if (frames.length > bestFrames.length) {
+          bestFrames = frames;
+        }
+      } catch {
+        // Skip failing parsers
+      }
+    }
+
+    return {
+      frames: bestFrames,
+      raw: rawStackTrace,
+    };
+  }
+
+  /**
+   * Determine if a file path is application code (not library/framework).
+   */
+  private static isAppCode(filePath: string): boolean {
+    if (!filePath) {
+      return true;
+    }
+
+    for (const pattern of LIBRARY_PATTERNS) {
+      if (pattern.test(filePath)) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  /**
+   * Parse JavaScript/Node.js stack traces.
+   * Format: `at functionName (filePath:line:col)` or `at filePath:line:col`
+   */
+  private static parseJavaScript(lines: string[]): StackFrame[] {
+    const frames: StackFrame[] = [];
+
+    // Pattern 1: at functionName (filePath:line:col)
+    const patternWithParens: RegExp = /^at\s+(.+?)\s+\((.+?):(\d+):(\d+)\)$/;
+    // Pattern 2: at filePath:line:col
+    const patternWithoutParens: RegExp = /^at\s+(.+?):(\d+):(\d+)$/;
+    // Pattern 3: at functionName (filePath:line)
+    const patternWithParensNoCol: RegExp = /^at\s+(.+?)\s+\((.+?):(\d+)\)$/;
+    // Pattern 4: at eval (eval at functionName (filePath:line:col))
+    const patternEval: RegExp =
+      /^at\s+eval\s+\(eval\s+at\s+(.+?)\s+\((.+?):(\d+):(\d+)\)/;
+
+    for (const line of lines) {
+      let match: RegExpMatchArray | null = null;
+
+      match = line.match(patternEval);
+      if (match) {
+        frames.push({
+          functionName: `eval at ${match[1]!}`,
+          fileName: match[2]!,
+          lineNumber: parseInt(match[3]!, 10),
+          columnNumber: parseInt(match[4]!, 10),
+          inApp: StackTraceParser.isAppCode(match[2]!),
+        });
+        continue;
+      }
+
+      match = line.match(patternWithParens);
+      if (match) {
+        frames.push({
+          functionName: match[1]!,
+          fileName: match[2]!,
+          lineNumber: parseInt(match[3]!, 10),
+          columnNumber: parseInt(match[4]!, 10),
+          inApp: StackTraceParser.isAppCode(match[2]!),
+        });
+        continue;
+      }
+
+      match = line.match(patternWithParensNoCol);
+      if (match) {
+        frames.push({
+          functionName: match[1]!,
+          fileName: match[2]!,
+          lineNumber: parseInt(match[3]!, 10),
+          inApp: StackTraceParser.isAppCode(match[2]!),
+        });
+        continue;
+      }
+
+      match = line.match(patternWithoutParens);
+      if (match) {
+        frames.push({
+          functionName: "<anonymous>",
+          fileName: match[1]!,
+          lineNumber: parseInt(match[2]!, 10),
+          columnNumber: parseInt(match[3]!, 10),
+          inApp: StackTraceParser.isAppCode(match[1]!),
+        });
+        continue;
+      }
+    }
+
+    return frames;
+  }
+
+  /**
+   * Parse Python stack traces.
+   * Format: `File "path", line N, in function`
+   */
+  private static parsePython(lines: string[]): StackFrame[] {
+    const frames: StackFrame[] = [];
+    const pattern: RegExp =
+      /^File\s+"(.+?)",\s+line\s+(\d+)(?:,\s+in\s+(.+))?$/;
+
+    for (const line of lines) {
+      const match: RegExpMatchArray | null = line.match(pattern);
+      if (match) {
+        frames.push({
+          functionName: match[3] || "<module>",
+          fileName: match[1]!,
+          lineNumber: parseInt(match[2]!, 10),
+          inApp: StackTraceParser.isAppCode(match[1]!),
+        });
+      }
+    }
+
+    return frames;
+  }
+
+  /**
+   * Parse Java stack traces.
+   * Format: `at package.Class.method(File.java:line)`
+   */
+  private static parseJava(lines: string[]): StackFrame[] {
+    const frames: StackFrame[] = [];
+    // Pattern: at com.package.Class.method(File.java:123)
+    const pattern: RegExp = /^at\s+([\w.$]+)\(([\w.]+):(\d+)\)$/;
+    // Pattern for native methods: at com.package.Class.method(Native Method)
+    const patternNative: RegExp = /^at\s+([\w.$]+)\(Native Method\)$/;
+    // Pattern for unknown source: at com.package.Class.method(Unknown Source)
+    const patternUnknown: RegExp = /^at\s+([\w.$]+)\(Unknown Source\)$/;
+
+    for (const line of lines) {
+      let match: RegExpMatchArray | null = null;
+
+      match = line.match(pattern);
+      if (match) {
+        const fullMethod: string = match[1]!;
+        frames.push({
+          functionName: fullMethod,
+          fileName: match[2]!,
+          lineNumber: parseInt(match[3]!, 10),
+          inApp: StackTraceParser.isAppCode(fullMethod),
+        });
+        continue;
+      }
+
+      match = line.match(patternNative);
+      if (match) {
+        frames.push({
+          functionName: match[1]!,
+          fileName: "Native Method",
+          lineNumber: 0,
+          inApp: false,
+        });
+        continue;
+      }
+
+      match = line.match(patternUnknown);
+      if (match) {
+        frames.push({
+          functionName: match[1]!,
+          fileName: "Unknown Source",
+          lineNumber: 0,
+          inApp: StackTraceParser.isAppCode(match[1]!),
+        });
+        continue;
+      }
+    }
+
+    return frames;
+  }
+
+  /**
+   * Parse Go stack traces.
+   * Format: `package/file.go:line +0xNN` or `goroutine N [reason]:`
+   * Go stack traces have pairs of lines:
+   *   functionName(args)
+   *   /path/to/file.go:line +0xNN
+   */
+  private static parseGo(lines: string[]): StackFrame[] {
+    const frames: StackFrame[] = [];
+    const filePattern: RegExp = /^(.+\.go):(\d+)\s*(?:\+0x[0-9a-f]+)?$/;
+
+    for (let i: number = 0; i < lines.length; i++) {
+      const line: string = lines[i]!;
+
+      // Skip goroutine headers
+      if (line.startsWith("goroutine ")) {
+        continue;
+      }
+
+      // Look for file:line pattern
+      const match: RegExpMatchArray | null = line.match(filePattern);
+      if (match) {
+        // The previous line should be the function name
+        let functionName: string = "<unknown>";
+        if (i > 0 && lines[i - 1]) {
+          // Remove arguments from function name
+          const funcLine: string = lines[i - 1]!;
+          const parenIndex: number = funcLine.indexOf("(");
+          functionName =
+            parenIndex > 0 ? funcLine.substring(0, parenIndex) : funcLine;
+        }
+
+        frames.push({
+          functionName: functionName,
+          fileName: match[1]!,
+          lineNumber: parseInt(match[2]!, 10),
+          inApp: StackTraceParser.isAppCode(match[1]!),
+        });
+      }
+    }
+
+    return frames;
+  }
+
+  /**
+   * Parse Ruby stack traces.
+   * Format: `file:line:in 'method'` or `file:line:in \`method'`
+   */
+  private static parseRuby(lines: string[]): StackFrame[] {
+    const frames: StackFrame[] = [];
+    const pattern: RegExp = /^(.+?):(\d+):in\s+[`'](.+?)'$/;
+
+    for (const line of lines) {
+      const match: RegExpMatchArray | null = line.match(pattern);
+      if (match) {
+        frames.push({
+          functionName: match[3]!,
+          fileName: match[1]!,
+          lineNumber: parseInt(match[2]!, 10),
+          inApp: StackTraceParser.isAppCode(match[1]!),
+        });
+      }
+    }
+
+    return frames;
+  }
+
+  /**
+   * Parse C#/.NET stack traces.
+   * Format: `at Namespace.Class.Method(params) in file:line N`
+   */
+  private static parseCSharp(lines: string[]): StackFrame[] {
+    const frames: StackFrame[] = [];
+    // Pattern: at Namespace.Class.Method(params) in /path/to/file.cs:line 42
+    const patternWithFile: RegExp = /^at\s+(.+?)\s+in\s+(.+?):line\s+(\d+)$/;
+    // Pattern: at Namespace.Class.Method(params)
+    const patternWithoutFile: RegExp = /^at\s+([\w.<>+]+\(.*?\))$/;
+
+    for (const line of lines) {
+      let match: RegExpMatchArray | null = null;
+
+      match = line.match(patternWithFile);
+      if (match) {
+        frames.push({
+          functionName: match[1]!,
+          fileName: match[2]!,
+          lineNumber: parseInt(match[3]!, 10),
+          inApp: StackTraceParser.isAppCode(match[1]!),
+        });
+        continue;
+      }
+
+      match = line.match(patternWithoutFile);
+      if (match) {
+        frames.push({
+          functionName: match[1]!,
+          fileName: "",
+          lineNumber: 0,
+          inApp: StackTraceParser.isAppCode(match[1]!),
+        });
+        continue;
+      }
+    }
+
+    return frames;
+  }
+
+  /**
+   * Parse PHP stack traces.
+   * Format: `#N /path/to/file.php(line): Class->method()`
+   */
+  private static parsePHP(lines: string[]): StackFrame[] {
+    const frames: StackFrame[] = [];
+    // Pattern: #0 /path/to/file.php(42): ClassName->method()
+    const pattern: RegExp = /^#\d+\s+(.+?)\((\d+)\):\s+(.+)$/;
+    // Pattern: #0 {main}
+    const patternMain: RegExp = /^#\d+\s+\{main\}$/;
+
+    for (const line of lines) {
+      if (patternMain.test(line)) {
+        frames.push({
+          functionName: "{main}",
+          fileName: "",
+          lineNumber: 0,
+          inApp: true,
+        });
+        continue;
+      }
+
+      const match: RegExpMatchArray | null = line.match(pattern);
+      if (match) {
+        frames.push({
+          functionName: match[3]!.replace(/\(\)$/, ""),
+          fileName: match[1]!,
+          lineNumber: parseInt(match[2]!, 10),
+          inApp: StackTraceParser.isAppCode(match[1]!),
+        });
+      }
+    }
+
+    return frames;
+  }
+}

package/Server/Utils/Telemetry/TelemetryContext.ts

@@ -0,0 +1,190 @@
+import { DisableTelemetry } from "../../EnvironmentConfig";
+import { AsyncLocalStorage } from "async_hooks";
+
+export type TelemetryContextAttributeValue =
+  | string
+  | number
+  | boolean
+  | undefined;
+
+/**
+ * Canonical set of tenant/business attributes we propagate across a unit of
+ * work (an HTTP request, a worker job, a probe check, a cron run). The open
+ * index signature allows additional ad-hoc keys, but prefer the named ones so
+ * dashboards and queries stay consistent.
+ */
+export interface TelemetryContextAttributes {
+  userId?: string | undefined;
+  projectId?: string | undefined;
+  requestId?: string | undefined;
+  incidentId?: string | undefined;
+  alertId?: string | undefined;
+  monitorId?: string | undefined;
+  statusPageId?: string | undefined;
+  scheduledMaintenanceId?: string | undefined;
+  onCallDutyPolicyId?: string | undefined;
+  onCallDutyPolicyScheduleId?: string | undefined;
+  incidentEpisodeId?: string | undefined;
+  alertEpisodeId?: string | undefined;
+  workspaceType?: string | undefined;
+  channelId?: string | undefined;
+  [key: string]: TelemetryContextAttributeValue;
+}
+
+interface TelemetryContextStore {
+  attributes: Record<string, string | number | boolean>;
+}
+
+/**
+ * Ambient, mutable telemetry context backed by AsyncLocalStorage.
+ *
+ * Why this exists: OpenTelemetry span attributes do NOT propagate from a
+ * parent span to its children, and OneUptime sets tenant context (projectId,
+ * userId, ...) deep in middleware while the spans that matter are created much
+ * further down the call stack. Rather than thread attributes through every
+ * function or tag ~1958 `@CaptureSpan` call sites by hand, we keep a small
+ * mutable attribute bag scoped to the current unit of work. `ContextSpanProcessor`
+ * stamps it onto every span at creation, and `Logger` merges it into every log
+ * record — so context flows everywhere automatically.
+ *
+ * Seed a scope at each entry point with `runWithContext`, then enrich it as
+ * more identifiers become known with `setAttributes`.
+ */
+export default class TelemetryContext {
+  private static storage: AsyncLocalStorage<TelemetryContextStore> =
+    new AsyncLocalStorage<TelemetryContextStore>();
+
+  /**
+   * Identifier keys we look for when seeding context from an arbitrary payload
+   * (see {@link pickKnownAttributes}).
+   */
+  private static readonly KNOWN_ID_KEYS: Array<string> = [
+    "projectId",
+    "userId",
+    "monitorId",
+    "incidentId",
+    "alertId",
+    "statusPageId",
+    "scheduledMaintenanceId",
+    "onCallDutyPolicyId",
+    "onCallDutyPolicyScheduleId",
+    "incidentEpisodeId",
+    "alertEpisodeId",
+    "workspaceType",
+    "channelId",
+    "requestId",
+  ];
+
+  /**
+   * Run `fn` within a fresh telemetry-context scope seeded with `attributes`.
+   * Any attributes from an enclosing scope are inherited so nested units of
+   * work (e.g. a job spawned while handling a request) keep their context.
+   */
+  public static runWithContext<T>(
+    attributes: TelemetryContextAttributes,
+    fn: () => T,
+  ): T {
+    if (DisableTelemetry) {
+      return fn();
+    }
+
+    const inherited: Record<string, string | number | boolean> =
+      this.getAttributes();
+
+    const store: TelemetryContextStore = {
+      attributes: { ...inherited },
+    };
+
+    this.mergeInto(store.attributes, attributes);
+
+    return this.storage.run(store, fn);
+  }
+
+  /**
+   * Merge `attributes` into the current scope. No-op when there is no active
+   * scope (e.g. code running outside any seeded entry point) or telemetry is
+   * disabled, so it is always safe to call.
+   */
+  public static setAttributes(attributes: TelemetryContextAttributes): void {
+    if (DisableTelemetry) {
+      return;
+    }
+
+    const store: TelemetryContextStore | undefined = this.storage.getStore();
+
+    if (!store) {
+      return;
+    }
+
+    this.mergeInto(store.attributes, attributes);
+  }
+
+  /**
+   * Read the attributes for the current scope. Returns an empty object when
+   * there is no active scope. The returned object is the live store — treat it
+   * as read-only (consumers copy it before mutating).
+   */
+  public static getAttributes(): Record<string, string | number | boolean> {
+    const store: TelemetryContextStore | undefined = this.storage.getStore();
+
+    if (!store) {
+      return {};
+    }
+
+    return store.attributes;
+  }
+
+  /**
+   * Best-effort extraction of known tenant/business identifiers from an
+   * arbitrary object (e.g. a queue job's `data` payload), so worker jobs can
+   * seed context without every job knowing about telemetry. Values are coerced
+   * to strings; unknown/empty values are skipped.
+   */
+  public static pickKnownAttributes(data: unknown): TelemetryContextAttributes {
+    const attributes: TelemetryContextAttributes = {};
+
+    if (!data || typeof data !== "object") {
+      return attributes;
+    }
+
+    const record: Record<string, unknown> = data as Record<string, unknown>;
+
+    for (const key of this.KNOWN_ID_KEYS) {
+      const value: unknown = record[key];
+
+      if (value === undefined || value === null) {
+        continue;
+      }
+
+      if (
+        typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean"
+      ) {
+        attributes[key] = value;
+        continue;
+      }
+
+      // ObjectID-like values expose a meaningful toString().
+      const asString: string = String(value);
+      if (asString && asString !== "[object Object]") {
+        attributes[key] = asString;
+      }
+    }
+
+    return attributes;
+  }
+
+  private static mergeInto(
+    target: Record<string, string | number | boolean>,
+    attributes: TelemetryContextAttributes,
+  ): void {
+    for (const key in attributes) {
+      const value: TelemetryContextAttributeValue = attributes[key];
+
+      if (value !== undefined && value !== null) {
+        target[key] = value;
+      }
+    }
+  }
+}