@senzops/apm-node 1.3.1 → 1.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@senzops/apm-node",
-  "version": "1.3.1",
+  "version": "1.3.2",
   "description": "Universal APM SDK for Senzor",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/core/client.ts

@@ -9,14 +9,20 @@ import { sanitizeAttributes } from './sanitizer';
 import { startCapturedSpan } from '../instrumentation/span';
 import { RuntimeMetricsCollector } from '../instrumentation/runtime';
 
-// Memory-safe JSON stringifier to handle cyclical objects 
-// (like Express 'req' objects) passed into console.log
+const MAX_STRINGIFY_LENGTH = 8192;
+
 const safeStringify = (obj: any): string => {
-  const cache = new Set();
-  return JSON.stringify(obj, (key, value) => {
+  const seen = new Set();
+  let length = 0;
+  return JSON.stringify(obj, function (_key, value) {
+    if (length > MAX_STRINGIFY_LENGTH) return undefined;
+    if (typeof value === 'string') {
+      length += value.length;
+      if (value.length > 2048) return value.slice(0, 2048) + '...[truncated]';
+    }
     if (typeof value === 'object' && value !== null) {
-      if (cache.has(value)) return '[Circular]';
-      cache.add(value);
+      if (seen.has(value)) return '[Circular]';
+      seen.add(value);
     }
     return value;
   });
@@ -299,14 +305,37 @@ export class SenzorClient {
       }
     };
 
+    const flushAndExit = (code: number) => {
+      if (this.transport) {
+        const timeout = setTimeout(() => process.exit(code), 2000);
+        if (typeof timeout.unref === 'function') timeout.unref();
+        this.transport.flush().then(
+          () => process.exit(code),
+          () => process.exit(code)
+        );
+      } else {
+        process.exit(code);
+      }
+    };
+
+    // Monitor-only: captures for telemetry without altering default crash behavior.
+    // Node.js will still print the stack and exit after this listener runs.
     process.on('uncaughtExceptionMonitor', (error) => safeCapture(error, { type: 'uncaughtExceptionMonitor', severity: 'fatal' }));
-    process.on('uncaughtException', (error) => safeCapture(error, { type: 'uncaughtException', severity: 'fatal' }));
+
     process.on('unhandledRejection', (reason) => safeCapture(reason, { type: 'unhandledRejection', severity: 'error' }));
     process.on('warning', (warning) => safeCapture(warning, { type: 'processWarning', severity: 'warning' }));
-    process.on('multipleResolves', (type, promise, reason) => safeCapture(reason || new Error('Multiple promise resolves'), { type: 'multipleResolves', resolveType: type, severity: 'warning' }));
-    process.on('rejectionHandled', (promise) => { if (this.options?.debug) { try { console.warn('[Senzor] rejectionHandled event detected'); } catch { } } });
-    process.on('SIGTERM', () => safeCapture(new Error('Process received SIGTERM'), { type: 'processSignal', signal: 'SIGTERM' }));
-    process.on('SIGINT', () => safeCapture(new Error('Process received SIGINT'), { type: 'processSignal', signal: 'SIGINT' }));
+
+    let shuttingDown = false;
+
+    const gracefulShutdown = (signal: string, exitCode: number) => {
+      if (shuttingDown) return;
+      shuttingDown = true;
+      safeCapture(new Error(`Process received ${signal}`), { type: 'processSignal', signal, severity: 'warning' });
+      flushAndExit(exitCode);
+    };
+
+    process.on('SIGTERM', () => gracefulShutdown('SIGTERM', 143));
+    process.on('SIGINT', () => gracefulShutdown('SIGINT', 130));
   }
 
   public startTrace<T>(data: Partial<ActiveTrace['data']> & { headers?: any }, next: () => T): T {

package/src/core/context.ts

@@ -6,54 +6,50 @@ interface IStorage<T> {
 }
 
 /**
- * Async-safe fallback when AsyncLocalStorage is unavailable.
+ * Per-callback context tracking for runtimes without AsyncLocalStorage.
  *
- * Not concurrency-safe across truly parallel requests in a single isolate,
- * but correct for sequential and async/await patterns (e.g. Cloudflare Workers
- * where each request gets its own execution context).
+ * Uses a stack instead of a single variable so overlapping synchronous
+ * Context.run() calls (e.g. nested middleware) don't clobber each other.
+ * Async context is propagated by chaining onto the returned thenable.
+ *
+ * NOT safe for truly concurrent requests in a single isolate — use
+ * AsyncLocalStorage for that. This exists as a last-resort fallback.
  */
 class NaiveStorage<T> implements IStorage<T> {
-  private store: T | undefined;
+  private stack: T[] = [];
 
   run<R>(store: T, callback: (...args: any[]) => R, ...args: any[]): R {
-    const prev = this.store;
-    this.store = store;
+    this.stack.push(store);
 
     let result: R;
     try {
       result = callback(...args);
     } catch (err) {
-      this.store = prev;
+      this.stack.pop();
       throw err;
     }
 
-    // If the callback returned a thenable (async handler), defer the restore
-    // until the promise settles so Context.current() works across awaits.
     if (result != null && typeof (result as any).then === 'function') {
       const promise = (result as any).then(
-        (val: any) => { this.store = prev; return val; },
-        (err: any) => { this.store = prev; throw err; }
+        (val: any) => { this.stack.pop(); return val; },
+        (err: any) => { this.stack.pop(); throw err; }
       );
       return promise as R;
     }
 
-    // Sync callback — restore immediately.
-    this.store = prev;
+    this.stack.pop();
     return result;
   }
 
   getStore(): T | undefined {
-    return this.store;
+    return this.stack.length > 0 ? this.stack[this.stack.length - 1] : undefined;
   }
 }
 
 /**
  * Resolve the best available async context storage.
  *
- * Uses lazy re-resolution: if the initial attempt (at module evaluation time)
- * falls back to NaiveStorage, subsequent calls to resolveStorage() will retry.
- * This handles runtimes where AsyncLocalStorage becomes available after module
- * init (e.g. some Workers configurations).
+ * Tries multiple resolution strategies to cover CJS, ESM, and edge runtimes.
  */
 const tryResolveALS = <T>(): IStorage<T> | null => {
   // 1. Check globalThis (Cloudflare Workers nodejs_compat_v2, Bun, Deno)
@@ -76,6 +72,17 @@ const tryResolveALS = <T>(): IStorage<T> | null => {
     }
   } catch {}
 
+  // 3. ESM fallback: indirect require via Function constructor
+  // In bundled ESM (tsup/esbuild), `require` is shimmed and steps 1-2 work.
+  // This step handles raw ESM where require is truly unavailable.
+  try {
+    if (typeof require === 'undefined' && typeof process !== 'undefined') {
+      const fn = new Function('try { var m = require("module"); return m.createRequire(process.cwd() + "/")("node:async_hooks"); } catch(e) { return null; }');
+      const mod = fn();
+      if (mod?.AsyncLocalStorage) return new mod.AsyncLocalStorage();
+    }
+  } catch {}
+
   return null;
 };
 

package/src/core/transport.ts

@@ -15,6 +15,9 @@ interface TaskPayload {
   logs: SenzorLog[];
 }
 
+const MAX_BACKOFF_MS = 60_000;
+const BASE_BACKOFF_MS = 1_000;
+
 export class Transport {
   private traceQueue: Trace[] = [];
   private apmErrorQueue: SenzorError[] = [];
@@ -33,6 +36,9 @@ export class Transport {
   private flushAgain = false;
   private droppedItems = 0;
 
+  private consecutiveFailures = 0;
+  private backoffUntil = 0;
+
   constructor(private config: SenzorOptions) {
     const baseEndpoint = config.endpoint || 'https://api.senzor.dev';
     this.apmEndpoint = baseEndpoint.includes('/api/ingest')
@@ -41,10 +47,6 @@ export class Transport {
     this.taskEndpoint = baseEndpoint.includes('/api/ingest')
       ? baseEndpoint.replace('/apm', '/task')
       : `${baseEndpoint}/api/ingest/task`;
-
-    // Timer and shutdown flush are deferred to first enqueue.
-    // Cloudflare Workers forbids setInterval / process access in global scope,
-    // and init() may be called at module evaluation time (e.g. Nitro plugins).
   }
 
   private ensureTimer() {
@@ -94,7 +96,6 @@ export class Transport {
 
   public addRuntimeMetrics(payload: RuntimeMetricsPayload) {
     this.enqueue(this.runtimeMetricsQueue, payload);
-    // Runtime metrics don't trigger immediate flush — they ride the next timer
   }
 
   private enqueue<T>(queue: T[], item: T) {
@@ -236,6 +237,8 @@ export class Transport {
       return;
     }
 
+    if (Date.now() < this.backoffUntil) return;
+
     this.isFlushing = true;
 
     try {
@@ -271,6 +274,21 @@ export class Transport {
           (result) => result.status === 'rejected'
         );
 
+        if (failures.length > 0) {
+          this.consecutiveFailures++;
+          const delay = Math.min(
+            BASE_BACKOFF_MS * Math.pow(2, this.consecutiveFailures - 1),
+            MAX_BACKOFF_MS
+          );
+          this.backoffUntil = Date.now() + delay;
+          if (this.config.debug) {
+            console.warn(`[Senzor] Flush failed (attempt ${this.consecutiveFailures}), backing off ${delay}ms`);
+          }
+        } else {
+          this.consecutiveFailures = 0;
+          this.backoffUntil = 0;
+        }
+
         if (this.config.debug) {
           console.log(
             `[Senzor] Flushed: APM(${apmPayload.traces.length} traces, ${apmPayload.logs.length} logs), Task(${taskPayload.runs.length} runs, ${taskPayload.logs.length} logs), failures=${failures.length}, dropped=${this.droppedItems}`
@@ -296,10 +314,10 @@ export class Transport {
       enumerable: false
     });
 
-    const flushSyncBestEffort = () => {
+    const flushBestEffort = () => {
       void this.flush();
     };
 
-    process.once('beforeExit', flushSyncBestEffort);
+    process.once('beforeExit', flushBestEffort);
   }
 }

package/src/instrumentation/amqplib.ts

@@ -194,7 +194,7 @@ const patchChannel = (channelProto: any, options?: SenzorOptions) => {
       function patchedConsume(
         this: any,
         queue: string,
-        callback: (msg: any) => void,
+        callback: (msg: any) => any,
         consumeOptions?: any
       ) {
         if (typeof callback !== 'function') {

package/src/instrumentation/hook.ts

@@ -1,138 +1,120 @@
-type HookFn = (exports: unknown) => unknown | void;
-type HookMap = Map<string, HookFn[]>;
-
-let Module: any;
-let safeRequire: NodeRequire;
-
-try {
-  Module = require('module');
-  safeRequire = Module.createRequire(
-    typeof __filename !== 'undefined'
-      ? __filename
-      : process.cwd() + '/'
-  );
-} catch {}
-
-const SENZOR_PATCHED = Symbol.for('senzor.require.patched');
-const SENZOR_HOOKS = Symbol.for('senzor.require.hooks');
-
-function getHookRegistry(): HookMap {
-  const mod = Module as unknown as Record<symbol, HookMap>;
-
-  if (!mod[SENZOR_HOOKS]) {
-    Object.defineProperty(mod, SENZOR_HOOKS, {
-      value: new Map(),
-      enumerable: false
-    });
-  }
-
-  return mod[SENZOR_HOOKS];
-}
-
-function runHooks(moduleName: string, exports: unknown) {
-  const registry = (Module as unknown as Record<symbol, HookMap>)[SENZOR_HOOKS];
-  if (!registry) return exports;
-
-  const hooks = registry.get(moduleName);
-  if (!hooks?.length) return exports;
-
-  let currentExports = exports;
-
-  for (const hook of hooks) {
-    try {
-      const nextExports = hook(currentExports);
-      if (nextExports !== undefined) {
-        currentExports = nextExports;
-      }
-    } catch (err) {
-      console.error(`[Senzor] instrumentation failed for ${moduleName}`, err);
-    }
-  }
-
-  return currentExports;
-}
-
-function patchLoaderOnce() {
-  const mod = Module as unknown as any;
-
-  if (mod[SENZOR_PATCHED]) return;
-
-  const previousLoad = mod._load;
-
-  mod._load = function patchedLoad(
-    request: string,
-    parent: unknown,
-    isMain: boolean
-  ) {
-    const exports = previousLoad.apply(this, arguments);
-    return runHooks(request, exports);
-  };
-
-  Object.defineProperty(mod, SENZOR_PATCHED, {
-    value: true,
-    enumerable: false
-  });
-}
-
-function patchCached(moduleName: string, hook: HookFn) {
-  try {
-    const resolved = safeRequire.resolve(moduleName);
-    const cached = safeRequire.cache?.[resolved];
-
-    if (cached?.exports) {
-      const replacement = hook(cached.exports);
-      if (replacement !== undefined) {
-        cached.exports = replacement;
-      }
-    }
-  } catch { }
-}
-
-function tryRequire(moduleName: string, hook: HookFn) {
-  try {
-    const mod = safeRequire(moduleName);
-    if (mod) {
-      hook(mod);
-    }
-  } catch { }
-}
-
-function retryPatch(moduleName: string, hook: HookFn) {
-  let attempts = 0;
-  const max = 5;
-
-  const timer = setInterval(() => {
-    attempts++;
-
-    try {
-      const mod = safeRequire(moduleName);
-      if (mod) {
-        hook(mod);
-        clearInterval(timer);
-      }
-    } catch { }
-
-    if (attempts >= max) {
-      clearInterval(timer);
-    }
-  }, 200);
-
-  if (typeof timer.unref === 'function') timer.unref();
-}
-
-export const hookRequire = (moduleName: string, onRequire: HookFn) => {
-  if (!Module || !safeRequire) return;
-
-  const registry = getHookRegistry();
-
-  if (!registry.has(moduleName)) {
-    registry.set(moduleName, []);
-  }
-
-  registry.get(moduleName)!.push(onRequire);
-
-  patchLoaderOnce();
-  patchCached(moduleName, onRequire);
-  tryRequire(moduleName, onRequire);
-  retryPatch(moduleName, onRequire);
-};
+type HookFn = (exports: unknown) => unknown | void;
+type HookMap = Map<string, HookFn[]>;
+
+let Module: any = null;
+let safeRequire: NodeRequire | null = null;
+
+try {
+  Module = require('module');
+  safeRequire = Module.createRequire(
+    typeof __filename !== 'undefined'
+      ? __filename
+      : process.cwd() + '/'
+  );
+} catch {}
+
+// ESM fallback: if native require is unavailable, try to bootstrap via createRequire
+if (!Module || !safeRequire) {
+  try {
+    const nodeModule = (Function('try { return require("module") } catch(e) { return null }'))();
+    if (nodeModule?.createRequire) {
+      Module = nodeModule;
+      const cwd = typeof process !== 'undefined' && process.cwd ? process.cwd() : '/';
+      safeRequire = nodeModule.createRequire(cwd + '/');
+    }
+  } catch {}
+}
+
+const SENZOR_PATCHED = Symbol.for('senzor.require.patched');
+const SENZOR_HOOKS = Symbol.for('senzor.require.hooks');
+
+function getHookRegistry(): HookMap {
+  const mod = Module as unknown as Record<symbol, HookMap>;
+
+  if (!mod[SENZOR_HOOKS]) {
+    Object.defineProperty(mod, SENZOR_HOOKS, {
+      value: new Map(),
+      enumerable: false
+    });
+  }
+
+  return mod[SENZOR_HOOKS];
+}
+
+function runHooks(moduleName: string, exports: unknown) {
+  const registry = (Module as unknown as Record<symbol, HookMap>)[SENZOR_HOOKS];
+  if (!registry) return exports;
+
+  const hooks = registry.get(moduleName);
+  if (!hooks?.length) return exports;
+
+  let currentExports = exports;
+
+  for (const hook of hooks) {
+    try {
+      const nextExports = hook(currentExports);
+      if (nextExports !== undefined) {
+        currentExports = nextExports;
+      }
+    } catch (err) {
+      console.error(`[Senzor] instrumentation failed for ${moduleName}`, err);
+    }
+  }
+
+  return currentExports;
+}
+
+function patchLoaderOnce() {
+  const mod = Module as unknown as any;
+
+  if (mod[SENZOR_PATCHED]) return;
+
+  // Module._load is CJS-specific; in pure ESM runtimes it may not exist
+  if (typeof mod._load !== 'function') return;
+
+  const previousLoad = mod._load;
+
+  mod._load = function patchedLoad(
+    request: string,
+    parent: unknown,
+    isMain: boolean
+  ) {
+    const exports = previousLoad.apply(this, arguments);
+    return runHooks(request, exports);
+  };
+
+  Object.defineProperty(mod, SENZOR_PATCHED, {
+    value: true,
+    enumerable: false
+  });
+}
+
+function patchCached(moduleName: string, hook: HookFn) {
+  if (!safeRequire) return;
+  try {
+    const resolved = safeRequire.resolve(moduleName);
+    const cached = safeRequire.cache?.[resolved];
+
+    if (cached?.exports) {
+      const replacement = hook(cached.exports);
+      if (replacement !== undefined) {
+        cached.exports = replacement;
+      }
+    }
+  } catch { }
+}
+
+export const hookRequire = (moduleName: string, onRequire: HookFn) => {
+  if (!Module || !safeRequire) return;
+
+  const registry = getHookRegistry();
+
+  if (!registry.has(moduleName)) {
+    registry.set(moduleName, []);
+  }
+
+  registry.get(moduleName)!.push(onRequire);
+
+  patchLoaderOnce();
+  patchCached(moduleName, onRequire);
+};

package/src/instrumentation/undici.ts

@@ -70,6 +70,21 @@ const patchRequestLike = (
           return original.apply(this, arguments as any);
         }
 
+        // Skip if the request already has Senzor trace headers injected by
+        // the fetch instrumentation (Node.js fetch delegates to undici internally).
+        const existingHeaders = opts?.headers;
+        if (existingHeaders) {
+          let hasTrace = false;
+          if (typeof Headers !== 'undefined' && existingHeaders instanceof Headers) {
+            hasTrace = existingHeaders.has('x-senzor-trace-id');
+          } else if (Array.isArray(existingHeaders)) {
+            hasTrace = existingHeaders.some(([k]: [string, string]) => String(k).toLowerCase() === 'x-senzor-trace-id');
+          } else if (typeof existingHeaders === 'object') {
+            hasTrace = Object.keys(existingHeaders).some(k => k.toLowerCase() === 'x-senzor-trace-id');
+          }
+          if (hasTrace) return original.apply(this, arguments as any);
+        }
+
         const details = getUrlDetails(input?.origin ? input.origin : input);
         const method = String(opts?.method || 'GET').toUpperCase();
         const span = startCapturedSpan(