polyv-live-cli 1.1.4 → 1.1.5

package/dist/performance/performance-monitor.d.ts

@@ -0,0 +1,149 @@
+import { EventEmitter } from 'events';
+export interface PerformanceMonitorConfig {
+    enableAutoMonitoring: boolean;
+    monitoringInterval: number;
+    maxRecords: number;
+    cpuThreshold: number;
+    memoryThreshold: number;
+    responseTimeThreshold: number;
+    enableAlerts: boolean;
+    enableReporting: boolean;
+    reportInterval: number;
+    enableProfiling: boolean;
+    profilingSampleRate: number;
+}
+export interface PerformanceMetrics {
+    timestamp: number;
+    cpuUsage: number;
+    memoryUsage: number;
+    heapUsage: number;
+    eventLoopDelay: number;
+    renderTime: number;
+    apiResponseTime: number;
+    apiCallCount: number;
+    errorCount: number;
+    cacheHitRate: number;
+    activeConnections: number;
+    gcPauseTime: number;
+    frameRate: number;
+    systemLoad: number[];
+}
+export interface PerformanceTrend {
+    metric: string;
+    direction: 'increasing' | 'decreasing' | 'stable';
+    strength: number;
+    average: number;
+    min: number;
+    max: number;
+    standardDeviation: number;
+    prediction: number;
+}
+export interface PerformanceAlert {
+    id: string;
+    type: 'warning' | 'critical' | 'info';
+    message: string;
+    metric: string;
+    currentValue: number;
+    threshold: number;
+    timestamp: number;
+    severity: number;
+    suggestedActions: string[];
+}
+export interface PerformanceReport {
+    timestamp: number;
+    period: {
+        start: number;
+        end: number;
+    };
+    summary: {
+        averageCpuUsage: number;
+        averageMemoryUsage: number;
+        averageResponseTime: number;
+        totalApiCalls: number;
+        totalErrors: number;
+        averageCacheHitRate: number;
+        uptime: number;
+        systemHealth: 'healthy' | 'degraded' | 'critical';
+    };
+    trends: PerformanceTrend[];
+    alerts: PerformanceAlert[];
+    recommendations: string[];
+    metrics: PerformanceMetrics[];
+}
+export interface PerformanceProfile {
+    id: string;
+    name: string;
+    startTime: number;
+    endTime: number;
+    duration: number;
+    cpuSamples: Array<{
+        timestamp: number;
+        usage: number;
+    }>;
+    memorySamples: Array<{
+        timestamp: number;
+        usage: number;
+    }>;
+    callStack: Array<{
+        function: string;
+        duration: number;
+        calls: number;
+    }>;
+    hotSpots: Array<{
+        location: string;
+        time: number;
+        percentage: number;
+    }>;
+}
+export declare class PerformanceMonitor extends EventEmitter {
+    private config;
+    private metrics;
+    private alerts;
+    private profiles;
+    private monitoringTimer?;
+    private reportTimer?;
+    private isRunning;
+    private startTime;
+    private lastCpuUsage;
+    private lastMeasurement;
+    private alertIdCounter;
+    private activeProfiles;
+    constructor(config?: Partial<PerformanceMonitorConfig>);
+    start(): void;
+    stop(): void;
+    collectMetrics(): PerformanceMetrics;
+    recordMetrics(metrics: Partial<PerformanceMetrics>): void;
+    startProfile(profileId: string, name: string): void;
+    stopProfile(profileId: string): PerformanceProfile | null;
+    getMetrics(timeRange?: {
+        start: number;
+        end: number;
+    }): PerformanceMetrics[];
+    getTrends(timeRange?: {
+        start: number;
+        end: number;
+    }): PerformanceTrend[];
+    getAlerts(timeRange?: {
+        start: number;
+        end: number;
+    }): PerformanceAlert[];
+    generateReport(timeRange?: {
+        start: number;
+        end: number;
+    }): PerformanceReport;
+    getProfile(profileId: string): PerformanceProfile | null;
+    clearData(): void;
+    updateConfig(newConfig: Partial<PerformanceMonitorConfig>): void;
+    private measureEventLoopDelay;
+    private startMonitoring;
+    private startReporting;
+    private checkAlerts;
+    private startProfilingSampling;
+    private analyzeProfile;
+    private findHotSpots;
+    private calculateTrend;
+    private calculateSummary;
+    private generateRecommendations;
+    private setupEventHandlers;
+}
+//# sourceMappingURL=performance-monitor.d.ts.map

