@senzops/apm-node 1.2.5 → 1.2.6

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@senzops/apm-node",
-  "version": "1.2.5",
+  "version": "1.2.6",
   "description": "Universal APM SDK for Senzor",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
+      "worker": "./dist/index.mjs",
       "require": "./dist/index.js",
       "import": "./dist/index.mjs"
     },
@@ -26,7 +27,8 @@
     "typescript": "^5.0.0"
   },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=18.0.0",
+    "bun": ">=1.0.0"
   },
   "keywords": [
     "apm",
@@ -35,7 +37,10 @@
     "node",
     "javascript",
     "api",
-    "observability"
+    "observability",
+    "cloudflare-workers",
+    "edge",
+    "universal"
   ],
   "author": "Senzops",
   "license": "MIT"

package/src/core/client.ts

@@ -1,19 +1,7 @@
 import { Transport } from './transport';
 import { Context } from './context';
 import { SenzorOptions, ActiveTrace, TaskRun, SenzorLog } from './types';
-import { randomUUID } from 'crypto';
-import { instrumentHttp, instrumentFetch } from '../instrumentation/http';
-import { instrumentExpress } from '../instrumentation/express';
-import { instrumentFastify } from '../instrumentation/fastify';
-import { instrumentKoa } from '../instrumentation/koa';
-import { instrumentMongo } from '../instrumentation/mongo';
-import { instrumentPg } from '../instrumentation/pg';
-import { instrumentUndici } from '../instrumentation/undici';
-import { instrumentRedis } from '../instrumentation/redis';
-import { instrumentMysql } from '../instrumentation/mysql';
-import { instrumentMongoose } from '../instrumentation/mongoose';
-import { instrumentBullMQ } from '../instrumentation/bullmq';
-import { instrumentNodeCron } from '../instrumentation/cron';
+import { isNode } from './runtime';
 import { SDK_META } from '../utils/sdkMeta';
 import { parseTraceparent } from '../utils/traceContext';
 import { generateSpanId, generateTraceId } from '../utils/ids';
