@senzops/apm-node 1.1.3 → 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

@@ -122,7 +122,7 @@ export const instrumentHttp = (ingestUrl: string, debug = false) => {
           startTime,
           duration,
           status: error ? 500 : res?.statusCode || 0,
-          meta: { url: urlStr, method, library: 'http' }
+          meta: { url: urlStr, method, library: 'http', error: error ? error.message : undefined }
         });
       };
 

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