@senzops/apm-node 1.2.2 → 1.2.4

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

@@ -1,173 +0,0 @@
-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/.claude/worktrees/infallible-chatelet-f3fb36/src/instrumentation/mongo.ts

@@ -1,202 +0,0 @@
-import { SenzorOptions } from '../core/types';
-import { hookRequire } from './hook';
-import { patchMethod } from './patch';
-import { runWithCapturedSpan, startCapturedSpan } from './span';
-
-const collectionName = (collection: any): string =>
-  collection?.collectionName ||
-  collection?.s?.namespace?.collection ||
-  collection?.namespace?.collection ||
-  'unknown';
-
-const databaseName = (collection: any): string | undefined =>
-  collection?.dbName ||
-  collection?.s?.namespace?.db ||
-  collection?.namespace?.db;
-
-const cursorCollectionName = (cursor: any): string =>
-  cursor?.namespace?.collection ||
-  cursor?.ns?.collection ||
-  cursor?.cursorNamespace?.collection ||
-  'unknown';
-
-const patchCollectionMethod = (
-  proto: any,
-  method: string,
-  options?: SenzorOptions
-) => {
-  patchMethod(
-    proto,
-    method,
-    `senzor.mongodb.collection.${method}`,
-    (original) =>
-      function patchedMongoCollection(this: any, ...args: any[]) {
-        const collection = collectionName(this);
-        const span = startCapturedSpan(
-          `MongoDB ${method}`,
-          'db',
-          {
-            collection,
-            operation: method,
-            'db.system.name': 'mongodb',
-            'db.collection.name': collection,
-            'db.namespace': databaseName(this)
-              ? `${databaseName(this)}.${collection}`
-              : collection,
-            'db.operation.name': method,
-            library: 'mongodb'
-          },
-          options
-        );
-
-        if (!span) return original.apply(this, args);
-
-        return runWithCapturedSpan(span, () => {
-          try {
-            const result = original.apply(this, args);
-            if (result && typeof result.then === 'function') {
-              return result.then(
-                (value: any) => {
-                  span.end(0, {
-                    matchedCount: value?.matchedCount,
-                    modifiedCount: value?.modifiedCount,
-                    deletedCount: value?.deletedCount,
-                    insertedCount: value?.insertedCount
-                  });
-                  return value;
-                },
-                (error: any) => {
-                  span.end(500, {
-                    error: error?.message,
-                    'error.type': error?.name || 'Error'
-                  });
-                  throw error;
-                }
-              );
-            }
-
-            span.end(0);
-            return result;
-          } catch (error: any) {
-            span.end(500, {
-              error: error?.message,
-              'error.type': error?.name || 'Error'
-            });
-            throw error;
-          }
-        });
-      }
-  );
-};
-
-const patchCursorMethod = (
-  proto: any,
-  method: string,
-  operation: string,
-  options?: SenzorOptions
-) => {
-  patchMethod(
-    proto,
-    method,
-    `senzor.mongodb.cursor.${operation}.${method}`,
-    (original) =>
-      function patchedMongoCursor(this: any, ...args: any[]) {
-        const collection = cursorCollectionName(this);
-        const span = startCapturedSpan(
-          `MongoDB ${operation}`,
-          'db',
-          {
-            collection,
-            operation,
-            'db.system.name': 'mongodb',
-            'db.collection.name': collection,
-            'db.operation.name': operation,
-            library: 'mongodb'
-          },
-          options
-        );
-
-        if (!span) return original.apply(this, args);
-
-        return runWithCapturedSpan(span, () => {
-          try {
-            const result = original.apply(this, args);
-            if (result && typeof result.then === 'function') {
-              return result.then(
-                (value: any) => {
-                  span.end(0, {
-                    resultCount: Array.isArray(value) ? value.length : undefined
-                  });
-                  return value;
-                },
-                (error: any) => {
-                  span.end(500, {
-                    error: error?.message,
-                    'error.type': error?.name || 'Error'
-                  });
-                  throw error;
-                }
-              );
-            }
-
-            span.end(0);
-            return result;
-          } catch (error: any) {
-            span.end(500, {
-              error: error?.message,
-              'error.type': error?.name || 'Error'
-            });
-            throw error;
-          }
-        });
-      }
-  );
-};
-
-const patchMongo = (mongodb: any, options?: SenzorOptions) => {
-  const Collection = mongodb?.Collection || mongodb?.default?.Collection;
-  const collectionProto = Collection?.prototype;
-
-  [
-    'insertOne',
-    'insertMany',
-    'updateOne',
-    'updateMany',
-    'replaceOne',
-    'deleteOne',
-    'deleteMany',
-    'findOne',
-    'findOneAndUpdate',
-    'findOneAndDelete',
-    'findOneAndReplace',
-    'countDocuments',
-    'estimatedDocumentCount',
-    'distinct',
-    'bulkWrite',
-    'createIndex',
-    'dropIndex'
-  ].forEach((method) =>
-    patchCollectionMethod(collectionProto, method, options)
-  );
-
-  const FindCursor =
-    mongodb?.FindCursor || mongodb?.default?.FindCursor;
-  const AggregationCursor =
-    mongodb?.AggregationCursor || mongodb?.default?.AggregationCursor;
-
-  ['toArray', 'next', 'forEach'].forEach((method) =>
-    patchCursorMethod(FindCursor?.prototype, method, 'find', options)
-  );
-  ['toArray', 'next', 'forEach'].forEach((method) =>
-    patchCursorMethod(
-      AggregationCursor?.prototype,
-      method,
-      'aggregate',
-      options
-    )
-  );
-};
-
-export const instrumentMongo = (options?: SenzorOptions) => {
-  hookRequire('mongodb', (exports: any) => patchMongo(exports, options));
-};

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