@@ -72,29 +60,37 @@ export class SenzorClient {
   }
 
   private installNativeInstrumentations(endpoint: string, debug: boolean) {
-    if (!this.isInstrumented) {
-      this.setupGlobalErrorHandlers();
-      this.setupLogInterception(); // Fire up Auto Log Instrumentation
-
-      try { if (this.isInstrumentationEnabled('http')) instrumentHttp(this, endpoint, this.options || undefined); } catch (e) { }
-      try { if (this.isInstrumentationEnabled('express')) instrumentExpress(this.options || undefined); } catch (e) { }
-      try { if (this.isInstrumentationEnabled('fastify')) instrumentFastify(this.options || undefined); } catch (e) { }
-      try { if (this.isInstrumentationEnabled('koa')) instrumentKoa(this.options || undefined); } catch (e) { }
-      try { if (this.isInstrumentationEnabled('fetch')) instrumentFetch(endpoint, this.options || undefined); } catch (e) { }
-      try { if (this.isInstrumentationEnabled('undici')) instrumentUndici(this.options || undefined); } catch (e) { }
-      try { if (this.isInstrumentationEnabled('mongo')) instrumentMongo(this.options || undefined); } catch (e) { }
-      try { if (this.isInstrumentationEnabled('mongoose')) instrumentMongoose(this.options || undefined); } catch (e) { }
-      try { if (this.isInstrumentationEnabled('pg')) instrumentPg(this.options || undefined); } catch (e) { }
-      try { if (this.isInstrumentationEnabled('mysql')) instrumentMysql(this.options || undefined); } catch (e) { }
-      try { if (this.isInstrumentationEnabled('redis')) instrumentRedis(this.options || undefined); } catch (e) { }
-
-      // Task Integrations 
-      try { if (this.isInstrumentationEnabled('bullmq')) instrumentBullMQ(this, debug); } catch (e) { }
-      try { if (this.isInstrumentationEnabled('cron')) instrumentNodeCron(this, debug); } catch (e) { }
-
-      this.isInstrumented = true;
-      if (debug) console.log('[Senzor] Auto-instrumentation enabled');
+    if (this.isInstrumented) return;
+
+    this.setupGlobalErrorHandlers();
+    this.setupLogInterception();
+
+    // Fetch instrumentation works on all runtimes (Workers, Node, Bun, Deno)
+    try {
+      if (this.isInstrumentationEnabled('fetch')) {
+        const { instrumentFetch } = require('../instrumentation/http');
+        instrumentFetch(endpoint, this.options || undefined);
+      }
+    } catch {}
+
+    // Node-only instrumentations: http, module hooking, db drivers, etc.
+    if (isNode()) {
+      try { if (this.isInstrumentationEnabled('http')) { const { instrumentHttp } = require('../instrumentation/http'); instrumentHttp(this, endpoint, this.options || undefined); } } catch {}
+      try { if (this.isInstrumentationEnabled('express')) { const { instrumentExpress } = require('../instrumentation/express'); instrumentExpress(this.options || undefined); } } catch {}
+      try { if (this.isInstrumentationEnabled('fastify')) { const { instrumentFastify } = require('../instrumentation/fastify'); instrumentFastify(this.options || undefined); } } catch {}
+      try { if (this.isInstrumentationEnabled('koa')) { const { instrumentKoa } = require('../instrumentation/koa'); instrumentKoa(this.options || undefined); } } catch {}
+      try { if (this.isInstrumentationEnabled('undici')) { const { instrumentUndici } = require('../instrumentation/undici'); instrumentUndici(this.options || undefined); } } catch {}
+      try { if (this.isInstrumentationEnabled('mongo')) { const { instrumentMongo } = require('../instrumentation/mongo'); instrumentMongo(this.options || undefined); } } catch {}
+      try { if (this.isInstrumentationEnabled('mongoose')) { const { instrumentMongoose } = require('../instrumentation/mongoose'); instrumentMongoose(this.options || undefined); } } catch {}
+      try { if (this.isInstrumentationEnabled('pg')) { const { instrumentPg } = require('../instrumentation/pg'); instrumentPg(this.options || undefined); } } catch {}
+      try { if (this.isInstrumentationEnabled('mysql')) { const { instrumentMysql } = require('../instrumentation/mysql'); instrumentMysql(this.options || undefined); } } catch {}
+      try { if (this.isInstrumentationEnabled('redis')) { const { instrumentRedis } = require('../instrumentation/redis'); instrumentRedis(this.options || undefined); } } catch {}
+      try { if (this.isInstrumentationEnabled('bullmq')) { const { instrumentBullMQ } = require('../instrumentation/bullmq'); instrumentBullMQ(this, debug); } } catch {}
+      try { if (this.isInstrumentationEnabled('cron')) { const { instrumentNodeCron } = require('../instrumentation/cron'); instrumentNodeCron(this, debug); } } catch {}
     }
+
+    this.isInstrumented = true;
+    if (debug) console.log('[Senzor] Auto-instrumentation enabled');
   }
 
   // --- Enterprise Auto-Log Interception ---
@@ -177,6 +173,8 @@ export class SenzorClient {
   }
 
   private setupGlobalErrorHandlers() {
+    if (!isNode()) return;
+
     if ((process as any).__senzorGlobalHandlersInstalled) {
       return;
     }
@@ -338,11 +336,11 @@ export class SenzorClient {
     const currentContext = Context.current();
     const triggerTraceId = currentContext?.contextType === 'apm' ? currentContext.id : undefined;
 
-    const startMemory = process.memoryUsage ? process.memoryUsage().heapUsed : 0;
-    const startCpu = process.cpuUsage ? process.cpuUsage() : undefined;
+    const startMemory = isNode() && process.memoryUsage ? process.memoryUsage().heapUsed : 0;
+    const startCpu = isNode() && process.cpuUsage ? process.cpuUsage() : undefined;
 
     const task: ActiveTrace = {
-      id: randomUUID(),
+      id: generateTraceId(),
       contextType: 'task',
       startTime: performance.now(),
       rootSpanId: generateSpanId(),
@@ -367,7 +365,7 @@ export class SenzorClient {
     task.state.ended = true;
 
     let resourceMetrics;
-    if (process.memoryUsage && task.startMemory !== undefined && process.cpuUsage && task.startCpu) {
+    if (isNode() && process.memoryUsage && task.startMemory !== undefined && process.cpuUsage && task.startCpu) {
       const endMemory = process.memoryUsage().heapUsed;
       const cpuDelta = process.cpuUsage(task.startCpu);
 

package/src/core/context.ts

@@ -1,7 +1,51 @@
-import { AsyncLocalStorage } from 'async_hooks';
 import { ActiveTrace, Span } from './types';
 
-export const storage = new AsyncLocalStorage<ActiveTrace>();
+interface IStorage<T> {
+  run<R>(store: T, callback: (...args: any[]) => R, ...args: any[]): R;
+  getStore(): T | undefined;
+}
+
+class NaiveStorage<T> implements IStorage<T> {
+  private store: T | undefined;
+
+  run<R>(store: T, callback: (...args: any[]) => R, ...args: any[]): R {
+    const prev = this.store;
+    this.store = store;
+    try {
+      return callback(...args);
+    } finally {
+      this.store = prev;
+    }
+  }
+
+  getStore(): T | undefined {
+    return this.store;
+  }
+}
+
+const resolveStorage = <T>(): IStorage<T> => {
+  if (typeof globalThis !== 'undefined' && (globalThis as any).AsyncLocalStorage) {
+    return new (globalThis as any).AsyncLocalStorage();
+  }
+
+  try {
+    if (typeof require !== 'undefined') {
+      const { AsyncLocalStorage } = require('node:async_hooks');
+      if (AsyncLocalStorage) return new AsyncLocalStorage();
+    }
+  } catch {}
+
+  try {
+    if (typeof require !== 'undefined') {
+      const { AsyncLocalStorage } = require('async_hooks');
+      if (AsyncLocalStorage) return new AsyncLocalStorage();
+    }
+  } catch {}
+
+  return new NaiveStorage<T>();
+};
+
+export const storage = resolveStorage<ActiveTrace>();
 
 export const Context = {
   run: <T>(trace: ActiveTrace, fn: () => T): T => {

package/src/core/runtime.ts

@@ -0,0 +1,15 @@
+const _isNode = typeof process !== 'undefined' &&
+  typeof process.versions !== 'undefined' &&
+  typeof process.versions.node !== 'undefined';
+
+export const isNode = (): boolean => _isNode;
+
+export const isEdgeRuntime = (): boolean =>
+  typeof navigator !== 'undefined' &&
+  typeof navigator.userAgent === 'string' &&
+  navigator.userAgent.includes('Cloudflare');
+
+export const getEnv = (key: string): string | undefined => {
+  if (_isNode) return process.env[key];
+  return undefined;
+};

package/src/core/transport.ts

@@ -255,6 +255,8 @@ export class Transport {
   }
 
   private installShutdownFlush() {
+    if (typeof process === 'undefined' || typeof process.once !== 'function') return;
+
     const key = Symbol.for('senzor.transport.shutdownFlushInstalled');
     const proc = process as unknown as Record<symbol, boolean>;
     if (proc[key]) return;

package/src/index.ts

@@ -2,18 +2,20 @@ import { client } from './core/client';
 import { expressMiddleware, expressErrorHandler } from './middleware/express';
 import { wrapH3 } from './wrappers/h3';
 import { wrapNextRoute, wrapNextPages } from './wrappers/next';
+import { wrapWorker } from './wrappers/worker';
+import { nitroPlugin } from './wrappers/nitro';
 import { senzorPlugin } from './wrappers/fastify';
 import { SenzorOptions } from './core/types';
 
-const Senzor = {
-  preload: (options: Partial<SenzorOptions> = {}) => client.preload(options),
-  init: (options: SenzorOptions) => client.init(options),
-  flush: () => client.flush(),
+const Senzor = {
+  preload: (options: Partial<SenzorOptions> = {}) => client.preload(options),
+  init: (options: SenzorOptions) => client.init(options),
+  flush: () => client.flush(),
   track: client.track.bind(client),
   startSpan: client.startSpan.bind(client),
   captureException: client.captureError.bind(client),
 
-  // Task Monitoring (NEW)
+  // Task Monitoring
   wrapTask: client.wrapTask.bind(client),
   startTask: client.startTask.bind(client),
 
@@ -29,8 +31,14 @@ const Senzor = {
   wrapH3,
 
   // Fastify
-  fastifyPlugin: senzorPlugin
+  fastifyPlugin: senzorPlugin,
+
+  // Cloudflare Workers
+  worker: wrapWorker,
+
+  // Nitro / Nuxt
+  nitroPlugin
 };
 
 export default Senzor;
-export { Senzor };
+export { Senzor };

package/src/instrumentation/hook.ts

@@ -1,18 +1,20 @@
-import Module from 'module';
-
-const SENZOR_PATCHED = Symbol.for('senzor.require.patched');
-const SENZOR_HOOKS = Symbol.for('senzor.require.hooks');
-
 type HookFn = (exports: unknown) => unknown | void;
 type HookMap = Map<string, HookFn[]>;
 
-// Module.createRequire works in both CJS and ESM contexts,
-// unlike bare `require` which is unavailable in ESM builds.
-const safeRequire: NodeRequire = Module.createRequire(
-  typeof __filename !== 'undefined'
-    ? __filename
-    : process.cwd() + '/'
-);
+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>;
@@ -119,6 +121,8 @@ function retryPatch(moduleName: string, hook: HookFn) {
 }
 
 export const hookRequire = (moduleName: string, onRequire: HookFn) => {
+  if (!Module || !safeRequire) return;
+
   const registry = getHookRegistry();
 
   if (!registry.has(moduleName)) {

package/src/instrumentation/http.ts

@@ -1,6 +1,3 @@
-import http from 'http';
-import https from 'https';
-import { URL } from 'url';
 import type { SenzorClient } from '../core/client';
 import { Context } from '../core/context';
 import { getRoute, normalizePath } from '../core/normalizer';
@@ -299,7 +296,7 @@ const patchIncomingServer = (
 };
 
 const patchOutgoing = (
-  moduleRef: typeof http | typeof https,
+  moduleRef: any,
   protocol: 'http:' | 'https:',
   ingestUrl: string,
   options?: SenzorOptions
@@ -522,9 +519,19 @@ export const instrumentHttp = (
   ingestUrl: string,
   options?: SenzorOptions
 ) => {
-  patchIncomingServer(http.Server?.prototype, 'http', client, options);
-  patchIncomingServer(https.Server?.prototype, 'https', client, options);
+  let httpMod: any;
+  let httpsMod: any;
 
-  patchOutgoing(http, 'http:', ingestUrl, options);
-  patchOutgoing(https, 'https:', ingestUrl, options);
+  try { httpMod = require('http'); } catch { return; }
+  try { httpsMod = require('https'); } catch {}
+
+  if (httpMod?.Server?.prototype) {
+    patchIncomingServer(httpMod.Server.prototype, 'http', client, options);
+  }
+  if (httpsMod?.Server?.prototype) {
+    patchIncomingServer(httpsMod.Server.prototype, 'https', client, options);
+  }
+
+  patchOutgoing(httpMod, 'http:', ingestUrl, options);
+  if (httpsMod) patchOutgoing(httpsMod, 'https:', ingestUrl, options);
 };

package/src/register.ts

@@ -1,4 +1,5 @@
 import { client } from './core/client';
+import { getEnv } from './core/runtime';
 
 const truthy = (value: string | undefined): boolean =>
   value === '1' || value === 'true' || value === 'yes';
@@ -10,43 +11,43 @@ const numberFromEnv = (value: string | undefined): number | undefined => {
 };
 
 const apiKey =
-  process.env.SENZOR_API_KEY ||
-  process.env.SENZOR_APM_API_KEY ||
-  process.env.SENZOR_SERVICE_API_KEY;
+  getEnv('SENZOR_API_KEY') ||
+  getEnv('SENZOR_APM_API_KEY') ||
+  getEnv('SENZOR_SERVICE_API_KEY');
 
 const endpoint =
-  process.env.SENZOR_ENDPOINT ||
-  process.env.SENZOR_APM_ENDPOINT;
+  getEnv('SENZOR_ENDPOINT') ||
+  getEnv('SENZOR_APM_ENDPOINT');
 
 const options = {
   apiKey: apiKey || '',
   endpoint,
-  debug: truthy(process.env.SENZOR_DEBUG),
-  autoLogs: process.env.SENZOR_AUTO_LOGS === 'false' ? false : undefined,
-  batchSize: numberFromEnv(process.env.SENZOR_BATCH_SIZE),
-  flushInterval: numberFromEnv(process.env.SENZOR_FLUSH_INTERVAL),
-  flushTimeoutMs: numberFromEnv(process.env.SENZOR_FLUSH_TIMEOUT_MS),
-  maxQueueSize: numberFromEnv(process.env.SENZOR_MAX_QUEUE_SIZE),
-  maxSpansPerTrace: numberFromEnv(process.env.SENZOR_MAX_SPANS_PER_TRACE),
-  captureHeaders: truthy(process.env.SENZOR_CAPTURE_HEADERS),
+  debug: truthy(getEnv('SENZOR_DEBUG')),
+  autoLogs: getEnv('SENZOR_AUTO_LOGS') === 'false' ? false : undefined,
+  batchSize: numberFromEnv(getEnv('SENZOR_BATCH_SIZE')),
+  flushInterval: numberFromEnv(getEnv('SENZOR_FLUSH_INTERVAL')),
+  flushTimeoutMs: numberFromEnv(getEnv('SENZOR_FLUSH_TIMEOUT_MS')),
+  maxQueueSize: numberFromEnv(getEnv('SENZOR_MAX_QUEUE_SIZE')),
+  maxSpansPerTrace: numberFromEnv(getEnv('SENZOR_MAX_SPANS_PER_TRACE')),
+  captureHeaders: truthy(getEnv('SENZOR_CAPTURE_HEADERS')),
   captureDbStatement:
-    process.env.SENZOR_CAPTURE_DB_STATEMENT === 'false'
+    getEnv('SENZOR_CAPTURE_DB_STATEMENT') === 'false'
       ? false
       : undefined,
   frameworkSpans:
-    process.env.SENZOR_FRAMEWORK_SPANS === 'false'
+    getEnv('SENZOR_FRAMEWORK_SPANS') === 'false'
       ? false
       : undefined,
   captureMiddlewareSpans:
-    process.env.SENZOR_CAPTURE_MIDDLEWARE_SPANS === 'false'
+    getEnv('SENZOR_CAPTURE_MIDDLEWARE_SPANS') === 'false'
       ? false
       : undefined,
   captureRouterSpans:
-    process.env.SENZOR_CAPTURE_ROUTER_SPANS === 'false'
+    getEnv('SENZOR_CAPTURE_ROUTER_SPANS') === 'false'
       ? false
       : undefined,
   captureLifecycleHookSpans:
-    process.env.SENZOR_CAPTURE_LIFECYCLE_HOOK_SPANS === 'false'
+    getEnv('SENZOR_CAPTURE_LIFECYCLE_HOOK_SPANS') === 'false'
       ? false
       : undefined
 };