@senzops/apm-node 1.2.0 → 1.2.2

package/src/instrumentation/koa.ts

@@ -0,0 +1,173 @@
+import { normalizePath } from '../core/normalizer';
+import { SenzorOptions } from '../core/types';
+import { hookRequire } from './hook';
+import { patchMethod } from './patch';
+import { wrapFrameworkHandlerWithArity } from './framework';
+
+const routerMethods = [
+  'all',
+  'del',
+  'delete',
+  'get',
+  'head',
+  'options',
+  'patch',
+  'post',
+  'put'
+];
+
+const stringifyPath = (value: unknown): string | undefined => {
+  if (typeof value === 'string') return value;
+  if (value instanceof RegExp) return value.toString();
+  if (Array.isArray(value)) {
+    return value.map(stringifyPath).filter(Boolean).join(',');
+  }
+  return undefined;
+};
+
+const getPathFromArgs = (args: any[]): string | undefined => {
+  for (const arg of args) {
+    if (typeof arg === 'function') return undefined;
+    const path = stringifyPath(arg);
+    if (path) return path;
+  }
+
+  return undefined;
+};
+
+const wrapKoaMiddleware = (
+  middleware: any,
+  options?: SenzorOptions,
+  layerPath?: string,
+  layerType: 'middleware' | 'router' | 'route_handler' = 'middleware',
+  method?: string
+) => {
+  if (typeof middleware !== 'function') return middleware;
+
+  return wrapFrameworkHandlerWithArity(
+    middleware,
+    (_thisArg, args) => {
+      const ctx = args[0];
+      const route =
+        ctx?._matchedRoute ||
+        ctx?.matched?.[0]?.path ||
+        layerPath ||
+        normalizePath(ctx?.path || ctx?.request?.path || '/');
+      const actualMethod = method || ctx?.method || ctx?.request?.method;
+      const handlerName = middleware.name || layerType;
+
+      return {
+        framework: 'koa',
+        type: layerType,
+        name:
+          layerType === 'route_handler'
+            ? `koa.request_handler ${actualMethod || ''} ${route}`.trim()
+            : `koa.${layerType} ${route || handlerName}`,
+        route,
+        method: actualMethod,
+        layerPath,
+        handlerName,
+        request: ctx?.req || ctx?.request,
+        response: ctx?.res || ctx?.response,
+        attributes: {
+          'koa.type': layerType,
+          'http.route': route,
+          path: ctx?.path || ctx?.request?.path
+        }
+      };
+    },
+    options,
+    {
+      callbackCompletesSpan: false,
+      responseEndsSpan: false
+    }
+  );
+};
+
+const patchKoaApplication = (
+  koa: any,
+  options?: SenzorOptions
+) => {
+  const proto = koa?.prototype || koa?.default?.prototype;
+  if (!proto) return;
+
+  patchMethod(
+    proto,
+    'use',
+    'senzor.koa.application.use',
+    (original) =>
+      function patchedKoaUse(this: any, middleware: any) {
+        return original.call(
+          this,
+          wrapKoaMiddleware(middleware, options, undefined, 'middleware')
+        );
+      }
+  );
+};
+
+const patchKoaRouter = (
+  routerModule: any,
+  options?: SenzorOptions
+) => {
+  const Router =
+    routerModule?.Router ||
+    routerModule?.default ||
+    routerModule;
+  const proto = Router?.prototype;
+  if (!proto) return;
+
+  patchMethod(
+    proto,
+    'use',
+    'senzor.koa.router.use',
+    (original) =>
+      function patchedKoaRouterUse(this: any, ...args: any[]) {
+        const layerPath = getPathFromArgs(args);
+        const nextArgs = args.map((arg) =>
+          typeof arg === 'function'
+            ? wrapKoaMiddleware(arg, options, layerPath, 'router')
+            : arg
+        );
+        return original.apply(this, nextArgs);
+      }
+  );
+
+  for (const method of routerMethods) {
+    patchMethod(
+      proto,
+      method,
+      `senzor.koa.router.${method}`,
+      (original) =>
+        function patchedKoaRouterMethod(this: any, ...args: any[]) {
+          const layerPath = getPathFromArgs(args);
+          const nextArgs = args.map((arg) =>
+            typeof arg === 'function'
+              ? wrapKoaMiddleware(
+                arg,
+                options,
+                layerPath,
+                'route_handler',
+                method.toUpperCase()
+              )
+              : arg
+          );
+
+          return original.apply(this, nextArgs);
+        }
+    );
+  }
+};
+
+export const instrumentKoa = (options?: SenzorOptions) => {
+  hookRequire('koa', (exports: any) => {
+    patchKoaApplication(exports, options);
+  });
+
+  hookRequire('@koa/router', (exports: any) => {
+    patchKoaRouter(exports, options);
+  });
+
+  hookRequire('koa-router', (exports: any) => {
+    patchKoaRouter(exports, options);
+  });
+};

