@senzops/apm-node 1.2.1 → 1.2.2

package/.claude/worktrees/infallible-chatelet-f3fb36/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);

package/.claude/worktrees/infallible-chatelet-f3fb36/src/instrumentation/framework.ts

@@ -0,0 +1,301 @@
+import { Context } from '../core/context';
+import { SenzorOptions } from '../core/types';
+import { CapturedSpan, runWithCapturedSpan, startCapturedSpan } from './span';
+
+export type FrameworkSpanType =
+  | 'middleware'
+  | 'router'
+  | 'request_handler'
+  | 'route_handler'
+  | 'controller_handler'
+  | 'lifecycle_hook'
+  | 'error_handler'
+  | 'event_handler';
+
+export interface FrameworkSpanInfo {
+  framework: string;
+  type: FrameworkSpanType;
+  name: string;
+  route?: string;
+  method?: string;
+  layerPath?: string;
+  handlerName?: string;
+  request?: any;
+  response?: any;
+  attributes?: Record<string, unknown>;
+}
+
+interface InvokeOptions {
+  callbackIndex?: number;
+  callbackCompletesSpan?: boolean;
+  responseEndsSpan?: boolean;
+}
+
+const ignoredNextValues = new Set([undefined, null, 'route', 'router']);
+
+export const shouldCaptureFrameworkSpan = (
+  type: FrameworkSpanType,
+  options?: SenzorOptions
+): boolean => {
+  if (options?.frameworkSpans === false) return false;
+  if (type === 'middleware' && options?.captureMiddlewareSpans === false) return false;
+  if (type === 'router' && options?.captureRouterSpans === false) return false;
+  if (type === 'lifecycle_hook' && options?.captureLifecycleHookSpans === false) return false;
+  if (options?.ignoreFrameworkSpanTypes?.includes(type)) return false;
+  return true;
+};
+
+const statusFrom = (
+  info: FrameworkSpanInfo,
+  fallback = 0
+): number => {
+  const res = info.response;
+  return (
+    res?.statusCode ||
+    res?.status ||
+    res?.raw?.statusCode ||
+    res?.status_code ||
+    fallback
+  );
+};
+
+const isPromiseLike = (value: unknown): value is Promise<unknown> =>
+  Boolean(value && typeof (value as any).then === 'function');
+
+const runWithParentOf = <T>(
+  span: CapturedSpan,
+  fn: () => T
+): T => {
+  if (!span.parentSpanId) return fn();
+  return Context.withActiveSpan(span.parentSpanId, fn);
+};
+
+const copyFunctionProperties = (
+  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 { }
+  }
+};
+
+export const invokeWithFrameworkSpan = (
+  handler: Function,
+  thisArg: unknown,
+  args: any[],
+  info: FrameworkSpanInfo,
+  options?: SenzorOptions,
+  invokeOptions: InvokeOptions = {}
+) => {
+  if (!shouldCaptureFrameworkSpan(info.type, options) || !Context.current()) {
+    return handler.apply(thisArg, args);
+  }
+
+  const span = startCapturedSpan(
+    info.name,
+    'function',
+    {
+      framework: info.framework,
+      'senzor.framework': info.framework,
+      'senzor.framework.type': info.type,
+      'http.route': info.route,
+      route: info.route,
+      method: info.method,
+      layerPath: info.layerPath,
+      handlerName: info.handlerName,
+      ...info.attributes
+    },
+    options
+  );
+
+  if (!span) return handler.apply(thisArg, args);
+
+  let ended = false;
+  const cleanup: Array<() => void> = [];
+
+  const endSpan = (
+    status = statusFrom(info),
+    meta: Record<string, unknown> = {}
+  ) => {
+    if (ended) return;
+    ended = true;
+
+    for (const clean of cleanup) {
+      try { clean(); } catch { }
+    }
+
+    span.end(status, meta);
+  };
+
+  const res = info.response;
+  if (invokeOptions.responseEndsSpan !== false && res?.once) {
+    const onFinish = () =>
+      endSpan(statusFrom(info), { completion: 'response.finish' });
+    const onClose = () =>
+      endSpan(statusFrom(info), { completion: 'response.close' });
+
+    res.once('finish', onFinish);
+    res.once('close', onClose);
+
+    cleanup.push(() => {
+      try { res.removeListener?.('finish', onFinish); } catch { }
+      try { res.removeListener?.('close', onClose); } catch { }
+    });
+  }
+
+  const callbackIndex =
+    invokeOptions.callbackIndex ??
+    args.findIndex((arg) => typeof arg === 'function');
+
+  if (
+    invokeOptions.callbackCompletesSpan !== false &&
+    callbackIndex >= 0 &&
+    typeof args[callbackIndex] === 'function'
+  ) {
+    const originalCallback = args[callbackIndex];
+    args[callbackIndex] = function wrappedFrameworkCallback(
+      this: unknown,
+      ...callbackArgs: any[]
+    ) {
+      const maybeError = callbackArgs[0];
+      const hasError = !ignoredNextValues.has(maybeError);
+
+      endSpan(hasError ? 500 : statusFrom(info), {
+        completion: 'callback',
+        error: hasError ? String(maybeError?.message || maybeError) : undefined,
+        'error.type': hasError
+          ? maybeError?.name || typeof maybeError
+          : undefined
+      });
+
+      return runWithParentOf(span, () =>
+        originalCallback.apply(this, callbackArgs)
+      );
+    };
+  }
+
+  return runWithCapturedSpan(span, () => {
+    try {
+      const result = handler.apply(thisArg, args);
+
+      if (isPromiseLike(result)) {
+        return result.then(
+          (value) => {
+            endSpan(statusFrom(info), { completion: 'promise.resolve' });
+            return value;
+          },
+          (error) => {
+            endSpan(500, {
+              completion: 'promise.reject',
+              error: error?.message,
+              'error.type': error?.name || 'Error'
+            });
+            throw error;
+          }
+        );
+      }
+
+      if (callbackIndex < 0 && invokeOptions.responseEndsSpan === false) {
+        endSpan(statusFrom(info), { completion: 'sync.return' });
+      }
+
+      return result;
+    } catch (error: any) {
+      endSpan(500, {
+        completion: 'throw',
+        error: error?.message,
+        'error.type': error?.name || 'Error'
+      });
+      throw error;
+    }
+  });
+};
+
+export const wrapFrameworkHandler = <T extends Function>(
+  handler: T,
+  getInfo: (thisArg: unknown, args: any[]) => FrameworkSpanInfo,
+  options?: SenzorOptions,
+  invokeOptions: InvokeOptions = {}
+): T => {
+  if (typeof handler !== 'function') return handler;
+
+  const wrapped = function wrappedFrameworkHandler(
+    this: unknown,
+    ...args: any[]
+  ) {
+    return invokeWithFrameworkSpan(
+      handler,
+      this,
+      args,
+      getInfo(this, args),
+      options,
+      invokeOptions
+    );
+  };
+
+  copyFunctionProperties(handler, wrapped);
+  return wrapped as unknown as T;
+};
+
+export const wrapFrameworkHandlerWithArity = <T extends Function>(
+  handler: T,
+  getInfo: (thisArg: unknown, args: any[]) => FrameworkSpanInfo,
+  options?: SenzorOptions,
+  invokeOptions: InvokeOptions = {}
+): T => {
+  if (typeof handler !== 'function') return handler;
+
+  const invoke = (thisArg: unknown, args: any[]) =>
+    invokeWithFrameworkSpan(
+      handler,
+      thisArg,
+      args,
+      getInfo(thisArg, args),
+      options,
+      invokeOptions
+    );
+
+  let wrapped: Function;
+
+  switch (handler.length) {
+    case 4:
+      wrapped = function wrapped4(this: unknown, a: any, b: any, c: any, d: any) {
+        return invoke(this, [a, b, c, d]);
+      };
+      break;
+    case 3:
+      wrapped = function wrapped3(this: unknown, a: any, b: any, c: any) {
+        return invoke(this, [a, b, c]);
+      };
+      break;
+    case 2:
+      wrapped = function wrapped2(this: unknown, a: any, b: any) {
+        return invoke(this, [a, b]);
+      };
+      break;
+    case 1:
+      wrapped = function wrapped1(this: unknown, a: any) {
+        return invoke(this, [a]);
+      };
+      break;
+    default:
+      wrapped = function wrapped0(this: unknown) {
+        return invoke(this, Array.from(arguments));
+      };
+      break;
+  }
+
+  copyFunctionProperties(handler, wrapped);
+  return wrapped as unknown as T;
+};