codepulse-sdk 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export interface InitOptions {
+    ingestUrl: string;
+    projectId: string;
+    githubRepo: string;
+    apiKey?: string;
+}
+export declare function init(opts: InitOptions): void;

package/dist/index.js

@@ -0,0 +1,142 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = init;
+const module_1 = __importDefault(require("module"));
+const perf_hooks_1 = require("perf_hooks");
+const http_1 = __importDefault(require("http"));
+const https_1 = __importDefault(require("https"));
+let options = null;
+let statsBuffer = new Map();
+let intervalId = null;
+const wrappedCache = new WeakMap();
+function formatTimestamp() {
+    const date = new Date();
+    return date.toISOString().replace('T', ' ').substring(0, 19);
+}
+function recordStats(filePath, funcName, durationMs) {
+    if (!options)
+        return;
+    const relativePath = filePath.split(process.cwd())[1]?.replace(/^[\\\/]/, '') || filePath;
+    const key = `${relativePath}::${funcName}`;
+    const existing = statsBuffer.get(key) || { call_count: 0, total_duration_ms: 0, last_timestamp: '' };
+    existing.call_count++;
+    existing.total_duration_ms += durationMs;
+    existing.last_timestamp = formatTimestamp();
+    statsBuffer.set(key, existing);
+}
+function wrapFunction(fn, filePath, funcName) {
+    return new Proxy(fn, {
+        apply(target, thisArg, argumentsList) {
+            const start = perf_hooks_1.performance.now();
+            try {
+                const result = Reflect.apply(target, thisArg, argumentsList);
+                if (result instanceof Promise) {
+                    return result.then(val => {
+                        recordStats(filePath, funcName, perf_hooks_1.performance.now() - start);
+                        return val;
+                    }).catch(err => {
+                        recordStats(filePath, funcName, perf_hooks_1.performance.now() - start);
+                        throw err;
+                    });
+                }
+                recordStats(filePath, funcName, perf_hooks_1.performance.now() - start);
+                return result;
+            }
+            catch (err) {
+                recordStats(filePath, funcName, perf_hooks_1.performance.now() - start);
+                throw err;
+            }
+        }
+    });
+}
+function wrapExports(exportsObj, filePath, defaultName = 'default') {
+    if (typeof exportsObj === 'function') {
+        return wrapFunction(exportsObj, filePath, exportsObj.name || defaultName);
+    }
+    else if (typeof exportsObj === 'object' && exportsObj !== null) {
+        return new Proxy(exportsObj, {
+            get(target, prop, receiver) {
+                const val = Reflect.get(target, prop, receiver);
+                if (typeof val === 'function') {
+                    return wrapFunction(val, filePath, String(prop));
+                }
+                return val;
+            }
+        });
+    }
+    return exportsObj;
+}
+function flushStats() {
+    if (!options || statsBuffer.size === 0)
+        return;
+    const payload = Array.from(statsBuffer.entries()).map(([key, stat]) => {
+        const [file_path, function_name] = key.split('::');
+        return {
+            project_id: options.projectId,
+            repo: options.githubRepo,
+            file_path,
+            function_name,
+            call_count: stat.call_count,
+            avg_duration_ms: stat.total_duration_ms / stat.call_count,
+            timestamp: stat.last_timestamp,
+        };
+    });
+    statsBuffer.clear();
+    try {
+        const url = new URL(options.ingestUrl);
+        const client = url.protocol === 'https:' ? https_1.default : http_1.default;
+        const headers = { 'Content-Type': 'application/json' };
+        if (options.apiKey)
+            headers['x-api-key'] = options.apiKey;
+        const req = client.request(url, {
+            method: 'POST',
+            headers
+        });
+        req.on('error', (err) => {
+            console.error('[CodePulse] Error flushing stats:', err.message);
+        });
+        req.write(JSON.stringify(payload));
+        req.end();
+    }
+    catch (err) {
+        console.error('[CodePulse] Failed to parse ingestUrl:', err);
+    }
+}
+function init(opts) {
+    if (options) {
+        console.warn('[CodePulse] Already initialized');
+        return;
+    }
+    options = opts;
+    const originalLoad = module_1.default._load;
+    module_1.default._load = function (request, parent, isMain) {
+        const exports = originalLoad.apply(this, arguments);
+        try {
+            if (options && typeof request === 'string') {
+                const filename = module_1.default._resolveFilename(request, parent, isMain);
+                if (filename && !filename.includes('node_modules') && !filename.startsWith('node:') && require('path').isAbsolute(filename)) {
+                    if ((typeof exports === 'function' || typeof exports === 'object') && exports !== null) {
+                        if (!wrappedCache.has(exports)) {
+                            const wrapped = wrapExports(exports, filename);
+                            wrappedCache.set(exports, wrapped);
+                            return wrapped;
+                        }
+                        else {
+                            return wrappedCache.get(exports);
+                        }
+                    }
+                }
+            }
+        }
+        catch (e) {
+            // Ignore resolution errors during interception
+        }
+        return exports;
+    };
+    intervalId = setInterval(flushStats, 5000);
+    intervalId.unref(); // Don't block event loop exit
+    console.log('[CodePulse] SDK initialized for project:', opts.projectId);
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "codepulse-sdk",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "description": "Zero-config runtime observability SDK for Node.js",
+  "keywords": [
+    "observability",
+    "apm",
+    "telemetry",
+    "nodejs",
+    "monitoring"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Ramya-Shah/codepulse"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "@types/node": "^20.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc -w"
+  }
+}

