@himanshu-panchal/nodescope-sdk 1.0.0

package/auto-detect.js

@@ -0,0 +1,51 @@
+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');
+
+function autoDetectAndPatch() {
+  const patched = [];
+
+  // PostgreSQL detect
+  try {
+    const pg = require('pg');
+    patchPg(pg);
+    patched.push('postgresql');
+  } catch (e) { /* not installed */ }
+
+  // MySQL detect
+  try {
+    const mysql = require('mysql2');
+    patchMysql(mysql);
+    patched.push('mysql');
+  } catch (e) {
+    try {
+      const mysql = require('mysql');
+      patchMysql(mysql);
+      patched.push('mysql');
+    } catch (e) { /* not installed */ }
+  }
+
+  // MongoDB/Mongoose detect
+  try {
+    const mongoose = require('mongoose');
+    patchMongoose(mongoose);
+    patched.push('mongodb');
+  } catch (e) { /* not installed */ }
+
+  // Axios detect
+  try {
+    const axios = require('axios');
+    patchAxios(axios);
+    patched.push('axios');
+  } catch (e) { /* not installed */ }
+
+  if (patched.length > 0) {
+    console.log(`✅ NodeScope: Auto-detected [${patched.join(', ')}]`);
+  }
+
+  return patched;
+}
+
+module.exports = { autoDetectAndPatch };

package/context.js

@@ -0,0 +1,51 @@
+const { AsyncLocalStorage } = require('async_hooks');
+
+const storage = new AsyncLocalStorage();
+
+class Context {
+  static run(traceId, requestId, route, method, callback) {
+    const store = {
+      traceId,
+      requestId,
+      route,
+      method,
+      startTime: Date.now(),
+      spans: new Map(),
+      currentSpanId: null,
+    };
+    return storage.run(store, callback);
+  }
+
+  static getStore() {
+    return storage.getStore();
+  }
+
+  static getTraceId() {
+    return storage.getStore()?.traceId;
+  }
+
+  static addSpan(span) {
+    const store = storage.getStore();
+    if (store) store.spans.set(span.id, span);
+  }
+
+  static getSpan(spanId) {
+    return storage.getStore()?.spans.get(spanId);
+  }
+
+  static getAllSpans() {
+    const store = storage.getStore();
+    return store ? Array.from(store.spans.values()) : [];
+  }
+
+  static setCurrentSpanId(spanId) {
+    const store = storage.getStore();
+    if (store) store.currentSpanId = spanId;
+  }
+
+  static getCurrentSpanId() {
+    return storage.getStore()?.currentSpanId;
+  }
+}
+
+module.exports = { Context };

package/index.js

@@ -0,0 +1,75 @@
+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)
+  if (!autoDetectDone) {
+    autoDetectDone = true;
+    // Tracer pehle init karo
+    getInstance(config);
+    // Phir auto detect
+    setTimeout(() => autoDetectAndPatch(), 100);
+  }
+
+  return createMiddleware(config);
+}
+
+// Manual deep trace wrapper
+function trace(fn) {
+  return function (...args) {
+    const tracer = getInstance();
+    const traceId = Context.getTraceId();
+
+    if (!tracer || !traceId) {
+      return fn.apply(this, args);
+    }
+
+    const spanId = uuidv4();
+    const name = fn.name || 'anonymous';
+
+    tracer.startSpan(spanId, traceId, name, 'internal');
+
+    let result;
+    try {
+      result = fn.apply(this, args);
+    } catch (err) {
+      tracer.endSpan(spanId, err);
+      throw err;
+    }
+
+    if (result?.then) {
+      return result
+        .then((res) => { tracer.endSpan(spanId); return res; })
+        .catch((err) => { tracer.endSpan(spanId, err); throw err; });
+    }
+
+    tracer.endSpan(spanId);
+    return result;
+  };
+}
+
+// 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;

package/middleware.js