package/src/register.ts

@@ -31,6 +31,22 @@ const options = {
   captureHeaders: truthy(process.env.SENZOR_CAPTURE_HEADERS),
   captureDbStatement:
     process.env.SENZOR_CAPTURE_DB_STATEMENT === 'false'
+      ? false
+      : undefined,
+  frameworkSpans:
+    process.env.SENZOR_FRAMEWORK_SPANS === 'false'
+      ? false
+      : undefined,
+  captureMiddlewareSpans:
+    process.env.SENZOR_CAPTURE_MIDDLEWARE_SPANS === 'false'
+      ? false
+      : undefined,
+  captureRouterSpans:
+    process.env.SENZOR_CAPTURE_ROUTER_SPANS === 'false'
+      ? false
+      : undefined,
+  captureLifecycleHookSpans:
+    process.env.SENZOR_CAPTURE_LIFECYCLE_HOOK_SPANS === 'false'
       ? false
       : undefined
 };

package/src/wrappers/fastify.ts

@@ -1,11 +1,14 @@
-import { client } from '../core/client';
-import { SenzorOptions } from '../core/types';
-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);
-  }
+  if (options && options.apiKey) {
+    client.init(options);
+  }
+
+  instrumentFastifyInstance(fastify, options);
 
   fastify.addHook('onRequest', (request: any, reply: any, next: Function) => {
     client.startTrace({
@@ -29,4 +32,4 @@ export const senzorPlugin = (fastify: any, options: SenzorOptions, done: Functio
   });
 
   done();
-};
+};

package/src/wrappers/h3.ts

@@ -1,6 +1,7 @@
-import { client } from '../core/client';
-import { getRoute } from '../core/normalizer';
-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;
 
@@ -15,21 +16,44 @@ export const wrapH3 = (handler: EventHandler) => {
       ip: getClientIp(req),
       userAgent: req.headers['user-agent'],
       headers: req.headers // Pass headers
-    }, async () => {
-      try {
-        const response = await handler(event);
-        let status = 200;
-        if (event.node.res.statusCode) status = event.node.res.statusCode;
-        if (response && response.statusCode) status = response.statusCode;
-
-        client.endTrace(status, { route: getRoute(event, path) });
-        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',
+            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,6 +1,7 @@
-import { client } from '../core/client';
-import { normalizePath } from '../core/normalizer';
-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) => {
@@ -37,16 +38,39 @@ export const wrapNextRoute = (handler: Function) => {
       userAgent: ua,
       ip: ip || getClientIp(req),
       headers: headers // Pass extracted headers
-    }, async () => {
-      try {
-        const response = await handler(req, context);
-        const status = response?.status || 200;
-
-        client.endTrace(status, { route: normalizePath(url.pathname) });
-        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,
+            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;
       }
     });
@@ -71,14 +95,37 @@ export const wrapNextPages = (handler: Function) => {
       };
 
       res.once('finish', done);
-      res.once('close', done);
-
-      try {
-        return await handler(req, res);
-      } 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',
+            request: req,
+            response: res,
+            attributes: {
+              'next.router': 'pages',
+              'http.route': route
+            }
+          },
+          undefined,
+          {
+            callbackCompletesSpan: false,
+            responseEndsSpan: true
+          }
+        );
+      } catch (e: any) {
+        client.captureError(e);
+        throw e;
       }
     });
   };
-};
+};

package/wiki.md

@@ -82,6 +82,10 @@ Senzor.init({
   maxAttributes: 64,
   captureHeaders: false,
   captureDbStatement: true,
+  frameworkSpans: true,
+  captureMiddlewareSpans: true,
+  captureRouterSpans: true,
+  captureLifecycleHookSpans: true,
   autoLogs: true,
   debug: false
 });
@@ -133,6 +137,10 @@ SENZOR_MAX_QUEUE_SIZE=10000
 SENZOR_MAX_SPANS_PER_TRACE=500
 SENZOR_CAPTURE_HEADERS=false
 SENZOR_CAPTURE_DB_STATEMENT=true
+SENZOR_FRAMEWORK_SPANS=true
+SENZOR_CAPTURE_MIDDLEWARE_SPANS=true
+SENZOR_CAPTURE_ROUTER_SPANS=true
+SENZOR_CAPTURE_LIFECYCLE_HOOK_SPANS=true
 SENZOR_AUTO_LOGS=true
 SENZOR_DEBUG=false
 ```