package/src/index.ts

@@ -0,0 +1,163 @@
+import Module from 'module';
+import { performance } from 'perf_hooks';
+import http from 'http';
+import https from 'https';
+
+export interface InitOptions {
+  ingestUrl: string;
+  projectId: string;
+  githubRepo: string;
+  apiKey?: string;
+}
+
+interface CallStat {
+  call_count: number;
+  total_duration_ms: number;
+  last_timestamp: string;
+}
+
+let options: InitOptions | null = null;
+let statsBuffer = new Map<string, CallStat>();
+let intervalId: NodeJS.Timeout | null = null;
+const wrappedCache = new WeakMap<any, any>();
+
+function formatTimestamp(): string {
+  const date = new Date();
+  return date.toISOString().replace('T', ' ').substring(0, 19);
+}
+
+function recordStats(filePath: string, funcName: string, durationMs: number) {
+  if (!options) return;
+  
+  const relativePath = filePath.split(process.cwd())[1]?.replace(/^[\\\/]/, '') || filePath;
+  const key = `${relativePath}::${funcName}`;
+  const existing = statsBuffer.get(key) || { call_count: 0, total_duration_ms: 0, last_timestamp: '' };
+  
+  existing.call_count++;
+  existing.total_duration_ms += durationMs;
+  existing.last_timestamp = formatTimestamp();
+  
+  statsBuffer.set(key, existing);
+}
+
+function wrapFunction(fn: Function, filePath: string, funcName: string) {
+  return new Proxy(fn, {
+    apply(target, thisArg, argumentsList) {
+      const start = performance.now();
+      try {
+        const result = Reflect.apply(target, thisArg, argumentsList);
+        if (result instanceof Promise) {
+           return result.then(val => {
+             recordStats(filePath, funcName, performance.now() - start);
+             return val;
+           }).catch(err => {
+             recordStats(filePath, funcName, performance.now() - start);
+             throw err;
+           });
+        }
+        recordStats(filePath, funcName, performance.now() - start);
+        return result;
+      } catch (err) {
+        recordStats(filePath, funcName, performance.now() - start);
+        throw err;
+      }
+    }
+  });
+}
+
+function wrapExports(exportsObj: any, filePath: string, defaultName: string = 'default'): any {
+  if (typeof exportsObj === 'function') {
+      return wrapFunction(exportsObj, filePath, exportsObj.name || defaultName);
+  } else if (typeof exportsObj === 'object' && exportsObj !== null) {
+      return new Proxy(exportsObj, {
+        get(target, prop, receiver) {
+          const val = Reflect.get(target, prop, receiver);
+          if (typeof val === 'function') {
+            return wrapFunction(val, filePath, String(prop));
+          }
+          return val;
+        }
+      });
+  }
+  return exportsObj;
+}
+
+function flushStats() {
+  if (!options || statsBuffer.size === 0) return;
+
+  const payload = Array.from(statsBuffer.entries()).map(([key, stat]) => {
+    const [file_path, function_name] = key.split('::');
+    return {
+      project_id: options!.projectId,
+      repo: options!.githubRepo,
+      file_path,
+      function_name,
+      call_count: stat.call_count,
+      avg_duration_ms: stat.total_duration_ms / stat.call_count,
+      timestamp: stat.last_timestamp,
+    };
+  });
+  
+  statsBuffer.clear();
+
+  try {
+    const url = new URL(options.ingestUrl);
+    const client = url.protocol === 'https:' ? https : http;
+    
+    const headers: any = { 'Content-Type': 'application/json' };
+    if (options.apiKey) headers['x-api-key'] = options.apiKey;
+
+    const req = client.request(url, {
+      method: 'POST',
+      headers
+    });
+
+    req.on('error', (err) => {
+      console.error('[CodePulse] Error flushing stats:', err.message);
+    });
+    
+    req.write(JSON.stringify(payload));
+    req.end();
+  } catch (err) {
+    console.error('[CodePulse] Failed to parse ingestUrl:', err);
+  }
+}
+
+export function init(opts: InitOptions) {
+  if (options) {
+    console.warn('[CodePulse] Already initialized');
+    return;
+  }
+  options = opts;
+
+  const originalLoad = (Module as any)._load;
+  (Module as any)._load = function(request: string, parent: any, isMain: boolean) {
+    const exports = originalLoad.apply(this, arguments);
+    
+    try {
+      if (options && typeof request === 'string') {
+        const filename = (Module as any)._resolveFilename(request, parent, isMain);
+        if (filename && !filename.includes('node_modules') && !filename.startsWith('node:') && require('path').isAbsolute(filename)) {
+          if ((typeof exports === 'function' || typeof exports === 'object') && exports !== null) {
+            if (!wrappedCache.has(exports)) {
+              const wrapped = wrapExports(exports, filename);
+              wrappedCache.set(exports, wrapped);
+              return wrapped;
+            } else {
+              return wrappedCache.get(exports);
+            }
+          }
+        }
+      }
+    } catch (e) {
+      // Ignore resolution errors during interception
+    }
+    
+    return exports;
+  };
+
+  intervalId = setInterval(flushStats, 5000);
+  intervalId.unref(); // Don't block event loop exit
+  
+  console.log('[CodePulse] SDK initialized for project:', opts.projectId);
+}

