@sentienguard/apm 1.0.4 → 1.0.6

package/src/instrumentation.js

@@ -1,208 +1,208 @@
-/**
- * HTTP Request Auto-Instrumentation
- * Automatically instruments incoming HTTP requests for Express, Fastify, and plain Node.js http.
- *
- * Captures:
- * - Method
- * - Normalized route
- * - Status code
- * - Response time
- * - Error flag
- */
-
-import http from 'http';
-import https from 'https';
-import { extractRoute, normalizeRoute } from './normalizer.js';
-import { getAggregator } from './aggregator.js';
-import { debug } from './config.js';
-
-let isInstrumented = false;
-let originalHttpCreateServer = null;
-let originalHttpsCreateServer = null;
-
-/**
- * Wrap a request handler to capture metrics
- */
-function wrapRequestHandler(handler) {
-  return function wrappedHandler(req, res) {
-    const startTime = process.hrtime.bigint();
-
-    // Store original end method
-    const originalEnd = res.end;
-
-    // Override res.end to capture timing
-    res.end = function (...args) {
-      const endTime = process.hrtime.bigint();
-      const latencyMs = Number(endTime - startTime) / 1e6; // Convert nanoseconds to milliseconds
-
-      // Extract route (after response, frameworks may have populated route info)
-      const route = extractRoute(req);
-      const method = req.method || 'GET';
-      const statusCode = res.statusCode || 200;
-      const isError = statusCode >= 400;
-
-      // Record the metric
-      const aggregator = getAggregator();
-      aggregator.recordRequest(method, route, latencyMs, isError);
-
-      debug(`Request: ${method} ${route} ${statusCode} ${latencyMs.toFixed(2)}ms`);
-
-      // Call original end
-      return originalEnd.apply(this, args);
-    };
-
-    // Call original handler
-    return handler.call(this, req, res);
-  };
-}
-
-/**
- * Wrap a server's request listener
- */
-function wrapServer(server) {
-  const listeners = server.listeners('request');
-
-  // Remove existing listeners
-  server.removeAllListeners('request');
-
-  // Re-add wrapped listeners
-  for (const listener of listeners) {
-    server.on('request', wrapRequestHandler(listener));
-  }
-
-  // Also wrap future listeners
-  const originalOn = server.on.bind(server);
-  server.on = function (event, listener) {
-    if (event === 'request') {
-      return originalOn(event, wrapRequestHandler(listener));
-    }
-    return originalOn(event, listener);
-  };
-
-  return server;
-}
-
-/**
- * Create instrumented http.createServer
- */
-function createInstrumentedCreateServer(original, protocol) {
-  return function instrumentedCreateServer(...args) {
-    const server = original.apply(this, args);
-
-    // If a request handler was passed, it's already attached
-    // We need to wrap the server after creation
-    setImmediate(() => {
-      wrapServer(server);
-      debug(`${protocol} server instrumented`);
-    });
-
-    return server;
-  };
-}
-
-/**
- * Instrument Node.js HTTP module
- * This is the core instrumentation that works with any framework
- */
-export function instrumentHttp() {
-  if (isInstrumented) {
-    debug('HTTP already instrumented, skipping');
-    return;
-  }
-
-  // Store originals for cleanup
-  originalHttpCreateServer = http.createServer;
-  originalHttpsCreateServer = https.createServer;
-
-  // Patch http.createServer
-  http.createServer = createInstrumentedCreateServer(originalHttpCreateServer, 'HTTP');
-
-  // Patch https.createServer
-  https.createServer = createInstrumentedCreateServer(originalHttpsCreateServer, 'HTTPS');
-
-  isInstrumented = true;
-  debug('HTTP instrumentation enabled');
-}
-
-/**
- * Create Express middleware for more accurate route extraction
- * This is optional but provides better route patterns
- */
-export function expressMiddleware() {
-  return function sentienguardMiddleware(req, res, next) {
-    const startTime = process.hrtime.bigint();
-
-    // Use res.on('finish') for Express
-    res.on('finish', () => {
-      const endTime = process.hrtime.bigint();
-      const latencyMs = Number(endTime - startTime) / 1e6;
-
-      // Express populates req.route after routing
-      const route = extractRoute(req);
-      const method = req.method || 'GET';
-      const statusCode = res.statusCode || 200;
-      const isError = statusCode >= 400;
-
-      const aggregator = getAggregator();
-      aggregator.recordRequest(method, route, latencyMs, isError);
-
-      debug(`Express: ${method} ${route} ${statusCode} ${latencyMs.toFixed(2)}ms`);
-    });
-
-    next();
-  };
-}
-
-/**
- * Create Fastify plugin for instrumentation
- */
-export function fastifyPlugin(fastify, options, done) {
-  fastify.addHook('onRequest', async (request, reply) => {
-    request.sentienguardStart = process.hrtime.bigint();
-  });
-
-  fastify.addHook('onResponse', async (request, reply) => {
-    const endTime = process.hrtime.bigint();
-    const startTime = request.sentienguardStart || endTime;
-    const latencyMs = Number(endTime - startTime) / 1e6;
-
-    const route = extractRoute(request);
-    const method = request.method || 'GET';
-    const statusCode = reply.statusCode || 200;
-    const isError = statusCode >= 400;
-
-    const aggregator = getAggregator();
-    aggregator.recordRequest(method, route, latencyMs, isError);
-
-    debug(`Fastify: ${method} ${route} ${statusCode} ${latencyMs.toFixed(2)}ms`);
-  });
-
-  done();
-}
-
-// Mark as fastify plugin
-fastifyPlugin[Symbol.for('skip-override')] = true;
-
-/**
- * Remove instrumentation (for testing/cleanup)
- */
-export function uninstrumentHttp() {
-  if (!isInstrumented) return;
-
-  if (originalHttpCreateServer) {
-    http.createServer = originalHttpCreateServer;
-  }
-  if (originalHttpsCreateServer) {
-    https.createServer = originalHttpsCreateServer;
-  }
-
-  isInstrumented = false;
-  debug('HTTP instrumentation disabled');
-}
-
-export default {
-  instrumentHttp,
-  expressMiddleware,
-  fastifyPlugin,
-  uninstrumentHttp
-};
+/**
+ * HTTP Request Auto-Instrumentation
+ * Automatically instruments incoming HTTP requests for Express, Fastify, and plain Node.js http.
+ *
+ * Captures:
+ * - Method
+ * - Normalized route
+ * - Status code
+ * - Response time
+ * - Error flag
+ */
+
+import http from 'http';
+import https from 'https';
+import { extractRoute } from './normalizer.js';
+import { getAggregator } from './aggregator.js';
+import { debug } from './config.js';
+
+let isInstrumented = false;
+let originalHttpCreateServer = null;
+let originalHttpsCreateServer = null;
+
+/**
+ * Wrap a request handler to capture metrics
+ */
+function wrapRequestHandler(handler) {
+  return function wrappedHandler(req, res) {
+    const startTime = process.hrtime.bigint();
+
+    // Store original end method
+    const originalEnd = res.end;
+
+    // Override res.end to capture timing
+    res.end = function (...args) {
+      const endTime = process.hrtime.bigint();
+      const latencyMs = Number(endTime - startTime) / 1e6; // Convert nanoseconds to milliseconds
+
+      // Extract route (after response, frameworks may have populated route info)
+      const route = extractRoute(req);
+      const method = req.method || 'GET';
+      const statusCode = res.statusCode || 200;
+      const isError = statusCode >= 400;
+
+      // Record the metric
+      const aggregator = getAggregator();
+      aggregator.recordRequest(method, route, latencyMs, isError);
+
+      debug(`Request: ${method} ${route} ${statusCode} ${latencyMs.toFixed(2)}ms`);
+
+      // Call original end
+      return originalEnd.apply(this, args);
+    };
+
+    // Call original handler
+    return handler.call(this, req, res);
+  };
+}
+
+/**
+ * Wrap a server's request listener
+ */
+function wrapServer(server) {
+  const listeners = server.listeners('request');
+
+  // Remove existing listeners
+  server.removeAllListeners('request');
+
+  // Re-add wrapped listeners
+  for (const listener of listeners) {
+    server.on('request', wrapRequestHandler(listener));
+  }
+
+  // Also wrap future listeners
+  const originalOn = server.on.bind(server);
+  server.on = function (event, listener) {
+    if (event === 'request') {
+      return originalOn(event, wrapRequestHandler(listener));
+    }
+    return originalOn(event, listener);
+  };
+
+  return server;
+}
+
+/**
+ * Create instrumented http.createServer
+ */
+function createInstrumentedCreateServer(original, protocol) {
+  return function instrumentedCreateServer(...args) {
+    const server = original.apply(this, args);
+
+    // If a request handler was passed, it's already attached
+    // We need to wrap the server after creation
+    setImmediate(() => {
+      wrapServer(server);
+      debug(`${protocol} server instrumented`);
+    });
+
+    return server;
+  };
+}
+
+/**
+ * Instrument Node.js HTTP module
+ * This is the core instrumentation that works with any framework
+ */
+export function instrumentHttp() {
+  if (isInstrumented) {
+    debug('HTTP already instrumented, skipping');
+    return;
+  }
+
+  // Store originals for cleanup
+  originalHttpCreateServer = http.createServer;
+  originalHttpsCreateServer = https.createServer;
+
+  // Patch http.createServer
+  http.createServer = createInstrumentedCreateServer(originalHttpCreateServer, 'HTTP');
+
+  // Patch https.createServer
+  https.createServer = createInstrumentedCreateServer(originalHttpsCreateServer, 'HTTPS');
+
+  isInstrumented = true;
+  debug('HTTP instrumentation enabled');
+}
+
+/**
+ * Create Express middleware for more accurate route extraction
+ * This is optional but provides better route patterns
+ */
+export function expressMiddleware() {
+  return function sentienguardMiddleware(req, res, next) {
+    const startTime = process.hrtime.bigint();
+
+    // Use res.on('finish') for Express
+    res.on('finish', () => {
+      const endTime = process.hrtime.bigint();
+      const latencyMs = Number(endTime - startTime) / 1e6;
+
+      // Express populates req.route after routing
+      const route = extractRoute(req);
+      const method = req.method || 'GET';
+      const statusCode = res.statusCode || 200;
+      const isError = statusCode >= 400;
+
+      const aggregator = getAggregator();
+      aggregator.recordRequest(method, route, latencyMs, isError);
+
+      debug(`Express: ${method} ${route} ${statusCode} ${latencyMs.toFixed(2)}ms`);
+    });
+
+    next();
+  };
+}
+
+/**
+ * Create Fastify plugin for instrumentation
+ */
+export function fastifyPlugin(fastify, options, done) {
+  fastify.addHook('onRequest', async (request, reply) => {
+    request.sentienguardStart = process.hrtime.bigint();
+  });
+
+  fastify.addHook('onResponse', async (request, reply) => {
+    const endTime = process.hrtime.bigint();
+    const startTime = request.sentienguardStart || endTime;
+    const latencyMs = Number(endTime - startTime) / 1e6;
+
+    const route = extractRoute(request);
+    const method = request.method || 'GET';
+    const statusCode = reply.statusCode || 200;
+    const isError = statusCode >= 400;
+
+    const aggregator = getAggregator();
+    aggregator.recordRequest(method, route, latencyMs, isError);
+
+    debug(`Fastify: ${method} ${route} ${statusCode} ${latencyMs.toFixed(2)}ms`);
+  });
+
+  done();
+}
+
+// Mark as fastify plugin
+fastifyPlugin[Symbol.for('skip-override')] = true;
+
+/**
+ * Remove instrumentation (for testing/cleanup)
+ */
+export function uninstrumentHttp() {
+  if (!isInstrumented) return;
+
+  if (originalHttpCreateServer) {
+    http.createServer = originalHttpCreateServer;
+  }
+  if (originalHttpsCreateServer) {
+    https.createServer = originalHttpsCreateServer;
+  }
+
+  isInstrumented = false;
+  debug('HTTP instrumentation disabled');
+}
+
+export default {
+  instrumentHttp,
+  expressMiddleware,
+  fastifyPlugin,
+  uninstrumentHttp
+};