package/dist/performance/performance-monitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"performance-monitor.d.ts","sourceRoot":"","sources":["../../src/performance/performance-monitor.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAOtC,MAAM,WAAW,wBAAwB;IAEvC,oBAAoB,EAAE,OAAO,CAAC;IAE9B,kBAAkB,EAAE,MAAM,CAAC;IAE3B,UAAU,EAAE,MAAM,CAAC;IAEnB,YAAY,EAAE,MAAM,CAAC;IAErB,eAAe,EAAE,MAAM,CAAC;IAExB,qBAAqB,EAAE,MAAM,CAAC;IAE9B,YAAY,EAAE,OAAO,CAAC;IAEtB,eAAe,EAAE,OAAO,CAAC;IAEzB,cAAc,EAAE,MAAM,CAAC;IAEvB,eAAe,EAAE,OAAO,CAAC;IAEzB,mBAAmB,EAAE,MAAM,CAAC;CAC7B;AAKD,MAAM,WAAW,kBAAkB;IAEjC,SAAS,EAAE,MAAM,CAAC;IAElB,QAAQ,EAAE,MAAM,CAAC;IAEjB,WAAW,EAAE,MAAM,CAAC;IAEpB,SAAS,EAAE,MAAM,CAAC;IAElB,cAAc,EAAE,MAAM,CAAC;IAEvB,UAAU,EAAE,MAAM,CAAC;IAEnB,eAAe,EAAE,MAAM,CAAC;IAExB,YAAY,EAAE,MAAM,CAAC;IAErB,UAAU,EAAE,MAAM,CAAC;IAEnB,YAAY,EAAE,MAAM,CAAC;IAErB,iBAAiB,EAAE,MAAM,CAAC;IAE1B,WAAW,EAAE,MAAM,CAAC;IAEpB,SAAS,EAAE,MAAM,CAAC;IAElB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB;AAKD,MAAM,WAAW,gBAAgB;IAE/B,MAAM,EAAE,MAAM,CAAC;IAEf,SAAS,EAAE,YAAY,GAAG,YAAY,GAAG,QAAQ,CAAC;IAElD,QAAQ,EAAE,MAAM,CAAC;IAEjB,OAAO,EAAE,MAAM,CAAC;IAEhB,GAAG,EAAE,MAAM,CAAC;IAEZ,GAAG,EAAE,MAAM,CAAC;IAEZ,iBAAiB,EAAE,MAAM,CAAC;IAE1B,UAAU,EAAE,MAAM,CAAC;CACpB;AAKD,MAAM,WAAW,gBAAgB;IAE/B,EAAE,EAAE,MAAM,CAAC;IAEX,IAAI,EAAE,SAAS,GAAG,UAAU,GAAG,MAAM,CAAC;IAEtC,OAAO,EAAE,MAAM,CAAC;IAEhB,MAAM,EAAE,MAAM,CAAC;IAEf,YAAY,EAAE,MAAM,CAAC;IAErB,SAAS,EAAE,MAAM,CAAC;IAElB,SAAS,EAAE,MAAM,CAAC;IAElB,QAAQ,EAAE,MAAM,CAAC;IAEjB,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B;AAKD,MAAM,WAAW,iBAAiB;IAEhC,SAAS,EAAE,MAAM,CAAC;IAElB,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC;IAEvC,OAAO,EAAE;QACP,eAAe,EAAE,MAAM,CAAC;QACxB,kBAAkB,EAAE,MAAM,CAAC;QAC3B,mBAAmB,EAAE,MAAM,CAAC;QAC5B,aAAa,EAAE,MAAM,CAAC;QACtB,WAAW,EAAE,MAAM,CAAC;QACpB,mBAAmB,EAAE,MAAM,CAAC;QAC5B,MAAM,EAAE,MAAM,CAAC;QACf,YAAY,EAAE,SAAS,GAAG,UAAU,GAAG,UAAU,CAAC;KACnD,CAAC;IAEF,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAE3B,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAE3B,eAAe,EAAE,MAAM,EAAE,CAAC;IAE1B,OAAO,EAAE,kBAAkB,EAAE,CAAC;CAC/B;AAKD,MAAM,WAAW,kBAAkB;IAEjC,EAAE,EAAE,MAAM,CAAC;IAEX,IAAI,EAAE,MAAM,CAAC;IAEb,SAAS,EAAE,MAAM,CAAC;IAElB,OAAO,EAAE,MAAM,CAAC;IAEhB,QAAQ,EAAE,MAAM,CAAC;IAEjB,UAAU,EAAE,KAAK,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAExD,aAAa,EAAE,KAAK,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAE3D,SAAS,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAExE,QAAQ,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACzE;AAKD,qBAAa,kBAAmB,SAAQ,YAAY;IAClD,OAAO,CAAC,MAAM,CAA2B;IACzC,OAAO,CAAC,OAAO,CAA4B;IAC3C,OAAO,CAAC,MAAM,CAA0B;IACxC,OAAO,CAAC,QAAQ,CAA8C;IAC9D,OAAO,CAAC,eAAe,CAAC,CAAiB;IACzC,OAAO,CAAC,WAAW,CAAC,CAAiB;IACrC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,SAAS,CAAc;IAC/B,OAAO,CAAC,YAAY,CAAsB;IAC1C,OAAO,CAAC,eAAe,CAAc;IACrC,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,cAAc,CAAqB;gBAE/B,MAAM,GAAE,OAAO,CAAC,wBAAwB,CAAM;IAwBnD,KAAK,IAAI,IAAI;IA2Bb,IAAI,IAAI,IAAI;IAkCZ,cAAc,IAAI,kBAAkB;IAsCpC,aAAa,CAAC,OAAO,EAAE,OAAO,CAAC,kBAAkB,CAAC,GAAG,IAAI;IAyBzD,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAkCnD,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,kBAAkB,GAAG,IAAI;IAyBzD,UAAU,CAAC,SAAS,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,GAAG,kBAAkB,EAAE;IAa5E,SAAS,CAAC,SAAS,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,GAAG,gBAAgB,EAAE;IAyBzE,SAAS,CAAC,SAAS,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,GAAG,gBAAgB,EAAE;IAazE,cAAc,CAAC,SAAS,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,GAAG,iBAAiB;IA4B7E,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,kBAAkB,GAAG,IAAI;IAOxD,SAAS,IAAI,IAAI;IAoBjB,YAAY,CAAC,SAAS,EAAE,OAAO,CAAC,wBAAwB,CAAC,GAAG,IAAI;IAkBvE,OAAO,CAAC,qBAAqB;IAY7B,OAAO,CAAC,eAAe;IASvB,OAAO,CAAC,cAAc;IAatB,OAAO,CAAC,WAAW;IA2EnB,OAAO,CAAC,sBAAsB;IA0B9B,OAAO,CAAC,cAAc;IAsBtB,OAAO,CAAC,YAAY;IAUpB,OAAO,CAAC,cAAc;IAoDtB,OAAO,CAAC,gBAAgB;IA4CxB,OAAO,CAAC,uBAAuB;IA0C/B,OAAO,CAAC,kBAAkB;CAiB3B"}

