ai-perf-sdk 1.0.3 → 1.0.4

package/package.json

@@ -1,14 +1,12 @@
 {
   "name": "ai-perf-sdk",
-  "version": "1.0.3",
-  "description": "Plug-and-play performance monitoring SDK using OpenTelemetry",
+  "version": "1.0.4",
+  "description": "Plug-and-play custom performance monitoring SDK",
   "license": "MIT",
   "author": "Akash",
   "type": "commonjs",
   "main": "src/index.js",
   "dependencies": {
-    "@opentelemetry/sdk-node": "^0.46.0",
-    "@opentelemetry/auto-instrumentations-node": "^0.46.0",
-    "@opentelemetry/exporter-trace-otlp-http": "^0.46.0"
+    "node-fetch": "^2.7.0"
   }
 }

package/src/batcher.js

@@ -0,0 +1,64 @@
+const { sendBatch } = require("./client");
+
+let queue = [];
+let timer = null;
+let config = {};
+
+/**
+ * Initializes the batching system.
+ */
+function initBatcher(opts) {
+    config = {
+        endpoint: opts.endpoint,
+        batchSize: opts.batchSize || 10,
+        flushInterval: opts.flushInterval || 5000,
+        headers: opts.headers || {}
+    };
+
+    if (timer) clearInterval(timer);
+    timer = setInterval(flush, config.flushInterval);
+
+    return {
+        stop: () => {
+            if (timer) clearInterval(timer);
+            return flush();
+        }
+    };
+}
+
+/**
+ * Adds data to the queue and flushes if batch size reached.
+ */
+function enqueue(data) {
+    queue.push(data);
+    if (queue.length >= config.batchSize) {
+        flush();
+    }
+}
+
+/**
+ * Flushes the current queue using the client.
+ */
+async function flush() {
+    if (queue.length === 0) return;
+
+    const payload = queue.splice(0, queue.length);
+
+    try {
+        await sendBatch({
+            endpoint: config.endpoint,
+            headers: config.headers,
+            payload: payload
+        });
+    } catch (err) {
+        console.error("[AI-PERF-SDK] Batch flush failed. Retrying later...", err.message);
+        // Put back in queue to retry
+        queue.unshift(...payload);
+    }
+}
+
+module.exports = {
+    initBatcher,
+    enqueue,
+    flush
+};

package/src/client.js

@@ -0,0 +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 }) {
+    if (!fetch) {
+        throw new Error("Fetch is not available. Please install 'node-fetch' if using Node.js < 18.");
+    }
+
+    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();
+        throw new Error(
+            `Telemetry send failed: ${response.status} ${text}`
+        );
+    }
+}
+
+module.exports = { sendBatch };

package/src/index.js

@@ -1,6 +1,46 @@
-const { startSDK, shutdownSDK } = require("./sdk");
+const { initBatcher, flush } = require("./batcher");
+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 = {}) {
+    if (!options.endpoint) {
+        console.error("[AI-PERF-SDK] Configuration error: Missing 'endpoint'.");
+        return;
+    }
+
+    // Initialize Batching Logic
+    const batcher = initBatcher(options);
+    stopBatcher = batcher.stop;
+
+    // Initialize Instrumentation (Fetch/HTTP/HTTPS)
+    instrumentHttp();
+
+    console.log("[AI-PERF-SDK] SDK Initialized successfully.");
+}
+
+/**
+ * Shuts down the SDK and flushing pending spans.
+ */
+async function shutdownSdk() {
+    console.log("[AI-PERF-SDK] Shutting down and flushing final batch...");
+    if (stopBatcher) {
+        await stopBatcher();
+    }
+}
 
 module.exports = {
-    initPerformanceSDK: startSDK,
-    shutdownPerformanceSDK: shutdownSDK
+    startSDK: startSdk,
+    shutdownSDK: shutdownSdk,
+    // Aliases for compatibility
+    initPerformanceSDK: startSdk,
+    shutdownPerformanceSDK: shutdownSdk
 };

package/src/instrument.js

@@ -0,0 +1,102 @@
+const { performance } = require("perf_hooks");
+const { enqueue } = require("./batcher");
+const http = require("http");
+const https = require("https");
+
+/**
+ * Instruments global fetch and Node.js http/https modules.
+ */
+function instrumentHttp() {
+    // 1. Instrument global fetch
+    if (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);
+            }
+
+            const start = performance.now();
+            let status = 0;
+            let error = null;
+
+            try {
+                const res = await originalFetch(...args);
+                status = res.status;
+                return res;
+            } catch (err) {
+                error = err.message;
+                throw err;
+            } finally {
+                const duration = performance.now() - start;
+                enqueue({
+                    type: "http-fetch",
+                    url: urlStr,
+                    method: args[1]?.method || 'GET',
+                    duration: Math.round(duration),
+                    status: status,
+                    error: error,
+                    timestamp: new Date().toISOString()
+                });
+            }
+        };
+    }
+
+    // 2. Instrument Node.js http/https modules
+    [http, https].forEach((module) => {
+        const originalRequest = module.request;
+        module.request = function (options, callback) {
+            const start = performance.now();
+
+            // Reconstruct URL
+            const protocol = module === https ? 'https:' : 'http:';
+            const host = options.host || options.hostname || 'localhost';
+            const path = options.path || '/';
+            const urlStr = `${protocol}//${host}${path}`;
+
+            if (urlStr.includes('/api/telemetry')) {
+                return originalRequest.apply(this, arguments);
+            }
+
+            const req = originalRequest.call(this, options, (res) => {
+                res.on('end', () => {
+                    enqueue({
+                        type: "http-node",
+                        url: urlStr,
+                        method: options.method || 'GET',
+                        duration: Math.round(performance.now() - start),
+                        status: res.statusCode,
+                        timestamp: new Date().toISOString()
+                    });
+                });
+                if (callback) callback(res);
+            });
+
+            req.on('error', (err) => {
+                enqueue({
+                    type: "http-node-error",
+                    url: urlStr,
+                    method: options.method || 'GET',
+                    duration: Math.round(performance.now() - start),
+                    status: 0,
+                    error: err.message,
+                    timestamp: new Date().toISOString()
+                });
+            });
+
+            return req;
+        };
+
+        // Also patch module.get
+        module.get = function (options, callback) {
+            const req = module.request(options, callback);
+            req.end();
+            return req;
+        };
+    });
+}
+
+module.exports = { instrumentHttp };

