@senzops/apm-node 1.2.2 → 1.2.3

package/.claude/worktrees/infallible-chatelet-f3fb36/src/core/sanitizer.ts

@@ -1,203 +0,0 @@
-import { SenzorOptions } from './types';
-
-const DEFAULT_MAX_ATTRIBUTES = 64;
-const DEFAULT_MAX_ATTRIBUTE_LENGTH = 2048;
-const MAX_DEPTH = 4;
-const MAX_ARRAY_ITEMS = 20;
-
-const SENSITIVE_KEY_PATTERN =
-  /(^|[-_.])(authorization|cookie|set-cookie|password|passwd|pwd|secret|token|api[-_.]?key|x-api-key|access[-_.]?token|refresh[-_.]?token|client[-_.]?secret|private[-_.]?key)([-_.]|$)/i;
-
-export interface SanitizerOptions {
-  maxAttributes?: number;
-  maxAttributeLength?: number;
-}
-
-const getLimits = (options?: SanitizerOptions | SenzorOptions) => ({
-  maxAttributes: options?.maxAttributes ?? DEFAULT_MAX_ATTRIBUTES,
-  maxAttributeLength:
-    options?.maxAttributeLength ?? DEFAULT_MAX_ATTRIBUTE_LENGTH
-});
-
-export const truncate = (
-  value: string,
-  maxLength = DEFAULT_MAX_ATTRIBUTE_LENGTH
-): string => {
-  if (value.length <= maxLength) return value;
-  return `${value.slice(0, Math.max(0, maxLength - 15))}...[truncated]`;
-};
-
-export const isSensitiveKey = (key: string): boolean =>
-  SENSITIVE_KEY_PATTERN.test(key);
-
-const sanitizePrimitive = (
-  value: unknown,
-  maxLength: number
-): string | number | boolean | null | undefined => {
-  if (value === null || value === undefined) return value;
-
-  if (
-    typeof value === 'number' ||
-    typeof value === 'boolean'
-  ) {
-    return value;
-  }
-
-  if (typeof value === 'bigint') {
-    return value.toString();
-  }
-
-  if (typeof value === 'string') {
-    return truncate(value, maxLength);
-  }
-
-  return undefined;
-};
-
-const sanitizeValue = (
-  key: string,
-  value: unknown,
-  options: Required<SanitizerOptions>,
-  depth: number
-): unknown => {
-  if (isSensitiveKey(key)) return '[REDACTED]';
-
-  const primitive =
-    sanitizePrimitive(value, options.maxAttributeLength);
-
-  if (primitive !== undefined || value === undefined) {
-    return primitive;
-  }
-
-  if (value instanceof Error) {
-    return {
-      name: truncate(value.name, options.maxAttributeLength),
-      message: truncate(value.message, options.maxAttributeLength),
-      stack: value.stack
-        ? truncate(value.stack, options.maxAttributeLength)
-        : undefined
-    };
-  }
-
-  if (depth >= MAX_DEPTH) {
-    return '[MaxDepth]';
-  }
-
-  if (Array.isArray(value)) {
-    return value
-      .slice(0, MAX_ARRAY_ITEMS)
-      .map((item) =>
-        sanitizeValue(key, item, options, depth + 1)
-      );
-  }
-
-  if (typeof value === 'object') {
-    const output: Record<string, unknown> = {};
-    let count = 0;
-
-    for (const [childKey, childValue] of Object.entries(
-      value as Record<string, unknown>
-    )) {
-      if (count >= options.maxAttributes) {
-        output.__truncated = true;
-        break;
-      }
-
-      output[childKey] = sanitizeValue(
-        childKey,
-        childValue,
-        options,
-        depth + 1
-      );
-      count++;
-    }
-
-    return output;
-  }
-
-  return truncate(String(value), options.maxAttributeLength);
-};
-
-export const sanitizeAttributes = (
-  attributes: Record<string, unknown> = {},
-  options?: SanitizerOptions | SenzorOptions
-): Record<string, unknown> => {
-  const limits = getLimits(options);
-  const normalizedOptions: Required<SanitizerOptions> = {
-    maxAttributes: limits.maxAttributes,
-    maxAttributeLength: limits.maxAttributeLength
-  };
-
-  const output: Record<string, unknown> = {};
-  let count = 0;
-
-  for (const [key, value] of Object.entries(attributes)) {
-    if (count >= normalizedOptions.maxAttributes) {
-      output.__truncated = true;
-      break;
-    }
-
-    output[key] = sanitizeValue(
-      key,
-      value,
-      normalizedOptions,
-      0
-    );
-    count++;
-  }
-
-  return output;
-};
-
-export const sanitizeHeaders = (
-  headers: unknown,
-  options?: SanitizerOptions | SenzorOptions
-): Record<string, unknown> => {
-  if (!headers || typeof headers !== 'object') return {};
-
-  const plainHeaders: Record<string, unknown> = {};
-
-  if (typeof (headers as any).forEach === 'function') {
-    (headers as any).forEach((value: unknown, key: string) => {
-      plainHeaders[key.toLowerCase()] = value;
-    });
-  } else {
-    for (const [key, value] of Object.entries(
-      headers as Record<string, unknown>
-    )) {
-      plainHeaders[key.toLowerCase()] = Array.isArray(value)
-        ? value.join(', ')
-        : value;
-    }
-  }
-
-  return sanitizeAttributes(plainHeaders, options);
-};
-
-export const normalizeSql = (
-  sql: unknown,
-  options?: SenzorOptions
-): string | undefined => {
-  if (typeof sql !== 'string') return undefined;
-
-  const collapsed = sql.replace(/\s+/g, ' ').trim();
-  if (!collapsed) return undefined;
-
-  const withoutLiterals = collapsed
-    .replace(/'(?:''|[^'])*'/g, '?')
-    .replace(/"(?:\\"|[^"])*"/g, '?')
-    .replace(/\b\d+(\.\d+)?\b/g, '?');
-
-  return truncate(
-    options?.captureDbStatement === false
-      ? withoutLiterals.split(' ').slice(0, 6).join(' ')
-      : withoutLiterals,
-    options?.maxAttributeLength ?? DEFAULT_MAX_ATTRIBUTE_LENGTH
-  );
-};
-
-export const getSqlOperation = (sql: unknown): string | undefined => {
-  if (typeof sql !== 'string') return undefined;
-  const match = sql.trim().match(/^([a-z]+)/i);
-  return match?.[1]?.toUpperCase();
-};