package/dist/performance/performance-monitor.js

@@ -0,0 +1,513 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PerformanceMonitor = void 0;
+const events_1 = require("events");
+const perf_hooks_1 = require("perf_hooks");
+const os = __importStar(require("os"));
+class PerformanceMonitor extends events_1.EventEmitter {
+    constructor(config = {}) {
+        super();
+        this.metrics = [];
+        this.alerts = [];
+        this.profiles = new Map();
+        this.isRunning = false;
+        this.startTime = Date.now();
+        this.lastCpuUsage = process.cpuUsage();
+        this.lastMeasurement = Date.now();
+        this.alertIdCounter = 0;
+        this.activeProfiles = new Set();
+        this.config = {
+            enableAutoMonitoring: true,
+            monitoringInterval: 5000,
+            maxRecords: 1000,
+            cpuThreshold: 80,
+            memoryThreshold: 100,
+            responseTimeThreshold: 1000,
+            enableAlerts: true,
+            enableReporting: true,
+            reportInterval: 300000,
+            enableProfiling: false,
+            profilingSampleRate: 0.1,
+            ...config,
+        };
+        this.setupEventHandlers();
+    }
+    start() {
+        if (this.isRunning) {
+            return;
+        }
+        this.isRunning = true;
+        this.startTime = Date.now();
+        this.lastMeasurement = Date.now();
+        this.lastCpuUsage = process.cpuUsage();
+        if (this.config.enableAutoMonitoring) {
+            this.startMonitoring();
+        }
+        if (this.config.enableReporting) {
+            this.startReporting();
+        }
+        this.emit('monitoringStarted', {
+            timestamp: Date.now(),
+            config: this.config,
+        });
+    }
+    stop() {
+        if (!this.isRunning) {
+            return;
+        }
+        this.isRunning = false;
+        if (this.monitoringTimer) {
+            clearInterval(this.monitoringTimer);
+            delete this.monitoringTimer;
+        }
+        if (this.reportTimer) {
+            clearInterval(this.reportTimer);
+            delete this.reportTimer;
+        }
+        for (const profileId of this.activeProfiles) {
+            this.stopProfile(profileId);
+        }
+        const finalReport = this.generateReport();
+        this.emit('monitoringStopped', {
+            timestamp: Date.now(),
+            uptime: Date.now() - this.startTime,
+            finalReport,
+        });
+    }
+    collectMetrics() {
+        const now = Date.now();
+        const memoryUsage = process.memoryUsage();
+        const cpuUsage = process.cpuUsage(this.lastCpuUsage);
+        const systemLoad = os.loadavg();
+        const cpuPercent = (cpuUsage.user + cpuUsage.system) / ((now - this.lastMeasurement) * 1000) * 100;
+        const eventLoopDelay = this.measureEventLoopDelay();
+        const metrics = {
+            timestamp: now,
+            cpuUsage: Math.min(cpuPercent, 100),
+            memoryUsage: memoryUsage.rss / 1024 / 1024,
+            heapUsage: memoryUsage.heapUsed / 1024 / 1024,
+            eventLoopDelay,
+            renderTime: 0,
+            apiResponseTime: 0,
+            apiCallCount: 0,
+            errorCount: 0,
+            cacheHitRate: 0,
+            activeConnections: 0,
+            gcPauseTime: 0,
+            frameRate: 0,
+            systemLoad,
+        };
+        this.lastCpuUsage = process.cpuUsage();
+        this.lastMeasurement = now;
+        return metrics;
+    }
+    recordMetrics(metrics) {
+        const currentMetrics = this.collectMetrics();
+        const combinedMetrics = { ...currentMetrics, ...metrics };
+        this.metrics.push(combinedMetrics);
+        if (this.metrics.length > this.config.maxRecords) {
+            this.metrics = this.metrics.slice(-this.config.maxRecords);
+        }
+        if (this.config.enableAlerts) {
+            this.checkAlerts(combinedMetrics);
+        }
+        this.emit('metricsRecorded', {
+            metrics: combinedMetrics,
+            timestamp: Date.now(),
+        });
+    }
+    startProfile(profileId, name) {
+        if (this.activeProfiles.has(profileId)) {
+            return;
+        }
+        const profile = {
+            id: profileId,
+            name,
+            startTime: Date.now(),
+            endTime: 0,
+            duration: 0,
+            cpuSamples: [],
+            memorySamples: [],
+            callStack: [],
+            hotSpots: [],
+        };
+        this.profiles.set(profileId, profile);
+        this.activeProfiles.add(profileId);
+        if (this.config.enableProfiling) {
+            this.startProfilingSampling(profileId);
+        }
+        this.emit('profileStarted', {
+            profileId,
+            name,
+            timestamp: Date.now(),
+        });
+    }
+    stopProfile(profileId) {
+        const profile = this.profiles.get(profileId);
+        if (!profile || !this.activeProfiles.has(profileId)) {
+            return null;
+        }
+        profile.endTime = Date.now();
+        profile.duration = profile.endTime - profile.startTime;
+        this.activeProfiles.delete(profileId);
+        this.analyzeProfile(profile);
+        this.emit('profileStopped', {
+            profileId,
+            duration: profile.duration,
+            timestamp: Date.now(),
+        });
+        return profile;
+    }
+    getMetrics(timeRange) {
+        if (!timeRange) {
+            return [...this.metrics];
+        }
+        return this.metrics.filter(metric => metric.timestamp >= timeRange.start && metric.timestamp <= timeRange.end);
+    }
+    getTrends(timeRange) {
+        const metrics = this.getMetrics(timeRange);
+        if (metrics.length < 2) {
+            return [];
+        }
+        const trends = [];
+        const metricKeys = [
+            'cpuUsage', 'memoryUsage', 'renderTime', 'apiResponseTime', 'errorCount'
+        ];
+        for (const key of metricKeys) {
+            const values = metrics.map(m => m[key]).filter(v => !isNaN(v));
+            if (values.length < 2)
+                continue;
+            const trend = this.calculateTrend(key, values);
+            trends.push(trend);
+        }
+        return trends;
+    }
+    getAlerts(timeRange) {
+        if (!timeRange) {
+            return [...this.alerts];
+        }
+        return this.alerts.filter(alert => alert.timestamp >= timeRange.start && alert.timestamp <= timeRange.end);
+    }
+    generateReport(timeRange) {
+        const now = Date.now();
+        const period = timeRange || {
+            start: now - 3600000,
+            end: now,
+        };
+        const metrics = this.getMetrics(period);
+        const trends = this.getTrends(period);
+        const alerts = this.getAlerts(period);
+        const summary = this.calculateSummary(metrics);
+        const recommendations = this.generateRecommendations(metrics, trends, alerts);
+        return {
+            timestamp: now,
+            period,
+            summary,
+            trends,
+            alerts,
+            recommendations,
+            metrics,
+        };
+    }
+    getProfile(profileId) {
+        return this.profiles.get(profileId) || null;
+    }
+    clearData() {
+        const clearedMetrics = this.metrics.length;
+        const clearedAlerts = this.alerts.length;
+        const clearedProfiles = this.profiles.size;
+        this.metrics = [];
+        this.alerts = [];
+        this.profiles.clear();
+        this.emit('dataCleared', {
+            clearedMetrics,
+            clearedAlerts,
+            clearedProfiles,
+            timestamp: Date.now(),
+        });
+    }
+    updateConfig(newConfig) {
+        this.config = { ...this.config, ...newConfig };
+        if (this.isRunning) {
+            this.stop();
+            this.start();
+        }
+        this.emit('configUpdated', {
+            config: this.config,
+            timestamp: Date.now(),
+        });
+    }
+    measureEventLoopDelay() {
+        const start = perf_hooks_1.performance.now();
+        return new Promise((resolve) => {
+            setImmediate(() => {
+                resolve(perf_hooks_1.performance.now() - start);
+            });
+        });
+    }
+    startMonitoring() {
+        this.monitoringTimer = setInterval(() => {
+            this.recordMetrics({});
+        }, this.config.monitoringInterval);
+    }
+    startReporting() {
+        this.reportTimer = setInterval(() => {
+            const report = this.generateReport();
+            this.emit('reportGenerated', {
+                report,
+                timestamp: Date.now(),
+            });
+        }, this.config.reportInterval);
+    }
+    checkAlerts(metrics) {
+        const alerts = [];
+        if (metrics.cpuUsage > this.config.cpuThreshold) {
+            alerts.push({
+                id: `alert_${++this.alertIdCounter}`,
+                type: 'warning',
+                message: `High CPU usage: ${metrics.cpuUsage.toFixed(1)}%`,
+                metric: 'cpuUsage',
+                currentValue: metrics.cpuUsage,
+                threshold: this.config.cpuThreshold,
+                timestamp: Date.now(),
+                severity: 7,
+                suggestedActions: [
+                    'Review CPU-intensive operations',
+                    'Optimize algorithms',
+                    'Consider load balancing',
+                ],
+            });
+        }
+        if (metrics.memoryUsage > this.config.memoryThreshold) {
+            alerts.push({
+                id: `alert_${++this.alertIdCounter}`,
+                type: 'warning',
+                message: `High memory usage: ${metrics.memoryUsage.toFixed(1)}MB`,
+                metric: 'memoryUsage',
+                currentValue: metrics.memoryUsage,
+                threshold: this.config.memoryThreshold,
+                timestamp: Date.now(),
+                severity: 6,
+                suggestedActions: [
+                    'Review memory allocation',
+                    'Clear unused cache',
+                    'Check for memory leaks',
+                ],
+            });
+        }
+        if (metrics.apiResponseTime > this.config.responseTimeThreshold) {
+            alerts.push({
+                id: `alert_${++this.alertIdCounter}`,
+                type: 'warning',
+                message: `Slow API response: ${metrics.apiResponseTime.toFixed(0)}ms`,
+                metric: 'apiResponseTime',
+                currentValue: metrics.apiResponseTime,
+                threshold: this.config.responseTimeThreshold,
+                timestamp: Date.now(),
+                severity: 5,
+                suggestedActions: [
+                    'Check network connectivity',
+                    'Optimize API queries',
+                    'Enable caching',
+                ],
+            });
+        }
+        for (const alert of alerts) {
+            this.alerts.push(alert);
+            this.emit('alertTriggered', alert);
+        }
+        if (this.alerts.length > this.config.maxRecords) {
+            this.alerts = this.alerts.slice(-this.config.maxRecords);
+        }
+    }
+    startProfilingSampling(profileId) {
+        const profile = this.profiles.get(profileId);
+        if (!profile)
+            return;
+        const sampleInterval = 100;
+        const samplingTimer = setInterval(() => {
+            if (!this.activeProfiles.has(profileId)) {
+                clearInterval(samplingTimer);
+                return;
+            }
+            const metrics = this.collectMetrics();
+            profile.cpuSamples.push({
+                timestamp: Date.now(),
+                usage: metrics.cpuUsage,
+            });
+            profile.memorySamples.push({
+                timestamp: Date.now(),
+                usage: metrics.memoryUsage,
+            });
+        }, sampleInterval);
+    }
+    analyzeProfile(profile) {
+        const cpuHotSpots = this.findHotSpots(profile.cpuSamples);
+        const memoryHotSpots = this.findHotSpots(profile.memorySamples);
+        profile.hotSpots = [
+            ...cpuHotSpots.map(spot => ({
+                location: `CPU-${spot.timestamp}`,
+                time: spot.usage,
+                percentage: (spot.usage / 100) * 100,
+            })),
+            ...memoryHotSpots.map(spot => ({
+                location: `Memory-${spot.timestamp}`,
+                time: spot.usage,
+                percentage: (spot.usage / (profile.memorySamples.reduce((max, s) => Math.max(max, s.usage), 0) || 1)) * 100,
+            })),
+        ];
+    }
+    findHotSpots(samples) {
+        if (samples.length < 2)
+            return [];
+        const threshold = samples.reduce((sum, s) => sum + s.usage, 0) / samples.length * 1.5;
+        return samples.filter(sample => sample.usage > threshold);
+    }
+    calculateTrend(metric, values) {
+        if (values.length < 2) {
+            return {
+                metric,
+                direction: 'stable',
+                strength: 0,
+                average: 0,
+                min: 0,
+                max: 0,
+                standardDeviation: 0,
+                prediction: 0,
+            };
+        }
+        const average = values.reduce((sum, val) => sum + val, 0) / values.length;
+        const min = Math.min(...values);
+        const max = Math.max(...values);
+        const variance = values.reduce((sum, val) => sum + Math.pow(val - average, 2), 0) / values.length;
+        const standardDeviation = Math.sqrt(variance);
+        const firstHalf = values.slice(0, Math.floor(values.length / 2));
+        const secondHalf = values.slice(Math.floor(values.length / 2));
+        const firstAvg = firstHalf.reduce((sum, val) => sum + val, 0) / firstHalf.length;
+        const secondAvg = secondHalf.reduce((sum, val) => sum + val, 0) / secondHalf.length;
+        const difference = secondAvg - firstAvg;
+        const direction = Math.abs(difference) < average * 0.1 ? 'stable' :
+            difference > 0 ? 'increasing' : 'decreasing';
+        const strength = Math.min(Math.abs(difference) / average, 1);
+        const prediction = average + (difference / firstHalf.length) * values.length;
+        return {
+            metric,
+            direction,
+            strength,
+            average,
+            min,
+            max,
+            standardDeviation,
+            prediction,
+        };
+    }
+    calculateSummary(metrics) {
+        if (metrics.length === 0) {
+            return {
+                averageCpuUsage: 0,
+                averageMemoryUsage: 0,
+                averageResponseTime: 0,
+                totalApiCalls: 0,
+                totalErrors: 0,
+                averageCacheHitRate: 0,
+                uptime: Date.now() - this.startTime,
+                systemHealth: 'healthy',
+            };
+        }
+        const averageCpuUsage = metrics.reduce((sum, m) => sum + m.cpuUsage, 0) / metrics.length;
+        const averageMemoryUsage = metrics.reduce((sum, m) => sum + m.memoryUsage, 0) / metrics.length;
+        const averageResponseTime = metrics.reduce((sum, m) => sum + m.apiResponseTime, 0) / metrics.length;
+        const totalApiCalls = metrics.reduce((sum, m) => sum + m.apiCallCount, 0);
+        const totalErrors = metrics.reduce((sum, m) => sum + m.errorCount, 0);
+        const averageCacheHitRate = metrics.reduce((sum, m) => sum + m.cacheHitRate, 0) / metrics.length;
+        let systemHealth = 'healthy';
+        if (averageCpuUsage > 80 || averageMemoryUsage > 200 || averageResponseTime > 2000) {
+            systemHealth = 'critical';
+        }
+        else if (averageCpuUsage > 60 || averageMemoryUsage > 150 || averageResponseTime > 1000) {
+            systemHealth = 'degraded';
+        }
+        return {
+            averageCpuUsage,
+            averageMemoryUsage,
+            averageResponseTime,
+            totalApiCalls,
+            totalErrors,
+            averageCacheHitRate,
+            uptime: Date.now() - this.startTime,
+            systemHealth,
+        };
+    }
+    generateRecommendations(_metrics, trends, alerts) {
+        const recommendations = [];
+        const cpuTrend = trends.find(t => t.metric === 'cpuUsage');
+        if (cpuTrend && cpuTrend.direction === 'increasing' && cpuTrend.average > 50) {
+            recommendations.push('Consider optimizing CPU-intensive operations');
+        }
+        const memoryTrend = trends.find(t => t.metric === 'memoryUsage');
+        if (memoryTrend && memoryTrend.direction === 'increasing') {
+            recommendations.push('Review memory usage and implement cleanup strategies');
+        }
+        const responseTrend = trends.find(t => t.metric === 'apiResponseTime');
+        if (responseTrend && responseTrend.average > 500) {
+            recommendations.push('Optimize API calls with caching and request batching');
+        }
+        const criticalAlerts = alerts.filter(a => a.type === 'critical');
+        if (criticalAlerts.length > 0) {
+            recommendations.push('Address critical performance alerts immediately');
+        }
+        if (recommendations.length === 0) {
+            recommendations.push('Performance is within acceptable ranges');
+        }
+        return recommendations;
+    }
+    setupEventHandlers() {
+        process.on('warning', (warning) => {
+            this.emit('performanceWarning', {
+                warning: warning.message,
+                timestamp: Date.now(),
+            });
+        });
+        process.on('uncaughtException', (error) => {
+            this.emit('performanceError', {
+                error: error.message,
+                timestamp: Date.now(),
+            });
+        });
+    }
+}
+exports.PerformanceMonitor = PerformanceMonitor;
+//# sourceMappingURL=performance-monitor.js.map