ai-perf-sdk 1.0.4 → 1.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-perf-sdk",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Plug-and-play custom performance monitoring SDK",
   "license": "MIT",
   "author": "Akash",

package/src/batcher.js

@@ -4,9 +4,6 @@ let queue = [];
 let timer = null;
 let config = {};
 
-/**
- * Initializes the batching system.
- */
 function initBatcher(opts) {
     config = {
         endpoint: opts.endpoint,
@@ -15,34 +12,38 @@ function initBatcher(opts) {
         headers: opts.headers || {}
     };
 
+    console.log("[AI-PERF-SDK] Batcher initialized with:", JSON.stringify(config));
+
     if (timer) clearInterval(timer);
     timer = setInterval(flush, config.flushInterval);
 
     return {
         stop: () => {
+            console.log("[AI-PERF-SDK] Stopping batcher...");
             if (timer) clearInterval(timer);
             return flush();
         }
     };
 }
 
-/**
- * Adds data to the queue and flushes if batch size reached.
- */
 function enqueue(data) {
     queue.push(data);
+    console.log(`[AI-PERF-SDK] Item enqueued. Current queue size: ${queue.length}`);
+
     if (queue.length >= config.batchSize) {
+        console.log("[AI-PERF-SDK] Batch size reached. Triggering flush.");
         flush();
     }
 }
 
-/**
- * Flushes the current queue using the client.
- */
 async function flush() {
-    if (queue.length === 0) return;
+    if (queue.length === 0) {
+        // console.log("[AI-PERF-SDK] Flush called, but queue is empty.");
+        return;
+    }
 
     const payload = queue.splice(0, queue.length);
+    console.log(`[AI-PERF-SDK] Flushing ${payload.length} items...`);
 
     try {
         await sendBatch({
@@ -51,8 +52,7 @@ async function flush() {
             payload: payload
         });
     } catch (err) {
-        console.error("[AI-PERF-SDK] Batch flush failed. Retrying later...", err.message);
-        // Put back in queue to retry
+        console.error("[AI-PERF-SDK] Flush failed. Returning items to queue.");
         queue.unshift(...payload);
     }
 }

package/src/client.js

@@ -1,31 +1,32 @@
 const fetch = global.fetch || (typeof require !== 'undefined' ? require("node-fetch") : null);
 
-/**
- * Sends a batch of telemetry data to the endpoint.
- * @param {Object} options
- * @param {string} options.endpoint - Collector URL
- * @param {Object} options.headers - Custom request headers
- * @param {Array} options.payload - Array of telemetry items
- */
 async function sendBatch({ endpoint, headers, payload }) {
+    console.log(`[AI-PERF-SDK] Sending batch to ${endpoint}... Payload size: ${payload.length}`);
+
     if (!fetch) {
-        throw new Error("Fetch is not available. Please install 'node-fetch' if using Node.js < 18.");
+        throw new Error("Fetch is not available.");
     }
 
-    const response = await fetch(endpoint, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            ...headers,
-        },
-        body: JSON.stringify(payload),
-    });
+    try {
+        const response = await fetch(endpoint, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...headers,
+            },
+            body: JSON.stringify(payload),
+        });
+
+        if (!response.ok) {
+            const text = await response.text();
+            console.error(`[AI-PERF-SDK] HTTP Error: ${response.status} - ${text}`);
+            throw new Error(`Telemetry send failed: ${response.status} ${text}`);
+        }
 
-    if (!response.ok) {
-        const text = await response.text();
-        throw new Error(
-            `Telemetry send failed: ${response.status} ${text}`
-        );
+        console.log(`[AI-PERF-SDK] Batch successfully sent to ${endpoint} (Status: ${response.status})`);
+    } catch (err) {
+        console.error(`[AI-PERF-SDK] Network Error sending batch:`, err.message);
+        throw err;
     }
 }
 

package/src/index.js

@@ -3,35 +3,28 @@ const { instrumentHttp } = require("./instrument");
 
 let stopBatcher = null;
 
