@sentienguard/apm 1.0.8 → 1.0.9

package/src/dependencies.js

@@ -1,231 +1,374 @@
-/**
- * Dependency Tracking
- * Automatically times outgoing HTTP calls (fetch, axios, node http/https).
- *
- * For each dependency:
- * - name (e.g., "OpenAI API", "api.example.com")
- * - type (http, db, cache)
- * - response time
- * - error flag
- */
-
-import http from 'http';
-import https from 'https';
-import { getAggregator } from './aggregator.js';
-import { debug, getConfig } from './config.js';
-
-let isInstrumented = false;
-let originalHttpRequest = null;
-let originalHttpsRequest = null;
-
-// Known service patterns for better naming
-const KNOWN_SERVICES = [
-  { pattern: /openai\.com/i, name: 'OpenAI API' },
-  { pattern: /anthropic\.com/i, name: 'Anthropic API' },
-  { pattern: /api\.stripe\.com/i, name: 'Stripe API' },
-  { pattern: /api\.sendgrid\.com/i, name: 'SendGrid' },
-  { pattern: /api\.twilio\.com/i, name: 'Twilio API' },
-  { pattern: /s3\.amazonaws\.com/i, name: 'AWS S3' },
-  { pattern: /dynamodb\..+\.amazonaws\.com/i, name: 'DynamoDB' },
-  { pattern: /sqs\..+\.amazonaws\.com/i, name: 'AWS SQS' },
-  { pattern: /sns\..+\.amazonaws\.com/i, name: 'AWS SNS' },
-  { pattern: /mongodb\.net/i, name: 'MongoDB Atlas' },
-  { pattern: /redis/i, name: 'Redis' },
-  { pattern: /postgresql|postgres/i, name: 'PostgreSQL' },
-  { pattern: /mysql/i, name: 'MySQL' }
-];
-
-/**
- * Extract a friendly name from hostname
- */
-function getServiceName(hostname) {
-  if (!hostname) return 'unknown';
-
-  // Check known services
-  for (const service of KNOWN_SERVICES) {
-    if (service.pattern.test(hostname)) {
-      return service.name;
-    }
-  }
-
-  // Default to hostname
-  return hostname;
-}
-
-/**
- * Determine dependency type from hostname/path
- */
-function getDependencyType(hostname, path) {
-  const lowerHost = (hostname || '').toLowerCase();
-
-  // Database indicators
-  if (/mongodb|postgres|mysql|dynamodb|redis|memcache/i.test(lowerHost)) {
-    return 'db';
-  }
-
-  // Cache indicators
-  if (/redis|memcache|elasticache/i.test(lowerHost)) {
-    return 'cache';
-  }
-
-  // Storage indicators
-  if (/s3\.amazonaws|storage\.googleapis|blob\.core\.windows/i.test(lowerHost)) {
-    return 'storage';
-  }
-
-  // Default to HTTP
-  return 'http';
-}
-
-/**
- * Check if this request should be excluded from tracking
- */
-function shouldExclude(hostname) {
-  const config = getConfig();
-
-  // Don't track our own APM endpoint
-  if (config.endpoint) {
-    try {
-      const endpointUrl = new URL(config.endpoint);
-      if (hostname === endpointUrl.hostname) {
-        return true;
-      }
-    } catch {
-      // Invalid endpoint URL, continue
-    }
-  }
-
-  // Exclude localhost by default (internal services)
-  return hostname === 'localhost' || hostname === '127.0.0.1';
-}
-
-/**
- * Wrap http/https request to track dependencies
- */
-function wrapRequest(original, protocol) {
-  return function instrumentedRequest(options, callback) {
-    // Parse options to get hostname
-    let hostname = '';
-    let path = '/';
-
-    if (typeof options === 'string') {
-      try {
-        const url = new URL(options);
-        hostname = url.hostname;
-        path = url.pathname;
-      } catch {
-        // Invalid URL
-      }
-    } else if (options) {
-      hostname = options.hostname || options.host || '';
-      path = options.path || '/';
-      // Remove port from host if present
-      hostname = hostname.split(':')[0];
-    }
-
-    // Check exclusions
-    if (shouldExclude(hostname)) {
-      return original.apply(this, arguments);
-    }
-
-    const startTime = process.hrtime.bigint();
-    const serviceName = getServiceName(hostname);
-    const depType = getDependencyType(hostname, path);
-
-    // Call original
-    const req = original.apply(this, arguments);
-
-    // Track response
-    req.on('response', (res) => {
-      const endTime = process.hrtime.bigint();
-      const latencyMs = Number(endTime - startTime) / 1e6;
-      const isError = res.statusCode >= 400;
-
-      const aggregator = getAggregator();
-      aggregator.recordDependency(serviceName, depType, latencyMs, isError);
-
-      debug(`Dependency: ${serviceName} (${depType}) ${res.statusCode} ${latencyMs.toFixed(2)}ms`);
-    });
-
-    // Track errors
-    req.on('error', () => {
-      const endTime = process.hrtime.bigint();
-      const latencyMs = Number(endTime - startTime) / 1e6;
-
-      const aggregator = getAggregator();
-      aggregator.recordDependency(serviceName, depType, latencyMs, true);
-
-      debug(`Dependency error: ${serviceName} (${depType}) ${latencyMs.toFixed(2)}ms`);
-    });
-
-    return req;
-  };
-}
-
-/**
- * Instrument outgoing HTTP requests
- */
-export function instrumentDependencies() {
-  if (isInstrumented) {
-    debug('Dependencies already instrumented, skipping');
-    return;
-  }
-
-  // Store originals
-  originalHttpRequest = http.request;
-  originalHttpsRequest = https.request;
-
-  // Patch http.request
-  http.request = wrapRequest(originalHttpRequest, 'http');
-  http.get = function (options, callback) {
-    const req = http.request(options, callback);
-    req.end();
-    return req;
-  };
-
-  // Patch https.request
-  https.request = wrapRequest(originalHttpsRequest, 'https');
-  https.get = function (options, callback) {
-    const req = https.request(options, callback);
-    req.end();
-    return req;
-  };
-
-  isInstrumented = true;
-  debug('Dependency instrumentation enabled');
-}
-
-/**
- * Remove instrumentation (for testing/cleanup)
- */
-export function uninstrumentDependencies() {
-  if (!isInstrumented) return;
-
-  if (originalHttpRequest) {
-    http.request = originalHttpRequest;
-    http.get = function (options, callback) {
-      const req = http.request(options, callback);
-      req.end();
-      return req;
-    };
-  }
-
-  if (originalHttpsRequest) {
-    https.request = originalHttpsRequest;
-    https.get = function (options, callback) {
-      const req = https.request(options, callback);
-      req.end();
-      return req;
-    };
-  }
-
-  isInstrumented = false;
-  debug('Dependency instrumentation disabled');
-}
-
-export default {
-  instrumentDependencies,
-  uninstrumentDependencies,
-  getServiceName,
-  getDependencyType
-};
+/**
+ * Dependency Tracking
+ * Automatically times outgoing HTTP calls (fetch, axios, node http/https).
+ *
+ * For each dependency:
+ * - name (e.g., "OpenAI API", "api.example.com")
+ * - type (http, db, cache)
+ * - response time
+ * - error flag
+ */
+
+import http from 'http';
+import https from 'https';
+import { context, propagation } from '@opentelemetry/api';
+import { getAggregator } from './aggregator.js';
+import { debug, getConfig } from './config.js';
+
+let isInstrumented = false;
+let originalHttpRequest = null;
+let originalHttpsRequest = null;
+let originalFetch = null;
+let isFetchInstrumented = false;
+
+// Known service patterns for better naming
+const KNOWN_SERVICES = [
+  { pattern: /openai\.com/i, name: 'OpenAI API' },
+  { pattern: /anthropic\.com/i, name: 'Anthropic API' },
+  { pattern: /api\.stripe\.com/i, name: 'Stripe API' },
+  { pattern: /api\.sendgrid\.com/i, name: 'SendGrid' },
+  { pattern: /api\.twilio\.com/i, name: 'Twilio API' },
+  { pattern: /s3\.amazonaws\.com/i, name: 'AWS S3' },
+  { pattern: /dynamodb\..+\.amazonaws\.com/i, name: 'DynamoDB' },
+  { pattern: /sqs\..+\.amazonaws\.com/i, name: 'AWS SQS' },
+  { pattern: /sns\..+\.amazonaws\.com/i, name: 'AWS SNS' },
+  { pattern: /mongodb\.net/i, name: 'MongoDB Atlas' },
+  { pattern: /redis/i, name: 'Redis' },
+  { pattern: /postgresql|postgres/i, name: 'PostgreSQL' },
+  { pattern: /mysql/i, name: 'MySQL' }
+];
+
+/**
+ * Label for outgoing HTTP dependency (matches spanExporter peer labels when tracing local services).
+ */
+function resolveOutgoingPeerLabel(hostname, options) {
+  const cfg = getConfig();
+  const h = (hostname || '').split(':')[0];
+  const isLocal = h === 'localhost' || h === '127.0.0.1' || h === '::1';
+  if (isLocal && cfg.tracing?.traceLocalHttp) {
+    let port = '';
+    if (typeof options === 'string') {
+      try {
+        const u = new URL(options);
+        port = u.port || (u.protocol === 'https:' ? '443' : '80');
+      } catch {
+        // ignore
+      }
+    } else if (options && typeof options === 'object') {
+      port = options.port ? String(options.port) : '';
+    }
+    const map = cfg.tracing?.peerServiceMap || {};
+    if (port && map[port]) return map[port];
+    if (port) return `localhost:${port}`;
+  }
+  return getServiceName(hostname);
+}
+
+/**
+ * Extract a friendly name from hostname
+ */
+function getServiceName(hostname) {
+  if (!hostname) return 'unknown';
+
+  // Check known services
+  for (const service of KNOWN_SERVICES) {
+    if (service.pattern.test(hostname)) {
+      return service.name;
+    }
+  }
+
+  // Default to hostname
+  return hostname;
+}
+
+/**
+ * Determine dependency type from hostname/path
+ */
+function getDependencyType(hostname, path) {
+  const lowerHost = (hostname || '').toLowerCase();
+
+  // Database indicators
+  if (/mongodb|postgres|mysql|dynamodb|redis|memcache/i.test(lowerHost)) {
+    return 'db';
+  }
+
+  // Cache indicators
+  if (/redis|memcache|elasticache/i.test(lowerHost)) {
+    return 'cache';
+  }
+
+  // Storage indicators
+  if (/s3\.amazonaws|storage\.googleapis|blob\.core\.windows/i.test(lowerHost)) {
+    return 'storage';
+  }
+
+  // Default to HTTP
+  return 'http';
+}
+
+/**
+ * Check if this request should be excluded from tracking
+ */
+function resolvePortFromOptions(optionsOrUrl) {
+  try {
+    if (!optionsOrUrl) return '';
+    if (optionsOrUrl instanceof URL) {
+      return optionsOrUrl.port || (optionsOrUrl.protocol === 'https:' ? '443' : '80');
+    }
+    if (typeof optionsOrUrl === 'string') {
+      const u = new URL(optionsOrUrl);
+      return u.port || (u.protocol === 'https:' ? '443' : '80');
+    }
+    if (typeof optionsOrUrl === 'object') {
+      if (optionsOrUrl.port) return String(optionsOrUrl.port);
+      // Node supports host like "localhost:3001"
+      const host = optionsOrUrl.host || optionsOrUrl.hostname || '';
+      if (typeof host === 'string') {
+        const idx = host.lastIndexOf(':');
+        if (idx > -1) return host.slice(idx + 1);
+      }
+    }
+  } catch {
+    // ignore
+  }
+  return '';
+}
+
+function resolvePortFromEndpoint(endpointUrl) {
+  if (!endpointUrl) return '';
+  return endpointUrl.port || (endpointUrl.protocol === 'https:' ? '443' : '80');
+}
+
+function shouldExclude(hostname, optionsOrUrl) {
+  const config = getConfig();
+
+  // Don't track our own APM endpoint
+  if (config.endpoint) {
+    try {
+      const endpointUrl = new URL(config.endpoint);
+      if (hostname === endpointUrl.hostname) {
+        const reqPort = resolvePortFromOptions(optionsOrUrl);
+        const ingestPort = resolvePortFromEndpoint(endpointUrl);
+        // If we can't determine request port, be conservative and exclude.
+        if (!reqPort || reqPort === ingestPort) return true;
+      }
+    } catch {
+      // Invalid endpoint URL, continue
+    }
+  }
+
+  const h = (hostname || '').toLowerCase();
+  const isLocal = h === 'localhost' || h === '127.0.0.1' || h === '::1';
+  // Exclude localhost unless tracing local HTTP peers (multi-service dev)
+  if (isLocal) return !config.tracing?.traceLocalHttp;
+
+  return false;
+}
+
+function safeParseUrl(input) {
+  try {
+    return new URL(String(input));
+  } catch {
+    return null;
+  }
+}
+
+function shouldExcludeUrl(u) {
+  if (!u) return true;
+  return shouldExclude(u.hostname, u);
+}
+
+function injectTraceHeaders(init) {
+  const headers = new Headers((init && init.headers) || {});
+  try {
+    propagation.inject(context.active(), headers, {
+      set: (carrier, key, value) => {
+        carrier.set(key, value);
+      }
+    });
+  } catch {
+    // ignore
+  }
+  return { ...(init || {}), headers };
+}
+
+/**
+ * Instrument global fetch (Node 18+ / undici) to record dependency edges.
+ * This is needed because OTel HttpInstrumentation doesn't always cover fetch.
+ */
+export function instrumentFetch() {
+  if (isFetchInstrumented) return;
+  const f = globalThis.fetch;
+  if (typeof f !== 'function') return;
+  originalFetch = f;
+
+  globalThis.fetch = async function sentienguardFetch(input, init) {
+    const u = safeParseUrl(typeof input === 'string' ? input : input?.url);
+    if (shouldExcludeUrl(u)) {
+      return originalFetch.call(this, input, init);
+    }
+
+    const startTime = process.hrtime.bigint();
+    const cfg = getConfig();
+    const caller = cfg.service || 'unknown';
+    const hostname = u?.hostname || '';
+    const peerLabel = resolveOutgoingPeerLabel(hostname, u ? u.toString() : '');
+    const depType = getDependencyType(hostname, u?.pathname || '/');
+
+    try {
+      const res = await originalFetch.call(this, input, injectTraceHeaders(init));
+      const endTime = process.hrtime.bigint();
+      const latencyMs = Number(endTime - startTime) / 1e6;
+      const isError = (res?.status || 0) >= 400;
+      getAggregator().recordDependency(peerLabel, depType, latencyMs, isError);
+      debug(`Service call: ${caller} -> ${peerLabel} ${latencyMs.toFixed(2)}ms (${depType}) ${res?.status}`);
+      return res;
+    } catch (err) {
+      const endTime = process.hrtime.bigint();
+      const latencyMs = Number(endTime - startTime) / 1e6;
+      getAggregator().recordDependency(peerLabel, depType, latencyMs, true);
+      debug(`Service call: ${caller} -> ${peerLabel} ${latencyMs.toFixed(2)}ms (${depType}) error`);
+      throw err;
+    }
+  };
+
+  isFetchInstrumented = true;
+  debug('Fetch dependency instrumentation enabled');
+}
+
+/**
+ * Wrap http/https request to track dependencies
+ */
+function wrapRequest(original, protocol) {
+  return function instrumentedRequest(options, callback) {
+    // Parse options to get hostname
+    let hostname = '';
+    let path = '/';
+
+    if (typeof options === 'string') {
+      try {
+        const url = new URL(options);
+        hostname = url.hostname;
+        path = url.pathname;
+      } catch {
+        // Invalid URL
+      }
+    } else if (options) {
+      hostname = options.hostname || options.host || '';
+      path = options.path || '/';
+      // Remove port from host if present
+      hostname = hostname.split(':')[0];
+    }
+
+    // Check exclusions
+    if (shouldExclude(hostname, options)) {
+      return original.apply(this, arguments);
+    }
+
+    const startTime = process.hrtime.bigint();
+    const peerLabel = resolveOutgoingPeerLabel(hostname, options);
+    const depType = getDependencyType(hostname, path);
+    const caller = getConfig().service || 'unknown';
+
+    // Call original
+    const req = original.apply(this, arguments);
+
+    // Track response
+    req.on('response', (res) => {
+      const endTime = process.hrtime.bigint();
+      const latencyMs = Number(endTime - startTime) / 1e6;
+      const isError = res.statusCode >= 400;
+
+      const aggregator = getAggregator();
+      aggregator.recordDependency(peerLabel, depType, latencyMs, isError);
+
+      debug(
+        `Service call: ${caller} -> ${peerLabel} ${latencyMs.toFixed(2)}ms (${depType}) ${res.statusCode}`
+      );
+    });
+
+    // Track errors
+    req.on('error', () => {
+      const endTime = process.hrtime.bigint();
+      const latencyMs = Number(endTime - startTime) / 1e6;
+
+      const aggregator = getAggregator();
+      aggregator.recordDependency(peerLabel, depType, latencyMs, true);
+
+      debug(`Service call: ${caller} -> ${peerLabel} ${latencyMs.toFixed(2)}ms (${depType}) error`);
+    });
+
+    return req;
+  };
+}
+
+/**
+ * Instrument outgoing HTTP requests
+ */
+export function instrumentDependencies() {
+  if (isInstrumented) {
+    debug('Dependencies already instrumented, skipping');
+    return;
+  }
+
+  // Store originals
+  originalHttpRequest = http.request;
+  originalHttpsRequest = https.request;
+
+  // Patch http.request
+  http.request = wrapRequest(originalHttpRequest, 'http');
+  http.get = function (options, callback) {
+    const req = http.request(options, callback);
+    req.end();
+    return req;
+  };
+
+  // Patch https.request
+  https.request = wrapRequest(originalHttpsRequest, 'https');
+  https.get = function (options, callback) {
+    const req = https.request(options, callback);
+    req.end();
+    return req;
+  };
+
+  isInstrumented = true;
+  debug('Dependency instrumentation enabled');
+}
+
+/**
+ * Remove instrumentation (for testing/cleanup)
+ */
+export function uninstrumentDependencies() {
+  if (!isInstrumented) return;
+
+  if (originalHttpRequest) {
+    http.request = originalHttpRequest;
+    http.get = function (options, callback) {
+      const req = http.request(options, callback);
+      req.end();
+      return req;
+    };
+  }
+
+  if (originalHttpsRequest) {
+    https.request = originalHttpsRequest;
+    https.get = function (options, callback) {
+      const req = https.request(options, callback);
+      req.end();
+      return req;
+    };
+  }
+
+  isInstrumented = false;
+  debug('Dependency instrumentation disabled');
+}
+
+export { getServiceName, getDependencyType };
+
+export default {
+  instrumentDependencies,
+  instrumentFetch,
+  uninstrumentDependencies,
+  getServiceName,
+  getDependencyType
+};