@himanshu-panchal/nodescope-sdk 1.0.0 → 1.0.1

package/index.js

@@ -2,30 +2,29 @@ const { createMiddleware } = require('./middleware');
 const { getInstance } = require('./tracer');
 const { Context } = require('./context');
 const { autoDetectAndPatch } = require('./auto-detect');
-const { patchPg } = require('./patches/pg');
-const { patchMysql } = require('./patches/mysql');
-const { patchMongoose } = require('./patches/mongoose');
-const { patchRedis } = require('./patches/redis');
-const { patchAxios } = require('./patches/axios');
 const { v4: uuidv4 } = require('uuid');
 
 let autoDetectDone = false;
 
-// Main function
-function nodescope(config) {
-  // Auto detect libraries (ek baar)
+function nodescope(config = {}) {
+  // Enhanced default config
+  const enhancedConfig = {
+    ...config,
+    captureHeaders: config.captureHeaders || false,
+    captureBody: config.captureBody || false,
+    captureResponse: config.captureResponse || false,
+    captureQueries: config.captureQueries !== false, // true by default
+  };
+
   if (!autoDetectDone) {
     autoDetectDone = true;
-    // Tracer pehle init karo
-    getInstance(config);
-    // Phir auto detect
+    getInstance(enhancedConfig);
     setTimeout(() => autoDetectAndPatch(), 100);
   }
 
-  return createMiddleware(config);
+  return createMiddleware(enhancedConfig);
 }
 
-// Manual deep trace wrapper
 function trace(fn) {
   return function (...args) {
     const tracer = getInstance();
@@ -40,6 +39,20 @@ function trace(fn) {
 
     tracer.startSpan(spanId, traceId, name, 'internal');
 
+    // Capture function arguments (safely)
+    if (args.length > 0) {
+      const safeArgs = args.map((arg, i) => {
+        if (typeof arg === 'object' && arg !== null) {
+          // Truncate large objects
+          return JSON.stringify(arg).length > 500 
+            ? `[Object: ${Object.keys(arg).length} keys]` 
+            : arg;
+        }
+        return arg;
+      });
+      tracer.addAttribute(spanId, 'function.arguments', safeArgs);
+    }
+
     let result;
     try {
       result = fn.apply(this, args);
@@ -50,8 +63,33 @@ function trace(fn) {
 
     if (result?.then) {
       return result
-        .then((res) => { tracer.endSpan(spanId); return res; })
-        .catch((err) => { tracer.endSpan(spanId, err); throw err; });
+        .then((res) => {
+          // Capture return value (safely)
+          if (res !== undefined) {
+            const safeResult = typeof res === 'object' && res !== null
+              ? JSON.stringify(res).length > 500 
+                ? `[Object: ${Object.keys(res).length} keys]`
+                : res
+              : res;
+            tracer.addAttribute(spanId, 'function.result', safeResult);
+          }
+          tracer.endSpan(spanId);
+          return res;
+        })
+        .catch((err) => {
+          tracer.endSpan(spanId, err);
+          throw err;
+        });
+    }
+
+    // Capture synchronous return value
+    if (result !== undefined) {
+      const safeResult = typeof result === 'object' && result !== null
+        ? JSON.stringify(result).length > 500 
+          ? `[Object: ${Object.keys(result).length} keys]`
+          : result
+        : result;
+      tracer.addAttribute(spanId, 'function.result', safeResult);
     }
 
     tracer.endSpan(spanId);
@@ -59,17 +97,7 @@ function trace(fn) {
   };
 }
 
-// Exports
 module.exports = nodescope;
-
-// Named exports for manual use
 module.exports.nodescope = nodescope;
 module.exports.trace = trace;
-module.exports.Context = Context;
-
-// Manual patches (agar auto-detect kaam na kare)
-module.exports.patchPg = patchPg;
-module.exports.patchMysql = patchMysql;
-module.exports.patchMongoose = patchMongoose;
-module.exports.patchRedis = patchRedis;
-module.exports.patchAxios = patchAxios;
+module.exports.Context = Context;

package/middleware.js

@@ -2,21 +2,25 @@ const { v4: uuidv4 } = require('uuid');
 const { Context } = require('./context');
 const { getInstance } = require('./tracer');
 
-function createMiddleware(config) {
+function createMiddleware(config = {}) {
   const tracer = getInstance(config);
 
   return function nodeScopeMiddleware(req, res, next) {
-    // Health check skip karo
-    if (req.path === '/health' || req.path === '/ping') {
+    // Skip health checks and static assets
+    if (req.path === '/health' || req.path === '/ping' || req.path.startsWith('/static')) {
       return next();
     }
 
     const traceId = uuidv4();
     const requestId = uuidv4();
 
+    // Start the main request trace
     tracer.startTrace(traceId, req.method, req.path);
 
+    // Run within AsyncLocalStorage context
     Context.run(traceId, requestId, req.path, req.method, () => {
+      
+      // Attach NodeScope helper to request object
       req.nodescope = {
         traceId,
         startSpan: (name) => {
@@ -25,44 +29,292 @@ function createMiddleware(config) {
           return {
             end: (error) => tracer.endSpan(spanId, error),
             setAttribute: (key, value) => tracer.addAttribute(spanId, key, value),
+            addEvent: (name, attributes) => tracer.addAttribute(spanId, `event.${name}`, attributes || {}),
           };
         },
       };
 
+      // Capture request metadata
       const metadata = {
-        ip: req.ip || req.connection?.remoteAddress,
+        ip: req.ip || req.connection?.remoteAddress || req.socket?.remoteAddress,
         userAgent: req.get('user-agent'),
-        query: Object.keys(req.query).length ? req.query : undefined,
-        route: req.route?.path,
+        route: req.route?.path || req.path,
+        method: req.method,
+        protocol: req.protocol,
+        hostname: req.hostname,
+        originalUrl: req.originalUrl,
+        timestamp: new Date().toISOString(),
       };
 
+      // Capture query parameters
+      if (req.query && Object.keys(req.query).length > 0) {
+        metadata.query = req.query;
+      }
+
+      // Capture request headers (with masking)
+      if (config.captureHeaders) {
+        metadata.headers = maskSensitiveHeaders(req.headers, config.mask || []);
+      }
+
+      // Capture request body (with size limit and masking)
+      if (config.captureBody && req.body) {
+        metadata.body = maskSensitiveData(req.body, config.mask || []);
+      }
+
+      // Capture request size
+      const contentLength = req.get('content-length');
+      if (contentLength) {
+        metadata.requestSize = parseInt(contentLength);
+      }
+
+      // Response tracking variables
       let ended = false;
+      let responseBody = null;
+      let responseStartTime = Date.now();
 
       function endTrace() {
-        if (!ended) {
-          ended = true;
-          tracer.endTrace(traceId, res.statusCode, metadata);
+        if (ended) return;
+        ended = true;
+
+        // Calculate response time
+        const responseTime = Date.now() - responseStartTime;
+
+        // Add response metadata
+        const responseMetadata = {
+          ...metadata,
+          responseTime,
+          statusCode: res.statusCode,
+          statusMessage: res.statusMessage,
+        };
+
+        // Capture response headers
+        if (config.captureHeaders) {
+          responseMetadata.responseHeaders = res.getHeaders();
+        }
+
+        // Capture response body
+        if (config.captureResponse && responseBody !== null) {
+          responseMetadata.responseBody = maskSensitiveData(responseBody, config.mask || []);
         }
+
+        // Capture response size
+        const responseLength = res.get('content-length');
+        if (responseLength) {
+          responseMetadata.responseSize = parseInt(responseLength);
+        }
+
+        // End the trace with all metadata
+        tracer.endTrace(traceId, res.statusCode, responseMetadata);
       }
 
+      // Intercept response methods
       const originalJson = res.json.bind(res);
       const originalSend = res.send.bind(res);
+      const originalEnd = res.end.bind(res);
 
+      // Override res.json()
       res.json = function (data) {
+        if (config.captureResponse && data !== undefined) {
+          responseBody = data;
+        }
         endTrace();
         return originalJson(data);
       };
 
+      // Override res.send()
       res.send = function (data) {
+        if (config.captureResponse && data !== undefined) {
+          try {
+            // Try to parse as JSON if it's a string
+            responseBody = typeof data === 'string' ? JSON.parse(data) : data;
+          } catch (e) {
+            // If not JSON, store as string (truncated if too long)
+            responseBody = typeof data === 'string' && data.length > 1000 
+              ? data.substring(0, 1000) + '...[truncated]'
+              : data;
+          }
+        }
         endTrace();
         return originalSend(data);
       };
 
-      res.on('finish', endTrace);
+      // Override res.end()
+      res.end = function (chunk, encoding) {
+        if (config.captureResponse && chunk && !responseBody) {
+          try {
+            responseBody = chunk.toString();
+            if (responseBody.length > 1000) {
+              responseBody = responseBody.substring(0, 1000) + '...[truncated]';
+            }
+          } catch (e) {
+            responseBody = '[Binary data]';
+          }
+        }
+        endTrace();
+        return originalEnd(chunk, encoding);
+      };
+
+      // Handle response finish event as fallback
+      res.on('finish', () => {
+        endTrace();
+      });
+
+      // Handle response close event (for aborted requests)
+      res.on('close', () => {
+        if (!res.headersSent) {
+          endTrace();
+        }
+      });
+
+      // Error handling
+      res.on('error', (error) => {
+        metadata.error = {
+          message: error.message,
+          stack: error.stack,
+          type: error.name,
+        };
+        endTrace();
+      });
 
+      // Continue to next middleware
       next();
     });
   };
 }
 
-module.exports = { createMiddleware };
+// Helper function to mask sensitive headers
+function maskSensitiveHeaders(headers, maskKeys = []) {
+  const sensitiveKeys = [
+    'authorization', 'cookie', 'set-cookie', 'x-api-key', 
+    'x-auth-token', 'auth-token', 'access-token', 'refresh-token',
+    'x-csrf-token', 'csrf-token', 'session-id', 'sessionid',
+    ...maskKeys
+  ];
+
+  const masked = {};
+  
+  for (const [key, value] of Object.entries(headers)) {
+    const lowerKey = key.toLowerCase();
+    const shouldMask = sensitiveKeys.some(sensitive => 
+      lowerKey.includes(sensitive.toLowerCase())
+    );
+    
+    if (shouldMask) {
+      masked[key] = '***MASKED***';
+    } else {
+      // Truncate very long header values
+      masked[key] = typeof value === 'string' && value.length > 200
+        ? value.substring(0, 200) + '...[truncated]'
+        : value;
+    }
+  }
+  
+  return masked;
+}
+
+// Helper function to mask sensitive data in objects
+function maskSensitiveData(data, maskKeys = []) {
+  if (!data || typeof data !== 'object') {
+    return data;
+  }
+
+  const sensitiveKeys = [
+    'password', 'passwd', 'pwd', 'secret', 'token', 'key', 'auth',
+    'authorization', 'cookie', 'session', 'csrf', 'ssn', 'social',
+    'credit', 'card', 'cvv', 'pin', 'otp', 'email', 'phone', 'mobile',
+    ...maskKeys
+  ];
+
+  function maskObject(obj) {
+    if (Array.isArray(obj)) {
+      return obj.map(item => maskObject(item));
+    }
+
+    if (obj === null || typeof obj !== 'object') {
+      return obj;
+    }
+
+    const masked = {};
+    
+    for (const [key, value] of Object.entries(obj)) {
+      const lowerKey = key.toLowerCase();
+      const shouldMask = sensitiveKeys.some(sensitive => 
+        lowerKey.includes(sensitive.toLowerCase())
+      );
+
+      if (shouldMask) {
+        masked[key] = '***MASKED***';
+      } else if (typeof value === 'object' && value !== null) {
+        masked[key] = maskObject(value);
+      } else if (typeof value === 'string' && value.length > 1000) {
+        // Truncate very long strings
+        masked[key] = value.substring(0, 1000) + '...[truncated]';
+      } else {
+        masked[key] = value;
+      }
+    }
+
+    return masked;
+  }
+
+  return maskObject(data);
+}
+
+// Helper function to safely stringify with size limit
+function safeStringify(obj, maxSize = 10000) {
+  try {
+    const str = JSON.stringify(obj, null, 2);
+    return str.length > maxSize 
+      ? str.substring(0, maxSize) + '\n...[truncated]'
+      : str;
+  } catch (error) {
+    return '[Circular reference or non-serializable data]';
+  }
+}
+
+// Helper function to get request size estimate
+function getRequestSizeEstimate(req) {
+  let size = 0;
+  
+  // Headers size
+  if (req.headers) {
+    size += JSON.stringify(req.headers).length;
+  }
+  
+  // Body size
+  if (req.body) {
+    size += JSON.stringify(req.body).length;
+  }
+  
+  // Query size
+  if (req.query && Object.keys(req.query).length > 0) {
+    size += JSON.stringify(req.query).length;
+  }
+  
+  return size;
+}
+
+// Helper function to detect content type
+function getResponseContentType(res) {
+  const contentType = res.get('content-type');
+  if (!contentType) return 'unknown';
+  
+  if (contentType.includes('application/json')) return 'json';
+  if (contentType.includes('text/html')) return 'html';
+  if (contentType.includes('text/plain')) return 'text';
+  if (contentType.includes('application/xml')) return 'xml';
+  if (contentType.includes('image/')) return 'image';
+  if (contentType.includes('video/')) return 'video';
+  if (contentType.includes('audio/')) return 'audio';
+  
+  return 'other';
+}
+
+module.exports = { 
+  createMiddleware,
+  maskSensitiveHeaders,
+  maskSensitiveData,
+  safeStringify,
+  getRequestSizeEstimate,
+  getResponseContentType
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@himanshu-panchal/nodescope-sdk",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Universal Node.js observability SDK - works with any project",
   "main": "index.js",
   "scripts": {
@@ -32,11 +32,23 @@
     "express": ">=4.0.0"
   },
   "peerDependenciesMeta": {
-    "express": { "optional": true },
-    "pg": { "optional": true },
-    "mysql2": { "optional": true },
-    "mongoose": { "optional": true },
-    "redis": { "optional": true },
-    "axios": { "optional": true }
+    "express": {
+      "optional": true
+    },
+    "pg": {
+      "optional": true
+    },
+    "mysql2": {
+      "optional": true
+    },
+    "mongoose": {
+      "optional": true
+    },
+    "redis": {
+      "optional": true
+    },
+    "axios": {
+      "optional": true
+    }
   }
-}
+}