package/src/sdk.js

@@ -1,118 +0,0 @@
-const { NodeSDK } = require("@opentelemetry/sdk-node");
-const { getNodeAutoInstrumentations } = require("@opentelemetry/auto-instrumentations-node");
-const { OTLPTraceExporter } = require("@opentelemetry/exporter-trace-otlp-http");
-const { diag, DiagConsoleLogger, DiagLogLevel } = require("@opentelemetry/api");
-const defaults = require("./config");
-
-let sdkInstance = null;
-
-/**
- * Initializes the AI Performance SDK.
- * @param {Object} options Configuration options
- * @param {string} [options.collectorEndpoint] - URL of the telemetry collector
- * @param {Object} [options.headers] - Headers to send with telemetry (e.g., x-session-id)
- * @param {string} [options.serviceName] - Name of the service
- * @param {boolean} [options.debug] - Enable debug logging
- * @param {boolean} [options.disableDbInstrumentation] - Disable DB auto-instrumentation (MongoDB/Mongoose/Redis) to prevent crashes
- */
-function startSDK(options = {}) {
-    if (sdkInstance) {
-        if (options.debug) console.log("[AI-PERF] SDK already started.");
-        return;
-    }
-
-    // 1. Merge Configuration
-    const config = {
-        ...defaults,
-        ...options
-    };
-
-    // 2. Enable Debug Logging if requested
-    if (config.debug) {
-        console.log("[AI-PERF] Debug Mode Enabled");
-        diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.DEBUG);
-    }
-
-    // 3. Robust Header Handling
-    let combinedHeaders = { ...config.headers };
-
-    if (process.env.OTEL_EXPORTER_OTLP_HEADERS) {
-        try {
-            const envHeaders = process.env.OTEL_EXPORTER_OTLP_HEADERS.split(',').reduce((acc, pair) => {
-                const [k, v] = pair.split('=');
-                if (k && v) acc[k.trim()] = v.trim();
-                return acc;
-            }, {});
-            combinedHeaders = { ...combinedHeaders, ...envHeaders };
-        } catch (e) {
-            console.warn("[AI-PERF] Failed to parse OTEL_EXPORTER_OTLP_HEADERS", e);
-        }
-    }
-
-    if (config.debug) {
-        console.log("[AI-PERF] Exporter Config:", {
-            url: config.collectorEndpoint,
-            headers: combinedHeaders,
-            protocol: process.env.OTEL_EXPORTER_OTLP_PROTOCOL || 'default (protobuf)'
-        });
-    }
-
-    const exporter = new OTLPTraceExporter({
-        url: config.collectorEndpoint,
-        headers: combinedHeaders
-    });
-
-    // 4. Configure Auto-Instrumentation
-    const instrumentationConfig = {};
-
-    if (config.disableDbInstrumentation) {
-        if (config.debug) console.log("[AI-PERF] Disabling DB Instrumentations");
-        instrumentationConfig['@opentelemetry/instrumentation-mongodb'] = { enabled: false };
-        instrumentationConfig['@opentelemetry/instrumentation-mongoose'] = { enabled: false };
-        instrumentationConfig['@opentelemetry/instrumentation-redis'] = { enabled: false };
-        instrumentationConfig['@opentelemetry/instrumentation-ioredis'] = { enabled: false };
-        instrumentationConfig['@opentelemetry/instrumentation-pg'] = { enabled: false };
-        instrumentationConfig['@opentelemetry/instrumentation-mysql'] = { enabled: false };
-        instrumentationConfig['@opentelemetry/instrumentation-mysql2'] = { enabled: false };
-    }
-
-    sdkInstance = new NodeSDK({
-        serviceName: config.serviceName,
-        traceExporter: exporter,
-        instrumentations: [getNodeAutoInstrumentations(instrumentationConfig)]
-    });
-
-    try {
-        sdkInstance.start();
-        console.log(`[AI-PERF] SDK started for ${config.serviceName} ` + (config.disableDbInstrumentation ? "(Safe Mode)" : ""));
-
-        // 5. Automatic Graceful Shutdown
-        const handleShutdown = async () => {
-            console.log("[AI-PERF] Graceful shutdown initiated...");
-            await shutdownSDK();
-            process.exit(0);
-        };
-
-        process.on('SIGTERM', handleShutdown);
-        process.on('SIGINT', handleShutdown);
-
-    } catch (e) {
-        console.error("[AI-PERF] Failed to start SDK:", e);
-    }
-}
-
-function shutdownSDK() {
-    if (!sdkInstance) return;
-
-    sdkInstance.shutdown().then(() => {
-        console.log("[AI-PERF] SDK shutdown");
-        sdkInstance = null;
-    }).catch((error) => {
-        console.error("[AI-PERF] Error shutting down SDK", error);
-    });
-}
-
-module.exports = {
-    startSDK,
-    shutdownSDK
-};