@senzops/apm-node 1.2.2 → 1.2.4

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

@@ -1,56 +0,0 @@
-const PATCHES = Symbol.for('senzor.patch.keys');
-const ORIGINAL = Symbol.for('senzor.patch.original');
-
-type WrappedFunction = Function & {
-  [PATCHES]?: Set<string>;
-  [ORIGINAL]?: Function;
-};
-
-export const patchMethod = (
-  target: any,
-  methodName: string,
-  patchKey: string,
-  wrapper: (original: Function) => Function
-): boolean => {
-  if (!target) return false;
-
-  const current = target[methodName] as WrappedFunction | undefined;
-  if (typeof current !== 'function') return false;
-
-  const existingPatches = current[PATCHES];
-  if (existingPatches?.has(patchKey)) return false;
-
-  const original = current[ORIGINAL] || current;
-  const wrapped = wrapper(current) as WrappedFunction;
-  const patches = new Set(existingPatches || []);
-  patches.add(patchKey);
-
-  try {
-    Object.defineProperty(wrapped, PATCHES, {
-      value: patches,
-      enumerable: false
-    });
-    Object.defineProperty(wrapped, ORIGINAL, {
-      value: original,
-      enumerable: false
-    });
-  } catch {
-    return false;
-  }
-
-  try {
-    target[methodName] = wrapped;
-    return true;
-  } catch {
-    return false;
-  }
-};
-
-export const isPatched = (
-  target: any,
-  methodName: string,
-  patchKey: string
-): boolean => {
-  const current = target?.[methodName] as WrappedFunction | undefined;
-  return Boolean(current?.[PATCHES]?.has(patchKey));
-};

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