@@ -0,0 +1,68 @@
+const { v4: uuidv4 } = require('uuid');
+const { Context } = require('./context');
+const { getInstance } = require('./tracer');
+
+function createMiddleware(config) {
+  const tracer = getInstance(config);
+
+  return function nodeScopeMiddleware(req, res, next) {
+    // Health check skip karo
+    if (req.path === '/health' || req.path === '/ping') {
+      return next();
+    }
+
+    const traceId = uuidv4();
+    const requestId = uuidv4();
+
+    tracer.startTrace(traceId, req.method, req.path);
+
+    Context.run(traceId, requestId, req.path, req.method, () => {
+      req.nodescope = {
+        traceId,
+        startSpan: (name) => {
+          const spanId = uuidv4();
+          tracer.startSpan(spanId, traceId, name, 'internal');
+          return {
+            end: (error) => tracer.endSpan(spanId, error),
+            setAttribute: (key, value) => tracer.addAttribute(spanId, key, value),
+          };
+        },
+      };
+
+      const metadata = {
+        ip: req.ip || req.connection?.remoteAddress,
+        userAgent: req.get('user-agent'),
+        query: Object.keys(req.query).length ? req.query : undefined,
+        route: req.route?.path,
+      };
+
+      let ended = false;
+
+      function endTrace() {
+        if (!ended) {
+          ended = true;
+          tracer.endTrace(traceId, res.statusCode, metadata);
+        }
+      }
+
+      const originalJson = res.json.bind(res);
+      const originalSend = res.send.bind(res);
+
+      res.json = function (data) {
+        endTrace();
+        return originalJson(data);
+      };
+
+      res.send = function (data) {
+        endTrace();
+        return originalSend(data);
+      };
+
+      res.on('finish', endTrace);
+
+      next();
+    });
+  };
+}
+
+module.exports = { createMiddleware };

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@himanshu-panchal/nodescope-sdk",
+  "version": "1.0.0",
+  "description": "Universal Node.js observability SDK - works with any project",
+  "main": "index.js",
+  "scripts": {
+    "start": "node index.js"
+  },
+  "keywords": [
+    "observability",
+    "tracing",
+    "monitoring",
+    "nodejs",
+    "express",
+    "postgresql",
+    "mongodb",
+    "mysql",
+    "redis",
+    "apm"
+  ],
+  "author": "Himanshu Panchal",
+  "license": "MIT",
+  "dependencies": {
+    "socket.io-client": "^4.6.1",
+    "uuid": "^9.0.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/YOUR_USERNAME/nodescope-sdk"
+  },
+  "peerDependencies": {
+    "express": ">=4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "express": { "optional": true },
+    "pg": { "optional": true },
+    "mysql2": { "optional": true },
+    "mongoose": { "optional": true },
+    "redis": { "optional": true },
+    "axios": { "optional": true }
+  }
+}

package/patches/axios.js

@@ -0,0 +1,60 @@
+const { v4: uuidv4 } = require('uuid');
+const { Context } = require('../context');
+const { getInstance } = require('../tracer');
+
+function patchAxios(axios) {
+  if (!axios || axios.__nodescope_patched__) return axios;
+
+  // Request interceptor
+  axios.interceptors.request.use((config) => {
+    const tracer = getInstance();
+    const traceId = Context.getTraceId();
+
+    if (!tracer || !traceId) return config;
+
+    const spanId = uuidv4();
+    const method = (config.method || 'GET').toUpperCase();
+    const url = config.url || '';
+
+    tracer.startSpan(spanId, traceId, `http.${method} ${url}`, 'client');
+    tracer.addAttribute(spanId, 'http.method', method);
+    tracer.addAttribute(spanId, 'http.url', url);
+    tracer.addAttribute(spanId, 'http.base_url', config.baseURL || '');
+
+    config._nodescope_spanId = spanId;
+    return config;
+  });
+
+  // Response interceptor
+  axios.interceptors.response.use(
+    (response) => {
+      const tracer = getInstance();
+      const spanId = response.config?._nodescope_spanId;
+
+      if (tracer && spanId) {
+        tracer.addAttribute(spanId, 'http.status_code', response.status);
+        tracer.addAttribute(spanId, 'http.response_size', JSON.stringify(response.data || '').length);
+        tracer.endSpan(spanId);
+      }
+
+      return response;
+    },
+    (error) => {
+      const tracer = getInstance();
+      const spanId = error.config?._nodescope_spanId;
+
+      if (tracer && spanId) {
+        tracer.addAttribute(spanId, 'http.status_code', error.response?.status || 0);
+        tracer.endSpan(spanId, error);
+      }
+
+      throw error;
+    }
+  );
+
+  axios.__nodescope_patched__ = true;
+  console.log('✅ NodeScope: Axios instrumented');
+  return axios;
+}
+
+module.exports = { patchAxios };

