@senzops/apm-node 1.1.2 → 1.1.4

package/src/core/types.ts

@@ -2,36 +2,43 @@ export interface SenzorOptions {
   apiKey: string;
   endpoint?: string;
   batchSize?: number;
-  flushInterval?: number; // ms
+  flushInterval?: number;
   debug?: boolean;
 }
 
 export interface Span {
   name: string;
   type: 'db' | 'http' | 'function' | 'custom';
-  startTime: number; // Relative to trace start
+  startTime: number;
   duration: number;
   status?: number;
   meta?: Record<string, any>;
 }
 
+export interface TraceError {
+  name: string;
+  message: string;
+  stack?: string;
+}
+
 export interface Trace {
   traceId: string;
   method: string;
-  route: string; // Normalized
-  path: string;  // Raw
+  route: string;
+  path: string;
   status: number;
   duration: number;
   ip?: string;
   userAgent?: string;
   timestamp: string;
   spans: Span[];
+  error?: TraceError;
 }
 
-// Internal interface for an active trace object
 export interface ActiveTrace {
   id: string;
   startTime: number;
   data: Partial<Trace>;
   spans: Span[];
+  error?: TraceError;
 }

package/src/index.ts

@@ -1,23 +1,26 @@
 import { client } from './core/client';
-import { expressMiddleware } from './middleware/express';
+import { expressMiddleware, expressErrorHandler } from './middleware/express';
 import { wrapH3 } from './wrappers/h3';
 import { wrapNextRoute, wrapNextPages } from './wrappers/next';
 import { senzorPlugin } from './wrappers/fastify';
 import { SenzorOptions } from './core/types';
 
 const Senzor = {
-  // Core
   init: (options: SenzorOptions) => client.init(options),
   flush: () => client.flush(),
+  track: client.track.bind(client),
+  startSpan: client.startSpan.bind(client),
+  captureException: client.captureError.bind(client),
 
-  // Express / Connect
+  // Express
   requestHandler: expressMiddleware,
+  errorHandler: expressErrorHandler,
 
-  // Next.js
-  wrapNextRoute, // For App Router (Route Handlers)
-  wrapNextPages, // For Pages Router (API Routes)
+  // Next
+  wrapNextRoute,
+  wrapNextPages,
 
-  // H3 / Nuxt / Nitro
+  // H3
   wrapH3,
 
   // Fastify

package/src/instrumentation/http.ts

@@ -9,15 +9,79 @@ const shimmer = (module: any, methodName: string, wrapper: (original: Function)
   module[methodName] = wrapper(original);
 };
 
+// --- Native Fetch Instrumentation (Node 18+) ---
+export const instrumentFetch = (ingestUrl: string, debug = false) => {
+  if (!globalThis.fetch) return;
+
+  let ingestHost = '';
+  try { ingestHost = new URL(ingestUrl).hostname; } catch (e) { }
+
+  const originalFetch = globalThis.fetch;
+
+  // @ts-ignore
+  globalThis.fetch = async (input: RequestInfo | URL, init?: RequestInit) => {
+    // 1. Extract URL
+    let urlStr = '';
+    if (typeof input === 'string') urlStr = input;
+    else if (input instanceof URL) urlStr = input.toString();
+    else if (input && input.url) urlStr = input.url; // Request object
+
+    // 2. Infinite Loop Guard
+    if (ingestHost && urlStr.includes(ingestHost)) {
+      return originalFetch(input, init);
+    }
+
+    // 3. Context Check
+    const trace = Context.current();
+    if (!trace) {
+      return originalFetch(input, init);
+    }
+
+    // 4. Start Span
+    const method = (init?.method || 'GET').toUpperCase();
+    const startTime = performance.now() - trace.startTime;
+    const spanStartAbs = performance.now();
+    let hostname = 'unknown';
+    try { hostname = new URL(urlStr).hostname; } catch (e) { }
+
+    if (debug) console.log(`[Senzor] Tracking Fetch: ${method} ${hostname}`);
+
+    try {
+      const response = await originalFetch(input, init);
+
+      // 5. End Span
+      const duration = performance.now() - spanStartAbs;
+      Context.addSpan({
+        name: `${method} ${hostname}`,
+        type: 'http',
+        startTime,
+        duration,
+        status: response.status,
+        meta: { url: urlStr, method, library: 'fetch' }
+      });
+
+      return response;
+    } catch (err: any) {
+      const duration = performance.now() - spanStartAbs;
+      Context.addSpan({
+        name: `${method} ${hostname}`,
+        type: 'http',
+        startTime,
+        duration,
+        status: 500,
+        meta: { error: err.message, url: urlStr, library: 'fetch' }
+      });
+      throw err;
+    }
+  };
+};
+
+// --- Standard HTTP/HTTPS Instrumentation ---
 export const instrumentHttp = (ingestUrl: string, debug = false) => {
   let ingestHost = '';
   try {
     ingestHost = new URL(ingestUrl).hostname;
-    if (debug) console.log(`[Senzor] HTTP Instrumentation ignoring host: ${ingestHost}`);
-  } catch (e) {
-    // If invalid URL passed, we can't filter loop safely, so we might skip instrumentation
-    if (debug) console.error('[Senzor] Invalid Ingest URL for HTTP instrumentation');
-  }
+  } catch (e) { }
 
   const requestWrapper = (original: Function) => {
     return function (this: any, ...args: any[]) {
@@ -35,16 +99,12 @@ export const instrumentHttp = (ingestUrl: string, debug = false) => {
         urlStr = `${protocol}//${host}${path}`;
       }
 
-      // Safety Guard: Ignore calls to Senzor Ingest API
       if (ingestHost && (urlStr.includes(ingestHost) || (options.hostname && options.hostname.includes(ingestHost)))) {
         return original.apply(this, args);
       }
 
       const trace = Context.current();
-      if (!trace) {
-        // Not inside a tracked request
-        return original.apply(this, args);
-      }
+      if (!trace) return original.apply(this, args);
 
       const method = (options.method || 'GET').toUpperCase();
       const startTime = performance.now() - trace.startTime;
@@ -52,8 +112,6 @@ export const instrumentHttp = (ingestUrl: string, debug = false) => {
       let hostname = 'unknown';
       try { hostname = new URL(urlStr).hostname; } catch (e) { hostname = options.hostname || 'unknown'; }
 
-      if (debug) console.log(`[Senzor] Tracking HTTP: ${method} ${hostname}`);
-
       const req = original.apply(this, args);
 
       const captureSpan = (res: any, error?: Error) => {
@@ -64,21 +122,16 @@ export const instrumentHttp = (ingestUrl: string, debug = false) => {
           startTime,
           duration,
           status: error ? 500 : res?.statusCode || 0,
-          meta: { url: urlStr, method }
+          meta: { url: urlStr, method, library: 'http', error: error ? error.message : undefined }
         });
       };
 
       req.on('response', (res: any) => {
-        // We capture on 'response' (headers received) to be safe.
-        // Waiting for 'end' might miss requests where body isn't consumed.
         res.once('end', () => captureSpan(res));
-        // Fallback if 'end' doesn't fire fast enough
-        // setTimeout(() => captureSpan(res), 5000); 
+        res.once('error', (err: Error) => captureSpan(res, err));
       });
 
-      req.on('error', (err: Error) => {
-        captureSpan(null, err);
-      });
+      req.on('error', (err: Error) => captureSpan(null, err));
 
       return req;
     };

package/src/instrumentation/mongo.ts

@@ -2,25 +2,35 @@ import { Context } from '../core/context';
 
 export const instrumentMongo = (debug = false) => {
   try {
-    // Attempt to load the user's installed mongodb driver
-    // This works for both native driver users and Mongoose users (as mongoose depends on this)
     const mongodb = require('mongodb');
     const Collection = mongodb.Collection;
 
-    if (debug) console.log('[Senzor] Instrumenting MongoDB...');
-
-    // Methods that return Promises
-    const promiseMethods = [
-      'insertOne', 'insertMany', 'updateOne', 'updateMany',
-      'replaceOne', 'deleteOne', 'deleteMany', 'count', 'countDocuments',
-      'estimatedDocumentCount', 'distinct'
-    ];
-
-    // Methods that return Cursors (need special handling)
-    const cursorMethods = ['find', 'aggregate'];
-
-    // 1. Instrument Promise-based methods
-    promiseMethods.forEach((method) => {
+    // Attempt to get Cursor classes
+    // Note: The location of these classes varies by driver version, 
+    // checking common locations
+    const FindCursor = mongodb.FindCursor || require('mongodb/lib/cursor/find_cursor').FindCursor;
+    const AggregationCursor = mongodb.AggregationCursor || require('mongodb/lib/cursor/aggregation_cursor').AggregationCursor;
+
+    if (debug) console.log('[Senzor] Instrumenting MongoDB (Collection + Cursors)...');
+
+    // --- Helper to Record Span ---
+    const recordSpan = (name: string, operation: string, collection: string, startAbs: number, traceStart: number, err?: Error) => {
+      const duration = performance.now() - startAbs;
+      Context.addSpan({
+        name: `MongoDB ${name}`,
+        type: 'db',
+        startTime: performance.now() - traceStart - duration, // Adjust start time to when op actually started
+        duration,
+        status: err ? 500 : 0,
+        meta: { collection, operation, error: err ? err.message : undefined }
+      });
+      if (debug) console.log(`[Senzor] Captured Mongo: ${name} (${duration.toFixed(2)}ms)`);
+    };
+
+    // --- 1. Instrument Immediate Operations (Insert/Update/Delete) ---
+    const immediateMethods = ['insertOne', 'insertMany', 'updateOne', 'updateMany', 'deleteOne', 'deleteMany', 'countDocuments'];
+
+    immediateMethods.forEach((method) => {
       if (!Collection.prototype[method]) return;
       const original = Collection.prototype[method];
 
@@ -28,68 +38,68 @@ export const instrumentMongo = (debug = false) => {
         const trace = Context.current();
         if (!trace) return original.apply(this, args);
 
-        const startTime = performance.now() - trace.startTime;
         const spanStartAbs = performance.now();
-        const collectionName = this.collectionName;
-
-        const endSpan = (err?: Error) => {
-          const duration = performance.now() - spanStartAbs;
-          Context.addSpan({
-            name: `MongoDB ${method} (${collectionName})`,
-            type: 'db',
-            startTime,
-            duration,
-            status: err ? 500 : 0,
-            meta: { collection: collectionName, operation: method }
-          });
-          if (debug) console.log(`[Senzor] Captured Mongo Span: ${method}`);
-        };
+        const traceStart = trace.startTime;
+        const collName = this.collectionName;
 
         try {
           const result = original.apply(this, args);
           if (result && typeof result.then === 'function') {
             return result.then(
-              (res: any) => { endSpan(); return res; },
-              (err: any) => { endSpan(err); throw err; }
+              (res: any) => { recordSpan(method, method, collName, spanStartAbs, traceStart); return res; },
+              (err: any) => { recordSpan(method, method, collName, spanStartAbs, traceStart, err); throw err; }
             );
           }
           return result;
         } catch (err: any) {
-          endSpan(err);
+          recordSpan(method, method, collName, spanStartAbs, traceStart, err);
           throw err;
         }
       };
     });
 
-    // 2. Instrument Cursor-based methods (find, aggregate)
-    // We trace the *creation* of the cursor, not the fetching, as fetching is async/streamed
-    cursorMethods.forEach((method) => {
-      if (!Collection.prototype[method]) return;
-      const original = Collection.prototype[method];
+    // --- 2. Instrument Cursor Execution (find -> toArray) ---
+    const patchCursor = (CursorClass: any, label: string) => {
+      if (!CursorClass || !CursorClass.prototype.toArray) return;
 
-      Collection.prototype[method] = function (...args: any[]) {
-        const trace = Context.current();
-        if (!trace) return original.apply(this, args);
+      const originalToArray = CursorClass.prototype.toArray;
 
-        const startTime = performance.now() - trace.startTime;
+      CursorClass.prototype.toArray = function (...args: any[]) {
+        const trace = Context.current();
+        // Cursors are often created in context but executed later. 
+        // We check context at execution time.
+        if (!trace) return originalToArray.apply(this, args);
 
-        // Record the intent to query
-        Context.addSpan({
-          name: `MongoDB ${method} (${this.collectionName})`,
-          type: 'db',
-          startTime,
-          duration: 0, // Placeholder, as cursor creation is instant
-          status: 0,
-          meta: { collection: this.collectionName, operation: method }
-        });
+        const spanStartAbs = performance.now();
+        const traceStart = trace.startTime;
+        // Attempt to get collection name from cursor internal state
+        const collName = this.namespace?.collection || 'unknown';
 
-        if (debug) console.log(`[Senzor] Captured Mongo Cursor: ${method}`);
+        const onSuccess = (res: any) => {
+          recordSpan(label, label, collName, spanStartAbs, traceStart);
+          return res;
+        };
+        const onError = (err: any) => {
+          recordSpan(label, label, collName, spanStartAbs, traceStart, err);
+          throw err;
+        };
 
-        return original.apply(this, args);
+        try {
+          const result = originalToArray.apply(this, args);
+          if (result && typeof result.then === 'function') {
+            return result.then(onSuccess, onError);
+          }
+          return onSuccess(result);
+        } catch (e) {
+          onError(e);
+        }
       };
-    });
+    };
+
+    patchCursor(FindCursor, 'find');
+    patchCursor(AggregationCursor, 'aggregate');
 
   } catch (e: any) {
-    if (debug) console.warn('[Senzor] MongoDB instrumentation skipped:', e.message);
+    if (debug) console.warn('[Senzor] MongoDB instrumentation warning:', e.message);
   }
 };

package/src/middleware/express.ts

@@ -1,8 +1,8 @@
 import { client } from '../core/client';
 
+// 1. Request Handler (Place before routes)
 export const expressMiddleware = () => {
   return (req: any, res: any, next: () => void) => {
-    // We MUST use startTrace to enable Auto-Instrumentation for this request
     client.startTrace({
       method: req.method,
       path: req.originalUrl || req.url,
@@ -10,9 +10,11 @@ export const expressMiddleware = () => {
       userAgent: req.headers['user-agent'],
     }, () => {
 
+      // Auto-detect status code on finish
       res.once('finish', () => {
         try {
           let route = 'UNKNOWN';
+          // Express populates req.route only if a route matched
           if (req.route && req.route.path) {
             route = (req.baseUrl || '') + req.route.path;
           } else if (res.statusCode === 404) {
@@ -22,12 +24,23 @@ export const expressMiddleware = () => {
           }
 
           client.endTrace(res.statusCode, { route });
-        } catch (e) {
-          // Fail open
-        }
+        } catch (e) { /* Fail open */ }
       });
 
       next();
     });
   };
+};
+
+// 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) => {
+
+    // 1. Capture the exception context
+    client.captureError(err);
+
+    // 2. Pass it to the next error handler (don't swallow it)
+    next(err);
+  };
 };

package/src/wrappers/fastify.ts

@@ -1,37 +1,33 @@
 import { client } from '../core/client';
 import { SenzorOptions } from '../core/types';
 
-// We don't import Fastify types to keep zero-deps, but structure matches
 export const senzorPlugin = (fastify: any, options: SenzorOptions, done: Function) => {
 
-  // Init if options provided inline, otherwise assume global init
   if (options && options.apiKey) {
     client.init(options);
   }
 
-  // Hook: On Request (Start Timer)
+  // 1. Start Trace
   fastify.addHook('onRequest', (request: any, reply: any, next: Function) => {
-    request.senzorStart = performance.now();
-    next();
-  });
-
-  // Hook: On Response (End Timer & Track)
-  fastify.addHook('onResponse', (request: any, reply: any, next: Function) => {
-    const duration = performance.now() - (request.senzorStart || performance.now());
-
-    // Fastify provides 'routerPath' (e.g. /user/:id)
-    const route = request.routeOptions?.url || request.routerPath;
-
-    client.track({
+    // FIX: Wrap next in a closure to satisfy TS types
+    client.startTrace({
       method: request.method,
-      route: route || 'UNKNOWN',
       path: request.raw.url || request.url,
-      status: reply.statusCode,
-      duration: duration,
       ip: request.ip,
       userAgent: request.headers['user-agent']
-    });
+    }, () => next());
+  });
 
+  // 2. Capture Errors
+  fastify.addHook('onError', (request: any, reply: any, error: any, next: Function) => {
+    client.captureError(error);
+    next();
+  });
+
+  // 3. End Trace
+  fastify.addHook('onResponse', (request: any, reply: any, next: Function) => {
+    const route = request.routeOptions?.url || request.routerPath || 'UNKNOWN';
+    client.endTrace(reply.statusCode, { route });
     next();
   });
 

package/src/wrappers/h3.ts

@@ -1,7 +1,6 @@
 import { client } from '../core/client';
 import { getRoute } from '../core/normalizer';
 
-// Minimal types for H3 to avoid peer-deps
 type EventHandler = (event: any) => any;
 
 export const wrapH3 = (handler: EventHandler) => {
@@ -9,7 +8,6 @@ export const wrapH3 = (handler: EventHandler) => {
     const req = event.node.req;
     const path = req.originalUrl || req.url || '/';
 
-    // Start Trace Context
     return client.startTrace({
       method: req.method || 'GET',
       path: path,
@@ -18,16 +16,16 @@ export const wrapH3 = (handler: EventHandler) => {
     }, async () => {
       try {
         const response = await handler(event);
-
-        // H3/Nitro response status
         let status = 200;
         if (event.node.res.statusCode) status = event.node.res.statusCode;
-        // Check if response is an error object
         if (response && response.statusCode) status = response.statusCode;
 
         client.endTrace(status, { route: getRoute(event, path) });
         return response;
       } catch (err: any) {
+        // AUTOMATIC ERROR CAPTURE
+        client.captureError(err);
+
         const status = err.statusCode || err.status || 500;
         client.endTrace(status, { route: getRoute(event, path) });
         throw err;

package/src/wrappers/next.ts

@@ -1,16 +1,14 @@
 import { client } from '../core/client';
 import { normalizePath } from '../core/normalizer';
 
-// --- App Router Wrapper (Route Handlers) ---
+// --- App Router Wrapper ---
 export const wrapNextRoute = (handler: Function) => {
   return async (req: Request | any, context?: any) => {
-    // 1. Extract Info
     const url = req.url ? new URL(req.url) : { pathname: '/' };
     const method = req.method || 'GET';
     const ua = req.headers.get ? req.headers.get('user-agent') : undefined;
     const ip = req.headers.get ? req.headers.get('x-forwarded-for') : undefined;
 
-    // 2. Run in Context
     return client.startTrace({
       method,
       path: url.pathname,
@@ -20,44 +18,44 @@ export const wrapNextRoute = (handler: Function) => {
       try {
         const response = await handler(req, context);
         const status = response?.status || 200;
-        
         client.endTrace(status, { route: normalizePath(url.pathname) });
         return response;
       } catch (err: any) {
+        // AUTOMATIC ERROR CAPTURE
+        client.captureError(err);
         client.endTrace(500, { route: normalizePath(url.pathname) });
-        throw err;
+        throw err; // Re-throw so Next.js handles the error page
       }
     });
   };
 };
 
-// --- Pages Router Wrapper (API Routes) ---
+// --- Pages Router Wrapper ---
 export const wrapNextPages = (handler: Function) => {
   return async (req: any, res: any) => {
     const path = req.url ? req.url.split('?')[0] : '/';
-    
-    // 1. Run in Context
+
     return client.startTrace({
       method: req.method || 'GET',
       path: path,
       userAgent: req.headers['user-agent'],
       ip: req.headers['x-forwarded-for'] || req.socket?.remoteAddress,
     }, async () => {
-      
-      // 2. Hook Response
+
       const done = () => {
         client.endTrace(res.statusCode || 200, { route: normalizePath(path) });
       };
-      
+
       res.once('finish', done);
-      res.once('close', done); // Fallback if finish doesn't fire
+      res.once('close', done);
 
-      // 3. Execute
       try {
         return await handler(req, res);
-      } catch (e) {
-        // Next.js Pages router usually handles errors internally, 
-        // but we ensure we catch sync errors here
+      } catch (e: any) {
+        // AUTOMATIC ERROR CAPTURE
+        client.captureError(e);
+        // Note: In Pages dir, we rely on 'finish' listener above to close trace, 
+        // but capturing here ensures the error data is attached.
         throw e;
       }
     });