@@ -1,156 +0,0 @@
-import { SenzorOptions } from '../core/types';
-import { hookRequire } from './hook';
-import { patchMethod } from './patch';
-import { runWithCapturedSpan, startCapturedSpan } from './span';
-
-const modelName = (target: any): string =>
-  target?.model?.modelName ||
-  target?.constructor?.modelName ||
-  target?.modelName ||
-  'unknown';
-
-const collectionName = (target: any): string =>
-  target?.mongooseCollection?.name ||
-  target?.collection?.name ||
-  target?.model?.collection?.name ||
-  'unknown';
-
-const patchExec = (
-  proto: any,
-  label: 'query' | 'aggregate',
-  options?: SenzorOptions
-) => {
-  patchMethod(
-    proto,
-    'exec',
-    `senzor.mongoose.${label}.exec`,
-    (original) =>
-      function patchedMongooseExec(this: any, ...args: any[]) {
-        const operation =
-          String(this?.op || this?._op || label).toUpperCase();
-        const collection = collectionName(this);
-        const span = startCapturedSpan(
-          `Mongoose ${operation}`,
-          'db',
-          {
-            collection,
-            model: modelName(this),
-            operation,
-            'db.system.name': 'mongodb',
-            'db.collection.name': collection,
-            'db.operation.name': operation,
-            library: 'mongoose'
-          },
-          options
-        );
-
-        if (!span) return original.apply(this, args);
-
-        return runWithCapturedSpan(span, () => {
-          try {
-            const result = original.apply(this, args);
-            if (result && typeof result.then === 'function') {
-              return result.then(
-                (value: any) => {
-                  span.end(0, {
-                    resultCount: Array.isArray(value) ? value.length : undefined
-                  });
-                  return value;
-                },
-                (error: any) => {
-                  span.end(500, {
-                    error: error?.message,
-                    'error.type': error?.name || 'Error'
-                  });
-                  throw error;
-                }
-              );
-            }
-
-            span.end(0);
-            return result;
-          } catch (error: any) {
-            span.end(500, {
-              error: error?.message,
-              'error.type': error?.name || 'Error'
-            });
-            throw error;
-          }
-        });
-      }
-  );
-};
-
-const patchSave = (modelProto: any, options?: SenzorOptions) => {
-  patchMethod(
-    modelProto,
-    'save',
-    'senzor.mongoose.model.save',
-    (original) =>
-      function patchedMongooseSave(this: any, ...args: any[]) {
-        const collection = collectionName(this);
-        const span = startCapturedSpan(
-          'Mongoose SAVE',
-          'db',
-          {
-            collection,
-            model: modelName(this),
-            operation: 'SAVE',
-            'db.system.name': 'mongodb',
-            'db.collection.name': collection,
-            'db.operation.name': 'SAVE',
-            library: 'mongoose'
-          },
-          options
-        );
-
-        if (!span) return original.apply(this, args);
-
-        return runWithCapturedSpan(span, () => {
-          try {
-            const result = original.apply(this, args);
-            if (result && typeof result.then === 'function') {
-              return result.then(
-                (value: any) => {
-                  span.end(0);
-                  return value;
-                },
-                (error: any) => {
-                  span.end(500, {
-                    error: error?.message,
-                    'error.type': error?.name || 'Error'
-                  });
-                  throw error;
-                }
-              );
-            }
-
-            span.end(0);
-            return result;
-          } catch (error: any) {
-            span.end(500, {
-              error: error?.message,
-              'error.type': error?.name || 'Error'
-            });
-            throw error;
-          }
-        });
-      }
-  );
-};
-
-const patchMongoose = (mongoose: any, options?: SenzorOptions) => {
-  patchExec(mongoose?.Query?.prototype, 'query', options);
-  patchExec(mongoose?.Aggregate?.prototype, 'aggregate', options);
-  patchSave(mongoose?.Model?.prototype, options);
-
-  if (mongoose?.default) {
-    patchExec(mongoose.default?.Query?.prototype, 'query', options);
-    patchExec(mongoose.default?.Aggregate?.prototype, 'aggregate', options);
-    patchSave(mongoose.default?.Model?.prototype, options);
-  }
-};
-
-export const instrumentMongoose = (options?: SenzorOptions) => {
-  hookRequire('mongoose', (exports: any) => patchMongoose(exports, options));
-};

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