package/patches/mongoose.js

@@ -0,0 +1,57 @@
+const { v4: uuidv4 } = require('uuid');
+const { Context } = require('../context');
+const { getInstance } = require('../tracer');
+
+function patchMongoose(mongoose) {
+  if (!mongoose || mongoose.__nodescope_patched__) return mongoose;
+
+  // Mongoose middleware plugin use karo
+  mongoose.plugin(function nodeScopePlugin(schema) {
+    const ops = [
+      'find', 'findOne', 'findOneAndUpdate', 'findOneAndDelete',
+      'save', 'updateOne', 'updateMany', 'deleteOne', 'deleteMany',
+      'countDocuments', 'aggregate',
+    ];
+
+    ops.forEach((op) => {
+      schema.pre(op, function () {
+        const tracer = getInstance();
+        const traceId = Context.getTraceId();
+        if (!tracer || !traceId) return;
+
+        const spanId = uuidv4();
+        const modelName = this?.model?.modelName || this?.modelName || 'Model';
+
+        this._nodescope_spanId = spanId;
+
+        tracer.startSpan(spanId, traceId, `mongo.${op} ${modelName}`, 'client');
+        tracer.addAttribute(spanId, 'db.system', 'mongodb');
+        tracer.addAttribute(spanId, 'db.operation', op);
+        tracer.addAttribute(spanId, 'db.collection', modelName);
+      });
+
+      schema.post(op, function (result) {
+        const tracer = getInstance();
+        const spanId = this._nodescope_spanId;
+        if (!tracer || !spanId) return;
+
+        const count = Array.isArray(result) ? result.length : result ? 1 : 0;
+        tracer.addAttribute(spanId, 'db.rows_returned', count);
+        tracer.endSpan(spanId);
+      });
+
+      schema.post(op, function (err, result, next) {
+        const tracer = getInstance();
+        const spanId = this._nodescope_spanId;
+        if (tracer && spanId) tracer.endSpan(spanId, err);
+        if (next) next(err);
+      });
+    });
+  });
+
+  mongoose.__nodescope_patched__ = true;
+  console.log('✅ NodeScope: MongoDB/Mongoose instrumented');
+  return mongoose;
+}
+
+module.exports = { patchMongoose };

package/patches/mysql.js

@@ -0,0 +1,62 @@
+const { v4: uuidv4 } = require('uuid');
+const { Context } = require('../context');
+const { getInstance } = require('../tracer');
+
+function patchMysql(mysql) {
+  if (!mysql || mysql.__nodescope_patched__) return mysql;
+
+  const originalCreateConnection = mysql.createConnection;
+  const originalCreatePool = mysql.createPool;
+
+  function patchConnection(conn) {
+    const originalQuery = conn.query.bind(conn);
+
+    conn.query = function (sql, params, callback) {
+      const tracer = getInstance();
+      const traceId = Context.getTraceId();
+
+      if (!tracer || !traceId) {
+        return originalQuery(sql, params, callback);
+      }
+
+      const spanId = uuidv4();
+      const queryText = typeof sql === 'string' ? sql : sql?.sql || '';
+      const operation = queryText.trim().split(/\s+/)[0].toUpperCase();
+      const tableMatch = queryText.match(/(?:FROM|INTO|UPDATE|TABLE)\s+`?(\w+)`?/i);
+      const table = tableMatch ? tableMatch[1] : 'unknown';
+
+      tracer.startSpan(spanId, traceId, `mysql.${operation} ${table}`, 'client');
+      tracer.addAttribute(spanId, 'db.system', 'mysql');
+      tracer.addAttribute(spanId, 'db.operation', operation);
+      tracer.addAttribute(spanId, 'db.table', table);
+      tracer.addAttribute(spanId, 'db.query', queryText.substring(0, 300));
+
+      const startTime = Date.now();
+
+      return originalQuery(sql, params, (err, results) => {
+        if (err) {
+          tracer.endSpan(spanId, err);
+        } else {
+          tracer.addAttribute(spanId, 'db.rows_returned', Array.isArray(results) ? results.length : 0);
+          tracer.endSpan(spanId);
+        }
+        if (callback) callback(err, results);
+      });
+    };
+
+    return conn;
+  }
+
+  if (originalCreateConnection) {
+    mysql.createConnection = function (...args) {
+      const conn = originalCreateConnection.apply(this, args);
+      return patchConnection(conn);
+    };
+  }
+
+  mysql.__nodescope_patched__ = true;
+  console.log('✅ NodeScope: MySQL instrumented');
+  return mysql;
+}
+
+module.exports = { patchMysql };

