@senzops/apm-node 1.1.16 → 1.1.18

package/src/core/client.ts

@@ -1,6 +1,6 @@
 import { Transport } from './transport';
 import { Context } from './context';
-import { SenzorOptions, ActiveTrace, TaskRun } from './types';
+import { SenzorOptions, ActiveTrace, TaskRun, SenzorLog } from './types';
 import { randomUUID } from 'crypto';
 import { instrumentHttp, instrumentFetch } from '../instrumentation/http';
 import { instrumentMongo } from '../instrumentation/mongo';
@@ -8,10 +8,23 @@ import { instrumentPg } from '../instrumentation/pg';
 import { instrumentBullMQ } from '../instrumentation/bullmq';
 import { instrumentNodeCron } from '../instrumentation/cron';
 import { SDK_META } from '../utils/sdkMeta';
-import { parseTraceparent } from '../utils/traceContext'; // NEW
+import { parseTraceparent } from '../utils/traceContext';
 
 const generateW3CTraceId = () => randomUUID().replace(/-/g, '');
 
+// Memory-safe JSON stringifier to handle cyclical objects 
+// (like Express 'req' objects) passed into console.log
+const safeStringify = (obj: any): string => {
+  const cache = new Set();
+  return JSON.stringify(obj, (key, value) => {
+    if (typeof value === 'object' && value !== null) {
+      if (cache.has(value)) return '[Circular]';
+      cache.add(value);
+    }
+    return value;
+  });
+};
+
 export class SenzorClient {
   private transport: Transport | null = null;
   private options: SenzorOptions | null = null;
@@ -30,21 +43,101 @@ export class SenzorClient {
 
     if (!this.isInstrumented) {
       this.setupGlobalErrorHandlers();
+      this.setupLogInterception(); // Fire up Auto Log Instrumentation
 
       try { instrumentHttp(endpoint, debug); } catch (e) { }
       try { instrumentFetch(endpoint, debug); } catch (e) { }
       try { instrumentMongo(debug); } catch (e) { }
       try { instrumentPg(); } catch (e) { }
 
-      // Task Integrations (NEW)
+      // Task Integrations 
       try { instrumentBullMQ(this, debug); } catch (e) { }
       try { instrumentNodeCron(this, debug); } catch (e) { }
 
       this.isInstrumented = true;
-      if (debug) console.log('[Senzor] Auto-instrumentation & Error Tracking enabled');
+      if (debug) console.log('[Senzor] Auto-instrumentation enabled');
     }
   }
 
+  // --- Enterprise Auto-Log Interception ---
+  private setupLogInterception() {
+    if (this.options?.autoLogs === false) return; // Opt-out check
+
+    const levels = ['log', 'info', 'warn', 'error', 'debug'] as const;
+    const originalConsole = {
+      log: console.log,
+      info: console.info,
+      warn: console.warn,
+      error: console.error,
+      debug: console.debug
+    };
+
+    let isIntercepting = false; // Lock to prevent SDK internal logs from looping infinitely
+
+    levels.forEach(level => {
+      console[level] = (...args: any[]) => {
+        // Always execute original console so user's terminal isn't broken
+        originalConsole[level].apply(console, args);
+
+        if (isIntercepting || !this.transport) return;
+        isIntercepting = true;
+
+        try {
+          let message = '';
+          let attributes: Record<string, any> = {};
+
+          args.forEach(arg => {
+            if (typeof arg === 'string') {
+              message += (message ? ' ' : '') + arg;
+            } else if (arg instanceof Error) {
+              message += (message ? ' ' : '') + arg.message;
+              attributes.errorStack = arg.stack;
+              attributes.errorName = arg.name;
+            } else if (typeof arg === 'object' && arg !== null) {
+              try {
+                // New Relic Style Destructuring: Merge all object keys into `attributes`
+                const parsed = JSON.parse(safeStringify(arg));
+                attributes = { ...attributes, ...parsed };
+              } catch (e) {
+                attributes.unparseableObject = true;
+              }
+            } else {
+              message += (message ? ' ' : '') + String(arg);
+            }
+          });
+
+          // Fallback if the user purely logged an object without text e.g., console.log({ user: 123 })
+          if (!message && Object.keys(attributes).length > 0) {
+            message = 'Object Log';
+          }
+
+          // Attach to Active Context seamlessly (Works for BOTH APM and Tasks!)
+          const currentTrace = Context.current();
+          const logType = currentTrace?.contextType === 'task' ? 'task' : 'apm';
+
+          const logPayload: SenzorLog = {
+            message: message || 'Empty log',
+            level: level === 'log' ? 'info' : level, // Map generic log -> info
+            attributes,
+            timestamp: new Date().toISOString()
+          };
+
+          // Attach the specific contextual ID
+          if (currentTrace) {
+            if (logType === 'task') logPayload.runId = currentTrace.id;
+            else logPayload.traceId = currentTrace.id;
+          }
+
+          this.transport.addLog(logPayload, logType);
+        } catch (e) {
+          // Absolute failure isolation. Never crash host app during logging.
+        } finally {
+          isIntercepting = false; // Release lock
+        }
+      };
+    });
+  }
+
   private setupGlobalErrorHandlers() {
     if ((process as any).__senzorGlobalHandlersInstalled) {
       return;
@@ -97,21 +190,14 @@ export class SenzorClient {
         }
         const enrichedMeta = {
           ...meta,
-          runtime: {
-            name: 'node',
-            version: process.version
-          },
+          runtime: { name: 'node', version: process.version },
           process: getProcessContext(),
           memory: getMemoryContext(),
-          sdk: {
-            name: SDK_META.name,
-            version: SDK_META.version
-          }
+          sdk: { name: SDK_META.name, version: SDK_META.version }
         };
 
         this.captureError(parsedError, enrichedMeta);
       } catch (internalFailure) {
-        // NEVER allow SDK to crash host app
         try {
           if (this.options?.debug) {
             console.error('[Senzor] Error handler failure:', internalFailure);
@@ -120,69 +206,14 @@ export class SenzorClient {
       }
     };
 
-    process.on('uncaughtExceptionMonitor', (error) => {
-      safeCapture(error, {
-        type: 'uncaughtExceptionMonitor',
-        severity: 'fatal'
-      });
-    });
-
-    process.on('uncaughtException', (error) => {
-      safeCapture(error, {
-        type: 'uncaughtException',
-        severity: 'fatal'
-      });
-    });
-
-    process.on('unhandledRejection', (reason) => {
-      safeCapture(reason, {
-        type: 'unhandledRejection',
-        severity: 'error'
-      });
-    });
-
-    process.on('warning', (warning) => {
-      safeCapture(warning, {
-        type: 'processWarning',
-        severity: 'warning'
-      });
-    });
-
-    process.on('multipleResolves', (type, promise, reason) => {
-      safeCapture(reason || new Error('Multiple promise resolves'), {
-        type: 'multipleResolves',
-        resolveType: type,
-        severity: 'warning'
-      });
-    });
-
-    process.on('rejectionHandled', (promise) => {
-      if (this.options?.debug) {
-        try {
-          console.warn('[Senzor] rejectionHandled event detected');
-        } catch { }
-      }
-    });
-
-    process.on('SIGTERM', () => {
-      safeCapture(
-        new Error('Process received SIGTERM'),
-        {
-          type: 'processSignal',
-          signal: 'SIGTERM'
-        }
-      );
-    });
-
-    process.on('SIGINT', () => {
-      safeCapture(
-        new Error('Process received SIGINT'),
-        {
-          type: 'processSignal',
-          signal: 'SIGINT'
-        }
-      );
-    });
+    process.on('uncaughtExceptionMonitor', (error) => safeCapture(error, { type: 'uncaughtExceptionMonitor', severity: 'fatal' }));
+    process.on('uncaughtException', (error) => safeCapture(error, { type: 'uncaughtException', severity: 'fatal' }));
+    process.on('unhandledRejection', (reason) => safeCapture(reason, { type: 'unhandledRejection', severity: 'error' }));
+    process.on('warning', (warning) => safeCapture(warning, { type: 'processWarning', severity: 'warning' }));
+    process.on('multipleResolves', (type, promise, reason) => safeCapture(reason || new Error('Multiple promise resolves'), { type: 'multipleResolves', resolveType: type, severity: 'warning' }));
+    process.on('rejectionHandled', (promise) => { if (this.options?.debug) { try { console.warn('[Senzor] rejectionHandled event detected'); } catch { } } });
+    process.on('SIGTERM', () => safeCapture(new Error('Process received SIGTERM'), { type: 'processSignal', signal: 'SIGTERM' }));
+    process.on('SIGINT', () => safeCapture(new Error('Process received SIGINT'), { type: 'processSignal', signal: 'SIGINT' }));
   }
 
   public startTrace<T>(data: Partial<ActiveTrace['data']> & { headers?: any }, next: () => T): T {
@@ -198,7 +229,6 @@ export class SenzorClient {
         return undefined;
       };
 
-      // 1. Prioritize standard W3C Context (e.g., from RUM Frontend)
       const traceparent = getHeader('traceparent');
       const parsedContext = parseTraceparent(traceparent);
 
@@ -206,7 +236,6 @@ export class SenzorClient {
         inheritedTraceId = parsedContext.traceId;
         inheritedParentSpanId = parsedContext.parentSpanId;
       } else {
-        // 2. Fallback to legacy proprietary headers
         const rawTrace = getHeader('x-senzor-trace-id');
         const rawSpan = getHeader('x-senzor-parent-span-id');
         inheritedTraceId = Array.isArray(rawTrace) ? rawTrace[0] : rawTrace;
@@ -214,18 +243,13 @@ export class SenzorClient {
       }
     }
 
-    // Crucial: ADOPT the inherited traceId to perfectly link Frontend & Backend
     const activeTraceId = inheritedTraceId || generateW3CTraceId();
 
     const trace: ActiveTrace = {
       id: activeTraceId,
-      contextType: 'apm', // Ensure we distinguish APM traces from Background Tasks
+      contextType: 'apm',
       startTime: performance.now(),
-      data: {
-        ...data,
-        parentTraceId: inheritedTraceId,
-        parentSpanId: inheritedParentSpanId
-      },
+      data: { ...data, parentTraceId: inheritedTraceId, parentSpanId: inheritedParentSpanId },
       spans: []
     };
 
@@ -255,7 +279,6 @@ export class SenzorClient {
     const currentContext = Context.current();
     const triggerTraceId = currentContext?.contextType === 'apm' ? currentContext.id : undefined;
 
-    // Snapshot system resources before execution
     const startMemory = process.memoryUsage ? process.memoryUsage().heapUsed : 0;
     const startCpu = process.cpuUsage ? process.cpuUsage() : undefined;
 
@@ -275,14 +298,13 @@ export class SenzorClient {
     const task = Context.current();
     if (!task || task.contextType !== 'task' || !this.transport) return;
 
-    // Calculate resource deltas
     let resourceMetrics;
     if (process.memoryUsage && task.startMemory !== undefined && process.cpuUsage && task.startCpu) {
       const endMemory = process.memoryUsage().heapUsed;
       const cpuDelta = process.cpuUsage(task.startCpu);
 
       resourceMetrics = {
-        memoryDeltaBytes: endMemory - task.startMemory, // Can be negative if GC ran!
+        memoryDeltaBytes: endMemory - task.startMemory,
         cpuUserUs: cpuDelta.user,
         cpuSystemUs: cpuDelta.system
       };
@@ -295,7 +317,7 @@ export class SenzorClient {
       triggerTraceId: task.data.triggerTraceId,
       queueDelay: task.data.queueDelay,
       attempts: task.data.attempts,
-      isDeadLetter: task.data.isDeadLetter, // Extracted from options/metadata if provided
+      isDeadLetter: task.data.isDeadLetter,
       metadata: { ...task.data.metadata, ...extraMetadata },
       resourceMetrics,
       status,
@@ -323,7 +345,6 @@ export class SenzorClient {
     }) as unknown as T;
   }
 
-  // --- MODIFIED: Context-Aware Error Capture ---
   public captureError(error: unknown, context: any = {}) {
     if (!this.transport) return;
 
@@ -360,7 +381,6 @@ export class SenzorClient {
     if (!trace) return { end: () => { } };
     const startTime = performance.now() - trace.startTime;
     const spanStartAbs = performance.now();
-    // Use 16 char hex for span IDs for W3C compatibility
     const spanId = randomUUID().replace(/-/g, '').slice(0, 16);
     return { end: (meta?: any, status?: number) => { Context.addSpan({ spanId, name, type, startTime, duration: performance.now() - spanStartAbs, status, meta }); } };
   }

package/src/core/transport.ts

@@ -1,11 +1,13 @@
-import { SenzorOptions, Trace, TaskRun, SenzorError } from './types';
+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;
@@ -41,40 +43,59 @@ export class Transport {
     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;
-    const totalTask = this.taskQueue.length + this.taskErrorQueue.length;
+    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] };
-    const taskPayload = { runs: [...this.taskQueue], errors: [...this.taskErrorQueue] };
-
+    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 = [];
 
-      if (apmPayload.traces.length > 0 || apmPayload.errors.length > 0) {
+      // 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) {
+      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: ${apmPayload.traces.length} traces, ${taskPayload.runs.length} tasks`);
+        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);

package/src/core/types.ts

@@ -4,6 +4,7 @@ export interface SenzorOptions {
   batchSize?: number;
   flushInterval?: number;
   debug?: boolean;
+  autoLogs?: boolean;
 }
 
 export interface Span {
@@ -26,6 +27,17 @@ export interface SenzorError {
   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;

package/src/middleware/express.ts

@@ -1,4 +1,5 @@
 import { client } from '../core/client';
+import { getClientIp } from '../utils/getClientIp';
 
 // 1. Request Handler (Place before routes)
 export const expressMiddleware = () => {
@@ -6,7 +7,7 @@ export const expressMiddleware = () => {
     client.startTrace({
       method: req.method,
       path: req.originalUrl || req.url,
-      ip: req.ip || req.socket?.remoteAddress,
+      ip: getClientIp(req),
       userAgent: req.headers['user-agent'],
       headers: req.headers
     }, () => {

package/src/utils/getClientIp.ts

@@ -0,0 +1,175 @@
+/**
+ * getClientIp.ts
+ *
+ * Robust, proxy-aware client IP extraction.
+ *
+ * Priority order (mirrors Umami + industry best practice):
+ *   1. ENV-configured custom header  (CLIENT_IP_HEADER)
+ *   2. CF-Connecting-IP              (Cloudflare — single trusted IP)
+ *   3. True-Client-IP                (Cloudflare Enterprise / Akamai)
+ *   4. X-Real-IP                     (Nginx realip module)
+ *   5. Forwarded                     (RFC 7239 — "for=" field)
+ *   6. X-Forwarded-For               (De-facto standard — leftmost public IP)
+ *   7. req.socket.remoteAddress      (Direct connection fallback)
+ *
+ * Security note: headers 2-6 can be spoofed by clients when your server is
+ * directly internet-facing. If that is a concern, restrict extraction to the
+ * header your trusted reverse-proxy injects (CLIENT_IP_HEADER or X-Real-IP).
+ */
+
+import { isIP } from "net";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/** Strip IPv4-mapped IPv6 prefix (::ffff:1.2.3.4 → 1.2.3.4) */
+const stripIPv6Mapped = (ip: string): string =>
+  ip.startsWith("::ffff:") ? ip.slice(7) : ip;
+
+/** Strip optional port from an IPv4 address (1.2.3.4:5678 → 1.2.3.4). */
+const stripIPv4Port = (ip: string): string => {
+  const lastColon = ip.lastIndexOf(":");
+  if (lastColon === -1) return ip;
+  const maybeIP = ip.slice(0, lastColon);
+  return isIP(maybeIP) === 4 ? maybeIP : ip;
+};
+
+/** Strip brackets + optional port from an IPv6 address ([::1]:5678 → ::1). */
+const stripIPv6Brackets = (ip: string): string => {
+  const match = ip.match(/^\[([^\]]+)\](?::\d+)?$/);
+  return match ? match[1] : ip;
+};
+
+/** Normalise raw IP string into a clean, routable address (or null). */
+export const normaliseIP = (raw: string | undefined | null): string | null => {
+  if (!raw) return null;
+  let ip = raw.trim();
+  if (!ip) return null;
+
+  ip = stripIPv6Brackets(ip);
+  ip = stripIPv4Port(ip);
+  ip = stripIPv6Mapped(ip);
+
+  return isIP(ip) !== 0 ? ip : null;
+};
+
+/**
+ * Returns true for IPs that will never produce a geo result:
+ * loopback, link-local, private ranges, and unspecified addresses.
+ */
+export const isPrivateOrLoopback = (ip: string): boolean => {
+  // IPv4 private / loopback / link-local
+  if (
+    ip === "127.0.0.1" ||
+    ip.startsWith("10.") ||
+    ip.startsWith("192.168.") ||
+    ip.startsWith("169.254.") || // link-local
+    /^172\.(1[6-9]|2\d|3[01])\./.test(ip) // 172.16–31
+  )
+    return true;
+
+  // IPv6 loopback / unspecified / link-local / unique-local
+  if (
+    ip === "::1" ||
+    ip === "::" ||
+    ip.toLowerCase().startsWith("fe80:") || // link-local
+    ip.toLowerCase().startsWith("fc") || // unique-local
+    ip.toLowerCase().startsWith("fd") // unique-local
+  )
+    return true;
+
+  return false;
+};
+
+// ---------------------------------------------------------------------------
+// RFC 7239 "Forwarded" header parser
+//   e.g.  Forwarded: for=192.0.2.60;proto=http, for="[2001:db8::cafe]"
+// ---------------------------------------------------------------------------
+const parseForwardedHeader = (header: string): string | null => {
+  const parts = header.split(",");
+  for (const part of parts) {
+    const forMatch = part.match(/for=["[]?([^\]",;>\s]+)/i);
+    if (forMatch) {
+      const ip = normaliseIP(forMatch[1]);
+      if (ip && !isPrivateOrLoopback(ip)) return ip;
+    }
+  }
+  return null;
+};
+
+// ---------------------------------------------------------------------------
+// X-Forwarded-For parser — pick the leftmost *public* IP
+//   e.g.  X-Forwarded-For: client, proxy1, proxy2
+// ---------------------------------------------------------------------------
+const parseXForwardedFor = (header: string): string | null => {
+  const ips = header.split(",").map((s) => s.trim());
+  for (const raw of ips) {
+    const ip = normaliseIP(raw);
+    if (ip && !isPrivateOrLoopback(ip)) return ip;
+  }
+  // If every hop is private (intranet-only setup) fall back to first valid IP
+  for (const raw of ips) {
+    const ip = normaliseIP(raw);
+    if (ip) return ip;
+  }
+  return null;
+};
+
+// ---------------------------------------------------------------------------
+// Main export
+// ---------------------------------------------------------------------------
+
+/**
+ * Extract the best-available client IP from a request.
+ *
+ * Returns `null` if no valid IP can be determined.
+ */
+export const getClientIp = (req: any): string | null => {
+  const h = req.headers;
+
+  // 2. Cloudflare single-IP header (most reliable when behind CF)
+  {
+    const ip = normaliseIP(h["cf-connecting-ip"] as string);
+    if (ip) return ip;
+  }
+
+  // 3. Cloudflare Enterprise / Akamai
+  {
+    const ip = normaliseIP(h["true-client-ip"] as string);
+    if (ip) return ip;
+  }
+
+  // 4. Nginx realip module (single, already-trusted IP)
+  {
+    const ip = normaliseIP(h["x-real-ip"] as string);
+    if (ip) return ip;
+  }
+
+  // 5. RFC 7239 Forwarded header
+  {
+    const fwd = h["forwarded"] as string;
+    if (fwd) {
+      const ip = parseForwardedHeader(fwd);
+      if (ip) return ip;
+    }
+  }
+
+  // 6. De-facto standard XFF
+  {
+    const xff = h["x-forwarded-for"] as string;
+    if (xff) {
+      const ip = parseXForwardedFor(xff);
+      if (ip) return ip;
+    }
+  }
+
+  // 7. Direct TCP connection (local dev / no proxy)
+  {
+    const raw = req.socket?.remoteAddress;
+    const ip = normaliseIP(raw);
+    if (ip) return ip;
+  }
+
+  return null;
+};

package/src/wrappers/fastify.ts

@@ -1,5 +1,6 @@
 import { client } from '../core/client';
 import { SenzorOptions } from '../core/types';
+import { getClientIp } from '../utils/getClientIp';
 
 export const senzorPlugin = (fastify: any, options: SenzorOptions, done: Function) => {
   if (options && options.apiKey) {
@@ -10,7 +11,7 @@ export const senzorPlugin = (fastify: any, options: SenzorOptions, done: Functio
     client.startTrace({
       method: request.method,
       path: request.raw.url || request.url,
-      ip: request.ip,
+      ip: getClientIp(request),
       userAgent: request.headers['user-agent'],
       headers: request.headers // Pass headers
     }, () => next());

package/src/wrappers/h3.ts

@@ -1,5 +1,6 @@
 import { client } from '../core/client';
 import { getRoute } from '../core/normalizer';
+import { getClientIp } from '../utils/getClientIp';
 
 type EventHandler = (event: any) => any;
 
@@ -11,7 +12,7 @@ export const wrapH3 = (handler: EventHandler) => {
     return client.startTrace({
       method: req.method || 'GET',
       path: path,
-      ip: req.headers['x-forwarded-for'] || req.socket?.remoteAddress,
+      ip: getClientIp(req),
       userAgent: req.headers['user-agent'],
       headers: req.headers // Pass headers
     }, async () => {

package/src/wrappers/next.ts

@@ -1,5 +1,6 @@
 import { client } from '../core/client';
 import { normalizePath } from '../core/normalizer';
+import { getClientIp } from '../utils/getClientIp';
 
 // --- App Router Wrapper ---
 export const wrapNextRoute = (handler: Function) => {
@@ -34,7 +35,7 @@ export const wrapNextRoute = (handler: Function) => {
       method,
       path: url.pathname,
       userAgent: ua,
-      ip: ip,
+      ip: ip || getClientIp(req),
       headers: headers // Pass extracted headers
     }, async () => {
       try {
@@ -61,7 +62,7 @@ export const wrapNextPages = (handler: Function) => {
       method: req.method || 'GET',
       path: path,
       userAgent: req.headers['user-agent'],
-      ip: req.headers['x-forwarded-for'] || req.socket?.remoteAddress,
+      ip: getClientIp(req),
       headers: req.headers // Standard Node headers work fine
     }, async () => {