@senzops/apm-node 1.1.18 → 1.2.0

package/src/core/transport.ts

@@ -1,104 +1,273 @@
-import { SenzorOptions, Trace, TaskRun, SenzorError, SenzorLog } from './types';
-
-export class Transport {
-  private traceQueue: Trace[] = [];
-  private apmErrorQueue: SenzorError[] = [];
-  private apmLogQueue: SenzorLog[] = []; // APM Logs
-
-  private taskQueue: TaskRun[] = [];
-  private taskErrorQueue: SenzorError[] = [];
-  private taskLogQueue: SenzorLog[] = []; // Task Logs
-
-  private timer: NodeJS.Timeout | null = null;
-  private apmEndpoint: string;
-  private taskEndpoint: string;
-
-  constructor(private config: SenzorOptions) {
-    const baseEndpoint = config.endpoint || 'https://api.senzor.dev';
-    // Support legacy full URLs or base URLs
-    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(() => this.flush(), config.flushInterval || 10000);
-      if (this.timer && typeof this.timer.unref === 'function') {
-        this.timer.unref();
-      }
-    }
-  }
-
-  public addTrace(trace: any) {
-    this.traceQueue.push(trace);
-    this.checkFlush();
-  }
-
-  public addTask(task: TaskRun) {
-    this.taskQueue.push(task);
-    this.checkFlush();
-  }
-
-  public addError(error: SenzorError, type: 'apm' | 'task' = 'apm') {
-    if (type === 'task') this.taskErrorQueue.push(error);
-    else this.apmErrorQueue.push(error);
-    this.checkFlush();
-  }
-
-  // Add captured log to the correct batch queue
-  public addLog(log: SenzorLog, type: 'apm' | 'task' = 'apm') {
-    if (type === 'task') this.taskLogQueue.push(log);
-    else this.apmLogQueue.push(log);
-    this.checkFlush();
-  }
-
-  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)) {
-      this.flush();
-    }
-  }
-
-  public async flush() {
-    const apmPayload = {
-      traces: [...this.traceQueue],
-      errors: [...this.apmErrorQueue],
-      logs: [...this.apmLogQueue]
-    };
-    const taskPayload = {
-      runs: [...this.taskQueue],
-      errors: [...this.taskErrorQueue],
-      logs: [...this.taskLogQueue]
-    };
-
-    // Reset Queues instantly
-    this.traceQueue = [];
-    this.apmErrorQueue = [];
-    this.apmLogQueue = [];
-    this.taskQueue = [];
-    this.taskErrorQueue = [];
-    this.taskLogQueue = [];
-
-    const headers = { 'Content-Type': 'application/json', 'x-service-api-key': this.config.apiKey };
-
-    try {
-      const promises = [];
-
-      // Piggyback logs onto APM/Task batch ingestion to bypass extra network round-trips
-      if (apmPayload.traces.length > 0 || apmPayload.errors.length > 0 || apmPayload.logs.length > 0) {
-        promises.push(fetch(this.apmEndpoint, { method: 'POST', headers, body: JSON.stringify(apmPayload), keepalive: true }));
-      }
-
-      if (taskPayload.runs.length > 0 || taskPayload.errors.length > 0 || taskPayload.logs.length > 0) {
-        promises.push(fetch(this.taskEndpoint, { method: 'POST', headers, body: JSON.stringify(taskPayload), keepalive: true }));
-      }
-
-      await Promise.allSettled(promises);
-
-      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)`);
-      }
-    } catch (err) {
-      if (this.config.debug) console.error('[Senzor] Transport Flush Error:', err);
-    }
-  }
-}
+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/src/core/types.ts

@@ -1,18 +1,27 @@
-export interface SenzorOptions {
-  apiKey: string;
-  endpoint?: string;
-  batchSize?: number;
-  flushInterval?: number;
-  debug?: boolean;
-  autoLogs?: boolean;
-}
-
-export interface Span {
-  spanId: string;
-  name: string;
-  type: 'db' | 'http' | 'function' | 'custom';
-  startTime: number;
-  duration: number;
+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[];
+  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>;
 }
@@ -76,12 +85,17 @@ export interface TaskRun {
 }
 
 // Unified Context Payload for async_hooks
-export interface ActiveTrace {
-  id: string; // The APM traceId OR the Task runId
-  contextType: 'apm' | 'task';
-  startTime: number;
-  startMemory?: number; // Baseline heap
-  startCpu?: NodeJS.CpuUsage; // Baseline CPU tick
-  data: any; // Holds Partial<Trace> or Partial<TaskRun>
-  spans: Span[];
-}
+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/src/index.ts

@@ -5,9 +5,10 @@ import { wrapNextRoute, wrapNextPages } from './wrappers/next';
 import { senzorPlugin } from './wrappers/fastify';
 import { SenzorOptions } from './core/types';
 
-const Senzor = {
-  init: (options: SenzorOptions) => client.init(options),
-  flush: () => client.flush(),
+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),
@@ -32,4 +33,4 @@ const Senzor = {
 };
 
 export default Senzor;
-export { Senzor };
+export { Senzor };