@sentienguard/apm 1.0.5 → 1.0.6

package/src/aggregator.js

@@ -1,463 +1,463 @@
-/**
- * Metrics Aggregator
- * Aggregates metrics in memory per interval.
- * Never streams raw events - only sends aggregated data.
- *
- * Aggregation key: (service, method, route) for requests
- * Aggregation key: (service, name, type) for dependencies
- * Aggregation key: (collection, operation) for MongoDB operations
- */
-
-import { RouteRegistry } from './normalizer.js';
-import config from './config.js';
-
-/**
- * Create an aggregation key for request metrics
- */
-function createRequestKey(method, route) {
-  return `${method}:${route}`;
-}
-
-/**
- * Create an aggregation key for dependency metrics
- */
-function createDependencyKey(name, type) {
-  return `${name}:${type}`;
-}
-
-/**
- * Create an aggregation key for MongoDB operation metrics
- */
-function createMongoKey(collection, operation) {
-  return `${collection}:${operation}`;
-}
-
-/**
- * Create an aggregation key for OpenAI operation metrics
- */
-function createOpenAIKey(operation, model) {
-  return `${operation}:${model}`;
-}
-
-/**
- * Metrics Aggregator class
- * Maintains in-memory aggregated metrics that are flushed periodically
- */
-export class MetricsAggregator {
-  constructor() {
-    this.routeRegistry = new RouteRegistry(config.maxRoutes);
-    this.reset();
-  }
-
-  /**
-   * Reset all aggregated metrics (called after flush)
-   */
-  reset() {
-    // Request metrics: Map<key, {count, errorCount, latency: {sum, min, max}}>
-    this.requests = new Map();
-
-    // Dependency metrics: Map<key, {name, type, count, errorCount, latency: {sum, min, max}}>
-    this.dependencies = new Map();
-
-    // MongoDB operation metrics: Map<key, {collection, operation, count, errorCount, latency: {sum, min, max}}>
-    this.mongodbOperations = new Map();
-
-    // MongoDB slow queries: Array<{collection, operation, latency, timestamp}>
-    this.slowQueries = [];
-
-    // OpenAI operation metrics: Map<key, {operation, model, count, errorCount, latency, tokens, cost}>
-    this.openaiOperations = new Map();
-
-    // MongoDB connection pool stats (updated periodically, not reset)
-    if (!this.mongodbPoolStats) {
-      this.mongodbPoolStats = {
-        active: 0,
-        idle: 0,
-        waitQueueSize: 0,
-        lastUpdated: null
-      };
-    }
-
-    // Circuit breaker state changes: Array<{service, state, timestamp}>
-    this.circuitBreakerStates = [];
-
-    // Error counter for unhandled exceptions
-    this.unhandledErrors = 0;
-  }
-
-  /**
-   * Record an incoming HTTP request
-   *
-   * @param {string} method - HTTP method (GET, POST, etc.)
-   * @param {string} route - Normalized route path
-   * @param {number} latency - Response time in milliseconds
-   * @param {boolean} isError - Whether the request resulted in an error (4xx/5xx)
-   */
-  recordRequest(method, route, latency, isError = false) {
-    // Register route with limit enforcement
-    const registeredRoute = this.routeRegistry.register(route);
-    const key = createRequestKey(method.toUpperCase(), registeredRoute);
-
-    let metric = this.requests.get(key);
-    if (!metric) {
-      metric = {
-        method: method.toUpperCase(),
-        route: registeredRoute,
-        count: 0,
-        errorCount: 0,
-        latency: {
-          sum: 0,
-          min: Infinity,
-          max: 0
-        }
-      };
-      this.requests.set(key, metric);
-    }
-
-    metric.count++;
-    if (isError) {
-      metric.errorCount++;
-    }
-
-    metric.latency.sum += latency;
-    metric.latency.min = Math.min(metric.latency.min, latency);
-    metric.latency.max = Math.max(metric.latency.max, latency);
-  }
-
-  /**
-   * Record an outgoing dependency call
-   *
-   * @param {string} name - Dependency name (e.g., "OpenAI API", "MongoDB")
-   * @param {string} type - Dependency type (http, db, cache)
-   * @param {number} latency - Response time in milliseconds
-   * @param {boolean} isError - Whether the call resulted in an error
-   */
-  recordDependency(name, type, latency, isError = false) {
-    const key = createDependencyKey(name, type);
-
-    let metric = this.dependencies.get(key);
-    if (!metric) {
-      metric = {
-        name,
-        type,
-        count: 0,
-        errorCount: 0,
-        latency: {
-          sum: 0,
-          min: Infinity,
-          max: 0
-        }
-      };
-      this.dependencies.set(key, metric);
-    }
-
-    metric.count++;
-    if (isError) {
-      metric.errorCount++;
-    }
-
-    metric.latency.sum += latency;
-    metric.latency.min = Math.min(metric.latency.min, latency);
-    metric.latency.max = Math.max(metric.latency.max, latency);
-  }
-
-  /**
-   * Record an unhandled error
-   */
-  recordError() {
-    this.unhandledErrors++;
-  }
-
-  /**
-   * Record a MongoDB operation
-   *
-   * @param {string} collection - Collection name
-   * @param {string} operation - Operation type (find, insert, update, delete, aggregate)
-   * @param {number} latency - Response time in milliseconds
-   * @param {boolean} isError - Whether the operation resulted in an error
-   */
-  recordMongoOperation(collection, operation, latency, isError = false) {
-    const key = createMongoKey(collection, operation);
-
-    let metric = this.mongodbOperations.get(key);
-    if (!metric) {
-      metric = {
-        collection,
-        operation,
-        count: 0,
-        errorCount: 0,
-        latency: {
-          sum: 0,
-          min: Infinity,
-          max: 0
-        }
-      };
-      this.mongodbOperations.set(key, metric);
-    }
-
-    metric.count++;
-    if (isError) {
-      metric.errorCount++;
-    }
-
-    metric.latency.sum += latency;
-    metric.latency.min = Math.min(metric.latency.min, latency);
-    metric.latency.max = Math.max(metric.latency.max, latency);
-  }
-
-  /**
-   * Record a slow MongoDB query
-   *
-   * @param {string} collection - Collection name
-   * @param {string} operation - Operation type
-   * @param {number} latency - Response time in milliseconds
-   */
-  recordSlowQuery(collection, operation, latency) {
-    // Keep only the most recent slow queries (max 100 per interval)
-    if (this.slowQueries.length >= 100) {
-      this.slowQueries.shift();
-    }
-
-    this.slowQueries.push({
-      collection,
-      operation,
-      latency: Math.round(latency),
-      timestamp: Date.now()
-    });
-  }
-
-  /**
-   * Record an OpenAI API operation
-   *
-   * @param {Object} data - Operation data
-   * @param {string} data.operation - Operation type (chat.completions, embeddings, images.generate, etc.)
-   * @param {string} data.model - Model used (gpt-4, gpt-3.5-turbo, etc.)
-   * @param {number} data.latency - Response time in milliseconds
-   * @param {number} data.promptTokens - Number of prompt tokens used
-   * @param {number} data.completionTokens - Number of completion tokens used
-   * @param {number} data.totalTokens - Total tokens used
-   * @param {number} data.cost - Estimated cost in USD
-   * @param {string|null} data.error - Error message if failed
-   * @param {number} data.statusCode - HTTP status code
-   */
-  recordOpenAIOperation(data) {
-    const key = createOpenAIKey(data.operation, data.model);
-
-    let metric = this.openaiOperations.get(key);
-    if (!metric) {
-      metric = {
-        operation: data.operation,
-        model: data.model,
-        count: 0,
-        errorCount: 0,
-        latency: {
-          sum: 0,
-          min: Infinity,
-          max: 0
-        },
-        tokens: {
-          prompt: 0,
-          completion: 0,
-          total: 0
-        },
-        cost: 0
-      };
-      this.openaiOperations.set(key, metric);
-    }
-
-    metric.count++;
-    if (data.error) {
-      metric.errorCount++;
-    }
-
-    metric.latency.sum += data.latency;
-    metric.latency.min = Math.min(metric.latency.min, data.latency);
-    metric.latency.max = Math.max(metric.latency.max, data.latency);
-
-    metric.tokens.prompt += data.promptTokens || 0;
-    metric.tokens.completion += data.completionTokens || 0;
-    metric.tokens.total += data.totalTokens || 0;
-
-    metric.cost += data.cost || 0;
-  }
-
-  /**
-   * Update MongoDB connection pool statistics
-   *
-   * @param {Object} stats - Pool statistics
-   * @param {number} stats.active - Active connections (checked out)
-   * @param {number} stats.idle - Idle connections (available in pool)
-   * @param {number} stats.waitQueueSize - Wait queue size
-   * @param {number} stats.total - Total connections in pool
-   */
-  updatePoolStats(stats) {
-    this.mongodbPoolStats = {
-      active: stats.active || 0,
-      idle: stats.idle || 0,
-      waitQueueSize: stats.waitQueueSize || 0,
-      total: stats.total || (stats.active || 0) + (stats.idle || 0),
-      lastUpdated: Date.now()
-    };
-  }
-
-  /**
-   * Record a circuit breaker state change
-   *
-   * @param {string} service - Service/dependency name (e.g., 'mongodb')
-   * @param {string} state - New state ('open', 'halfOpen', 'close')
-   */
-  recordCircuitState(service, state) {
-    this.circuitBreakerStates.push({
-      service,
-      state,
-      timestamp: Date.now()
-    });
-  }
-
-  /**
-   * Check if there's data to flush
-   */
-  hasData() {
-    return this.requests.size > 0 ||
-           this.dependencies.size > 0 ||
-           this.mongodbOperations.size > 0 ||
-           this.slowQueries.length > 0 ||
-           this.circuitBreakerStates.length > 0 ||
-           this.openaiOperations.size > 0;
-  }
-
-  /**
-   * Get aggregated data for flushing to backend
-   * Returns the payload in the expected format and resets counters
-   */
-  flush() {
-    const payload = {
-      interval: `${config.flushInterval}s`,
-      service: config.service,
-      environment: config.environment,
-      requests: [],
-      dependencies: [],
-      mongodb: [],
-      mongodbPool: null,
-      slowQueries: [],
-      circuitBreaker: [],
-      openai: []
-    };
-
-    // Convert request metrics to array
-    for (const metric of this.requests.values()) {
-      payload.requests.push({
-        method: metric.method,
-        route: metric.route,
-        count: metric.count,
-        errorCount: metric.errorCount,
-        latency: {
-          sum: Math.round(metric.latency.sum),
-          min: metric.latency.min === Infinity ? 0 : Math.round(metric.latency.min),
-          max: Math.round(metric.latency.max)
-        }
-      });
-    }
-
-    // Convert dependency metrics to array
-    for (const metric of this.dependencies.values()) {
-      payload.dependencies.push({
-        name: metric.name,
-        type: metric.type,
-        count: metric.count,
-        errorCount: metric.errorCount,
-        latency: {
-          sum: Math.round(metric.latency.sum),
-          min: metric.latency.min === Infinity ? 0 : Math.round(metric.latency.min),
-          max: Math.round(metric.latency.max)
-        }
-      });
-    }
-
-    // Convert MongoDB operation metrics to array
-    for (const metric of this.mongodbOperations.values()) {
-      payload.mongodb.push({
-        collection: metric.collection,
-        operation: metric.operation,
-        count: metric.count,
-        errorCount: metric.errorCount,
-        latency: {
-          sum: Math.round(metric.latency.sum),
-          min: metric.latency.min === Infinity ? 0 : Math.round(metric.latency.min),
-          max: Math.round(metric.latency.max)
-        }
-      });
-    }
-
-    // Include MongoDB pool stats if available
-    if (this.mongodbPoolStats && this.mongodbPoolStats.lastUpdated) {
-      payload.mongodbPool = { ...this.mongodbPoolStats };
-    }
-
-    // Include slow queries
-    payload.slowQueries = [...this.slowQueries];
-
-    // Include circuit breaker state changes
-    payload.circuitBreaker = [...this.circuitBreakerStates];
-
-    // Convert OpenAI operation metrics to array
-    for (const metric of this.openaiOperations.values()) {
-      payload.openai.push({
-        operation: metric.operation,
-        model: metric.model,
-        count: metric.count,
-        errorCount: metric.errorCount,
-        latency: {
-          sum: Math.round(metric.latency.sum),
-          min: metric.latency.min === Infinity ? 0 : Math.round(metric.latency.min),
-          max: Math.round(metric.latency.max)
-        },
-        tokens: {
-          prompt: metric.tokens.prompt,
-          completion: metric.tokens.completion,
-          total: metric.tokens.total
-        },
-        cost: Math.round(metric.cost * 1000000) / 1000000 // 6 decimal places
-      });
-    }
-
-    // Reset for next interval
-    this.reset();
-
-    return payload;
-  }
-
-  /**
-   * Get current metrics count (for monitoring/testing)
-   */
-  getStats() {
-    return {
-      requestMetrics: this.requests.size,
-      dependencyMetrics: this.dependencies.size,
-      mongodbMetrics: this.mongodbOperations.size,
-      openaiMetrics: this.openaiOperations.size,
-      slowQueries: this.slowQueries.length,
-      circuitBreakerEvents: this.circuitBreakerStates.length,
-      uniqueRoutes: this.routeRegistry.size,
-      unhandledErrors: this.unhandledErrors
-    };
-  }
-}
-
-// Singleton instance
-let instance = null;
-
-/**
- * Get the singleton aggregator instance
- */
-export function getAggregator() {
-  if (!instance) {
-    instance = new MetricsAggregator();
-  }
-  return instance;
-}
-
-export default {
-  MetricsAggregator,
-  getAggregator
-};
+/**
+ * Metrics Aggregator
+ * Aggregates metrics in memory per interval.
+ * Never streams raw events - only sends aggregated data.
+ *
+ * Aggregation key: (service, method, route) for requests
+ * Aggregation key: (service, name, type) for dependencies
+ * Aggregation key: (collection, operation) for MongoDB operations
+ */
+
+import { RouteRegistry } from './normalizer.js';
+import config from './config.js';
+
+/**
+ * Create an aggregation key for request metrics
+ */
+function createRequestKey(method, route) {
+  return `${method}:${route}`;
+}
+
+/**
+ * Create an aggregation key for dependency metrics
+ */
+function createDependencyKey(name, type) {
+  return `${name}:${type}`;
+}
+
+/**
+ * Create an aggregation key for MongoDB operation metrics
+ */
+function createMongoKey(collection, operation) {
+  return `${collection}:${operation}`;
+}
+
+/**
+ * Create an aggregation key for OpenAI operation metrics
+ */
+function createOpenAIKey(operation, model) {
+  return `${operation}:${model}`;
+}
+
+/**
+ * Metrics Aggregator class
+ * Maintains in-memory aggregated metrics that are flushed periodically
+ */
+export class MetricsAggregator {
+  constructor() {
+    this.routeRegistry = new RouteRegistry(config.maxRoutes);
+    this.reset();
+  }
+
+  /**
+   * Reset all aggregated metrics (called after flush)
+   */
+  reset() {
+    // Request metrics: Map<key, {count, errorCount, latency: {sum, min, max}}>
+    this.requests = new Map();
+
+    // Dependency metrics: Map<key, {name, type, count, errorCount, latency: {sum, min, max}}>
+    this.dependencies = new Map();
+
+    // MongoDB operation metrics: Map<key, {collection, operation, count, errorCount, latency: {sum, min, max}}>
+    this.mongodbOperations = new Map();
+
+    // MongoDB slow queries: Array<{collection, operation, latency, timestamp}>
+    this.slowQueries = [];
+
+    // OpenAI operation metrics: Map<key, {operation, model, count, errorCount, latency, tokens, cost}>
+    this.openaiOperations = new Map();
+
+    // MongoDB connection pool stats (updated periodically, not reset)
+    if (!this.mongodbPoolStats) {
+      this.mongodbPoolStats = {
+        active: 0,
+        idle: 0,
+        waitQueueSize: 0,
+        lastUpdated: null
+      };
+    }
+
+    // Circuit breaker state changes: Array<{service, state, timestamp}>
+    this.circuitBreakerStates = [];
+
+    // Error counter for unhandled exceptions
+    this.unhandledErrors = 0;
+  }
+
+  /**
+   * Record an incoming HTTP request
+   *
+   * @param {string} method - HTTP method (GET, POST, etc.)
+   * @param {string} route - Normalized route path
+   * @param {number} latency - Response time in milliseconds
+   * @param {boolean} isError - Whether the request resulted in an error (4xx/5xx)
+   */
+  recordRequest(method, route, latency, isError = false) {
+    // Register route with limit enforcement
+    const registeredRoute = this.routeRegistry.register(route);
+    const key = createRequestKey(method.toUpperCase(), registeredRoute);
+
+    let metric = this.requests.get(key);
+    if (!metric) {
+      metric = {
+        method: method.toUpperCase(),
+        route: registeredRoute,
+        count: 0,
+        errorCount: 0,
+        latency: {
+          sum: 0,
+          min: Infinity,
+          max: 0
+        }
+      };
+      this.requests.set(key, metric);
+    }
+
+    metric.count++;
+    if (isError) {
+      metric.errorCount++;
+    }
+
+    metric.latency.sum += latency;
+    metric.latency.min = Math.min(metric.latency.min, latency);
+    metric.latency.max = Math.max(metric.latency.max, latency);
+  }
+
+  /**
+   * Record an outgoing dependency call
+   *
+   * @param {string} name - Dependency name (e.g., "OpenAI API", "MongoDB")
+   * @param {string} type - Dependency type (http, db, cache)
+   * @param {number} latency - Response time in milliseconds
+   * @param {boolean} isError - Whether the call resulted in an error
+   */
+  recordDependency(name, type, latency, isError = false) {
+    const key = createDependencyKey(name, type);
+
+    let metric = this.dependencies.get(key);
+    if (!metric) {
+      metric = {
+        name,
+        type,
+        count: 0,
+        errorCount: 0,
+        latency: {
+          sum: 0,
+          min: Infinity,
+          max: 0
+        }
+      };
+      this.dependencies.set(key, metric);
+    }
+
+    metric.count++;
+    if (isError) {
+      metric.errorCount++;
+    }
+
+    metric.latency.sum += latency;
+    metric.latency.min = Math.min(metric.latency.min, latency);
+    metric.latency.max = Math.max(metric.latency.max, latency);
+  }
+
+  /**
+   * Record an unhandled error
+   */
+  recordError() {
+    this.unhandledErrors++;
+  }
+
+  /**
+   * Record a MongoDB operation
+   *
+   * @param {string} collection - Collection name
+   * @param {string} operation - Operation type (find, insert, update, delete, aggregate)
+   * @param {number} latency - Response time in milliseconds
+   * @param {boolean} isError - Whether the operation resulted in an error
+   */
+  recordMongoOperation(collection, operation, latency, isError = false) {
+    const key = createMongoKey(collection, operation);
+
+    let metric = this.mongodbOperations.get(key);
+    if (!metric) {
+      metric = {
+        collection,
+        operation,
+        count: 0,
+        errorCount: 0,
+        latency: {
+          sum: 0,
+          min: Infinity,
+          max: 0
+        }
+      };
+      this.mongodbOperations.set(key, metric);
+    }
+
+    metric.count++;
+    if (isError) {
+      metric.errorCount++;
+    }
+
+    metric.latency.sum += latency;
+    metric.latency.min = Math.min(metric.latency.min, latency);
+    metric.latency.max = Math.max(metric.latency.max, latency);
+  }
+
+  /**
+   * Record a slow MongoDB query
+   *
+   * @param {string} collection - Collection name
+   * @param {string} operation - Operation type
+   * @param {number} latency - Response time in milliseconds
+   */
+  recordSlowQuery(collection, operation, latency) {
+    // Keep only the most recent slow queries (max 100 per interval)
+    if (this.slowQueries.length >= 100) {
+      this.slowQueries.shift();
+    }
+
+    this.slowQueries.push({
+      collection,
+      operation,
+      latency: Math.round(latency),
+      timestamp: Date.now()
+    });
+  }
+
+  /**
+   * Record an OpenAI API operation
+   *
+   * @param {Object} data - Operation data
+   * @param {string} data.operation - Operation type (chat.completions, embeddings, images.generate, etc.)
+   * @param {string} data.model - Model used (gpt-4, gpt-3.5-turbo, etc.)
+   * @param {number} data.latency - Response time in milliseconds
+   * @param {number} data.promptTokens - Number of prompt tokens used
+   * @param {number} data.completionTokens - Number of completion tokens used
+   * @param {number} data.totalTokens - Total tokens used
+   * @param {number} data.cost - Estimated cost in USD
+   * @param {string|null} data.error - Error message if failed
+   * @param {number} data.statusCode - HTTP status code
+   */
+  recordOpenAIOperation(data) {
+    const key = createOpenAIKey(data.operation, data.model);
+
+    let metric = this.openaiOperations.get(key);
+    if (!metric) {
+      metric = {
+        operation: data.operation,
+        model: data.model,
+        count: 0,
+        errorCount: 0,
+        latency: {
+          sum: 0,
+          min: Infinity,
+          max: 0
+        },
+        tokens: {
+          prompt: 0,
+          completion: 0,
+          total: 0
+        },
+        cost: 0
+      };
+      this.openaiOperations.set(key, metric);
+    }
+
+    metric.count++;
+    if (data.error) {
+      metric.errorCount++;
+    }
+
+    metric.latency.sum += data.latency;
+    metric.latency.min = Math.min(metric.latency.min, data.latency);
+    metric.latency.max = Math.max(metric.latency.max, data.latency);
+
+    metric.tokens.prompt += data.promptTokens || 0;
+    metric.tokens.completion += data.completionTokens || 0;
+    metric.tokens.total += data.totalTokens || 0;
+
+    metric.cost += data.cost || 0;
+  }
+
+  /**
+   * Update MongoDB connection pool statistics
+   *
+   * @param {Object} stats - Pool statistics
+   * @param {number} stats.active - Active connections (checked out)
+   * @param {number} stats.idle - Idle connections (available in pool)
+   * @param {number} stats.waitQueueSize - Wait queue size
+   * @param {number} stats.total - Total connections in pool
+   */
+  updatePoolStats(stats) {
+    this.mongodbPoolStats = {
+      active: stats.active || 0,
+      idle: stats.idle || 0,
+      waitQueueSize: stats.waitQueueSize || 0,
+      total: stats.total || (stats.active || 0) + (stats.idle || 0),
+      lastUpdated: Date.now()
+    };
+  }
+
+  /**
+   * Record a circuit breaker state change
+   *
+   * @param {string} service - Service/dependency name (e.g., 'mongodb')
+   * @param {string} state - New state ('open', 'halfOpen', 'close')
+   */
+  recordCircuitState(service, state) {
+    this.circuitBreakerStates.push({
+      service,
+      state,
+      timestamp: Date.now()
+    });
+  }
+
+  /**
+   * Check if there's data to flush
+   */
+  hasData() {
+    return this.requests.size > 0 ||
+           this.dependencies.size > 0 ||
+           this.mongodbOperations.size > 0 ||
+           this.slowQueries.length > 0 ||
+           this.circuitBreakerStates.length > 0 ||
+           this.openaiOperations.size > 0;
+  }
+
+  /**
+   * Get aggregated data for flushing to backend
+   * Returns the payload in the expected format and resets counters
+   */
+  flush() {
+    const payload = {
+      interval: `${config.flushInterval}s`,
+      service: config.service,
+      environment: config.environment,
+      requests: [],
+      dependencies: [],
+      mongodb: [],
+      mongodbPool: null,
+      slowQueries: [],
+      circuitBreaker: [],
+      openai: []
+    };
+
+    // Convert request metrics to array
+    for (const metric of this.requests.values()) {
+      payload.requests.push({
+        method: metric.method,
+        route: metric.route,
+        count: metric.count,
+        errorCount: metric.errorCount,
+        latency: {
+          sum: Math.round(metric.latency.sum),
+          min: metric.latency.min === Infinity ? 0 : Math.round(metric.latency.min),
+          max: Math.round(metric.latency.max)
+        }
+      });
+    }
+
+    // Convert dependency metrics to array
+    for (const metric of this.dependencies.values()) {
+      payload.dependencies.push({
+        name: metric.name,
+        type: metric.type,
+        count: metric.count,
+        errorCount: metric.errorCount,
+        latency: {
+          sum: Math.round(metric.latency.sum),
+          min: metric.latency.min === Infinity ? 0 : Math.round(metric.latency.min),
+          max: Math.round(metric.latency.max)
+        }
+      });
+    }
+
+    // Convert MongoDB operation metrics to array
+    for (const metric of this.mongodbOperations.values()) {
+      payload.mongodb.push({
+        collection: metric.collection,
+        operation: metric.operation,
+        count: metric.count,
+        errorCount: metric.errorCount,
+        latency: {
+          sum: Math.round(metric.latency.sum),
+          min: metric.latency.min === Infinity ? 0 : Math.round(metric.latency.min),
+          max: Math.round(metric.latency.max)
+        }
+      });
+    }
+
+    // Include MongoDB pool stats if available
+    if (this.mongodbPoolStats?.lastUpdated) {
+      payload.mongodbPool = { ...this.mongodbPoolStats };
+    }
+
+    // Include slow queries
+    payload.slowQueries = [...this.slowQueries];
+
+    // Include circuit breaker state changes
+    payload.circuitBreaker = [...this.circuitBreakerStates];
+
+    // Convert OpenAI operation metrics to array
+    for (const metric of this.openaiOperations.values()) {
+      payload.openai.push({
+        operation: metric.operation,
+        model: metric.model,
+        count: metric.count,
+        errorCount: metric.errorCount,
+        latency: {
+          sum: Math.round(metric.latency.sum),
+          min: metric.latency.min === Infinity ? 0 : Math.round(metric.latency.min),
+          max: Math.round(metric.latency.max)
+        },
+        tokens: {
+          prompt: metric.tokens.prompt,
+          completion: metric.tokens.completion,
+          total: metric.tokens.total
+        },
+        cost: Math.round(metric.cost * 1000000) / 1000000 // 6 decimal places
+      });
+    }
+
+    // Reset for next interval
+    this.reset();
+
+    return payload;
+  }
+
+  /**
+   * Get current metrics count (for monitoring/testing)
+   */
+  getStats() {
+    return {
+      requestMetrics: this.requests.size,
+      dependencyMetrics: this.dependencies.size,
+      mongodbMetrics: this.mongodbOperations.size,
+      openaiMetrics: this.openaiOperations.size,
+      slowQueries: this.slowQueries.length,
+      circuitBreakerEvents: this.circuitBreakerStates.length,
+      uniqueRoutes: this.routeRegistry.size,
+      unhandledErrors: this.unhandledErrors
+    };
+  }
+}
+
+// Singleton instance
+let instance = null;
+
+/**
+ * Get the singleton aggregator instance
+ */
+export function getAggregator() {
+  if (!instance) {
+    instance = new MetricsAggregator();
+  }
+  return instance;
+}
+
+export default {
+  MetricsAggregator,
+  getAggregator
+};