@sentienguard/apm 1.0.5 → 1.0.7

package/src/config.js

@@ -2,87 +2,93 @@
  * SDK Configuration
  * Environment-driven configuration with sensible defaults.
  * No config → SDK disables itself silently.
+ *
+ * Config is loaded lazily (at initialize() time, not import time)
+ * so that dotenv or other env loaders can run first.
  */
 
-const config = {
-  // API key for authentication (required)
-  apiKey: process.env.SENTIENGUARD_APM_KEY || '',
-
-  // Service name (required for data to be meaningful)
-  service: process.env.SENTIENGUARD_SERVICE || '',
-
-  // Environment (production, staging, development)
-  environment: process.env.SENTIENGUARD_ENV || 'production',
-
-  // Backend endpoint for data ingestion
-  // Production: https://sentienguard-dev.the-algo.com/api/v1/apm/ingest
-  // Local: http://localhost:4000/api/v1/apm/ingest
-  endpoint: process.env.SENTIENGUARD_ENDPOINT || 'https://sentienguard-dev.the-algo.com/api/v1/apm/ingest',
-
-  // Flush interval in seconds (default: 10s)
-  flushInterval: parseInt(process.env.SENTIENGUARD_FLUSH_INTERVAL, 10) || 10,
-
-  // Max unique routes to track per service (prevents memory bloat)
-  maxRoutes: parseInt(process.env.SENTIENGUARD_MAX_ROUTES, 10) || 100,
-
-  // Max payload size in bytes (prevent oversized payloads)
-  maxPayloadSize: parseInt(process.env.SENTIENGUARD_MAX_PAYLOAD_SIZE, 10) || 1024 * 1024, // 1MB
-
-  // Enable/disable SDK (auto-disabled if no API key)
-  enabled: process.env.SENTIENGUARD_ENABLED !== 'false',
+let configLoaded = false;
 
-  // Debug mode (logs SDK activity)
-  debug: process.env.SENTIENGUARD_DEBUG === 'true',
-
-  // MongoDB monitoring configuration
+const config = {
+  apiKey: '',
+  service: '',
+  environment: 'production',
+  endpoint: 'https://sentienguard-dev.the-algo.com/api/v1/apm/ingest',
+  flushInterval: 10,
+  maxRoutes: 100,
+  maxPayloadSize: 1024 * 1024,
+  enabled: true,
+  debug: false,
   mongodb: {
-    // Enable/disable MongoDB instrumentation (default: true)
-    enabled: process.env.SENTIENGUARD_MONGODB_ENABLED !== 'false',
-    // Slow query threshold in milliseconds (default: 100ms)
-    slowQueryMs: parseInt(process.env.SENTIENGUARD_MONGODB_SLOW_QUERY_MS, 10) || 100,
-    // Interval for collecting pool stats in milliseconds (default: 10s)
-    poolStatsInterval: parseInt(process.env.SENTIENGUARD_MONGODB_POOL_INTERVAL, 10) || 10000
+    enabled: true,
+    slowQueryMs: 100,
+    poolStatsInterval: 10000
   },
-
-  // Circuit breaker configuration
   circuitBreaker: {
-    // Enable/disable circuit breaker (default: false - opt-in)
-    enabled: process.env.SENTIENGUARD_CIRCUIT_BREAKER_ENABLED === 'true',
-    // Timeout for operations in milliseconds (default: 3s)
-    timeout: parseInt(process.env.SENTIENGUARD_CIRCUIT_TIMEOUT_MS, 10) || 3000,
-    // Error threshold percentage to trip circuit (default: 50%)
-    errorThresholdPercentage: parseInt(process.env.SENTIENGUARD_CIRCUIT_ERROR_THRESHOLD, 10) || 50,
-    // Time to wait before attempting recovery in milliseconds (default: 30s)
-    resetTimeout: parseInt(process.env.SENTIENGUARD_CIRCUIT_RESET_TIMEOUT, 10) || 30000,
-    // Minimum requests before calculating error percentage (default: 5)
-    volumeThreshold: parseInt(process.env.SENTIENGUARD_CIRCUIT_VOLUME_THRESHOLD, 10) || 5
+    enabled: false,
+    timeout: 3000,
+    errorThresholdPercentage: 50,
+    resetTimeout: 30000,
+    volumeThreshold: 5
   },
-
-  // OpenAI monitoring configuration
   openai: {
-    // Enable/disable OpenAI instrumentation (default: true)
-    enabled: process.env.SENTIENGUARD_OPENAI_ENABLED !== 'false',
-    // Track token usage (default: true)
-    trackTokens: process.env.SENTIENGUARD_OPENAI_TRACK_TOKENS !== 'false',
-    // Track estimated costs (default: true)
-    trackCosts: process.env.SENTIENGUARD_OPENAI_TRACK_COSTS !== 'false',
-    // Slow API call threshold in milliseconds (default: 5000ms / 5s)
-    slowCallMs: parseInt(process.env.SENTIENGUARD_OPENAI_SLOW_CALL_MS, 10) || 5000
+    enabled: true,
+    trackTokens: true,
+    trackCosts: true,
+    slowCallMs: 5000
   }
 };
 
 /**
- * Check if SDK is properly configured and should be active
+ * Load configuration from environment variables.
+ * Called lazily on first use (e.g., from initialize() or isEnabled()).
+ * Safe to call multiple times — only reads env vars once.
+ */
+export function loadConfig({ force = false } = {}) {
+  if (configLoaded && !force) return;
+  configLoaded = true;
+
+  config.apiKey = process.env.SENTIENGUARD_APM_KEY || '';
+  config.service = process.env.SENTIENGUARD_SERVICE || '';
+  config.environment = process.env.SENTIENGUARD_ENV || 'production';
+  config.endpoint = process.env.SENTIENGUARD_ENDPOINT || 'https://sentienguard-dev.the-algo.com/api/v1/apm/ingest';
+  config.flushInterval = parseInt(process.env.SENTIENGUARD_FLUSH_INTERVAL, 10) || 10;
+  config.maxRoutes = parseInt(process.env.SENTIENGUARD_MAX_ROUTES, 10) || 100;
+  config.maxPayloadSize = parseInt(process.env.SENTIENGUARD_MAX_PAYLOAD_SIZE, 10) || 1024 * 1024;
+  config.enabled = process.env.SENTIENGUARD_ENABLED !== 'false';
+  config.debug = process.env.SENTIENGUARD_DEBUG === 'true';
+
+  config.mongodb.enabled = process.env.SENTIENGUARD_MONGODB_ENABLED !== 'false';
+  config.mongodb.slowQueryMs = parseInt(process.env.SENTIENGUARD_MONGODB_SLOW_QUERY_MS, 10) || 100;
+  config.mongodb.poolStatsInterval = parseInt(process.env.SENTIENGUARD_MONGODB_POOL_INTERVAL, 10) || 10000;
+
+  config.circuitBreaker.enabled = process.env.SENTIENGUARD_CIRCUIT_BREAKER_ENABLED === 'true';
+  config.circuitBreaker.timeout = parseInt(process.env.SENTIENGUARD_CIRCUIT_TIMEOUT_MS, 10) || 3000;
+  config.circuitBreaker.errorThresholdPercentage = parseInt(process.env.SENTIENGUARD_CIRCUIT_ERROR_THRESHOLD, 10) || 50;
+  config.circuitBreaker.resetTimeout = parseInt(process.env.SENTIENGUARD_CIRCUIT_RESET_TIMEOUT, 10) || 30000;
+  config.circuitBreaker.volumeThreshold = parseInt(process.env.SENTIENGUARD_CIRCUIT_VOLUME_THRESHOLD, 10) || 5;
+
+  config.openai.enabled = process.env.SENTIENGUARD_OPENAI_ENABLED !== 'false';
+  config.openai.trackTokens = process.env.SENTIENGUARD_OPENAI_TRACK_TOKENS !== 'false';
+  config.openai.trackCosts = process.env.SENTIENGUARD_OPENAI_TRACK_COSTS !== 'false';
+  config.openai.slowCallMs = parseInt(process.env.SENTIENGUARD_OPENAI_SLOW_CALL_MS, 10) || 5000;
+}
+
+/**
+ * Check if SDK is properly configured and should be active.
+ * Triggers lazy config load if not yet loaded.
  */
 export function isEnabled() {
-  // SDK disables itself silently if no API key or service name
+  loadConfig();
   return config.enabled && !!config.apiKey && !!config.service;
 }
 
 /**
- * Get validated configuration
+ * Get validated configuration.
+ * Triggers lazy config load if not yet loaded.
  */
 export function getConfig() {
+  loadConfig();
   return { ...config };
 }
 

package/src/dependencies.js

@@ -1,236 +1,231 @@
-/**
- * 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();
-  const lowerPath = (path || '').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)
-  if (hostname === 'localhost' || hostname === '127.0.0.1') {
-    return true;
-  }
-
-  return false;
-}
-
-/**
- * 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 { 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
+};