@senzops/apm-node 1.2.0 → 1.2.2

package/package.json

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

package/src/core/client.ts

@@ -2,8 +2,11 @@ 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 { instrumentMongo } from '../instrumentation/mongo';
+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';
@@ -74,6 +77,9 @@ export class SenzorClient {
       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) { }

package/src/core/types.ts

@@ -11,6 +11,11 @@ export interface SenzorOptions {
   captureHeaders?: boolean;
   captureDbStatement?: boolean;
   instrumentations?: boolean | string[];
+  frameworkSpans?: boolean;
+  captureMiddlewareSpans?: boolean;
+  captureRouterSpans?: boolean;
+  captureLifecycleHookSpans?: boolean;
+  ignoreFrameworkSpanTypes?: string[];
   debug?: boolean;
   autoLogs?: boolean;
 }

package/src/instrumentation/express.ts

@@ -0,0 +1,338 @@
+import { normalizePath } from '../core/normalizer';
+import { SenzorOptions } from '../core/types';
+import { hookRequire } from './hook';
+import { patchMethod } from './patch';
+import { invokeWithFrameworkSpan } from './framework';
+
+const LAYER_PATCHED = Symbol.for('senzor.express.layer.patched');
+
+const routeMethods = new Set([
+  'checkout',
+  'copy',
+  'delete',
+  'get',
+  'head',
+  'lock',
+  'merge',
+  'mkactivity',
+  'mkcol',
+  'move',
+  'm-search',
+  'notify',
+  'options',
+  'patch',
+  'post',
+  'purge',
+  'put',
+  'report',
+  'search',
+  'subscribe',
+  'trace',
+  'unlock',
+  'unsubscribe'
+]);
+
+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(',');
+  }
+  if (typeof value === 'number') return String(value);
+  return undefined;
+};
+
+const getLayerPath = (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 getRequestRoute = (
+  req: any,
+  layer: any,
+  layerPath?: string
+): string | undefined => {
+  const routePath = stringifyPath(layer?.route?.path);
+  if (routePath) {
+    const baseUrl = req?.baseUrl || '';
+    return `${baseUrl}${routePath}` || routePath;
+  }
+
+  if (req?.route?.path) {
+    return `${req.baseUrl || ''}${req.route.path}`;
+  }
+
+  if (layerPath) {
+    const baseUrl = req?.baseUrl || '';
+    return `${baseUrl}${layerPath}` || layerPath;
+  }
+
+  const path = req?.originalUrl || req?.url || req?.path;
+  return path ? normalizePath(String(path).split('?')[0]) : undefined;
+};
+
+const getLayerType = (
+  layer: any,
+  original: Function,
+  forcedType?: 'middleware' | 'router' | 'request_handler' | 'error_handler'
+) => {
+  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;
+  }
+  return 'middleware' as const;
+};
+
+const getRouteMethod = (layer: any, req: any): string | undefined => {
+  if (layer?.route?.methods) {
+    const method = Object.keys(layer.route.methods).find(
+      (candidate) => layer.route.methods[candidate]
+    );
+    if (method) return method.toUpperCase();
+  }
+
+  return req?.method;
+};
+
+const copyEnumerableProperties = (
+  source: Function,
+  target: Function
+) => {
+  for (const key in source as any) {
+    try {
+      Object.defineProperty(target, key, {
+        configurable: true,
+        enumerable: true,
+        get() {
+          return (source as any)[key];
+        },
+        set(value) {
+          (source as any)[key] = value;
+        }
+      });
+    } catch { }
+  }
+};
+
+const patchLayer = (
+  layer: any,
+  layerPath: string | undefined,
+  options?: SenzorOptions,
+  forcedType?: 'middleware' | 'router' | 'request_handler' | 'error_handler'
+) => {
+  if (!layer || layer[LAYER_PATCHED] || typeof layer.handle !== 'function') {
+    return;
+  }
+
+  Object.defineProperty(layer, LAYER_PATCHED, {
+    value: true,
+    enumerable: false
+  });
+
+  patchMethod(
+    layer,
+    'handle',
+    'senzor.express.layer.handle',
+    (original) => {
+      const layerType = getLayerType(layer, original, forcedType);
+      const handlerName =
+        original.name ||
+        layer.name ||
+        layerType;
+
+      if (original.length === 4) {
+        const wrapped = function senzorExpressErrorHandler(
+          this: unknown,
+          err: any,
+          req: any,
+          res: any,
+          next: Function
+        ) {
+          const route = getRequestRoute(req, layer, layerPath);
+          return invokeWithFrameworkSpan(
+            original,
+            this,
+            [err, req, res, next],
+            {
+              framework: 'express',
+              type: 'error_handler',
+              name: `express.error_handler ${route || handlerName}`,
+              route,
+              method: getRouteMethod(layer, req),
+              layerPath,
+              handlerName,
+              request: req,
+              response: res,
+              attributes: {
+                'express.type': 'error_handler',
+                'express.layer.name': layer.name,
+                error: err?.message,
+                'error.type': err?.name || typeof err
+              }
+            },
+            options,
+            {
+              callbackIndex: 3,
+              callbackCompletesSpan: true,
+              responseEndsSpan: true
+            }
+          );
+        };
+
+        copyEnumerableProperties(original, wrapped);
+        return wrapped;
+      }
+
+      const wrapped = function senzorExpressLayer(
+        this: unknown,
+        req: any,
+        res: any,
+        next: Function
+      ) {
+        const route = getRequestRoute(req, layer, layerPath);
+        const method = getRouteMethod(layer, req);
+        const displayRoute = route || layerPath || handlerName;
+        const name =
+          layerType === 'request_handler'
+            ? `express.request_handler ${method || ''} ${displayRoute}`.trim()
+            : `express.${layerType} ${displayRoute}`;
+
+        return invokeWithFrameworkSpan(
+          original,
+          this,
+          [req, res, next],
+          {
+            framework: 'express',
+            type: layerType,
+            name,
+            route,
+            method,
+            layerPath,
+            handlerName,
+            request: req,
+            response: res,
+            attributes: {
+              'express.type': layerType,
+              'express.layer.name': layer.name,
+              'http.route': route
+            }
+          },
+          options,
+          {
+            callbackIndex: 2,
+            callbackCompletesSpan: true,
+            responseEndsSpan: true
+          }
+        );
+      };
+
+      copyEnumerableProperties(original, wrapped);
+      return wrapped;
+    }
+  );
+};
+
+const patchRouteMethodHandlers = (
+  route: any,
+  routePath: string | undefined,
+  options?: SenzorOptions
+) => {
+  if (!route || route.__senzorRouteMethodsPatched) return;
+
+  Object.defineProperty(route, '__senzorRouteMethodsPatched', {
+    value: true,
+    enumerable: false
+  });
+
+  for (const method of routeMethods) {
+    if (typeof route[method] !== 'function') continue;
+
+    patchMethod(
+      route,
+      method,
+      `senzor.express.route.${method}`,
+      (original) =>
+        function patchedExpressRouteMethod(this: any, ...args: any[]) {
+          const result = original.apply(this, args);
+          const stack = this?.stack || [];
+
+          for (const layer of stack) {
+          patchLayer(layer, routePath, options, 'request_handler');
+          }
+
+          return result;
+        }
+    );
+  }
+};
+
+const patchExpress = (
+  expressModule: any,
+  options?: SenzorOptions
+) => {
+  if (!expressModule) return;
+
+  const routerProto =
+    typeof expressModule?.Router?.prototype?.route === 'function'
+      ? expressModule.Router.prototype
+      : expressModule.Router;
+
+  patchMethod(
+    routerProto,
+    'route',
+    'senzor.express.router.route',
+    (original) =>
+      function patchedExpressRoute(this: any, ...args: any[]) {
+        const route = original.apply(this, args);
+        const routePath = getLayerPath(args);
+        const layer = this?.stack?.[this.stack.length - 1];
+
+        patchLayer(layer, routePath, options, 'router');
+        patchRouteMethodHandlers(route, routePath, options);
+
+        return route;
+      }
+  );
+
+  patchMethod(
+    routerProto,
+    'use',
+    'senzor.express.router.use',
+    (original) =>
+      function patchedExpressRouterUse(this: any, ...args: any[]) {
+        const result = original.apply(this, args);
+        const layer = this?.stack?.[this.stack.length - 1];
+        patchLayer(layer, getLayerPath(args), options);
+        return result;
+      }
+  );
+
+  patchMethod(
+    expressModule.application,
+    'use',
+    'senzor.express.application.use',
+    (original) =>
+      function patchedExpressApplicationUse(this: any, ...args: any[]) {
+        const router = this?.router || this?._router;
+        const result = original.apply(this, args);
+        const activeRouter = this?.router || this?._router || router;
+        const layer = activeRouter?.stack?.[activeRouter.stack.length - 1];
+        patchLayer(layer, getLayerPath(args), options);
+        return result;
+      }
+  );
+};
+
+export const instrumentExpress = (options?: SenzorOptions) => {
+  hookRequire('express', (exports: any) => {
+    patchExpress(exports, options);
+    if (exports?.default) patchExpress(exports.default, options);
+  });
+};

