vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/agents/PerformanceMetricsCollector.js

@@ -0,0 +1,493 @@
+/**
+ * Performance Metrics Collector
+ * 
+ * Collects and manages performance metrics for agent operations.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+/**
+ * Performance Metrics Collector class
+ */
+class PerformanceMetricsCollector {
+  /**
+   * Create metrics collector instance
+   * @param {Object} options - Collector options
+   */
+  constructor(options = {}) {
+    this.logger = options.logger || null;
+    this.enabled = options.enabled !== false; // Default to enabled
+    this.maxHistorySize = options.maxHistorySize || 1000;
+    this.flushInterval = options.flushInterval || 60000; // 1 minute
+    
+    // Metrics storage
+    this.metrics = {
+      operations: new Map(),
+      system: new Map(),
+      performance: new Map()
+    };
+    
+    // Active operations tracking
+    this.activeOperations = new Map();
+    
+    // Start periodic flush if enabled
+    if (this.enabled) {
+      this.startPeriodicFlush();
+    }
+  }
+
+  /**
+   * Start tracking an operation
+   * @param {string} operationId - Unique operation identifier
+   * @param {Object} context - Operation context
+   * @returns {Object} - Operation tracker
+   */
+  startOperation(operationId, context = {}) {
+    if (!this.enabled) return this.createNoOpTracker();
+    
+    const startTime = process.hrtime.bigint();
+    const startMemory = this.getMemoryUsage();
+    
+    const operation = {
+      id: operationId,
+      type: context.type || 'UNKNOWN',
+      agentId: context.agentId,
+      installerType: context.installerType,
+      startTime: Number(startTime / 1000000n), // Convert to milliseconds
+      startMemory,
+      status: 'RUNNING',
+      phases: [],
+      checkpoints: []
+    };
+    
+    this.activeOperations.set(operationId, operation);
+    
+    // Record initial system metrics
+    this.recordSystemMetrics('operation_start', {
+      operationId,
+      type: operation.type,
+      agentId: operation.agentId
+    });
+    
+    if (this.logger) {
+      this.logger.debug('Started operation tracking', {
+        operationId,
+        type: operation.type,
+        agentId: operation.agentId
+      });
+    }
+    
+    return {
+      addPhase: (phaseName, details = {}) => this.addOperationPhase(operationId, phaseName, details),
+      addCheckpoint: (checkpointName, details = {}) => this.addOperationCheckpoint(operationId, checkpointName, details),
+      complete: (result = {}) => this.completeOperation(operationId, result),
+      fail: (error) => this.failOperation(operationId, error),
+      getMetrics: () => this.getOperationMetrics(operationId)
+    };
+  }
+
+  /**
+   * Add phase to operation
+   * @param {string} operationId - Operation identifier
+   * @param {string} phaseName - Name of phase
+   * @param {Object} details - Phase details
+   */
+  addOperationPhase(operationId, phaseName, details = {}) {
+    if (!this.enabled) return;
+    
+    const operation = this.activeOperations.get(operationId);
+    if (!operation) return;
+    
+    const phase = {
+      name: phaseName,
+      startTime: Date.now(),
+      startMemory: this.getMemoryUsage(),
+      details
+    };
+    
+    operation.phases.push(phase);
+    
+    if (this.logger) {
+      this.logger.debug(`Added operation phase: ${phaseName}`, {
+        operationId,
+        phaseName,
+        details
+      });
+    }
+  }
+
+  /**
+   * Add checkpoint to operation
+   * @param {string} operationId - Operation identifier
+   * @param {string} checkpointName - Name of checkpoint
+   * @param {Object} details - Checkpoint details
+   */
+  addOperationCheckpoint(operationId, checkpointName, details = {}) {
+    if (!this.enabled) return;
+    
+    const operation = this.activeOperations.get(operationId);
+    if (!operation) return;
+    
+    const checkpoint = {
+      name: checkpointName,
+      timestamp: Date.now(),
+      memory: this.getMemoryUsage(),
+      details
+    };
+    
+    operation.checkpoints.push(checkpoint);
+    
+    if (this.logger) {
+      this.logger.debug(`Added operation checkpoint: ${checkpointName}`, {
+        operationId,
+        checkpointName,
+        details
+      });
+    }
+  }
+
+  /**
+   * Complete operation tracking
+   * @param {string} operationId - Operation identifier
+   * @param {Object} result - Operation result
+   */
+  completeOperation(operationId, result = {}) {
+    if (!this.enabled) return;
+    
+    const operation = this.activeOperations.get(operationId);
+    if (!operation) return;
+    
+    const endTime = process.hrtime.bigint();
+    const endMemory = this.getMemoryUsage();
+    
+    operation.endTime = Number(endTime / 1000000n);
+    operation.endMemory = endMemory;
+    operation.duration = operation.endTime - operation.startTime;
+    operation.memoryDelta = endMemory - operation.startMemory;
+    operation.status = 'COMPLETED';
+    operation.result = result;
+    
+    // Complete final phase
+    if (operation.phases.length > 0) {
+      const lastPhase = operation.phases[operation.phases.length - 1];
+      if (!lastPhase.endTime) {
+        lastPhase.endTime = operation.endTime;
+        lastPhase.duration = lastPhase.endTime - lastPhase.startTime;
+        lastPhase.memoryDelta = endMemory - lastPhase.startMemory;
+      }
+    }
+    
+    // Store in metrics
+    this.storeOperationMetrics(operation);
+    
+    // Remove from active operations
+    this.activeOperations.delete(operationId);
+    
+    // Record completion metrics
+    this.recordSystemMetrics('operation_complete', {
+      operationId,
+      type: operation.type,
+      duration: operation.duration,
+      memoryDelta: operation.memoryDelta,
+      success: true
+    });
+    
+    if (this.logger) {
+      this.logger.info('Completed operation tracking', {
+        operationId,
+        type: operation.type,
+        duration: operation.duration,
+        memoryDelta: operation.memoryDelta
+      });
+    }
+  }
+
+  /**
+   * Fail operation tracking
+   * @param {string} operationId - Operation identifier
+   * @param {Error} error - Error that caused failure
+   */
+  failOperation(operationId, error) {
+    if (!this.enabled) return;
+    
+    const operation = this.activeOperations.get(operationId);
+    if (!operation) return;
+    
+    const endTime = process.hrtime.bigint();
+    const endMemory = this.getMemoryUsage();
+    
+    operation.endTime = Number(endTime / 1000000n);
+    operation.endMemory = endMemory;
+    operation.duration = operation.endTime - operation.startTime;
+    operation.memoryDelta = endMemory - operation.startMemory;
+    operation.status = 'FAILED';
+    operation.error = error.message;
+    
+    // Store in metrics
+    this.storeOperationMetrics(operation);
+    
+    // Remove from active operations
+    this.activeOperations.delete(operationId);
+    
+    // Record failure metrics
+    this.recordSystemMetrics('operation_fail', {
+      operationId,
+      type: operation.type,
+      duration: operation.duration,
+      error: error.message,
+      success: false
+    });
+    
+    if (this.logger) {
+      this.logger.warn('Failed operation tracking', {
+        operationId,
+        type: operation.type,
+        duration: operation.duration,
+        error: error.message
+      });
+    }
+  }
+
+  /**
+   * Store operation metrics
+   * @param {Object} operation - Operation to store
+   */
+  storeOperationMetrics(operation) {
+    const typeMetrics = this.metrics.operations.get(operation.type) || [];
+    typeMetrics.push(operation);
+    
+    // Limit history size
+    if (typeMetrics.length > this.maxHistorySize) {
+      typeMetrics.shift();
+    }
+    
+    this.metrics.operations.set(operation.type, typeMetrics);
+  }
+
+  /**
+   * Record system metrics
+   * @param {string} event - Event type
+   * @param {Object} data - Event data
+   */
+  recordSystemMetrics(event, data = {}) {
+    if (!this.enabled) return;
+    
+    const timestamp = Date.now();
+    const memory = this.getMemoryUsage();
+    const cpu = this.getCpuUsage();
+    
+    const metric = {
+      timestamp,
+      event,
+      memory,
+      cpu,
+      data
+    };
+    
+    const systemMetrics = this.metrics.system.get(event) || [];
+    systemMetrics.push(metric);
+    
+    // Limit history size
+    if (systemMetrics.length > this.maxHistorySize) {
+      systemMetrics.shift();
+    }
+    
+    this.metrics.system.set(event, systemMetrics);
+  }
+
+  /**
+   * Get operation metrics
+   * @param {string} operationId - Operation identifier
+   * @returns {Object|null} - Operation metrics or null
+   */
+  getOperationMetrics(operationId) {
+    const operation = this.activeOperations.get(operationId);
+    if (!operation) return null;
+    
+    const currentMemory = this.getMemoryUsage();
+    const currentTime = Date.now();
+    
+    return {
+      id: operation.id,
+      type: operation.type,
+      agentId: operation.agentId,
+      status: operation.status,
+      startTime: operation.startTime,
+      currentDuration: currentTime - operation.startTime,
+      currentMemoryDelta: currentMemory - operation.startMemory,
+      phases: operation.phases,
+      checkpoints: operation.checkpoints
+    };
+  }
+
+  /**
+   * Get aggregated metrics
+   * @param {Object} filters - Filters to apply
+   * @returns {Object} - Aggregated metrics
+   */
+  getAggregatedMetrics(filters = {}) {
+    if (!this.enabled) return {};
+    
+    const { operationType, timeRange, agentId } = filters;
+    const now = Date.now();
+    const timeLimit = timeRange ? now - timeRange : 0;
+    
+    const result = {
+      summary: {},
+      operations: {},
+      performance: {},
+      system: {}
+    };
+    
+    // Aggregate operation metrics
+    for (const [type, operations] of this.metrics.operations) {
+      if (operationType && type !== operationType) continue;
+      
+      const filteredOps = operations.filter(op => 
+        op.endTime >= timeLimit && 
+        (!agentId || op.agentId === agentId)
+      );
+      
+      if (filteredOps.length === 0) continue;
+      
+      const completed = filteredOps.filter(op => op.status === 'COMPLETED');
+      const failed = filteredOps.filter(op => op.status === 'FAILED');
+      
+      const durations = completed.map(op => op.duration);
+      const memoryDeltas = completed.map(op => op.memoryDelta);
+      
+      result.operations[type] = {
+        total: filteredOps.length,
+        completed: completed.length,
+        failed: failed.length,
+        successRate: filteredOps.length > 0 ? (completed.length / filteredOps.length) * 100 : 0,
+        avgDuration: durations.length > 0 ? durations.reduce((a, b) => a + b, 0) / durations.length : 0,
+        minDuration: durations.length > 0 ? Math.min(...durations) : 0,
+        maxDuration: durations.length > 0 ? Math.max(...durations) : 0,
+        avgMemoryDelta: memoryDeltas.length > 0 ? memoryDeltas.reduce((a, b) => a + b, 0) / memoryDeltas.length : 0
+      };
+    }
+    
+    // System metrics summary
+    for (const [event, metrics] of this.metrics.system) {
+      const recentMetrics = metrics.filter(m => m.timestamp >= timeLimit);
+      result.system[event] = {
+        count: recentMetrics.length,
+        avgMemory: recentMetrics.length > 0 ? recentMetrics.reduce((sum, m) => sum + m.memory, 0) / recentMetrics.length : 0,
+        avgCpu: recentMetrics.length > 0 ? recentMetrics.reduce((sum, m) => sum + (m.cpu || 0), 0) / recentMetrics.length : 0
+      };
+    }
+    
+    return result;
+  }
+
+  /**
+   * Get memory usage
+   * @returns {number} - Memory usage in MB
+   */
+  getMemoryUsage() {
+    const usage = process.memoryUsage();
+    return Math.round(usage.heapUsed / 1024 / 1024); // MB
+  }
+
+  /**
+   * Get CPU usage
+   * @returns {number} - CPU usage percentage
+   */
+  getCpuUsage() {
+    const usage = process.cpuUsage();
+    return Math.round((usage.user + usage.system) / 1000000); // Convert to milliseconds
+  }
+
+  /**
+   * Start periodic flush
+   */
+  startPeriodicFlush() {
+    if (this.flushTimer) return;
+    
+    this.flushTimer = setInterval(() => {
+      this.flushMetrics();
+    }, this.flushInterval);
+  }
+
+  /**
+   * Stop periodic flush
+   */
+  stopPeriodicFlush() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+
+  /**
+   * Flush metrics to storage/log
+   */
+  flushMetrics() {
+    if (!this.enabled) return;
+    
+    const metrics = this.getAggregatedMetrics();
+    
+    if (this.logger) {
+      this.logger.debug('Flushing performance metrics', {
+        operationsCount: Object.keys(metrics.operations).length,
+        systemEventsCount: Object.keys(metrics.system).length
+      });
+    }
+    
+    // Could integrate with external metrics systems here
+    // For now, just log summary
+  }
+
+  /**
+   * Create no-op tracker for when metrics are disabled
+   * @returns {Object} - No-op tracker
+   */
+  createNoOpTracker() {
+    return {
+      addPhase: () => {},
+      addCheckpoint: () => {},
+      complete: () => {},
+      fail: () => {},
+      getMetrics: () => null
+    };
+  }
+
+  /**
+   * Reset all metrics
+   */
+  reset() {
+    this.metrics.operations.clear();
+    this.metrics.system.clear();
+    this.metrics.performance.clear();
+    this.activeOperations.clear();
+    
+    if (this.logger) {
+      this.logger.info('Reset all performance metrics');
+    }
+  }
+
+  /**
+   * Get current configuration
+   * @returns {Object} - Current configuration
+   */
+  getConfiguration() {
+    return {
+      enabled: this.enabled,
+      maxHistorySize: this.maxHistorySize,
+      flushInterval: this.flushInterval,
+      activeOperations: this.activeOperations.size,
+      operationTypes: Array.from(this.metrics.operations.keys()),
+      systemEvents: Array.from(this.metrics.system.keys())
+    };
+  }
+
+  /**
+   * Cleanup resources
+   */
+  cleanup() {
+    this.stopPeriodicFlush();
+    this.reset();
+  }
+}
+
+module.exports = PerformanceMetricsCollector;