@@ -1,169 +0,0 @@
-import { getSqlOperation, normalizeSql } from '../core/sanitizer';
-import { SenzorOptions } from '../core/types';
-import { hookRequire } from './hook';
-import { patchMethod } from './patch';
-import { runWithCapturedSpan, startCapturedSpan } from './span';
-
-const extractSql = (args: any[]): string | undefined => {
-  const first = args[0];
-  if (typeof first === 'string') return first;
-  if (first && typeof first.sql === 'string') return first.sql;
-  return undefined;
-};
-
-const patchSqlMethod = (
-  proto: any,
-  method: 'query' | 'execute',
-  library: string,
-  options?: SenzorOptions
-) => {
-  patchMethod(
-    proto,
-    method,
-    `senzor.${library}.${method}`,
-    (original) =>
-      function patchedMysqlMethod(this: any, ...args: any[]) {
-        const sql = extractSql(args);
-        const operation = getSqlOperation(sql) || method.toUpperCase();
-        const span = startCapturedSpan(
-          `MySQL ${operation}`,
-          'db',
-          {
-            query: normalizeSql(sql, options),
-            operation,
-            'db.system.name': 'mysql',
-            'db.operation.name': operation,
-            'db.query.text': normalizeSql(sql, options),
-            library
-          },
-          options
-        );
-
-        if (!span) return original.apply(this, args);
-
-        const callbackIndex = args.findIndex(
-          (arg) => typeof arg === 'function'
-        );
-        if (callbackIndex >= 0) {
-          const originalCallback = args[callbackIndex];
-          args[callbackIndex] = function wrappedMysqlCallback(
-            this: unknown,
-            err: any,
-            rows: any
-          ) {
-            span.end(err ? 500 : 0, {
-              error: err?.message,
-              'error.type': err?.name,
-              rowCount: Array.isArray(rows) ? rows.length : undefined
-            });
-            return originalCallback.apply(this, arguments as any);
-          };
-        }
-
-        return runWithCapturedSpan(span, () => {
-          try {
-            const result = original.apply(this, args);
-
-            if (result && typeof result.then === 'function') {
-              return result.then(
-                (value: any) => {
-                  const rows = Array.isArray(value) ? value[0] : value;
-                  span.end(0, {
-                    rowCount: Array.isArray(rows) ? rows.length : undefined
-                  });
-                  return value;
-                },
-                (error: any) => {
-                  span.end(500, {
-                    error: error?.message,
-                    'error.type': error?.name || 'Error'
-                  });
-                  throw error;
-                }
-              );
-            }
-
-            if (
-              callbackIndex < 0 &&
-              result &&
-              typeof result.once === 'function'
-            ) {
-              result.once('end', () => span.end(0));
-              result.once('error', (error: Error) =>
-                span.end(500, {
-                  error: error.message,
-                  'error.type': error.name
-                })
-              );
-            } else if (callbackIndex < 0) {
-              span.end(0);
-            }
-
-            return result;
-          } catch (error: any) {
-            span.end(500, {
-              error: error?.message,
-              'error.type': error?.name || 'Error'
-            });
-            throw error;
-          }
-        });
-      }
-  );
-};
-
-const patchKnownPrototypes = (
-  mysql: any,
-  library: string,
-  options?: SenzorOptions
-) => {
-  [
-    mysql?.Connection?.prototype,
-    mysql?.Pool?.prototype,
-    mysql?.PoolConnection?.prototype,
-    mysql?.PromiseConnection?.prototype,
-    mysql?.PromisePool?.prototype,
-    mysql?.default?.Connection?.prototype,
-    mysql?.default?.Pool?.prototype
-  ].forEach((proto) => {
-    patchSqlMethod(proto, 'query', library, options);
-    patchSqlMethod(proto, 'execute', library, options);
-  });
-};
-
-const patchFactories = (
-  mysql: any,
-  library: string,
-  options?: SenzorOptions
-) => {
-  ['createConnection', 'createPool'].forEach((factory) => {
-    patchMethod(
-      mysql,
-      factory,
-      `senzor.${library}.${factory}`,
-      (original) =>
-        function patchedMysqlFactory(this: any, ...args: any[]) {
-          const client = original.apply(this, args);
-          patchSqlMethod(client, 'query', library, options);
-          patchSqlMethod(client, 'execute', library, options);
-          patchSqlMethod(Object.getPrototypeOf(client), 'query', library, options);
-          patchSqlMethod(Object.getPrototypeOf(client), 'execute', library, options);
-          return client;
-        }
-    );
-  });
-};
-
-const patchMysql = (
-  mysql: any,
-  library: string,
-  options?: SenzorOptions
-) => {
-  patchKnownPrototypes(mysql, library, options);
-  patchFactories(mysql, library, options);
-};
-
-export const instrumentMysql = (options?: SenzorOptions) => {
-  hookRequire('mysql', (exports: any) => patchMysql(exports, 'mysql', options));
-  hookRequire('mysql2', (exports: any) => patchMysql(exports, 'mysql2', options));
-};