-/**
- * Starts the custom Performance SDK.
- * @param {Object} options 
- * @param {string} options.endpoint - Collector URL
- * @param {number} [options.batchSize] - Items per batch (default 10)
- * @param {number} [options.flushInterval] - MS between flushes (default 5000)
- * @param {Object} [options.headers] - Custom headers (e.g., x-session-id)
- */
 function startSdk(options = {}) {
+    console.log("[AI-PERF-SDK] startSDK called with configuration:", JSON.stringify(options));
+
     if (!options.endpoint) {
-        console.error("[AI-PERF-SDK] Configuration error: Missing 'endpoint'.");
+        console.error("[AI-PERF-SDK] CRITICAL ERROR: No endpoint provided. Telemetry will not be sent.");
         return;
     }
 
-    // Initialize Batching Logic
-    const batcher = initBatcher(options);
-    stopBatcher = batcher.stop;
+    try {
+        const batcher = initBatcher(options);
+        stopBatcher = batcher.stop;
 
-    // Initialize Instrumentation (Fetch/HTTP/HTTPS)
-    instrumentHttp();
+        instrumentHttp();
 
-    console.log("[AI-PERF-SDK] SDK Initialized successfully.");
+        console.log("[AI-PERF-SDK] SDK Start Sequence Complete.");
+    } catch (err) {
+        console.error("[AI-PERF-SDK] Initialization failed:", err);
+    }
 }
 
-/**
- * Shuts down the SDK and flushing pending spans.
- */
 async function shutdownSdk() {
-    console.log("[AI-PERF-SDK] Shutting down and flushing final batch...");
+    console.log("[AI-PERF-SDK] shutdownSDK initiated.");
     if (stopBatcher) {
         await stopBatcher();
     }
@@ -40,7 +33,6 @@ async function shutdownSdk() {
 module.exports = {
     startSDK: startSdk,
     shutdownSDK: shutdownSdk,
-    // Aliases for compatibility
     initPerformanceSDK: startSdk,
     shutdownPerformanceSDK: shutdownSdk
 };

package/src/instrument.js

@@ -3,22 +3,22 @@ const { enqueue } = require("./batcher");
 const http = require("http");
 const https = require("https");
 
-/**
- * Instruments global fetch and Node.js http/https modules.
- */
 function instrumentHttp() {
+    console.log("[AI-PERF-SDK] Starting HTTP instrumentation...");
+
     // 1. Instrument global fetch
     if (global.fetch) {
+        console.log("[AI-PERF-SDK] Fetch detected. Patching global.fetch...");
         const originalFetch = global.fetch;
         global.fetch = async (...args) => {
             const url = args[0];
             const urlStr = typeof url === 'string' ? url : (url.url || url.toString());
 
-            // Avoid self-telemetry loops
             if (urlStr && urlStr.includes('/api/telemetry')) {
                 return originalFetch(...args);
             }
 
+            console.log(`[AI-PERF-SDK] Fetch intercepted: ${urlStr}`);
             const start = performance.now();
             let status = 0;
             let error = null;
@@ -47,12 +47,13 @@ function instrumentHttp() {
 
     // 2. Instrument Node.js http/https modules
     [http, https].forEach((module) => {
+        const moduleName = module === https ? 'https' : 'http';
+        console.log(`[AI-PERF-SDK] Patching Node.js ${moduleName} module...`);
         const originalRequest = module.request;
+
         module.request = function (options, callback) {
             const start = performance.now();
-
-            // Reconstruct URL
-            const protocol = module === https ? 'https:' : 'http:';
+            const protocol = moduleName === 'https' ? 'https:' : 'http:';
             const host = options.host || options.hostname || 'localhost';
             const path = options.path || '/';
             const urlStr = `${protocol}//${host}${path}`;
@@ -61,6 +62,8 @@ function instrumentHttp() {
                 return originalRequest.apply(this, arguments);
             }
 
+            // console.log(`[AI-PERF-SDK] HTTP Request intercepted: ${urlStr}`);
+
             const req = originalRequest.call(this, options, (res) => {
                 res.on('end', () => {
                     enqueue({
@@ -90,13 +93,43 @@ function instrumentHttp() {
             return req;
         };
 
-        // Also patch module.get
+        const originalGet = module.get;
         module.get = function (options, callback) {
             const req = module.request(options, callback);
             req.end();
             return req;
         };
+
+        // --- Inbound Request (Server) Patching ---
+        const originalCreateServer = module.createServer;
+        module.createServer = function () {
+            const server = originalCreateServer.apply(this, arguments);
+
+            server.on('request', (req, res) => {
+                const start = performance.now();
+                const url = req.url;
+                const method = req.method;
+
+                // Ignore telemetry calls
+                if (url.includes('/api/telemetry')) return;
+
+                res.on('finish', () => {
+                    const duration = performance.now() - start;
+                    enqueue({
+                        type: "http-inbound",
+                        url: url,
+                        method: method,
+                        duration: Math.round(duration),
+                        status: res.statusCode,
+                        timestamp: new Date().toISOString()
+                    });
+                });
+            });
+
+            return server;
+        };
     });
 }
 
 module.exports = { instrumentHttp };
+