package/.claude/worktrees/infallible-chatelet-f3fb36/src/core/transport.ts

@@ -1,273 +0,0 @@
-import { SENZOR_INTERNAL_HEADER } from '../utils/internal';
-import { SenzorOptions, Trace, TaskRun, SenzorError, SenzorLog } from './types';
-
-interface ApmPayload {
-  traces: Trace[];
-  errors: SenzorError[];
-  logs: SenzorLog[];
-}
-
-interface TaskPayload {
-  runs: TaskRun[];
-  errors: SenzorError[];
-  logs: SenzorLog[];
-}
-
-export class Transport {
-  private traceQueue: Trace[] = [];
-  private apmErrorQueue: SenzorError[] = [];
-  private apmLogQueue: SenzorLog[] = [];
-
-  private taskQueue: TaskRun[] = [];
-  private taskErrorQueue: SenzorError[] = [];
-  private taskLogQueue: SenzorLog[] = [];
-
-  private timer: NodeJS.Timeout | null = null;
-  private apmEndpoint: string;
-  private taskEndpoint: string;
-  private isFlushing = false;
-  private flushAgain = false;
-  private droppedItems = 0;
-
-  constructor(private config: SenzorOptions) {
-    const baseEndpoint = config.endpoint || 'https://api.senzor.dev';
-    this.apmEndpoint = baseEndpoint.includes('/api/ingest')
-      ? baseEndpoint
-      : `${baseEndpoint}/api/ingest/apm`;
-    this.taskEndpoint = baseEndpoint.includes('/api/ingest')
-      ? baseEndpoint.replace('/apm', '/task')
-      : `${baseEndpoint}/api/ingest/task`;
-
-    if (typeof setInterval !== 'undefined') {
-      this.timer = setInterval(
-        () => void this.flush(),
-        config.flushInterval || 10000
-      );
-      if (this.timer && typeof this.timer.unref === 'function') {
-        this.timer.unref();
-      }
-    }
-
-    this.installShutdownFlush();
-  }
-
-  public addTrace(trace: any) {
-    this.enqueue(this.traceQueue, trace);
-    this.checkFlush();
-  }
-
-  public addTask(task: TaskRun) {
-    this.enqueue(this.taskQueue, task);
-    this.checkFlush();
-  }
-
-  public addError(error: SenzorError, type: 'apm' | 'task' = 'apm') {
-    this.enqueue(
-      type === 'task' ? this.taskErrorQueue : this.apmErrorQueue,
-      error
-    );
-    this.checkFlush();
-  }
-
-  public addLog(log: SenzorLog, type: 'apm' | 'task' = 'apm') {
-    this.enqueue(
-      type === 'task' ? this.taskLogQueue : this.apmLogQueue,
-      log
-    );
-    this.checkFlush();
-  }
-
-  private enqueue<T>(queue: T[], item: T) {
-    queue.push(item);
-
-    const maxQueueSize = this.config.maxQueueSize ?? 10000;
-    while (queue.length > maxQueueSize) {
-      queue.shift();
-      this.droppedItems++;
-    }
-  }
-
-  private prependWithLimit<T>(queue: T[], items: T[]) {
-    if (!items.length) return;
-    queue.unshift(...items);
-
-    const maxQueueSize = this.config.maxQueueSize ?? 10000;
-    while (queue.length > maxQueueSize) {
-      queue.pop();
-      this.droppedItems++;
-    }
-  }
-
-  private checkFlush() {
-    const totalApm =
-      this.traceQueue.length +
-      this.apmErrorQueue.length +
-      this.apmLogQueue.length;
-    const totalTask =
-      this.taskQueue.length +
-      this.taskErrorQueue.length +
-      this.taskLogQueue.length;
-
-    if (
-      totalApm >= (this.config.batchSize || 100) ||
-      totalTask >= (this.config.batchSize || 100)
-    ) {
-      void this.flush();
-    }
-  }
-
-  private takeApmPayload(): ApmPayload {
-    const payload = {
-      traces: this.traceQueue,
-      errors: this.apmErrorQueue,
-      logs: this.apmLogQueue
-    };
-
-    this.traceQueue = [];
-    this.apmErrorQueue = [];
-    this.apmLogQueue = [];
-    return payload;
-  }
-
-  private takeTaskPayload(): TaskPayload {
-    const payload = {
-      runs: this.taskQueue,
-      errors: this.taskErrorQueue,
-      logs: this.taskLogQueue
-    };
-
-    this.taskQueue = [];
-    this.taskErrorQueue = [];
-    this.taskLogQueue = [];
-    return payload;
-  }
-
-  private restoreApmPayload(payload: ApmPayload) {
-    this.prependWithLimit(this.apmLogQueue, payload.logs);
-    this.prependWithLimit(this.apmErrorQueue, payload.errors);
-    this.prependWithLimit(this.traceQueue, payload.traces);
-  }
-
-  private restoreTaskPayload(payload: TaskPayload) {
-    this.prependWithLimit(this.taskLogQueue, payload.logs);
-    this.prependWithLimit(this.taskErrorQueue, payload.errors);
-    this.prependWithLimit(this.taskQueue, payload.runs);
-  }
-
-  private hasApmPayload(payload: ApmPayload): boolean {
-    return (
-      payload.traces.length > 0 ||
-      payload.errors.length > 0 ||
-      payload.logs.length > 0
-    );
-  }
-
-  private hasTaskPayload(payload: TaskPayload): boolean {
-    return (
-      payload.runs.length > 0 ||
-      payload.errors.length > 0 ||
-      payload.logs.length > 0
-    );
-  }
-
-  private async postJson(endpoint: string, payload: unknown) {
-    const controller = new AbortController();
-    const timeout = setTimeout(
-      () => controller.abort(),
-      this.config.flushTimeoutMs ?? 5000
-    );
-
-    if (typeof timeout.unref === 'function') timeout.unref();
-
-    try {
-      const response = await fetch(endpoint, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'x-service-api-key': this.config.apiKey,
-          [SENZOR_INTERNAL_HEADER]: 'true'
-        },
-        body: JSON.stringify(payload),
-        keepalive: true,
-        signal: controller.signal
-      });
-
-      if (!response.ok) {
-        throw new Error(`Senzor ingest failed with status ${response.status}`);
-      }
-    } finally {
-      clearTimeout(timeout);
-    }
-  }
-
-  public async flush() {
-    if (this.isFlushing) {
-      this.flushAgain = true;
-      return;
-    }
-
-    this.isFlushing = true;
-
-    try {
-      do {
-        this.flushAgain = false;
-
-        const apmPayload = this.takeApmPayload();
-        const taskPayload = this.takeTaskPayload();
-        const sends: Promise<void>[] = [];
-
-        if (this.hasApmPayload(apmPayload)) {
-          sends.push(
-            this.postJson(this.apmEndpoint, apmPayload).catch((error) => {
-              this.restoreApmPayload(apmPayload);
-              throw error;
-            })
-          );
-        }
-
-        if (this.hasTaskPayload(taskPayload)) {
-          sends.push(
-            this.postJson(this.taskEndpoint, taskPayload).catch((error) => {
-              this.restoreTaskPayload(taskPayload);
-              throw error;
-            })
-          );
-        }
-
-        if (!sends.length) continue;
-
-        const results = await Promise.allSettled(sends);
-        const failures = results.filter(
-          (result) => result.status === 'rejected'
-        );
-
-        if (this.config.debug) {
-          console.log(
-            `[Senzor] Flushed: APM(${apmPayload.traces.length} traces, ${apmPayload.logs.length} logs), Task(${taskPayload.runs.length} runs, ${taskPayload.logs.length} logs), failures=${failures.length}, dropped=${this.droppedItems}`
-          );
-        }
-      } while (this.flushAgain);
-    } catch (err) {
-      if (this.config.debug) console.error('[Senzor] Transport Flush Error:', err);
-    } finally {
-      this.isFlushing = false;
-    }
-  }
-
-  private installShutdownFlush() {
-    const key = Symbol.for('senzor.transport.shutdownFlushInstalled');
-    const proc = process as unknown as Record<symbol, boolean>;
-    if (proc[key]) return;
-
-    Object.defineProperty(proc, key, {
-      value: true,
-      enumerable: false
-    });
-
-    const flushSyncBestEffort = () => {
-      void this.flush();
-    };
-
-    process.once('beforeExit', flushSyncBestEffort);
-  }
-}