package/patches/pg.js

@@ -0,0 +1,73 @@
+const { v4: uuidv4 } = require('uuid');
+const { Context } = require('../context');
+const { getInstance } = require('../tracer');
+
+function patchPg(pg) {
+  if (!pg || pg.__nodescope_patched__) return pg;
+
+  function patch(ClientClass) {
+    if (!ClientClass?.prototype?.query) return;
+
+    const original = ClientClass.prototype.query;
+
+    ClientClass.prototype.query = function (...args) {
+      const tracer = getInstance();
+      const traceId = Context.getTraceId();
+
+      if (!tracer || !traceId) {
+        return original.apply(this, args);
+      }
+
+      const spanId = uuidv4();
+      let queryText = '';
+      let queryParams = [];
+
+      if (typeof args[0] === 'string') {
+        queryText = args[0];
+        queryParams = args[1] || [];
+      } else if (args[0]?.text) {
+        queryText = args[0].text;
+        queryParams = args[0].values || [];
+      }
+
+      // Operation aur table detect karo
+      const operation = queryText.trim().split(/\s+/)[0].toUpperCase() || 'QUERY';
+      const tableMatch = queryText.match(/(?:FROM|INTO|UPDATE|TABLE|JOIN)\s+["']?(\w+)["']?/i);
+      const table = tableMatch ? tableMatch[1] : 'unknown';
+
+      tracer.startSpan(spanId, traceId, `pg.${operation} ${table}`, 'client');
+      tracer.addAttribute(spanId, 'db.system', 'postgresql');
+      tracer.addAttribute(spanId, 'db.operation', operation);
+      tracer.addAttribute(spanId, 'db.table', table);
+      tracer.addAttribute(spanId, 'db.query', queryText.substring(0, 300));
+      tracer.addAttribute(spanId, 'db.params_count', queryParams.length);
+
+      const result = original.apply(this, args);
+
+      if (result?.then) {
+        return result
+          .then((res) => {
+            tracer.addAttribute(spanId, 'db.rows_returned', res?.rows?.length ?? 0);
+            tracer.endSpan(spanId);
+            return res;
+          })
+          .catch((err) => {
+            tracer.endSpan(spanId, err);
+            throw err;
+          });
+      }
+
+      tracer.endSpan(spanId);
+      return result;
+    };
+  }
+
+  if (pg.Pool) patch(pg.Pool);
+  if (pg.Client) patch(pg.Client);
+
+  pg.__nodescope_patched__ = true;
+  console.log('✅ NodeScope: PostgreSQL instrumented');
+  return pg;
+}
+
+module.exports = { patchPg };

package/patches/redis.js

@@ -0,0 +1,44 @@
+const { v4: uuidv4 } = require('uuid');
+const { Context } = require('../context');
+const { getInstance } = require('../tracer');
+
+function patchRedis(redisClient) {
+  if (!redisClient || redisClient.__nodescope_patched__) return redisClient;
+
+  // Redis v4 (modern)
+  if (redisClient.sendCommand) {
+    const original = redisClient.sendCommand.bind(redisClient);
+
+    redisClient.sendCommand = async function (args) {
+      const tracer = getInstance();
+      const traceId = Context.getTraceId();
+
+      if (!tracer || !traceId) return original(args);
+
+      const spanId = uuidv4();
+      const command = Array.isArray(args) ? args[0] : 'CMD';
+      const key = Array.isArray(args) && args[1] ? String(args[1]).substring(0, 50) : '';
+
+      tracer.startSpan(spanId, traceId, `redis.${command} ${key}`.trim(), 'client');
+      tracer.addAttribute(spanId, 'db.system', 'redis');
+      tracer.addAttribute(spanId, 'db.operation', command);
+      if (key) tracer.addAttribute(spanId, 'db.key', key);
+
+      try {
+        const result = await original(args);
+        tracer.addAttribute(spanId, 'cache.hit', result !== null && result !== undefined);
+        tracer.endSpan(spanId);
+        return result;
+      } catch (err) {
+        tracer.endSpan(spanId, err);
+        throw err;
+      }
+    };
+  }
+
+  redisClient.__nodescope_patched__ = true;
+  console.log('✅ NodeScope: Redis instrumented');
+  return redisClient;
+}
+
+module.exports = { patchRedis };

package/tracer.js

@@ -0,0 +1,160 @@
+const { io } = require('socket.io-client');
+const { Context } = require('./context');
+
+class Tracer {
+  constructor(config) {
+    this.config = {
+      serverUrl: config.serverUrl || 'http://localhost:3001',
+      appName: config.appName || 'my-app',
+      environment: config.environment || 'development',
+      enabled: config.enabled !== false,
+    };
+
+    this.socket = null;
+    this.connected = false;
+    this.buffer = [];
+    this.traces = new Map();
+
+    if (this.config.enabled) {
+      this._connect();
+    }
+  }
+
+  _connect() {
+    try {
+      this.socket = io(this.config.serverUrl, {
+        auth: {
+          appName: this.config.appName,
+          environment: this.config.environment,
+        },
+        reconnection: true,
+        reconnectionDelay: 2000,
+        timeout: 5000,
+      });
+
+      this.socket.on('connect', () => {
+        console.log(`✅ NodeScope connected → ${this.config.serverUrl}`);
+        this.connected = true;
+        this._flushBuffer();
+      });
+
+      this.socket.on('disconnect', () => {
+        console.log('⚠️  NodeScope disconnected');
+        this.connected = false;
+      });
+
+      this.socket.on('connect_error', (err) => {
+        // Silent fail - app ko affect na kare
+      });
+
+    } catch (err) {
+      // Silent fail
+    }
+  }
+
+  _send(trace) {
+    if (this.connected && this.socket) {
+      this.socket.emit('trace', trace);
+    } else {
+      this.buffer.push(trace);
+      if (this.buffer.length > 500) this.buffer.shift();
+    }
+  }
+
+  _flushBuffer() {
+    if (this.buffer.length > 0) {
+      this.buffer.forEach(trace => this.socket.emit('trace', trace));
+      this.buffer = [];
+    }
+  }
+
+  startTrace(traceId, method, path) {
+    this.traces.set(traceId, {
+      traceId,
+      method,
+      path,
+      startTime: Date.now(),
+    });
+  }
+
+  endTrace(traceId, statusCode, metadata) {
+    const trace = this.traces.get(traceId);
+    if (!trace) return;
+
+    const now = Date.now();
+    const fullTrace = {
+      traceId: trace.traceId,
+      method: trace.method,
+      path: trace.path,
+      statusCode,
+      startTime: trace.startTime,
+      endTime: now,
+      duration: now - trace.startTime,
+      spans: Context.getAllSpans(),
+      metadata: metadata || {},
+    };
+
+    this._send(fullTrace);
+    this.traces.delete(traceId);
+  }
+
+  startSpan(spanId, traceId, name, kind, parentId) {
+    const span = {
+      id: spanId,
+      traceId,
+      parentId: parentId || Context.getCurrentSpanId() || undefined,
+      name,
+      kind: kind || 'internal',
+      timestamp: Date.now(),
+      duration: 0,
+      attributes: {},
+      status: 'ok',
+      events: [],
+    };
+
+    Context.addSpan(span);
+    Context.setCurrentSpanId(spanId);
+    return span;
+  }
+
+  endSpan(spanId, error) {
+    const span = Context.getSpan(spanId);
+    if (!span) return;
+
+    span.duration = Date.now() - span.timestamp;
+
+    if (error) {
+      span.status = 'error';
+      span.error = {
+        message: error.message,
+        stack: error.stack,
+        type: error.name,
+      };
+    }
+
+    if (span.parentId) {
+      Context.setCurrentSpanId(span.parentId);
+    }
+  }
+
+  addAttribute(spanId, key, value) {
+    const span = Context.getSpan(spanId);
+    if (span) span.attributes[key] = value;
+  }
+}
+
+// Singleton instance
+let instance = null;
+
+function getInstance(config) {
+  if (!instance && config) {
+    instance = new Tracer(config);
+  }
+  return instance;
+}
+
+function resetInstance() {
+  instance = null;
+}
+
+module.exports = { Tracer, getInstance, resetInstance };