@senzops/apm-node 1.2.8 → 1.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@senzops/apm-node",
-  "version": "1.2.8",
+  "version": "1.3.1",
   "description": "Universal APM SDK for Senzor",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -15,6 +15,11 @@
       "types": "./dist/register.d.ts",
       "require": "./dist/register.js",
       "import": "./dist/register.mjs"
+    },
+    "./lambda-handler": {
+      "types": "./dist/lambda-handler.d.ts",
+      "require": "./dist/lambda-handler.js",
+      "import": "./dist/lambda-handler.mjs"
     }
   },
   "scripts": {

package/src/core/client.ts

@@ -7,6 +7,7 @@ import { parseTraceparent } from '../utils/traceContext';
 import { generateSpanId, generateTraceId } from '../utils/ids';
 import { sanitizeAttributes } from './sanitizer';
 import { startCapturedSpan } from '../instrumentation/span';
+import { RuntimeMetricsCollector } from '../instrumentation/runtime';
 
 // Memory-safe JSON stringifier to handle cyclical objects 
 // (like Express 'req' objects) passed into console.log
@@ -25,6 +26,7 @@ export class SenzorClient {
   private transport: Transport | null = null;
   private options: SenzorOptions | null = null;
   private isInstrumented = false;
+  private runtimeMetricsCollector: RuntimeMetricsCollector | null = null;
 
   public preload(options: Partial<SenzorOptions> = {}) {
     const endpoint = options.endpoint || 'https://api.senzor.dev/api/ingest/apm';
@@ -87,6 +89,61 @@ export class SenzorClient {
       try { if (this.isInstrumentationEnabled('redis')) { const { instrumentRedis } = require('../instrumentation/redis'); instrumentRedis(this.options || undefined); } } catch {}
       try { if (this.isInstrumentationEnabled('bullmq')) { const { instrumentBullMQ } = require('../instrumentation/bullmq'); instrumentBullMQ(this, debug); } } catch {}
       try { if (this.isInstrumentationEnabled('cron')) { const { instrumentNodeCron } = require('../instrumentation/cron'); instrumentNodeCron(this, debug); } } catch {}
+
+      // --- Phase 1 Instrumentations ---
+      try { if (this.isInstrumentationEnabled('grpc')) { const { instrumentGrpc } = require('../instrumentation/grpc'); instrumentGrpc(this, this.options || undefined); } } catch {}
+      try { if (this.isInstrumentationEnabled('graphql')) { const { instrumentGraphQL } = require('../instrumentation/graphql'); instrumentGraphQL(this.options || undefined); } } catch {}
+      try { if (this.isInstrumentationEnabled('dns')) { const { instrumentDns } = require('../instrumentation/dns'); instrumentDns(this.options || undefined); } } catch {}
+      try { if (this.isInstrumentationEnabled('net')) { const { instrumentNet } = require('../instrumentation/net'); instrumentNet(this.options || undefined); } } catch {}
+
+      // --- Phase 2 Instrumentations: Messaging ---
+      try { if (this.isInstrumentationEnabled('kafka')) { const { instrumentKafka } = require('../instrumentation/kafka'); instrumentKafka(this.options || undefined); } } catch {}
+      try { if (this.isInstrumentationEnabled('amqplib')) { const { instrumentAmqplib } = require('../instrumentation/amqplib'); instrumentAmqplib(this.options || undefined); } } catch {}
+      try { if (this.isInstrumentationEnabled('socketio')) { const { instrumentSocketIO } = require('../instrumentation/socketio'); instrumentSocketIO(this.options || undefined); } } catch {}
+
+      // --- Phase 3 Instrumentations: Frameworks & Log Correlation ---
+      try { if (this.isInstrumentationEnabled('nestjs')) { const { instrumentNestJS } = require('../instrumentation/nestjs'); instrumentNestJS(this.options || undefined); } } catch {}
+      try { if (this.isInstrumentationEnabled('hapi')) { const { instrumentHapi } = require('../instrumentation/hapi'); instrumentHapi(this.options || undefined); } } catch {}
+      try { if (this.isInstrumentationEnabled('pino')) { const { instrumentPino } = require('../instrumentation/pino'); instrumentPino(this.options || undefined); } } catch {}
+      try { if (this.isInstrumentationEnabled('winston')) { const { instrumentWinston } = require('../instrumentation/winston'); instrumentWinston(this.options || undefined); } } catch {}
+      try { if (this.isInstrumentationEnabled('bunyan')) { const { instrumentBunyan } = require('../instrumentation/bunyan'); instrumentBunyan(this.options || undefined); } } catch {}
+
+      // --- Phase 4 Instrumentations: Cloud & Database ---
+      try { if (this.isInstrumentationEnabled('aws-sdk')) { const { instrumentAwsSdk } = require('../instrumentation/aws-sdk'); instrumentAwsSdk(this.options || undefined); } } catch {}
+      try { if (this.isInstrumentationEnabled('knex')) { const { instrumentKnex } = require('../instrumentation/knex'); instrumentKnex(this.options || undefined); } } catch {}
+      try { if (this.isInstrumentationEnabled('tedious')) { const { instrumentTedious } = require('../instrumentation/tedious'); instrumentTedious(this.options || undefined); } } catch {}
+      try { if (this.isInstrumentationEnabled('cassandra')) { const { instrumentCassandra } = require('../instrumentation/cassandra'); instrumentCassandra(this.options || undefined); } } catch {}
+      try { if (this.isInstrumentationEnabled('memcached')) { const { instrumentMemcached } = require('../instrumentation/memcached'); instrumentMemcached(this.options || undefined); } } catch {}
+      try { if (this.isInstrumentationEnabled('generic-pool')) { const { instrumentGenericPool } = require('../instrumentation/generic-pool'); instrumentGenericPool(this.options || undefined); } } catch {}
+
+      // --- Phase 5 Instrumentations: Frameworks, Utilities & AI ---
+      try { if (this.isInstrumentationEnabled('restify')) { const { instrumentRestify } = require('../instrumentation/restify'); instrumentRestify(this.options || undefined); } } catch {}
+      try { if (this.isInstrumentationEnabled('connect')) { const { instrumentConnect } = require('../instrumentation/connect'); instrumentConnect(this.options || undefined); } } catch {}
+      try { if (this.isInstrumentationEnabled('dataloader')) { const { instrumentDataloader } = require('../instrumentation/dataloader'); instrumentDataloader(this.options || undefined); } } catch {}
+      try { if (this.isInstrumentationEnabled('lru-memoizer')) { const { instrumentLruMemoizer } = require('../instrumentation/lru-memoizer'); instrumentLruMemoizer(this.options || undefined); } } catch {}
+      try { if (this.isInstrumentationEnabled('fs')) { const { instrumentFs } = require('../instrumentation/fs'); instrumentFs(this.options || undefined); } } catch {}
+      try { if (this.isInstrumentationEnabled('openai')) { const { instrumentOpenAI } = require('../instrumentation/openai'); instrumentOpenAI(this.options || undefined); } } catch {}
+
+      // --- Phase 6 Instrumentations: AI SDKs & Firebase ---
+      try { if (this.isInstrumentationEnabled('anthropic')) { const { instrumentAnthropic } = require('../instrumentation/anthropic'); instrumentAnthropic(this.options || undefined); } } catch {}
+      try { if (this.isInstrumentationEnabled('google-genai')) { const { instrumentGoogleGenAI } = require('../instrumentation/google-genai'); instrumentGoogleGenAI(this.options || undefined); } } catch {}
+      try { if (this.isInstrumentationEnabled('azure-openai')) { const { instrumentAzureOpenAI } = require('../instrumentation/azure-openai'); instrumentAzureOpenAI(this.options || undefined); } } catch {}
+      try { if (this.isInstrumentationEnabled('cohere')) { const { instrumentCohere } = require('../instrumentation/cohere'); instrumentCohere(this.options || undefined); } } catch {}
+      try { if (this.isInstrumentationEnabled('mistral')) { const { instrumentMistral } = require('../instrumentation/mistral'); instrumentMistral(this.options || undefined); } } catch {}
+      try { if (this.isInstrumentationEnabled('firebase')) { const { instrumentFirebase } = require('../instrumentation/firebase'); instrumentFirebase(this.options || undefined); } } catch {}
+
+      // --- Runtime Metrics ---
+      if (this.options?.runtimeMetrics !== false && this.transport) {
+        try {
+          this.runtimeMetricsCollector = new RuntimeMetricsCollector({
+            interval: this.options?.runtimeMetricsInterval ?? 15000,
+            onMetrics: (payload) => {
+              this.transport?.addRuntimeMetrics(payload);
+            },
+          });
+          this.runtimeMetricsCollector.start();
+        } catch {}
+      }
     }
 
     this.isInstrumented = true;

package/src/core/transport.ts

@@ -1,10 +1,12 @@
 import { SENZOR_INTERNAL_HEADER } from '../utils/internal';
 import { SenzorOptions, Trace, TaskRun, SenzorError, SenzorLog } from './types';
+import type { RuntimeMetricsPayload } from '../instrumentation/runtime';
 
 interface ApmPayload {
   traces: Trace[];
   errors: SenzorError[];
   logs: SenzorLog[];
+  runtimeMetrics?: RuntimeMetricsPayload[];
 }
 
 interface TaskPayload {
@@ -17,6 +19,7 @@ export class Transport {
   private traceQueue: Trace[] = [];
   private apmErrorQueue: SenzorError[] = [];
   private apmLogQueue: SenzorLog[] = [];
+  private runtimeMetricsQueue: RuntimeMetricsPayload[] = [];
 
   private taskQueue: TaskRun[] = [];
   private taskErrorQueue: SenzorError[] = [];
@@ -89,6 +92,11 @@ export class Transport {
     this.checkFlush();
   }
 
+  public addRuntimeMetrics(payload: RuntimeMetricsPayload) {
+    this.enqueue(this.runtimeMetricsQueue, payload);
+    // Runtime metrics don't trigger immediate flush — they ride the next timer
+  }
+
   private enqueue<T>(queue: T[], item: T) {
     this.ensureTimer();
     queue.push(item);
@@ -130,12 +138,17 @@ export class Transport {
   }
 
   private takeApmPayload(): ApmPayload {
-    const payload = {
+    const payload: ApmPayload = {
       traces: this.traceQueue,
       errors: this.apmErrorQueue,
-      logs: this.apmLogQueue
+      logs: this.apmLogQueue,
     };
 
+    if (this.runtimeMetricsQueue.length > 0) {
+      payload.runtimeMetrics = this.runtimeMetricsQueue;
+      this.runtimeMetricsQueue = [];
+    }
+
     this.traceQueue = [];
     this.apmErrorQueue = [];
     this.apmLogQueue = [];
@@ -159,6 +172,9 @@ export class Transport {
     this.prependWithLimit(this.apmLogQueue, payload.logs);
     this.prependWithLimit(this.apmErrorQueue, payload.errors);
     this.prependWithLimit(this.traceQueue, payload.traces);
+    if (payload.runtimeMetrics) {
+      this.prependWithLimit(this.runtimeMetricsQueue, payload.runtimeMetrics);
+    }
   }
 
   private restoreTaskPayload(payload: TaskPayload) {
@@ -171,7 +187,8 @@ export class Transport {
     return (
       payload.traces.length > 0 ||
       payload.errors.length > 0 ||
-      payload.logs.length > 0
+      payload.logs.length > 0 ||
+      (payload.runtimeMetrics?.length ?? 0) > 0
     );
   }
 

package/src/core/types.ts

@@ -18,13 +18,17 @@ export interface SenzorOptions {
   ignoreFrameworkSpanTypes?: string[];
   debug?: boolean;
   autoLogs?: boolean;
+  /** Enable runtime metrics collection (event loop, GC, heap). Default: true */
+  runtimeMetrics?: boolean;
+  /** Runtime metrics collection interval in milliseconds. Default: 15000 */
+  runtimeMetricsInterval?: number;
 }
 
 export interface Span {
   spanId: string;
   parentSpanId?: string;
   name: string;
-  type: 'db' | 'http' | 'function' | 'custom';
+  type: 'db' | 'http' | 'function' | 'custom' | 'rpc' | 'messaging' | 'dns' | 'net';
   startTime: number;
   duration: number;
   status?: number;

package/src/index.ts

@@ -3,6 +3,7 @@ import { expressMiddleware, expressErrorHandler } from './middleware/express';
 import { wrapH3 } from './wrappers/h3';
 import { wrapNextRoute, wrapNextPages } from './wrappers/next';
 import { wrapWorker } from './wrappers/worker';
+import { wrapLambda } from './wrappers/lambda';
 import { nitroPlugin } from './wrappers/nitro';
 import { senzorPlugin } from './wrappers/fastify';
 import { SenzorOptions } from './core/types';
@@ -36,6 +37,9 @@ const Senzor = {
   // Cloudflare Workers
   worker: wrapWorker,
 
+  // AWS Lambda
+  wrapLambda,
+
   // Nitro / Nuxt
   nitroPlugin
 };

package/src/instrumentation/amqplib.ts

@@ -0,0 +1,371 @@
+import { Context } from '../core/context';
+import { SenzorOptions } from '../core/types';
+import { hookRequire } from './hook';
+import { patchMethod } from './patch';
+import { runWithCapturedSpan, startCapturedSpan } from './span';
+import { generateTraceparent, parseTraceparent } from '../utils/traceContext';
+
+// ---------------------------------------------------------------------------
+// RabbitMQ (amqplib) Instrumentation
+//
+// Instruments the amqplib library:
+//   - Channel.publish()     — outbound publish spans
+//   - Channel.sendToQueue() — outbound send spans (shorthand for publish)
+//   - Channel.consume()     — wraps consumer callback with receive spans
+//
+// Context propagation via message headers (msg.properties.headers).
+//
+// ConfirmChannel inherits from Channel, so patches propagate automatically.
+//
+// Follows OTel messaging semantic conventions:
+//   messaging.system = rabbitmq
+//   messaging.destination.name = exchange or queue
+//   messaging.operation.name = publish | receive
+//   messaging.rabbitmq.routing_key
+//   messaging.rabbitmq.delivery_tag
+// ---------------------------------------------------------------------------
+
+const TRACEPARENT_KEY = 'traceparent';
+const SENZOR_TRACE_KEY = 'x-senzor-trace-id';
+const SENZOR_SPAN_KEY = 'x-senzor-parent-span-id';
+
+/** Inject trace context into AMQP message headers. */
+const injectHeaders = (
+  options: any,
+  traceId: string,
+  spanId: string
+): any => {
+  const opts = options ? { ...options } : {};
+  const headers = opts.headers ? { ...opts.headers } : {};
+  headers[TRACEPARENT_KEY] = generateTraceparent(traceId, spanId);
+  headers[SENZOR_TRACE_KEY] = traceId;
+  headers[SENZOR_SPAN_KEY] = spanId;
+  opts.headers = headers;
+  return opts;
+};
+
+/** Extract trace context from incoming AMQP message properties. */
+const extractHeaders = (
+  msg: any
+): { traceId?: string; parentSpanId?: string } => {
+  const headers = msg?.properties?.headers;
+  if (!headers) return {};
+
+  try {
+    const tp = headers[TRACEPARENT_KEY];
+    if (tp) {
+      const tpStr = Buffer.isBuffer(tp) ? tp.toString() : String(tp);
+      const parsed = parseTraceparent(tpStr);
+      if (parsed) return parsed;
+    }
+
+    const traceId = headers[SENZOR_TRACE_KEY];
+    const spanId = headers[SENZOR_SPAN_KEY];
+    return {
+      traceId: traceId ? (Buffer.isBuffer(traceId) ? traceId.toString() : String(traceId)) : undefined,
+      parentSpanId: spanId ? (Buffer.isBuffer(spanId) ? spanId.toString() : String(spanId)) : undefined,
+    };
+  } catch {
+    return {};
+  }
+};
+
+// ---------------------------------------------------------------------------
+// Channel patching
+// ---------------------------------------------------------------------------
+
+const patchChannel = (channelProto: any, options?: SenzorOptions) => {
+  if (!channelProto) return;
+
+  // --- publish(exchange, routingKey, content, options?) ---
+  patchMethod(
+    channelProto,
+    'publish',
+    'senzor.amqplib.channel.publish',
+    (original) =>
+      function patchedPublish(
+        this: any,
+        exchange: string,
+        routingKey: string,
+        content: Buffer,
+        publishOptions?: any
+      ) {
+        const trace = Context.current();
+        if (!trace) return original.call(this, exchange, routingKey, content, publishOptions);
+
+        const destination = exchange || routingKey || 'default';
+
+        const span = startCapturedSpan(
+          `RabbitMQ publish ${destination}`,
+          'messaging',
+          {
+            'messaging.system': 'rabbitmq',
+            'messaging.destination.name': destination,
+            'messaging.operation.name': 'publish',
+            'messaging.rabbitmq.exchange': exchange || '(default)',
+            'messaging.rabbitmq.routing_key': routingKey,
+            'messaging.message.body_size': content?.length || 0,
+          },
+          options
+        );
+
+        if (!span) return original.call(this, exchange, routingKey, content, publishOptions);
+
+        // Inject trace context into headers
+        const enrichedOptions = injectHeaders(publishOptions, trace.id, span.spanId);
+
+        return runWithCapturedSpan(span, () => {
+          try {
+            const result = original.call(this, exchange, routingKey, content, enrichedOptions);
+
+            // publish returns boolean (backpressure signal), not a promise
+            span.end(0, {
+              'messaging.rabbitmq.backpressure': result === false,
+            });
+
+            return result;
+          } catch (error: any) {
+            span.end(500, {
+              'error.message': error?.message,
+              'error.type': error?.name || 'AmqpError',
+            });
+            throw error;
+          }
+        });
+      }
+  );
+
+  // --- sendToQueue(queue, content, options?) ---
+  patchMethod(
+    channelProto,
+    'sendToQueue',
+    'senzor.amqplib.channel.sendToQueue',
+    (original) =>
+      function patchedSendToQueue(
+        this: any,
+        queue: string,
+        content: Buffer,
+        sendOptions?: any
+      ) {
+        const trace = Context.current();
+        if (!trace) return original.call(this, queue, content, sendOptions);
+
+        const span = startCapturedSpan(
+          `RabbitMQ send ${queue}`,
+          'messaging',
+          {
+            'messaging.system': 'rabbitmq',
+            'messaging.destination.name': queue,
+            'messaging.operation.name': 'publish',
+            'messaging.rabbitmq.routing_key': queue,
+            'messaging.message.body_size': content?.length || 0,
+          },
+          options
+        );
+
+        if (!span) return original.call(this, queue, content, sendOptions);
+
+        const enrichedOptions = injectHeaders(sendOptions, trace.id, span.spanId);
+
+        return runWithCapturedSpan(span, () => {
+          try {
+            const result = original.call(this, queue, content, enrichedOptions);
+            span.end(0, {
+              'messaging.rabbitmq.backpressure': result === false,
+            });
+            return result;
+          } catch (error: any) {
+            span.end(500, {
+              'error.message': error?.message,
+              'error.type': error?.name || 'AmqpError',
+            });
+            throw error;
+          }
+        });
+      }
+  );
+
+  // --- consume(queue, callback, options?) ---
+  patchMethod(
+    channelProto,
+    'consume',
+    'senzor.amqplib.channel.consume',
+    (original) =>
+      function patchedConsume(
+        this: any,
+        queue: string,
+        callback: (msg: any) => void,
+        consumeOptions?: any
+      ) {
+        if (typeof callback !== 'function') {
+          return original.call(this, queue, callback, consumeOptions);
+        }
+
+        const wrappedCallback = function (msg: any) {
+          // Null msg means consumer was cancelled
+          if (!msg) return callback(msg);
+
+          const parentCtx = extractHeaders(msg);
+          const exchange = msg.fields?.exchange || '';
+          const routingKey = msg.fields?.routingKey || queue;
+          const destination = exchange || routingKey || queue;
+
+          const span = startCapturedSpan(
+            `RabbitMQ receive ${destination}`,
+            'messaging',
+            {
+              'messaging.system': 'rabbitmq',
+              'messaging.destination.name': destination,
+              'messaging.operation.name': 'receive',
+              'messaging.rabbitmq.exchange': exchange || '(default)',
+              'messaging.rabbitmq.routing_key': routingKey,
+              'messaging.rabbitmq.delivery_tag': msg.fields?.deliveryTag,
+              'messaging.rabbitmq.redelivered': msg.fields?.redelivered,
+              'messaging.rabbitmq.consumer_tag': msg.fields?.consumerTag,
+              'messaging.message.body_size': msg.content?.length || 0,
+              ...(parentCtx.traceId ? { 'messaging.parent_trace_id': parentCtx.traceId } : {}),
+            },
+            options
+          );
+
+          if (!span) return callback(msg);
+
+          return runWithCapturedSpan(span, () => {
+            try {
+              const result = callback(msg);
+
+              // Handle async consumers (returning promises)
+              if (result && typeof (result as any).then === 'function') {
+                return (result as any).then(
+                  (val: any) => {
+                    span.end(0);
+                    return val;
+                  },
+                  (error: any) => {
+                    span.end(500, {
+                      'error.message': error?.message,
+                      'error.type': error?.name || 'Error',
+                    });
+                    throw error;
+                  }
+                );
+              }
+
+              span.end(0);
+              return result;
+            } catch (error: any) {
+              span.end(500, {
+                'error.message': error?.message,
+                'error.type': error?.name || 'Error',
+              });
+              throw error;
+            }
+          });
+        };
+
+        return original.call(this, queue, wrappedCallback, consumeOptions);
+      }
+  );
+};
+
+// ---------------------------------------------------------------------------
+// Module patching strategies
+// ---------------------------------------------------------------------------
+
+/**
+ * Strategy 1: Patch Channel prototypes from the internal module structure.
+ * amqplib/lib/channel_model exports Channel and ConfirmChannel.
+ */
+const patchFromInternals = (amqplib: any, options?: SenzorOptions) => {
+  // Try to reach Channel prototype via internal module
+  try {
+    const channelModel = require('amqplib/lib/channel_model');
+    if (channelModel?.Channel?.prototype) {
+      patchChannel(channelModel.Channel.prototype, options);
+    }
+    if (channelModel?.ConfirmChannel?.prototype) {
+      patchChannel(channelModel.ConfirmChannel.prototype, options);
+    }
+  } catch { }
+};
+
+/**
+ * Strategy 2: Wrap createChannel/createConfirmChannel to patch returned instances.
+ * Works even if internal structure changes between versions.
+ */
+const patchConnectionFactory = (amqplib: any, options?: SenzorOptions) => {
+  // Wrap amqplib.connect to intercept the connection object
+  patchMethod(
+    amqplib,
+    'connect',
+    'senzor.amqplib.connect',
+    (original) =>
+      function patchedConnect(this: any, ...args: any[]) {
+        const result = original.apply(this, args);
+
+        if (result && typeof result.then === 'function') {
+          return result.then((connection: any) => {
+            if (!connection) return connection;
+
+            // Wrap createChannel
+            patchMethod(
+              connection,
+              'createChannel',
+              'senzor.amqplib.createChannel',
+              (origCreate) =>
+                function patchedCreateChannel(this: any, ...createArgs: any[]) {
+                  const chResult = origCreate.apply(this, createArgs);
+                  if (chResult && typeof chResult.then === 'function') {
+                    return chResult.then((channel: any) => {
+                      if (channel) patchChannel(channel, options);
+                      return channel;
+                    });
+                  }
+                  if (chResult) patchChannel(chResult, options);
+                  return chResult;
+                }
+            );
+
+            // Wrap createConfirmChannel
+            patchMethod(
+              connection,
+              'createConfirmChannel',
+              'senzor.amqplib.createConfirmChannel',
+              (origCreate) =>
+                function patchedCreateConfirmChannel(this: any, ...createArgs: any[]) {
+                  const chResult = origCreate.apply(this, createArgs);
+                  if (chResult && typeof chResult.then === 'function') {
+                    return chResult.then((channel: any) => {
+                      if (channel) patchChannel(channel, options);
+                      return channel;
+                    });
+                  }
+                  if (chResult) patchChannel(chResult, options);
+                  return chResult;
+                }
+            );
+
+            return connection;
+          });
+        }
+
+        return result;
+      }
+  );
+};
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+export const instrumentAmqplib = (options?: SenzorOptions) => {
+  hookRequire('amqplib', (exports: any) => {
+    patchFromInternals(exports, options);
+    patchConnectionFactory(exports, options);
+  });
+
+  // Also hook the callback API variant
+  hookRequire('amqplib/callback_api', (exports: any) => {
+    patchConnectionFactory(exports, options);
+  });
+};