@senzops/apm-node 1.2.3 → 1.2.5

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/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, {

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/wrappers/fastify.ts

@@ -1,16 +1,16 @@
-import { client } from '../core/client';
-import { SenzorOptions } from '../core/types';
-import { instrumentFastifyInstance } from '../instrumentation/fastify';
-import { getClientIp } from '../utils/getClientIp';
+import { client } from '../core/client';
+import { SenzorOptions } from '../core/types';
+import { instrumentFastifyInstance } from '../instrumentation/fastify';
+import { getClientIp } from '../utils/getClientIp';
 
 export const senzorPlugin = (fastify: any, options: SenzorOptions, done: Function) => {
-  if (options && options.apiKey) {
-    client.init(options);
-  }
-
-  instrumentFastifyInstance(fastify, options);
+  if (options && options.apiKey) {
+    client.init(options);
+  }
 
-  fastify.addHook('onRequest', (request: any, reply: any, next: Function) => {
+  instrumentFastifyInstance(fastify, options);
+
+  fastify.addHook('onRequest', function senzorOnRequest(request: any, reply: any, next: Function) {
     client.startTrace({
       method: request.method,
       path: request.raw.url || request.url,
@@ -20,16 +20,16 @@ export const senzorPlugin = (fastify: any, options: SenzorOptions, done: Functio
     }, () => next());
   });
 
-  fastify.addHook('onError', (request: any, reply: any, error: any, next: Function) => {
+  fastify.addHook('onError', function senzorOnError(request: any, reply: any, error: any, next: Function) {
     client.captureError(error);
     next();
   });
 
-  fastify.addHook('onResponse', (request: any, reply: any, next: Function) => {
+  fastify.addHook('onResponse', function senzorOnResponse(request: any, reply: any, next: Function) {
     const route = request.routeOptions?.url || request.routerPath || 'UNKNOWN';
     client.endTrace(reply.statusCode, { route });
     next();
   });
 
   done();
-};
+};

package/src/wrappers/h3.ts

@@ -1,7 +1,7 @@
-import { client } from '../core/client';
-import { getRoute } from '../core/normalizer';
-import { invokeWithFrameworkSpan } from '../instrumentation/framework';
-import { getClientIp } from '../utils/getClientIp';
+import { client } from '../core/client';
+import { getRoute } from '../core/normalizer';
+import { invokeWithFrameworkSpan } from '../instrumentation/framework';
+import { getClientIp } from '../utils/getClientIp';
 
 type EventHandler = (event: any) => any;
 
@@ -16,44 +16,45 @@ export const wrapH3 = (handler: EventHandler) => {
       ip: getClientIp(req),
       userAgent: req.headers['user-agent'],
       headers: req.headers // Pass headers
-    }, async () => {
-      try {
-        const route = getRoute(event, path);
-        const response = await invokeWithFrameworkSpan(
-          handler,
-          undefined,
-          [event],
-          {
-            framework: 'h3',
-            type: 'event_handler',
-            name: `h3.event_handler ${req.method || 'GET'} ${route}`,
-            route,
-            method: req.method || 'GET',
-            request: req,
-            response: event.node.res,
-            attributes: {
-              'h3.type': 'event_handler',
-              'http.route': route
-            }
-          },
-          undefined,
-          {
-            callbackCompletesSpan: false,
-            responseEndsSpan: false
-          }
-        );
-        let status = 200;
-        if (event.node.res.statusCode) status = event.node.res.statusCode;
-        if (response && response.statusCode) status = response.statusCode;
-
-        client.endTrace(status, { route });
-        return response;
-      } catch (err: any) {
-        client.captureError(err);
-        const status = err.statusCode || err.status || 500;
+    }, async () => {
+      try {
+        const route = getRoute(event, path);
+        const response = await invokeWithFrameworkSpan(
+          handler,
+          undefined,
+          [event],
+          {
+            framework: 'h3',
+            type: 'event_handler',
+            name: `h3.event_handler ${req.method || 'GET'} ${route}`,
+            route,
+            method: req.method || 'GET',
+            handlerName: (handler as any).name || 'handler',
+            request: req,
+            response: event.node.res,
+            attributes: {
+              'h3.type': 'event_handler',
+              'http.route': route
+            }
+          },
+          undefined,
+          {
+            callbackCompletesSpan: false,
+            responseEndsSpan: false
+          }
+        );
+        let status = 200;
+        if (event.node.res.statusCode) status = event.node.res.statusCode;
+        if (response && response.statusCode) status = response.statusCode;
+
+        client.endTrace(status, { route });
+        return response;
+      } catch (err: any) {
+        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,7 +1,7 @@
-import { client } from '../core/client';
-import { normalizePath } from '../core/normalizer';
-import { invokeWithFrameworkSpan } from '../instrumentation/framework';
-import { getClientIp } from '../utils/getClientIp';
+import { client } from '../core/client';
+import { normalizePath } from '../core/normalizer';
+import { invokeWithFrameworkSpan } from '../instrumentation/framework';
+import { getClientIp } from '../utils/getClientIp';
 
 // --- App Router Wrapper ---
 export const wrapNextRoute = (handler: Function) => {
@@ -38,39 +38,40 @@ export const wrapNextRoute = (handler: Function) => {
       userAgent: ua,
       ip: ip || getClientIp(req),
       headers: headers // Pass extracted headers
-    }, async () => {
-      try {
-        const route = normalizePath(url.pathname);
-        const response = await invokeWithFrameworkSpan(
-          handler,
-          undefined,
-          [req, context],
-          {
-            framework: 'next',
-            type: 'route_handler',
-            name: `next.app_route_handler ${method} ${route}`,
-            route,
-            method,
-            request: req,
-            attributes: {
-              'next.router': 'app',
-              'http.route': route,
-              'url.path': url.pathname
-            }
-          },
-          undefined,
-          {
-            callbackCompletesSpan: false,
-            responseEndsSpan: false
-          }
-        );
-        const status = response?.status || 200;
-
-        client.endTrace(status, { route });
-        return response;
-      } catch (err: any) {
-        client.captureError(err);
-        client.endTrace(500, { route: normalizePath(url.pathname) });
+    }, async () => {
+      try {
+        const route = normalizePath(url.pathname);
+        const response = await invokeWithFrameworkSpan(
+          handler,
+          undefined,
+          [req, context],
+          {
+            framework: 'next',
+            type: 'route_handler',
+            name: `next.app_route_handler ${method} ${route}`,
+            route,
+            method,
+            handlerName: (handler as any).name || 'handler',
+            request: req,
+            attributes: {
+              'next.router': 'app',
+              'http.route': route,
+              'url.path': url.pathname
+            }
+          },
+          undefined,
+          {
+            callbackCompletesSpan: false,
+            responseEndsSpan: false
+          }
+        );
+        const status = response?.status || 200;
+
+        client.endTrace(status, { route });
+        return response;
+      } catch (err: any) {
+        client.captureError(err);
+        client.endTrace(500, { route: normalizePath(url.pathname) });
         throw err;
       }
     });
@@ -95,37 +96,38 @@ export const wrapNextPages = (handler: Function) => {
       };
 
       res.once('finish', done);
-      res.once('close', done);
-
-      try {
-        const route = normalizePath(path);
-        return await invokeWithFrameworkSpan(
-          handler,
-          undefined,
-          [req, res],
-          {
-            framework: 'next',
-            type: 'route_handler',
-            name: `next.pages_api_handler ${req.method || 'GET'} ${route}`,
-            route,
-            method: req.method || 'GET',
-            request: req,
-            response: res,
-            attributes: {
-              'next.router': 'pages',
-              'http.route': route
-            }
-          },
-          undefined,
-          {
-            callbackCompletesSpan: false,
-            responseEndsSpan: true
-          }
-        );
-      } catch (e: any) {
-        client.captureError(e);
-        throw e;
+      res.once('close', done);
+
+      try {
+        const route = normalizePath(path);
+        return await invokeWithFrameworkSpan(
+          handler,
+          undefined,
+          [req, res],
+          {
+            framework: 'next',
+            type: 'route_handler',
+            name: `next.pages_api_handler ${req.method || 'GET'} ${route}`,
+            route,
+            method: req.method || 'GET',
+            handlerName: (handler as any).name || 'handler',
+            request: req,
+            response: res,
+            attributes: {
+              'next.router': 'pages',
+              'http.route': route
+            }
+          },
+          undefined,
+          {
+            callbackCompletesSpan: false,
+            responseEndsSpan: true
+          }
+        );
+      } catch (e: any) {
+        client.captureError(e);
+        throw e;
       }
     });
   };
-};
+};