package/.claude/worktrees/infallible-chatelet-f3fb36/src/core/types.ts

@@ -1,106 +0,0 @@
-export interface SenzorOptions {
-  apiKey: string;
-  endpoint?: string;
-  batchSize?: number;
-  flushInterval?: number;
-  flushTimeoutMs?: number;
-  maxQueueSize?: number;
-  maxSpansPerTrace?: number;
-  maxAttributeLength?: number;
-  maxAttributes?: number;
-  captureHeaders?: boolean;
-  captureDbStatement?: boolean;
-  instrumentations?: boolean | string[];
-  frameworkSpans?: boolean;
-  captureMiddlewareSpans?: boolean;
-  captureRouterSpans?: boolean;
-  captureLifecycleHookSpans?: boolean;
-  ignoreFrameworkSpanTypes?: string[];
-  debug?: boolean;
-  autoLogs?: boolean;
-}
-
-export interface Span {
-  spanId: string;
-  parentSpanId?: string;
-  name: string;
-  type: 'db' | 'http' | 'function' | 'custom';
-  startTime: number;
-  duration: number;
-  status?: number;
-  meta?: Record<string, any>;
-}
-
-export interface SenzorError {
-  errorClass: string;
-  message: string;
-  stackTrace?: string;
-  traceId?: string; // Maps to APM traceId
-  runId?: string;   // Maps to Task runId
-  context?: any;
-  timestamp: string;
-}
-
-// NEW: Enterprise Log Payload
-export interface SenzorLog {
-  message: string;
-  level: 'info' | 'warn' | 'error' | 'debug' | 'fatal';
-  attributes: Record<string, any>;
-  traceId?: string; // Used if context is APM
-  runId?: string;   // Used if context is Task
-  spanId?: string;
-  timestamp: string;
-}
-
-export interface Trace {
-  traceId: string;
-  parentTraceId?: string;
-  parentSpanId?: string;
-  method: string;
-  route: string;
-  path: string;
-  status: number;
-  duration: number;
-  ip?: string;
-  userAgent?: string;
-  timestamp: string;
-  spans: Span[];
-}
-
-export interface ResourceMetrics {
-  memoryDeltaBytes: number; // Delta of process.memoryUsage().heapUsed
-  cpuUserUs: number;        // CPU time spent in user space (microseconds)
-  cpuSystemUs: number;      // CPU time spent in OS system calls (microseconds)
-}
-
-export interface TaskRun {
-  runId: string;
-  taskName: string;
-  taskType: 'cron' | 'queue' | 'pipeline' | 'custom';
-  status: 'success' | 'failed';
-  duration: number;
-  queueDelay?: number;
-  attempts?: number;
-  triggerTraceId?: string;
-  metadata?: any;
-  resourceMetrics?: ResourceMetrics; // Hardware cost profiling
-  isDeadLetter?: boolean;            // True if the job failed its final retry
-  spans: Span[];
-  timestamp: string;
-}
-
-// Unified Context Payload for async_hooks
-export interface ActiveTrace {
-  id: string; // The APM traceId OR the Task runId
-  contextType: 'apm' | 'task';
-  startTime: number;
-  rootSpanId?: string;
-  activeSpanId?: string;
-  startMemory?: number; // Baseline heap
-  startCpu?: NodeJS.CpuUsage; // Baseline CPU tick
-  data: any; // Holds Partial<Trace> or Partial<TaskRun>
-  spans: Span[];
-  maxSpans?: number;
-  droppedSpans?: number;
-  ended?: boolean;
-}

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

@@ -1,36 +0,0 @@
-import { client } from './core/client';
-import { expressMiddleware, expressErrorHandler } from './middleware/express';
-import { wrapH3 } from './wrappers/h3';
-import { wrapNextRoute, wrapNextPages } from './wrappers/next';
-import { senzorPlugin } from './wrappers/fastify';
-import { SenzorOptions } from './core/types';
-
-const Senzor = {
-  preload: (options: Partial<SenzorOptions> = {}) => client.preload(options),
-  init: (options: SenzorOptions) => client.init(options),
-  flush: () => client.flush(),
-  track: client.track.bind(client),
-  startSpan: client.startSpan.bind(client),
-  captureException: client.captureError.bind(client),
-
-  // Task Monitoring (NEW)
-  wrapTask: client.wrapTask.bind(client),
-  startTask: client.startTask.bind(client),
-
-  // Express
-  requestHandler: expressMiddleware,
-  errorHandler: expressErrorHandler,
-
-  // Next
-  wrapNextRoute,
-  wrapNextPages,
-
-  // H3
-  wrapH3,
-
-  // Fastify
-  fastifyPlugin: senzorPlugin
-};
-
-export default Senzor;
-export { Senzor };