@senzops/apm-node 1.2.1 → 1.2.2

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

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

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

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

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

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

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

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