@senzops/apm-node 1.2.3 → 1.2.4

package/package.json

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

package/src/core/client.ts

@@ -2,23 +2,23 @@ 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 { SDK_META } from '../utils/sdkMeta';
-import { parseTraceparent } from '../utils/traceContext';
-import { generateSpanId, generateTraceId } from '../utils/ids';
-import { sanitizeAttributes } from './sanitizer';
-import { startCapturedSpan } from '../instrumentation/span';
+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 { SDK_META } from '../utils/sdkMeta';
+import { parseTraceparent } from '../utils/traceContext';
+import { generateSpanId, generateTraceId } from '../utils/ids';
+import { sanitizeAttributes } from './sanitizer';
+import { startCapturedSpan } from '../instrumentation/span';
 
 // Memory-safe JSON stringifier to handle cyclical objects 
 // (like Express 'req' objects) passed into console.log
@@ -33,69 +33,69 @@ const safeStringify = (obj: any): string => {
   });
 };
 
-export class SenzorClient {
-  private transport: Transport | null = null;
-  private options: SenzorOptions | null = null;
-  private isInstrumented = false;
-
-  public preload(options: Partial<SenzorOptions> = {}) {
-    const endpoint = options.endpoint || 'https://api.senzor.dev/api/ingest/apm';
-    const debug = options.debug || false;
-
-    this.options = {
-      apiKey: '',
-      ...this.options,
-      ...options
-    };
-
-    this.installNativeInstrumentations(endpoint, debug);
-  }
-
-  public init(options: SenzorOptions) {
-    if (!options.apiKey) {
-      console.warn('[Senzor] API Key missing. SDK disabled.');
-      return;
-    }
+export class SenzorClient {
+  private transport: Transport | null = null;
+  private options: SenzorOptions | null = null;
+  private isInstrumented = false;
+
+  public preload(options: Partial<SenzorOptions> = {}) {
+    const endpoint = options.endpoint || 'https://api.senzor.dev/api/ingest/apm';
+    const debug = options.debug || false;
+
+    this.options = {
+      apiKey: '',
+      ...this.options,
+      ...options
+    };
+
+    this.installNativeInstrumentations(endpoint, debug);
+  }
+
+  public init(options: SenzorOptions) {
+    if (!options.apiKey) {
+      console.warn('[Senzor] API Key missing. SDK disabled.');
+      return;
+    }
     this.options = options;
     const endpoint = options.endpoint || 'https://api.senzor.dev/api/ingest/apm';
     const debug = options.debug || false;
-
-    this.transport = new Transport({ ...options, endpoint });
-    this.installNativeInstrumentations(endpoint, debug);
-  }
-
-  private isInstrumentationEnabled(name: string): boolean {
-    const setting = this.options?.instrumentations;
-    if (setting === false) return false;
-    if (Array.isArray(setting)) return setting.includes(name);
-    return true;
-  }
-
-  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');
-    }
-  }
+
+    this.transport = new Transport({ ...options, endpoint });
+    this.installNativeInstrumentations(endpoint, debug);
+  }
+
+  private isInstrumentationEnabled(name: string): boolean {
+    const setting = this.options?.instrumentations;
+    if (setting === false) return false;
+    if (Array.isArray(setting)) return setting.includes(name);
+    return true;
+  }
+
+  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');
+    }
+  }
 
   // --- Enterprise Auto-Log Interception ---
   private setupLogInterception() {
@@ -132,13 +132,13 @@ export class SenzorClient {
               attributes.errorStack = arg.stack;
               attributes.errorName = arg.name;
             } else if (typeof arg === 'object' && arg !== null) {
-              try {
-                // New Relic Style Destructuring: Merge all object keys into `attributes`
-                const parsed = JSON.parse(safeStringify(arg));
-                attributes = { ...attributes, ...sanitizeAttributes(parsed, this.options || undefined) };
-              } catch (e) {
-                attributes.unparseableObject = true;
-              }
+              try {
+                // New Relic Style Destructuring: Merge all object keys into `attributes`
+                const parsed = JSON.parse(safeStringify(arg));
+                attributes = { ...attributes, ...sanitizeAttributes(parsed, this.options || undefined) };
+              } catch (e) {
+                attributes.unparseableObject = true;
+              }
             } else {
               message += (message ? ' ' : '') + String(arg);
             }
@@ -254,20 +254,17 @@ export class SenzorClient {
     process.on('SIGINT', () => safeCapture(new Error('Process received SIGINT'), { type: 'processSignal', signal: 'SIGINT' }));
   }
 
-  public startTrace<T>(data: Partial<ActiveTrace['data']> & { headers?: any }, next: () => T): T {
-    if (!this.transport) return next();
-
-    const existingTrace = Context.current();
-    if (existingTrace?.contextType === 'apm') {
-      existingTrace.data = {
-        ...existingTrace.data,
-        ...data
-      };
-      return next();
-    }
-
-    let inheritedTraceId: string | undefined = undefined;
-    let inheritedParentSpanId: string | undefined = undefined;
+  public startTrace<T>(data: Partial<ActiveTrace['data']> & { headers?: any }, next: () => T): T {
+    if (!this.transport) return next();
+
+    const existingTrace = Context.current();
+    if (existingTrace?.contextType === 'apm') {
+      Object.assign(existingTrace.data, data);
+      return next();
+    }
+
+    let inheritedTraceId: string | undefined = undefined;
+    let inheritedParentSpanId: string | undefined = undefined;
 
     if (data.headers) {
       const getHeader = (key: string) => {
@@ -290,44 +287,47 @@ export class SenzorClient {
       }
     }
 
-    const activeTraceId = inheritedTraceId || generateTraceId();
-    const rootSpanId = generateSpanId();
-
-    const trace: ActiveTrace = {
-      id: activeTraceId,
-      contextType: 'apm',
-      startTime: performance.now(),
-      rootSpanId,
-      activeSpanId: rootSpanId,
-      data: { ...data, parentTraceId: inheritedTraceId, parentSpanId: inheritedParentSpanId, rootSpanId },
-      spans: [],
-      maxSpans: this.options?.maxSpansPerTrace ?? 500,
-      droppedSpans: 0
-    };
+    const activeTraceId = inheritedTraceId || generateTraceId();
+    const rootSpanId = generateSpanId();
+
+    const trace: ActiveTrace = {
+      id: activeTraceId,
+      contextType: 'apm',
+      startTime: performance.now(),
+      rootSpanId,
+      activeSpanId: rootSpanId,
+      data: { ...data, parentTraceId: inheritedTraceId, parentSpanId: inheritedParentSpanId, rootSpanId },
+      spans: [],
+      maxSpans: this.options?.maxSpansPerTrace ?? 500,
+      state: {
+        ended: false,
+        droppedSpans: 0
+      }
+    };
 
     return Context.run(trace, next);
   }
 
-  public endTrace(status: number, extraData: any = {}) {
-    const trace = Context.current();
-    if (!trace || trace.contextType !== 'apm' || !this.transport) return;
-    if (trace.ended) return;
-    trace.ended = true;
-    const duration = performance.now() - trace.startTime;
-
-    const payload = {
-      traceId: trace.id,
-      parentTraceId: trace.data.parentTraceId,
-      parentSpanId: trace.data.parentSpanId,
-      rootSpanId: trace.rootSpanId,
-      ...trace.data,
-      ...extraData,
-      status,
-      duration,
-      spans: trace.spans,
-      droppedSpans: trace.droppedSpans,
-      timestamp: new Date().toISOString()
-    };
+  public endTrace(status: number, extraData: any = {}) {
+    const trace = Context.current();
+    if (!trace || trace.contextType !== 'apm' || !this.transport) return;
+    if (trace.state.ended) return;
+    trace.state.ended = true;
+    const duration = performance.now() - trace.startTime;
+
+    const payload = {
+      traceId: trace.id,
+      parentTraceId: trace.data.parentTraceId,
+      parentSpanId: trace.data.parentSpanId,
+      rootSpanId: trace.rootSpanId,
+      ...trace.data,
+      ...extraData,
+      status,
+      duration,
+      spans: trace.spans,
+      droppedSpans: trace.state.droppedSpans,
+      timestamp: new Date().toISOString()
+    };
     this.transport.addTrace(payload);
   }
 
@@ -341,25 +341,30 @@ export class SenzorClient {
     const startMemory = process.memoryUsage ? process.memoryUsage().heapUsed : 0;
     const startCpu = process.cpuUsage ? process.cpuUsage() : undefined;
 
-    const task: ActiveTrace = {
-      id: randomUUID(),
-      contextType: 'task',
-      startTime: performance.now(),
-      rootSpanId: generateSpanId(),
-      startMemory,
-      startCpu,
-      data: { taskName: name, taskType: type, triggerTraceId, ...options },
-      spans: [],
-      maxSpans: this.options?.maxSpansPerTrace ?? 500,
-      droppedSpans: 0
-    };
-    task.activeSpanId = task.rootSpanId;
-    return Context.run(task, next);
-  }
+    const task: ActiveTrace = {
+      id: randomUUID(),
+      contextType: 'task',
+      startTime: performance.now(),
+      rootSpanId: generateSpanId(),
+      startMemory,
+      startCpu,
+      data: { taskName: name, taskType: type, triggerTraceId, ...options },
+      spans: [],
+      maxSpans: this.options?.maxSpansPerTrace ?? 500,
+      state: {
+        ended: false,
+        droppedSpans: 0
+      }
+    };
+    task.activeSpanId = task.rootSpanId;
+    return Context.run(task, next);
+  }
 
   public endTask(status: 'success' | 'failed', extraMetadata: any = {}) {
     const task = Context.current();
     if (!task || task.contextType !== 'task' || !this.transport) return;
+    if (task.state.ended) return;
+    task.state.ended = true;
 
     let resourceMetrics;
     if (process.memoryUsage && task.startMemory !== undefined && process.cpuUsage && task.startCpu) {
@@ -381,7 +386,7 @@ export class SenzorClient {
       queueDelay: task.data.queueDelay,
       attempts: task.data.attempts,
       isDeadLetter: task.data.isDeadLetter,
-      metadata: { ...task.data.metadata, ...extraMetadata, droppedSpans: task.droppedSpans },
+      metadata: { ...task.data.metadata, ...extraMetadata, droppedSpans: task.state.droppedSpans },
       resourceMetrics,
       status,
       duration: performance.now() - task.startTime,
@@ -420,32 +425,32 @@ export class SenzorClient {
 
     const currentTrace = Context.current();
 
-    const errPayload = {
-      errorClass: parsedError.name || 'Error',
-      message: parsedError.message,
-      stackTrace: parsedError.stack,
-      context: sanitizeAttributes(context, this.options || undefined),
-      timestamp: new Date().toISOString()
-    };
+    const errPayload = {
+      errorClass: parsedError.name || 'Error',
+      message: parsedError.message,
+      stackTrace: parsedError.stack,
+      context: sanitizeAttributes(context, this.options || undefined),
+      timestamp: new Date().toISOString()
+    };
 
     if (currentTrace?.contextType === 'task') {
       this.transport.addError({ ...errPayload, runId: currentTrace.id }, 'task');
     } else {
       this.transport.addError({ ...errPayload, traceId: currentTrace?.id }, 'apm');
     }
-  }
-
-  public track(data: any) {
-    this.transport?.addTrace({ traceId: generateTraceId(), ...data, spans: [], timestamp: new Date().toISOString() });
-  }
-
-  public startSpan(name: string, type: 'db' | 'http' | 'function' | 'custom' = 'custom') {
-    const span = startCapturedSpan(name, type, {}, this.options || undefined);
-    if (!span) return { end: () => { } };
-    return { end: (meta?: any, status?: number) => span.end(status, meta) };
-  }
+  }
+
+  public track(data: any) {
+    this.transport?.addTrace({ traceId: generateTraceId(), ...data, spans: [], timestamp: new Date().toISOString() });
+  }
+
+  public startSpan(name: string, type: 'db' | 'http' | 'function' | 'custom' = 'custom') {
+    const span = startCapturedSpan(name, type, {}, this.options || undefined);
+    if (!span) return { end: () => { } };
+    return { end: (meta?: any, status?: number) => span.end(status, meta) };
+  }
 
   public async flush() { if (this.transport) await this.transport.flush(); }
 }
 
-export const client = new SenzorClient();
+export const client = new SenzorClient();

package/src/core/context.ts

@@ -35,11 +35,11 @@ export const Context = {
   },
 
   addSpanToTrace: (trace: ActiveTrace, span: Span) => {
-    if (trace.ended) return;
+    if (trace.state.ended) return;
 
     const maxSpans = trace.maxSpans ?? 500;
     if (trace.spans.length >= maxSpans) {
-      trace.droppedSpans = (trace.droppedSpans ?? 0) + 1;
+      trace.state.droppedSpans = (trace.state.droppedSpans ?? 0) + 1;
       return;
     }
 

package/src/core/types.ts

@@ -1,32 +1,32 @@
-export interface SenzorOptions {
-  apiKey: string;
-  endpoint?: string;
-  batchSize?: number;
-  flushInterval?: number;
-  flushTimeoutMs?: number;
-  maxQueueSize?: number;
-  maxSpansPerTrace?: number;
-  maxAttributeLength?: number;
-  maxAttributes?: number;
-  captureHeaders?: boolean;
-  captureDbStatement?: boolean;
-  instrumentations?: boolean | string[];
-  frameworkSpans?: boolean;
-  captureMiddlewareSpans?: boolean;
-  captureRouterSpans?: boolean;
-  captureLifecycleHookSpans?: boolean;
-  ignoreFrameworkSpanTypes?: string[];
-  debug?: boolean;
-  autoLogs?: boolean;
-}
-
-export interface Span {
-  spanId: string;
-  parentSpanId?: string;
-  name: string;
-  type: 'db' | 'http' | 'function' | 'custom';
-  startTime: number;
-  duration: number;
+export interface SenzorOptions {
+  apiKey: string;
+  endpoint?: string;
+  batchSize?: number;
+  flushInterval?: number;
+  flushTimeoutMs?: number;
+  maxQueueSize?: number;
+  maxSpansPerTrace?: number;
+  maxAttributeLength?: number;
+  maxAttributes?: number;
+  captureHeaders?: boolean;
+  captureDbStatement?: boolean;
+  instrumentations?: boolean | string[];
+  frameworkSpans?: boolean;
+  captureMiddlewareSpans?: boolean;
+  captureRouterSpans?: boolean;
+  captureLifecycleHookSpans?: boolean;
+  ignoreFrameworkSpanTypes?: string[];
+  debug?: boolean;
+  autoLogs?: boolean;
+}
+
+export interface Span {
+  spanId: string;
+  parentSpanId?: string;
+  name: string;
+  type: 'db' | 'http' | 'function' | 'custom';
+  startTime: number;
+  duration: number;
   status?: number;
   meta?: Record<string, any>;
 }
@@ -89,18 +89,23 @@ export interface TaskRun {
   timestamp: string;
 }
 
+// NEW: Shared mutable state for a trace/task to prevent duplication during context shallow copying
+export interface ActiveTraceState {
+  ended: boolean;
+  droppedSpans: number;
+}
+
 // Unified Context Payload for async_hooks
-export interface ActiveTrace {
-  id: string; // The APM traceId OR the Task runId
-  contextType: 'apm' | 'task';
-  startTime: number;
-  rootSpanId?: string;
-  activeSpanId?: string;
-  startMemory?: number; // Baseline heap
-  startCpu?: NodeJS.CpuUsage; // Baseline CPU tick
-  data: any; // Holds Partial<Trace> or Partial<TaskRun>
-  spans: Span[];
-  maxSpans?: number;
-  droppedSpans?: number;
-  ended?: boolean;
-}
+export interface ActiveTrace {
+  id: string; // The APM traceId OR the Task runId
+  contextType: 'apm' | 'task';
+  startTime: number;
+  rootSpanId?: string;
+  activeSpanId?: string;
+  startMemory?: number; // Baseline heap
+  startCpu?: NodeJS.CpuUsage; // Baseline CPU tick
+  data: any; // Holds Partial<Trace> or Partial<TaskRun>
+  spans: Span[];
+  maxSpans?: number;
+  state: ActiveTraceState;
+}

package/src/instrumentation/http.ts

@@ -259,7 +259,7 @@ const patchIncomingServer = (
               finalized = true;
 
               setImmediate(() => {
-                if (trace.ended) return;
+                if (trace.state.ended) return;
 
                 Context.run(trace, () => {
                   client.endTrace(res.statusCode || 0, {