package/src/instrumentation/fastify.ts

@@ -0,0 +1,296 @@
+import { SenzorOptions } from '../core/types';
+import { hookRequire } from './hook';
+import { patchMethod } from './patch';
+import { wrapFrameworkHandlerWithArity } from './framework';
+
+const FACTORY_PATCHED = Symbol.for('senzor.fastify.factory.patched');
+const INSTANCE_PATCHED = Symbol.for('senzor.fastify.instance.patched');
+
+const lifecycleHookNames = new Set([
+  'onRequest',
+  'preParsing',
+  'preValidation',
+  'preHandler',
+  'preSerialization',
+  'onSend',
+  'onResponse',
+  'onError',
+  'onTimeout',
+  'onRequestAbort'
+]);
+
+const routeLifecycleKeys = [
+  'onRequest',
+  'preParsing',
+  'preValidation',
+  'preHandler',
+  'preSerialization',
+  'onSend',
+  'onResponse',
+  'onError'
+];
+
+const getRoute = (request: any, fallback?: string): string | undefined =>
+  request?.routeOptions?.url ||
+  request?.routerPath ||
+  request?.context?.config?.url ||
+  fallback;
+
+const wrapHook = (
+  hookName: string,
+  handler: any,
+  options?: SenzorOptions,
+  route?: string
+) => {
+  if (typeof handler !== 'function') return handler;
+
+  return wrapFrameworkHandlerWithArity(
+    handler,
+    (_thisArg, args) => {
+      const request = args[0];
+      const reply = args[1];
+      const currentRoute = getRoute(request, route);
+
+      return {
+        framework: 'fastify',
+        type: hookName === 'onError' ? 'error_handler' : 'lifecycle_hook',
+        name: `fastify.${hookName} ${currentRoute || request?.url || ''}`.trim(),
+        route: currentRoute,
+        method: request?.method,
+        handlerName: handler.name || hookName,
+        request,
+        response: reply?.raw || reply,
+        attributes: {
+          'fastify.hook': hookName,
+          'fastify.type': hookName === 'onError' ? 'error_handler' : 'lifecycle_hook',
+          'http.route': currentRoute,
+          url: request?.url
+        }
+      };
+    },
+    options,
+    {
+      callbackCompletesSpan: true,
+      responseEndsSpan: false
+    }
+  );
+};
+
+const wrapRouteHandler = (
+  handler: any,
+  options?: SenzorOptions,
+  route?: string
+) => {
+  if (typeof handler !== 'function') return handler;
+
+  return wrapFrameworkHandlerWithArity(
+    handler,
+    (_thisArg, args) => {
+      const request = args[0];
+      const reply = args[1];
+      const currentRoute = getRoute(request, route);
+
+      return {
+        framework: 'fastify',
+        type: 'route_handler',
+        name: `fastify.route_handler ${request?.method || ''} ${currentRoute || request?.url || ''}`.trim(),
+        route: currentRoute,
+        method: request?.method,
+        handlerName: handler.name || 'handler',
+        request,
+        response: reply?.raw || reply,
+        attributes: {
+          'fastify.type': 'route_handler',
+          'http.route': currentRoute,
+          url: request?.url
+        }
+      };
+    },
+    options,
+    {
+      callbackCompletesSpan: true,
+      responseEndsSpan: true
+    }
+  );
+};
+
+const wrapMaybeArray = (
+  value: any,
+  wrap: (handler: any) => any
+) => {
+  if (Array.isArray(value)) return value.map(wrap);
+  return wrap(value);
+};
+
+const patchFastifyInstance = (
+  instance: any,
+  options?: SenzorOptions
+) => {
+  if (!instance || instance[INSTANCE_PATCHED]) return instance;
+
+  Object.defineProperty(instance, INSTANCE_PATCHED, {
+    value: true,
+    enumerable: false
+  });
+
+  patchMethod(
+    instance,
+    'addHook',
+    'senzor.fastify.addHook',
+    (original) =>
+      function patchedFastifyAddHook(this: any, hookName: string, handler: any) {
+        if (lifecycleHookNames.has(hookName)) {
+          return original.call(this, hookName, wrapHook(hookName, handler, options));
+        }
+
+        return original.apply(this, arguments as any);
+      }
+  );
+
+  patchMethod(
+    instance,
+    'route',
+    'senzor.fastify.route',
+    (original) =>
+      function patchedFastifyRoute(this: any, routeOptions: any) {
+        if (!routeOptions || typeof routeOptions !== 'object') {
+          return original.apply(this, arguments as any);
+        }
+
+        const nextRouteOptions = { ...routeOptions };
+        const route =
+          nextRouteOptions.url ||
+          nextRouteOptions.path ||
+          nextRouteOptions.routePath;
+
+        if (nextRouteOptions.handler) {
+          nextRouteOptions.handler = wrapRouteHandler(
+            nextRouteOptions.handler,
+            options,
+            route
+          );
+        }
+
+        for (const key of routeLifecycleKeys) {
+          if (nextRouteOptions[key]) {
+            nextRouteOptions[key] = wrapMaybeArray(
+              nextRouteOptions[key],
+              (handler) => wrapHook(key, handler, options, route)
+            );
+          }
+        }
+
+        return original.call(this, nextRouteOptions);
+      }
+  );
+
+  patchMethod(
+    instance,
+    'setErrorHandler',
+    'senzor.fastify.setErrorHandler',
+    (original) =>
+      function patchedFastifySetErrorHandler(this: any, handler: any) {
+        return original.call(
+          this,
+          wrapFrameworkHandlerWithArity(
+            handler,
+            (_thisArg, args) => {
+              const request = args[1];
+              const reply = args[2];
+              const route = getRoute(request);
+
+              return {
+                framework: 'fastify',
+                type: 'error_handler',
+                name: `fastify.error_handler ${route || request?.url || ''}`.trim(),
+                route,
+                method: request?.method,
+                handlerName: handler?.name || 'errorHandler',
+                request,
+                response: reply?.raw || reply,
+                attributes: {
+                  'fastify.type': 'error_handler',
+                  error: args[0]?.message,
+                  'error.type': args[0]?.name || typeof args[0]
+                }
+              };
+            },
+            options,
+            {
+              callbackCompletesSpan: true,
+              responseEndsSpan: true
+            }
+          )
+        );
+      }
+  );
+
+  return instance;
+};
+
+const copyFactoryProperties = (
+  source: any,
+  target: any
+) => {
+  for (const key of Reflect.ownKeys(source)) {
+    if (['length', 'name', 'prototype'].includes(String(key))) continue;
+
+    try {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)!);
+    } catch { }
+  }
+};
+
+const wrapFastifyFactory = (
+  factory: any,
+  options?: SenzorOptions
+) => {
+  if (typeof factory !== 'function' || factory[FACTORY_PATCHED]) {
+    return factory;
+  }
+
+  const wrapped = function senzorFastifyFactory(this: unknown, ...args: any[]) {
+    const instance = factory.apply(this, args);
+    return patchFastifyInstance(instance, options);
+  };
+
+  copyFactoryProperties(factory, wrapped);
+
+  Object.defineProperty(wrapped, FACTORY_PATCHED, {
+    value: true,
+    enumerable: false
+  });
+
+  const mutableWrapped = wrapped as any;
+
+  if (mutableWrapped.fastify === factory) {
+    mutableWrapped.fastify = mutableWrapped;
+  }
+  if (mutableWrapped.default === factory) {
+    mutableWrapped.default = mutableWrapped;
+  }
+
+  return mutableWrapped;
+};
+
+export const instrumentFastify = (options?: SenzorOptions) => {
+  hookRequire('fastify', (exports: any) => {
+    if (typeof exports === 'function') {
+      return wrapFastifyFactory(exports, options);
+    }
+
+    if (exports?.fastify) {
+      exports.fastify = wrapFastifyFactory(exports.fastify, options);
+    }
+    if (exports?.default) {
+      exports.default = wrapFastifyFactory(exports.default, options);
+    }
+
+    return exports;
+  });
+};
+
+export const instrumentFastifyInstance = (
+  instance: any,
+  options?: SenzorOptions
+) => patchFastifyInstance(instance, options);