@senzops/apm-node 1.2.2 → 1.2.3

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

@@ -1,296 +0,0 @@
-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

@@ -1,301 +0,0 @@
-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;
-};