@clduab11/gemini-flow/src/monitoring/performance-monitor.ts

Revolutionary AI agent swarm coordination platform with Google Services integration, multimedia processing, and production-ready monitoring. Features 8 Google AI services, quantum computing capabilities, and enterprise-grade security.

/**
 * Performance Monitor
 *
 * Monitors and tracks performance metrics for parallel operations
 */

import { Logger } from "../utils/logger.js";

interface MetricData {
  value: number;
  timestamp: number;
  metadata?: any;
}

export class PerformanceMonitor {
  private metrics: Map<string, MetricData[]> = new Map();
  private logger: Logger;

  constructor() {
    this.logger = new Logger("PerformanceMonitor");
  }

  recordMetric(name: string, value: number, metadata?: any): void {
    if (!this.metrics.has(name)) {
      this.metrics.set(name, []);
    }

    this.metrics.get(name)!.push({
      value,
      timestamp: Date.now(),
      metadata,
    });

    // Keep only last 1000 entries per metric
    const entries = this.metrics.get(name)!;
    if (entries.length > 1000) {
      entries.splice(0, entries.length - 1000);
    }
  }

  getMetric(name: string): MetricData[] {
    return this.metrics.get(name) || [];
  }

  getAverageMetric(name: string, windowMs?: number): number {
    const entries = this.getMetric(name);
    if (entries.length === 0) return 0;

    let filteredEntries = entries;
    if (windowMs) {
      const cutoff = Date.now() - windowMs;
      filteredEntries = entries.filter((entry) => entry.timestamp >= cutoff);
    }

    if (filteredEntries.length === 0) return 0;

    const sum = filteredEntries.reduce((acc, entry) => acc + entry.value, 0);
    return sum / filteredEntries.length;
  }

  getPercentileMetric(name: string, percentile: number): number {
    const entries = this.getMetric(name);
    if (entries.length === 0) return 0;

    const values = entries.map((entry) => entry.value).sort((a, b) => a - b);
    const index = Math.ceil((percentile / 100) * values.length) - 1;
    return values[Math.max(0, index)];
  }

  clearMetrics(): void {
    this.metrics.clear();
  }

  getAllMetrics(): Record<string, any> {
    const result: Record<string, any> = {};

    for (const [name, entries] of this.metrics.entries()) {
      if (entries.length > 0) {
        result[name] = {
          current: entries[entries.length - 1].value,
          average: this.getAverageMetric(name),
          p95: this.getPercentileMetric(name, 95),
          p99: this.getPercentileMetric(name, 99),
          count: entries.length,
        };
      }
    }

    return result;
  }
}