@@ -1,131 +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.text === 'string') return first.text;
-  return undefined;
-};
-
-const wrapQueryMethod = (
-  proto: any,
-  label: string,
-  options?: SenzorOptions
-) => {
-  patchMethod(
-    proto,
-    'query',
-    `senzor.pg.${label}.query`,
-    (original) =>
-      function patchedPgQuery(this: any, ...args: any[]) {
-        const sql = extractSql(args);
-        const operation = getSqlOperation(sql) || 'QUERY';
-        const span = startCapturedSpan(
-          `Postgres ${operation}`,
-          'db',
-          {
-            query: normalizeSql(sql, options),
-            operation,
-            'db.system.name': 'postgresql',
-            'db.operation.name': operation,
-            'db.query.text': normalizeSql(sql, options),
-            library: 'pg'
-          },
-          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 wrappedPgCallback(
-            this: unknown,
-            err: Error | null,
-            result: any
-          ) {
-            span.end(err ? 500 : 0, {
-              error: err?.message,
-              'error.type': err?.name,
-              rowCount: result?.rowCount,
-              'db.response.row_count': result?.rowCount
-            });
-
-            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) => {
-                  span.end(0, {
-                    rowCount: value?.rowCount,
-                    'db.response.row_count': value?.rowCount
-                  });
-                  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 patchPg = (pg: any, options?: SenzorOptions) => {
-  if (!pg) return;
-
-  wrapQueryMethod(pg.Client?.prototype, 'client', options);
-  wrapQueryMethod(pg.Pool?.prototype, 'pool', options);
-
-  if (pg.default) {
-    wrapQueryMethod(pg.default.Client?.prototype, 'default.client', options);
-    wrapQueryMethod(pg.default.Pool?.prototype, 'default.pool', options);
-  }
-};
-
-export const instrumentPg = (options?: SenzorOptions) => {
-  hookRequire('pg', (exports: any) => patchPg(exports, options));
-};

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

@@ -1,109 +0,0 @@
-import { SenzorOptions } from '../core/types';
-import { hookRequire } from './hook';
-import { patchMethod } from './patch';
-import { runWithCapturedSpan, startCapturedSpan } from './span';
-
-const getCommandName = (command: any): string => {
-  if (typeof command === 'string') return command.toUpperCase();
-  if (Array.isArray(command)) return String(command[0] || 'COMMAND').toUpperCase();
-  if (command?.name) return String(command.name).toUpperCase();
-  if (Array.isArray(command?.args)) return String(command.args[0] || 'COMMAND').toUpperCase();
-  return 'COMMAND';
-};
-
-const patchSendCommand = (
-  target: any,
-  label: string,
-  options?: SenzorOptions
-) => {
-  patchMethod(
-    target,
-    'sendCommand',
-    `senzor.redis.${label}.sendCommand`,
-    (original) =>
-      function patchedRedisSendCommand(this: any, command: any, ...args: any[]) {
-        const commandName = getCommandName(command);
-        const span = startCapturedSpan(
-          `Redis ${commandName}`,
-          'db',
-          {
-            command: commandName,
-            operation: commandName,
-            'db.system.name': label === 'ioredis' ? 'redis' : 'redis',
-            'db.operation.name': commandName,
-            library: label
-          },
-          options
-        );
-
-        if (!span) return original.apply(this, arguments as any);
-
-        return runWithCapturedSpan(span, () => {
-          try {
-            const result = original.call(this, command, ...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 patchCreatedClient = (
-  client: any,
-  label: string,
-  options?: SenzorOptions
-) => {
-  patchSendCommand(client, label, options);
-  patchSendCommand(Object.getPrototypeOf(client), label, options);
-  return client;
-};
-
-const patchRedisPackage = (redis: any, options?: SenzorOptions) => {
-  ['createClient', 'createCluster'].forEach((factory) => {
-    patchMethod(
-      redis,
-      factory,
-      `senzor.redis.${factory}`,
-      (original) =>
-        function patchedRedisFactory(this: any, ...args: any[]) {
-          const client = original.apply(this, args);
-          return patchCreatedClient(client, 'redis', options);
-        }
-    );
-  });
-};
-
-const patchIORedisPackage = (ioredis: any, options?: SenzorOptions) => {
-  patchSendCommand(ioredis?.prototype, 'ioredis', options);
-  patchSendCommand(ioredis?.Redis?.prototype, 'ioredis', options);
-  patchSendCommand(ioredis?.Cluster?.prototype, 'ioredis-cluster', options);
-  patchSendCommand(ioredis?.default?.prototype, 'ioredis', options);
-};
-
-export const instrumentRedis = (options?: SenzorOptions) => {
-  hookRequire('redis', (exports: any) => patchRedisPackage(exports, options));
-  hookRequire('ioredis', (exports: any) => patchIORedisPackage(exports, options));
-};

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

@@ -1,73 +0,0 @@
-import { Context } from '../core/context';
-import { sanitizeAttributes } from '../core/sanitizer';
-import { ActiveTrace, SenzorOptions, Span } from '../core/types';
-import { generateSpanId } from '../utils/ids';
-
-type SpanType = Span['type'];
-
-export interface CapturedSpan {
-  spanId: string;
-  parentSpanId?: string;
-  trace?: ActiveTrace;
-  end: (
-    status?: number,
-    meta?: Record<string, unknown>
-  ) => void;
-}
-
-export const startCapturedSpan = (
-  name: string,
-  type: SpanType,
-  meta: Record<string, unknown> = {},
-  options?: SenzorOptions
-): CapturedSpan | null => {
-  const trace = Context.current();
-  if (!trace) return null;
-
-  const spanId = generateSpanId();
-  const parentSpanId = trace.activeSpanId;
-  const startTime = performance.now() - trace.startTime;
-  const startedAt = performance.now();
-  let ended = false;
-
-  return {
-    spanId,
-    parentSpanId,
-    trace,
-    end: (
-      status?: number,
-      extraMeta: Record<string, unknown> = {}
-    ) => {
-      if (ended) return;
-      ended = true;
-
-      const mergedMeta = sanitizeAttributes(
-        {
-          ...meta,
-          ...extraMeta,
-          parentSpanId
-        },
-        options
-      );
-
-      Context.addSpanToTrace(trace, {
-        spanId,
-        parentSpanId,
-        name,
-        type,
-        startTime,
-        duration: performance.now() - startedAt,
-        status,
-        meta: mergedMeta
-      });
-    }
-  };
-};
-
-export const runWithCapturedSpan = <T>(
-  span: CapturedSpan | null,
-  fn: () => T
-): T => {
-  if (!span) return fn();
-  return Context.withActiveSpan(span.spanId, fn);
-};

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

@@ -1,189 +0,0 @@
-import { normalizePath } from '../core/normalizer';
-import { SenzorOptions } from '../core/types';
-import { SENZOR_INTERNAL_HEADER } from '../utils/internal';
-import { generateTraceparent } from '../utils/traceContext';
-import { hookRequire } from './hook';
-import { patchMethod } from './patch';
-import { runWithCapturedSpan, startCapturedSpan } from './span';
-
-const hasInternalHeader = (headers: any): boolean => {
-  if (!headers) return false;
-  if (Array.isArray(headers)) {
-    return headers.some(
-      ([key, value]) =>
-        String(key).toLowerCase() === SENZOR_INTERNAL_HEADER &&
-        String(value).toLowerCase() === 'true'
-    );
-  }
-
-  return Object.entries(headers).some(
-    ([key, value]) =>
-      key.toLowerCase() === SENZOR_INTERNAL_HEADER &&
-      String(value).toLowerCase() === 'true'
-  );
-};
-
-const setHeader = (headers: any, key: string, value: string) => {
-  if (Array.isArray(headers)) {
-    headers.push([key, value]);
-    return headers;
-  }
-
-  const nextHeaders = { ...(headers || {}) };
-  const existingKey = Object.keys(nextHeaders).find(
-    (header) => header.toLowerCase() === key.toLowerCase()
-  );
-  nextHeaders[existingKey || key] = value;
-  return nextHeaders;
-};
-
-const getUrlDetails = (input: any) => {
-  try {
-    const url = new URL(String(input));
-    return {
-      url: url.toString(),
-      hostname: url.hostname,
-      path: `${url.pathname}${url.search}`
-    };
-  } catch {
-    return {
-      url: String(input || ''),
-      hostname: 'unknown',
-      path: '/'
-    };
-  }
-};
-
-const patchRequestLike = (
-  target: any,
-  methodName: string,
-  patchKey: string,
-  options?: SenzorOptions
-) => {
-  patchMethod(
-    target,
-    methodName,
-    patchKey,
-    (original) =>
-      function patchedUndiciRequest(this: any, input: any, opts?: any, cb?: any) {
-        if (hasInternalHeader(opts?.headers)) {
-          return original.apply(this, arguments as any);
-        }
-
-        const details = getUrlDetails(input?.origin ? input.origin : input);
-        const method = String(opts?.method || 'GET').toUpperCase();
-        const span = startCapturedSpan(
-          `${method} ${details.hostname}`,
-          'http',
-          {
-            url: details.url,
-            method,
-            route: normalizePath(details.path),
-            library: 'undici',
-            'http.request.method': method,
-            'url.full': details.url,
-            'url.path': details.path,
-            'server.address': details.hostname
-          },
-          options
-        );
-
-        if (!span) return original.apply(this, arguments as any);
-
-        const nextOptions = { ...(opts || {}) };
-        nextOptions.headers = setHeader(
-          nextOptions.headers,
-          'traceparent',
-          generateTraceparent(span.trace!.id, span.spanId)
-        );
-        nextOptions.headers = setHeader(
-          nextOptions.headers,
-          'x-senzor-trace-id',
-          span.trace!.id
-        );
-        nextOptions.headers = setHeader(
-          nextOptions.headers,
-          'x-senzor-parent-span-id',
-          span.spanId
-        );
-
-        const wrappedCallback =
-          typeof cb === 'function'
-            ? function wrappedUndiciCallback(this: unknown, err: any, data: any) {
-              span.end(err ? 500 : data?.statusCode || 0, {
-                error: err?.message,
-                'error.type': err?.name,
-                'http.response.status_code': data?.statusCode
-              });
-              return cb.apply(this, arguments as any);
-            }
-            : cb;
-
-        return runWithCapturedSpan(span, () => {
-          try {
-            const result = original.call(
-              this,
-              input,
-              nextOptions,
-              wrappedCallback
-            );
-
-            if (result && typeof result.then === 'function') {
-              return result.then(
-                (value: any) => {
-                  span.end(value?.statusCode || value?.status || 0, {
-                    'http.response.status_code':
-                      value?.statusCode || value?.status
-                  });
-                  return value;
-                },
-                (error: any) => {
-                  span.end(500, {
-                    error: error?.message,
-                    'error.type': error?.name || 'Error'
-                  });
-                  throw error;
-                }
-              );
-            }
-
-            if (typeof wrappedCallback !== 'function') {
-              span.end(0);
-            }
-
-            return result;
-          } catch (error: any) {
-            span.end(500, {
-              error: error?.message,
-              'error.type': error?.name || 'Error'
-            });
-            throw error;
-          }
-        });
-      }
-  );
-};
-
-const patchUndici = (undici: any, options?: SenzorOptions) => {
-  patchRequestLike(undici, 'request', 'senzor.undici.request', options);
-  patchRequestLike(undici, 'stream', 'senzor.undici.stream', options);
-  patchRequestLike(undici, 'pipeline', 'senzor.undici.pipeline', options);
-
-  [
-    undici?.Client?.prototype,
-    undici?.Pool?.prototype,
-    undici?.Agent?.prototype,
-    undici?.ProxyAgent?.prototype
-  ].forEach((proto, index) => {
-    patchRequestLike(
-      proto,
-      'request',
-      `senzor.undici.dispatcher.${index}.request`,
-      options
-    );
-  });
-};
-
-export const instrumentUndici = (options?: SenzorOptions) => {
-  hookRequire('undici', (exports: any) => patchUndici(exports, options));
-};

package/.claude/worktrees/infallible-chatelet-f3fb36/src/middleware/express.ts

@@ -1,48 +0,0 @@
-import { client } from '../core/client';
-import { getClientIp } from '../utils/getClientIp';
-
-// 1. Request Handler (Place before routes)
-export const expressMiddleware = () => {
-  return (req: any, res: any, next: () => void) => {
-    client.startTrace({
-      method: req.method,
-      path: req.originalUrl || req.url,
-      ip: getClientIp(req),
-      userAgent: req.headers['user-agent'],
-      headers: req.headers
-    }, () => {
-
-      // Auto-detect status code on finish
-      res.once('finish', () => {
-        try {
-          let route = 'UNKNOWN';
-          // Express populates req.route only if a route matched
-          if (req.route && req.route.path) {
-            route = (req.baseUrl || '') + req.route.path;
-          } else if (res.statusCode === 404) {
-            route = 'Not Found';
-          } else {
-            route = req.path || 'Wildcard';
-          }
-
-          client.endTrace(res.statusCode, { route });
-        } catch (e) { /* Fail open */ }
-      });
-
-      next();
-    });
-  };
-};
-
-// 2. Error Handler (Place after routes)
-// This is required in Express to capture the actual Error Object (Stack Trace)
-export const expressErrorHandler = () => {
-  return (err: any, req: any, res: any, next: (err?: any) => void) => {
-
-    // 1. Capture the exception context
-    client.captureError(err);
-
-    // 2. Pass it to the next error handler (don't swallow it)
-    next(err);
-  };
-};

package/.claude/worktrees/infallible-chatelet-f3fb36/src/register.ts

@@ -1,58 +0,0 @@
-import { client } from './core/client';
-
-const truthy = (value: string | undefined): boolean =>
-  value === '1' || value === 'true' || value === 'yes';
-
-const numberFromEnv = (value: string | undefined): number | undefined => {
-  if (!value) return undefined;
-  const parsed = Number(value);
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
-};
-
-const apiKey =
-  process.env.SENZOR_API_KEY ||
-  process.env.SENZOR_APM_API_KEY ||
-  process.env.SENZOR_SERVICE_API_KEY;
-
-const endpoint =
-  process.env.SENZOR_ENDPOINT ||
-  process.env.SENZOR_APM_ENDPOINT;
-
-const options = {
-  apiKey: apiKey || '',
-  endpoint,
-  debug: truthy(process.env.SENZOR_DEBUG),
-  autoLogs: process.env.SENZOR_AUTO_LOGS === 'false' ? false : undefined,
-  batchSize: numberFromEnv(process.env.SENZOR_BATCH_SIZE),
-  flushInterval: numberFromEnv(process.env.SENZOR_FLUSH_INTERVAL),
-  flushTimeoutMs: numberFromEnv(process.env.SENZOR_FLUSH_TIMEOUT_MS),
-  maxQueueSize: numberFromEnv(process.env.SENZOR_MAX_QUEUE_SIZE),
-  maxSpansPerTrace: numberFromEnv(process.env.SENZOR_MAX_SPANS_PER_TRACE),
-  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
-};
-
-if (apiKey) {
-  client.init(options);
-} else {
-  client.preload(options);
-}