@senzops/apm-node 1.2.4 → 1.2.6

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@senzops/apm-node",
-  "version": "1.2.4",
+  "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/express.ts

@@ -57,18 +57,24 @@ const getRequestRoute = (
   layer: any,
   layerPath?: string
 ): string | undefined => {
-  const routePath = stringifyPath(layer?.route?.path);
-  if (routePath) {
+  if (layer?.route?.path) {
+    const routePath = stringifyPath(layer.route.path);
     const baseUrl = req?.baseUrl || '';
+    // If baseUrl already ends with or contains the routePath, be careful
     return `${baseUrl}${routePath}` || routePath;
   }
 
   if (req?.route?.path) {
-    return `${req.baseUrl || ''}${req.route.path}`;
+    const baseUrl = req?.baseUrl || '';
+    return `${baseUrl}${req.route.path}`;
   }
 
   if (layerPath) {
     const baseUrl = req?.baseUrl || '';
+    // If baseUrl already contains layerPath, don't double it
+    if (baseUrl === layerPath || baseUrl.endsWith(layerPath)) {
+      return baseUrl;
+    }
     return `${baseUrl}${layerPath}` || layerPath;
   }
 
@@ -84,9 +90,14 @@ const getLayerType = (
   if (forcedType) return forcedType;
   if (original.length === 4) return 'error_handler' as const;
   if (layer?.route) return 'request_handler' as const;
-  if (layer?.name === 'router' || layer?.handle?.stack || layer?.handle?.name === 'router') {
-    return 'router' as const;
-  }
+
+  const isRouter =
+    layer?.name === 'router' ||
+    layer?.handle?.name === 'router' ||
+    typeof layer?.handle?.stack !== 'undefined' ||
+    typeof layer?.handle?.route === 'function';
+
+  if (isRouter) return 'router' as const;
   return 'middleware' as const;
 };
 
@@ -105,6 +116,7 @@ const copyEnumerableProperties = (
   source: Function,
   target: Function
 ) => {
+  // Copy enumerable properties
   for (const key in source as any) {
     try {
       Object.defineProperty(target, key, {
@@ -119,6 +131,13 @@ const copyEnumerableProperties = (
       });
     } catch { }
   }
+
+  // Ensure 'stack' is copied even if not enumerable (though it usually is)
+  if ((source as any).stack && !(target as any).stack) {
+    try {
+      (target as any).stack = (source as any).stack;
+    } catch { }
+  }
 };
 
 const patchLayer = (
@@ -145,7 +164,7 @@ const patchLayer = (
       const handlerName =
         original.name ||
         layer.name ||
-        layerType;
+        (layerType === 'request_handler' ? 'handler' : layerType);
 
       if (original.length === 4) {
         const wrapped = function senzorExpressErrorHandler(
@@ -264,7 +283,7 @@ const patchRouteMethodHandlers = (
           const stack = this?.stack || [];
 
           for (const layer of stack) {
-          patchLayer(layer, routePath, options, 'request_handler');
+            patchLayer(layer, routePath, options, 'request_handler');
           }
 
           return result;
@@ -277,10 +296,13 @@ const getSafeRouter = (app: any) => {
   if (!app) return undefined;
   if (app._router) return app._router;
   try {
-    return app.router;
-  } catch {
-    return undefined;
-  }
+    // In Express 4, app.router is a getter that throws.
+    // We only want it if it's not a throwing getter (Express 3)
+    // or if it actually has a stack.
+    const r = app.router;
+    if (r && (r.stack || typeof r === 'function')) return r;
+  } catch { }
+  return undefined;
 };
 
 const patchExpress = (
@@ -290,7 +312,7 @@ const patchExpress = (
   if (!expressModule) return;
 
   const routerProto =
-    typeof expressModule?.Router?.prototype?.route === 'function'
+    typeof expressModule?.Router?.prototype?.use === 'function'
       ? expressModule.Router.prototype
       : expressModule.Router;
 
@@ -302,8 +324,9 @@ const patchExpress = (
       function patchedExpressRoute(this: any, ...args: any[]) {
         const route = original.apply(this, args);
         const routePath = getLayerPath(args);
-        const layer = this?.stack?.[this.stack.length - 1];
+        const stack = this?.stack || [];
 
+        const layer = stack[stack.length - 1];
         patchLayer(layer, routePath, options, 'router');
         patchRouteMethodHandlers(route, routePath, options);
 
@@ -317,9 +340,13 @@ const patchExpress = (
     'senzor.express.router.use',
     (original) =>
       function patchedExpressRouterUse(this: any, ...args: any[]) {
+        const prevStackLength = this?.stack?.length || 0;
         const result = original.apply(this, args);
-        const layer = this?.stack?.[this.stack.length - 1];
-        patchLayer(layer, getLayerPath(args), options);
+        const stack = this?.stack || [];
+
+        for (let i = prevStackLength; i < stack.length; i++) {
+          patchLayer(stack[i], getLayerPath(args), options);
+        }
         return result;
       }
   );
@@ -330,11 +357,17 @@ const patchExpress = (
     'senzor.express.application.use',
     (original) =>
       function patchedExpressApplicationUse(this: any, ...args: any[]) {
-        const router = getSafeRouter(this);
+        const routerBefore = getSafeRouter(this);
+        const prevStackLength = routerBefore?.stack?.length || 0;
+
         const result = original.apply(this, args);
-        const activeRouter = getSafeRouter(this) || router;
-        const layer = activeRouter?.stack?.[activeRouter.stack.length - 1];
-        patchLayer(layer, getLayerPath(args), options);
+
+        const routerAfter = getSafeRouter(this);
+        const stack = routerAfter?.stack || [];
+
+        for (let i = prevStackLength; i < stack.length; i++) {
+          patchLayer(stack[i], getLayerPath(args), options);
+        }
         return result;
       }
   );

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/middleware/express.ts

@@ -3,7 +3,7 @@ import { getClientIp } from '../utils/getClientIp';
 
 // 1. Request Handler (Place before routes)
 export const expressMiddleware = () => {
-  return (req: any, res: any, next: () => void) => {
+  return function senzorMiddleware(req: any, res: any, next: () => void) {
     client.startTrace({
       method: req.method,
       path: req.originalUrl || req.url,
@@ -37,7 +37,7 @@ export const expressMiddleware = () => {
 // 2. Error Handler (Place after routes)
 // This is required in Express to capture the actual Error Object (Stack Trace)
 export const expressErrorHandler = () => {
-  return (err: any, req: any, res: any, next: (err?: any) => void) => {
+  return function senzorErrorHandler(err: any, req: any, res: any, next: (err?: any) => void) {
 
     // 1. Capture the exception context
     client.captureError(err);

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
 };