@sentienguard/apm 1.0.0

package/src/transport.js

@@ -0,0 +1,214 @@
+/**
+ * Transport Layer
+ * Handles periodic flush of aggregated metrics to backend.
+ *
+ * Rules:
+ * - Use async, non-blocking HTTP
+ * - Never block application requests
+ * - Retry with exponential backoff
+ * - Drop data on sustained failure
+ * - Never exceed payload size limits
+ *
+ * Data loss is acceptable. App slowdown is not.
+ */
+
+import https from 'https';
+import http from 'http';
+import { getAggregator } from './aggregator.js';
+import config, { debug, warn, isEnabled } from './config.js';
+
+let flushInterval = null;
+let isRunning = false;
+let consecutiveFailures = 0;
+
+// Max consecutive failures before we stop retrying
+const MAX_CONSECUTIVE_FAILURES = 5;
+
+// Base retry delay (doubles with each failure)
+const BASE_RETRY_DELAY_MS = 1000;
+
+// Max payload size (1MB default)
+const MAX_PAYLOAD_SIZE = config.maxPayloadSize || 1024 * 1024;
+
+/**
+ * Send data to backend using native http/https
+ * Returns a promise that resolves on success, rejects on failure
+ */
+function sendToBackend(payload) {
+  return new Promise((resolve, reject) => {
+    const data = JSON.stringify(payload);
+
+    // Check payload size
+    if (data.length > MAX_PAYLOAD_SIZE) {
+      warn(`Payload too large (${data.length} bytes), dropping`);
+      return reject(new Error('Payload too large'));
+    }
+
+    let url;
+    try {
+      url = new URL(config.endpoint);
+    } catch {
+      return reject(new Error('Invalid endpoint URL'));
+    }
+
+    const isHttps = url.protocol === 'https:';
+    const transport = isHttps ? https : http;
+
+    const options = {
+      hostname: url.hostname,
+      port: url.port || (isHttps ? 443 : 80),
+      path: url.pathname + url.search,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(data),
+        'X-APM-Key': config.apiKey,
+        'User-Agent': '@sentienguard/apm/1.0.0'
+      },
+      // Timeout to prevent hanging
+      timeout: 5000
+    };
+
+    const req = transport.request(options, (res) => {
+      let responseData = '';
+
+      res.on('data', (chunk) => {
+        responseData += chunk;
+      });
+
+      res.on('end', () => {
+        if (res.statusCode >= 200 && res.statusCode < 300) {
+          resolve({ statusCode: res.statusCode, data: responseData });
+        } else {
+          reject(new Error(`HTTP ${res.statusCode}: ${responseData}`));
+        }
+      });
+    });
+
+    req.on('error', (error) => {
+      reject(error);
+    });
+
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error('Request timeout'));
+    });
+
+    // Send data
+    req.write(data);
+    req.end();
+  });
+}
+
+/**
+ * Perform a flush of aggregated metrics
+ * Non-blocking, async operation
+ */
+async function flush() {
+  if (!isEnabled()) {
+    return;
+  }
+
+  const aggregator = getAggregator();
+
+  // Skip if no data
+  if (!aggregator.hasData()) {
+    debug('No data to flush');
+    return;
+  }
+
+  // Get and reset metrics
+  const payload = aggregator.flush();
+
+  debug(`Flushing ${payload.requests.length} request metrics, ${payload.dependencies.length} dependency metrics`);
+
+  try {
+    const startTime = Date.now();
+    await sendToBackend(payload);
+    const duration = Date.now() - startTime;
+
+    debug(`Flush successful in ${duration}ms`);
+
+    // Reset failure counter on success
+    consecutiveFailures = 0;
+
+  } catch (error) {
+    consecutiveFailures++;
+    warn(`Flush failed (attempt ${consecutiveFailures}): ${error.message}`);
+
+    // If too many failures, warn but continue (data loss is acceptable)
+    if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+      warn('Max consecutive failures reached, data will be dropped until backend recovers');
+    }
+  }
+}
+
+/**
+ * Start the periodic flush timer
+ */
+export function startFlushing() {
+  if (isRunning) {
+    debug('Flushing already started');
+    return;
+  }
+
+  if (!isEnabled()) {
+    debug('SDK disabled, not starting flush timer');
+    return;
+  }
+
+  const intervalMs = config.flushInterval * 1000;
+
+  flushInterval = setInterval(() => {
+    // Run flush in next tick to avoid blocking
+    setImmediate(flush);
+  }, intervalMs);
+
+  // Ensure timer doesn't prevent process exit
+  if (flushInterval.unref) {
+    flushInterval.unref();
+  }
+
+  isRunning = true;
+  debug(`Flush timer started (every ${config.flushInterval}s)`);
+}
+
+/**
+ * Stop the periodic flush timer
+ */
+export function stopFlushing() {
+  if (!isRunning) return;
+
+  if (flushInterval) {
+    clearInterval(flushInterval);
+    flushInterval = null;
+  }
+
+  isRunning = false;
+  debug('Flush timer stopped');
+}
+
+/**
+ * Perform a final flush before shutdown
+ * This is sync-ish but uses async internally
+ */
+export async function finalFlush() {
+  debug('Performing final flush');
+  try {
+    await flush();
+  } catch (error) {
+    warn('Final flush failed:', error.message);
+  }
+}
+
+/**
+ * Manual flush trigger (for testing)
+ */
+export { flush };
+
+export default {
+  startFlushing,
+  stopFlushing,
+  finalFlush,
+  flush
+};