package/test-math.js

@@ -0,0 +1,2 @@
+exports.add = (a, b) => a + b;
+exports.sub = (a, b) => a - b;

package/test.js

@@ -0,0 +1,37 @@
+const { init } = require('./dist/index.js');
+const http = require('http');
+
+// Dummy ingest server to capture the SDK payload
+const server = http.createServer((req, res) => {
+  if (req.method === 'POST' && req.url === '/ingest') {
+    let body = '';
+    req.on('data', chunk => body += chunk.toString());
+    req.on('end', () => {
+      console.log('\n--- Received Payload from SDK ---');
+      console.log(JSON.stringify(JSON.parse(body), null, 2));
+      console.log('---------------------------------');
+      res.end('ok');
+      process.exit(0);
+    });
+  }
+});
+server.listen(3005, () => {
+  console.log('Dummy ingest server on :3005');
+  
+  // Initialize SDK
+  init({
+    ingestUrl: 'http://localhost:3005/ingest',
+    projectId: 'test-project',
+    githubRepo: 'test-repo'
+  });
+
+  // Require local module *after* init to trigger the hook
+  const math = require('./test-math.js');
+  
+  console.log('Calling math functions...');
+  math.add(5, 10);
+  math.sub(10, 5);
+  
+  // Wait for SDK to flush (5s)
+  console.log('Waiting 6s for SDK to flush...');
+});

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "CommonJS",
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src"]
+}