mcp-wordpress 1.1.7 → 1.2.2

package/dist/performance/PerformanceMonitor.d.ts

@@ -0,0 +1,202 @@
+/**
+ * Performance Monitoring System for WordPress MCP Server
+ * Collects, analyzes, and reports performance metrics
+ */
+export interface PerformanceMetrics {
+    requests: {
+        total: number;
+        successful: number;
+        failed: number;
+        averageResponseTime: number;
+        minResponseTime: number;
+        maxResponseTime: number;
+        requestsPerSecond: number;
+        p50ResponseTime: number;
+        p95ResponseTime: number;
+        p99ResponseTime: number;
+    };
+    cache: {
+        hits: number;
+        misses: number;
+        hitRate: number;
+        totalSize: number;
+        memoryUsageMB: number;
+        evictions: number;
+        averageCacheTime: number;
+    };
+    system: {
+        cpuUsage: number;
+        memoryUsage: number;
+        uptime: number;
+        activeConnections: number;
+        concurrentRequests: number;
+    };
+    wordpress: {
+        authSuccessRate: number;
+        apiVersion: string;
+        siteHealth: 'healthy' | 'warning' | 'critical';
+        averageDbResponseTime: number;
+        pluginCompatibility: number;
+    };
+    tools: {
+        mostUsedTool: string;
+        toolUsageCount: Record<string, number>;
+        toolPerformance: Record<string, {
+            averageTime: number;
+            successRate: number;
+            callCount: number;
+        }>;
+    };
+}
+export interface PerformanceAlert {
+    id: string;
+    timestamp: number;
+    severity: 'info' | 'warning' | 'error' | 'critical';
+    category: 'performance' | 'cache' | 'system' | 'wordpress';
+    message: string;
+    metric: string;
+    threshold: number;
+    actualValue: number;
+    suggestion?: string;
+}
+export interface PerformanceConfig {
+    collectInterval: number;
+    retentionPeriod: number;
+    alertThresholds: {
+        responseTime: number;
+        errorRate: number;
+        cacheHitRate: number;
+        memoryUsage: number;
+        cpuUsage: number;
+    };
+    enableRealTimeMonitoring: boolean;
+    enableHistoricalData: boolean;
+    enableAlerts: boolean;
+}
+/**
+ * Core Performance Monitor class
+ */
+export declare class PerformanceMonitor {
+    private metrics;
+    private historicalData;
+    private alerts;
+    private config;
+    private startTime;
+    private responseTimes;
+    private collectionTimer?;
+    constructor(config?: Partial<PerformanceConfig>);
+    /**
+     * Initialize empty metrics structure
+     */
+    private initializeMetrics;
+    /**
+     * Record a request performance metric
+     */
+    recordRequest(responseTime: number, success: boolean, toolName?: string): void;
+    /**
+     * Update cache metrics from cache manager
+     */
+    updateCacheMetrics(cacheStats: any): void;
+    /**
+     * Update system metrics
+     */
+    updateSystemMetrics(): void;
+    /**
+     * Get current performance metrics
+     */
+    getMetrics(): PerformanceMetrics;
+    /**
+     * Get historical performance data
+     */
+    getHistoricalData(startTime?: number, endTime?: number): PerformanceMetrics[];
+    /**
+     * Get performance alerts
+     */
+    getAlerts(severity?: string): PerformanceAlert[];
+    /**
+     * Clear alerts
+     */
+    clearAlerts(): void;
+    /**
+     * Generate performance insights
+     */
+    generateInsights(): {
+        summary: string;
+        recommendations: string[];
+        trends: string[];
+        health: 'excellent' | 'good' | 'warning' | 'critical';
+    };
+    /**
+     * Export performance data
+     */
+    exportData(format?: 'json' | 'csv'): string;
+    /**
+     * Start automatic metric collection
+     */
+    private startCollection;
+    /**
+     * Stop metric collection
+     */
+    stop(): void;
+    /**
+     * Record tool usage and performance
+     */
+    private recordToolUsage;
+    /**
+     * Update response time metrics with percentiles
+     */
+    private updateResponseTimeMetrics;
+    /**
+     * Get percentile value from sorted array
+     */
+    private getPercentile;
+    /**
+     * Estimate cache memory usage
+     */
+    private estimateCacheMemoryUsage;
+    /**
+     * Get CPU usage (simplified)
+     */
+    private getCpuUsage;
+    /**
+     * Check for performance alerts
+     */
+    private checkPerformanceAlerts;
+    /**
+     * Add performance alert
+     */
+    private addAlert;
+    /**
+     * Calculate overall system health
+     */
+    private calculateOverallHealth;
+    /**
+     * Generate performance summary
+     */
+    private generateSummary;
+    /**
+     * Generate performance recommendations
+     */
+    private generateRecommendations;
+    /**
+     * Generate trend analysis
+     */
+    private generateTrends;
+    /**
+     * Check if values are increasing
+     */
+    private isIncreasing;
+    /**
+     * Check if values are decreasing
+     */
+    private isDecreasing;
+    /**
+     * Convert data to CSV format
+     */
+    private convertToCSV;
+    /**
+     * Clean up old historical data
+     */
+    private cleanupOldData;
+}
+//# sourceMappingURL=PerformanceMonitor.d.ts.map

package/dist/performance/PerformanceMonitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PerformanceMonitor.d.ts","sourceRoot":"","sources":["../../src/performance/PerformanceMonitor.ts"],"names":[],"mappings":"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"}

package/dist/performance/PerformanceMonitor.js

@@ -0,0 +1,478 @@
+/**
+ * Performance Monitoring System for WordPress MCP Server
+ * Collects, analyzes, and reports performance metrics
+ */
+/**
+ * Core Performance Monitor class
+ */
+export class PerformanceMonitor {
+    metrics;
+    historicalData = [];
+    alerts = [];
+    config;
+    startTime;
+    responseTimes = [];
+    collectionTimer;
+    constructor(config = {}) {
+        this.startTime = Date.now();
+        this.config = {
+            collectInterval: 30000, // 30 seconds
+            retentionPeriod: 24 * 60 * 60 * 1000, // 24 hours
+            alertThresholds: {
+                responseTime: 2000, // 2 seconds
+                errorRate: 0.05, // 5%
+                cacheHitRate: 0.8, // 80%
+                memoryUsage: 80, // 80%
+                cpuUsage: 80 // 80%
+            },
+            enableRealTimeMonitoring: true,
+            enableHistoricalData: true,
+            enableAlerts: true,
+            ...config
+        };
+        this.metrics = this.initializeMetrics();
+        if (this.config.enableRealTimeMonitoring) {
+            this.startCollection();
+        }
+    }
+    /**
+     * Initialize empty metrics structure
+     */
+    initializeMetrics() {
+        return {
+            requests: {
+                total: 0,
+                successful: 0,
+                failed: 0,
+                averageResponseTime: 0,
+                minResponseTime: 0,
+                maxResponseTime: 0,
+                requestsPerSecond: 0,
+                p50ResponseTime: 0,
+                p95ResponseTime: 0,
+                p99ResponseTime: 0
+            },
+            cache: {
+                hits: 0,
+                misses: 0,
+                hitRate: 0,
+                totalSize: 0,
+                memoryUsageMB: 0,
+                evictions: 0,
+                averageCacheTime: 0
+            },
+            system: {
+                cpuUsage: 0,
+                memoryUsage: 0,
+                uptime: 0,
+                activeConnections: 0,
+                concurrentRequests: 0
+            },
+            wordpress: {
+                authSuccessRate: 0,
+                apiVersion: 'v2',
+                siteHealth: 'healthy',
+                averageDbResponseTime: 0,
+                pluginCompatibility: 100
+            },
+            tools: {
+                mostUsedTool: '',
+                toolUsageCount: {},
+                toolPerformance: {}
+            }
+        };
+    }
+    /**
+     * Record a request performance metric
+     */
+    recordRequest(responseTime, success, toolName) {
+        this.metrics.requests.total++;
+        if (success) {
+            this.metrics.requests.successful++;
+        }
+        else {
+            this.metrics.requests.failed++;
+        }
+        // Track response times
+        this.responseTimes.push(responseTime);
+        this.updateResponseTimeMetrics();
+        // Track tool usage
+        if (toolName) {
+            this.recordToolUsage(toolName, responseTime, success);
+        }
+        // Check for alerts
+        if (this.config.enableAlerts) {
+            this.checkPerformanceAlerts();
+        }
+    }
+    /**
+     * Update cache metrics from cache manager
+     */
+    updateCacheMetrics(cacheStats) {
+        this.metrics.cache = {
+            hits: cacheStats.hits || 0,
+            misses: cacheStats.misses || 0,
+            hitRate: cacheStats.hitRate || 0,
+            totalSize: cacheStats.totalSize || 0,
+            memoryUsageMB: this.estimateCacheMemoryUsage(cacheStats.totalSize),
+            evictions: cacheStats.evictions || 0,
+            averageCacheTime: 0.5 // Sub-millisecond average
+        };
+    }
+    /**
+     * Update system metrics
+     */
+    updateSystemMetrics() {
+        const memUsage = process.memoryUsage();
+        this.metrics.system = {
+            cpuUsage: this.getCpuUsage(),
+            memoryUsage: Math.round((memUsage.heapUsed / memUsage.heapTotal) * 100),
+            uptime: Date.now() - this.startTime,
+            activeConnections: 1, // Will be updated by connection manager
+            concurrentRequests: 0 // Will be updated by request manager
+        };
+    }
+    /**
+     * Get current performance metrics
+     */
+    getMetrics() {
+        this.updateSystemMetrics();
+        return { ...this.metrics };
+    }
+    /**
+     * Get historical performance data
+     */
+    getHistoricalData(startTime, endTime) {
+        if (!this.config.enableHistoricalData) {
+            return [];
+        }
+        let data = [...this.historicalData];
+        if (startTime) {
+            data = data.filter(m => m.system.uptime >= startTime);
+        }
+        if (endTime) {
+            data = data.filter(m => m.system.uptime <= endTime);
+        }
+        return data;
+    }
+    /**
+     * Get performance alerts
+     */
+    getAlerts(severity) {
+        if (severity) {
+            return this.alerts.filter(alert => alert.severity === severity);
+        }
+        return [...this.alerts];
+    }
+    /**
+     * Clear alerts
+     */
+    clearAlerts() {
+        this.alerts = [];
+    }
+    /**
+     * Generate performance insights
+     */
+    generateInsights() {
+        const current = this.getMetrics();
+        const health = this.calculateOverallHealth(current);
+        return {
+            summary: this.generateSummary(current),
+            recommendations: this.generateRecommendations(current),
+            trends: this.generateTrends(),
+            health
+        };
+    }
+    /**
+     * Export performance data
+     */
+    exportData(format = 'json') {
+        const data = {
+            currentMetrics: this.getMetrics(),
+            historicalData: this.getHistoricalData(),
+            alerts: this.getAlerts(),
+            config: this.config,
+            generatedAt: new Date().toISOString()
+        };
+        if (format === 'csv') {
+            return this.convertToCSV(data);
+        }
+        return JSON.stringify(data, null, 2);
+    }
+    /**
+     * Start automatic metric collection
+     */
+    startCollection() {
+        this.collectionTimer = setInterval(() => {
+            const snapshot = this.getMetrics();
+            if (this.config.enableHistoricalData) {
+                this.historicalData.push(snapshot);
+                this.cleanupOldData();
+            }
+        }, this.config.collectInterval);
+    }
+    /**
+     * Stop metric collection
+     */
+    stop() {
+        if (this.collectionTimer) {
+            clearInterval(this.collectionTimer);
+        }
+    }
+    /**
+     * Record tool usage and performance
+     */
+    recordToolUsage(toolName, responseTime, success) {
+        // Update usage count
+        this.metrics.tools.toolUsageCount[toolName] =
+            (this.metrics.tools.toolUsageCount[toolName] || 0) + 1;
+        // Update performance metrics
+        if (!this.metrics.tools.toolPerformance[toolName]) {
+            this.metrics.tools.toolPerformance[toolName] = {
+                averageTime: responseTime,
+                successRate: success ? 1 : 0,
+                callCount: 1
+            };
+        }
+        else {
+            const perf = this.metrics.tools.toolPerformance[toolName];
+            const totalCalls = perf.callCount + 1;
+            // Update average time
+            perf.averageTime = (perf.averageTime * perf.callCount + responseTime) / totalCalls;
+            // Update success rate
+            const totalSuccess = perf.successRate * perf.callCount + (success ? 1 : 0);
+            perf.successRate = totalSuccess / totalCalls;
+            perf.callCount = totalCalls;
+        }
+        // Update most used tool
+        const usageCounts = this.metrics.tools.toolUsageCount;
+        this.metrics.tools.mostUsedTool = Object.keys(usageCounts)
+            .reduce((a, b) => usageCounts[a] > usageCounts[b] ? a : b);
+    }
+    /**
+     * Update response time metrics with percentiles
+     */
+    updateResponseTimeMetrics() {
+        if (this.responseTimes.length === 0)
+            return;
+        const sorted = [...this.responseTimes].sort((a, b) => a - b);
+        const total = this.metrics.requests.total;
+        this.metrics.requests.averageResponseTime =
+            this.responseTimes.reduce((sum, time) => sum + time, 0) / this.responseTimes.length;
+        this.metrics.requests.minResponseTime = sorted[0];
+        this.metrics.requests.maxResponseTime = sorted[sorted.length - 1];
+        // Calculate percentiles
+        this.metrics.requests.p50ResponseTime = this.getPercentile(sorted, 0.5);
+        this.metrics.requests.p95ResponseTime = this.getPercentile(sorted, 0.95);
+        this.metrics.requests.p99ResponseTime = this.getPercentile(sorted, 0.99);
+        // Calculate requests per second
+        const uptime = (Date.now() - this.startTime) / 1000;
+        this.metrics.requests.requestsPerSecond = total / uptime;
+        // Limit response time history to prevent memory growth
+        if (this.responseTimes.length > 10000) {
+            this.responseTimes = this.responseTimes.slice(-5000);
+        }
+    }
+    /**
+     * Get percentile value from sorted array
+     */
+    getPercentile(sorted, percentile) {
+        const index = Math.ceil(sorted.length * percentile) - 1;
+        return sorted[Math.max(0, index)];
+    }
+    /**
+     * Estimate cache memory usage
+     */
+    estimateCacheMemoryUsage(totalSize) {
+        // Rough estimate: ~1KB per cache entry
+        return (totalSize * 1024) / (1024 * 1024); // Convert to MB
+    }
+    /**
+     * Get CPU usage (simplified)
+     */
+    getCpuUsage() {
+        // Simplified CPU usage estimation
+        // In production, use more sophisticated monitoring
+        return Math.round(Math.random() * 20 + 10); // 10-30% placeholder
+    }
+    /**
+     * Check for performance alerts
+     */
+    checkPerformanceAlerts() {
+        const thresholds = this.config.alertThresholds;
+        // Response time alert
+        if (this.metrics.requests.averageResponseTime > thresholds.responseTime) {
+            this.addAlert('warning', 'performance', `High response time: ${this.metrics.requests.averageResponseTime}ms`, 'averageResponseTime', thresholds.responseTime, this.metrics.requests.averageResponseTime, 'Consider enabling caching or optimizing queries');
+        }
+        // Error rate alert
+        const errorRate = this.metrics.requests.failed / this.metrics.requests.total;
+        if (errorRate > thresholds.errorRate) {
+            this.addAlert('error', 'performance', `High error rate: ${Math.round(errorRate * 100)}%`, 'errorRate', thresholds.errorRate, errorRate, 'Check WordPress connectivity and authentication');
+        }
+        // Cache hit rate alert
+        if (this.metrics.cache.hitRate < thresholds.cacheHitRate) {
+            this.addAlert('warning', 'cache', `Low cache hit rate: ${Math.round(this.metrics.cache.hitRate * 100)}%`, 'cacheHitRate', thresholds.cacheHitRate, this.metrics.cache.hitRate, 'Consider cache warming or adjusting TTL values');
+        }
+    }
+    /**
+     * Add performance alert
+     */
+    addAlert(severity, category, message, metric, threshold, actualValue, suggestion) {
+        const alert = {
+            id: `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+            timestamp: Date.now(),
+            severity,
+            category,
+            message,
+            metric,
+            threshold,
+            actualValue,
+            ...(suggestion && { suggestion })
+        };
+        this.alerts.push(alert);
+        // Limit alert history
+        if (this.alerts.length > 1000) {
+            this.alerts = this.alerts.slice(-500);
+        }
+    }
+    /**
+     * Calculate overall system health
+     */
+    calculateOverallHealth(metrics) {
+        let score = 100;
+        // Response time impact
+        if (metrics.requests.averageResponseTime > 3000)
+            score -= 30;
+        else if (metrics.requests.averageResponseTime > 1000)
+            score -= 15;
+        // Error rate impact
+        const errorRate = metrics.requests.failed / metrics.requests.total;
+        if (errorRate > 0.1)
+            score -= 40;
+        else if (errorRate > 0.05)
+            score -= 20;
+        // Cache performance impact
+        if (metrics.cache.hitRate < 0.5)
+            score -= 25;
+        else if (metrics.cache.hitRate < 0.8)
+            score -= 10;
+        // System resource impact
+        if (metrics.system.memoryUsage > 90)
+            score -= 20;
+        else if (metrics.system.memoryUsage > 80)
+            score -= 10;
+        if (score >= 90)
+            return 'excellent';
+        if (score >= 75)
+            return 'good';
+        if (score >= 50)
+            return 'warning';
+        return 'critical';
+    }
+    /**
+     * Generate performance summary
+     */
+    generateSummary(metrics) {
+        const errorRate = metrics.requests.total > 0
+            ? (metrics.requests.failed / metrics.requests.total * 100).toFixed(1)
+            : '0';
+        return `Performance Summary: ${metrics.requests.total} requests processed with ${errorRate}% error rate. ` +
+            `Average response time: ${metrics.requests.averageResponseTime.toFixed(0)}ms. ` +
+            `Cache hit rate: ${(metrics.cache.hitRate * 100).toFixed(1)}%. ` +
+            `System uptime: ${Math.round(metrics.system.uptime / 1000 / 60)} minutes.`;
+    }
+    /**
+     * Generate performance recommendations
+     */
+    generateRecommendations(metrics) {
+        const recommendations = [];
+        if (metrics.requests.averageResponseTime > 1000) {
+            recommendations.push('Enable caching to reduce response times');
+        }
+        if (metrics.cache.hitRate < 0.8) {
+            recommendations.push('Warm cache with frequently accessed data');
+        }
+        if (metrics.system.memoryUsage > 80) {
+            recommendations.push('Consider increasing memory allocation or cache size limits');
+        }
+        const errorRate = metrics.requests.failed / metrics.requests.total;
+        if (errorRate > 0.05) {
+            recommendations.push('Review error logs and improve error handling');
+        }
+        return recommendations;
+    }
+    /**
+     * Generate trend analysis
+     */
+    generateTrends() {
+        if (this.historicalData.length < 2) {
+            return ['Insufficient data for trend analysis'];
+        }
+        const trends = [];
+        const recent = this.historicalData.slice(-5);
+        // Response time trend
+        const responseTimes = recent.map(d => d.requests.averageResponseTime);
+        if (this.isIncreasing(responseTimes)) {
+            trends.push('Response times are increasing');
+        }
+        else if (this.isDecreasing(responseTimes)) {
+            trends.push('Response times are improving');
+        }
+        // Cache hit rate trend
+        const hitRates = recent.map(d => d.cache.hitRate);
+        if (this.isIncreasing(hitRates)) {
+            trends.push('Cache performance is improving');
+        }
+        else if (this.isDecreasing(hitRates)) {
+            trends.push('Cache performance is declining');
+        }
+        return trends;
+    }
+    /**
+     * Check if values are increasing
+     */
+    isIncreasing(values) {
+        for (let i = 1; i < values.length; i++) {
+            if (values[i] <= values[i - 1])
+                return false;
+        }
+        return true;
+    }
+    /**
+     * Check if values are decreasing
+     */
+    isDecreasing(values) {
+        for (let i = 1; i < values.length; i++) {
+            if (values[i] >= values[i - 1])
+                return false;
+        }
+        return true;
+    }
+    /**
+     * Convert data to CSV format
+     */
+    convertToCSV(data) {
+        // Simplified CSV conversion for metrics
+        const metrics = data.currentMetrics;
+        const csv = [
+            'Metric,Value',
+            `Total Requests,${metrics.requests.total}`,
+            `Successful Requests,${metrics.requests.successful}`,
+            `Failed Requests,${metrics.requests.failed}`,
+            `Average Response Time,${metrics.requests.averageResponseTime}`,
+            `Cache Hit Rate,${metrics.cache.hitRate}`,
+            `Cache Size,${metrics.cache.totalSize}`,
+            `Memory Usage,${metrics.system.memoryUsage}%`,
+            `Uptime,${metrics.system.uptime}ms`
+        ];
+        return csv.join('\n');
+    }
+    /**
+     * Clean up old historical data
+     */
+    cleanupOldData() {
+        const cutoff = Date.now() - this.config.retentionPeriod;
+        this.historicalData = this.historicalData.filter(data => data.system.uptime > cutoff);
+    }
+}
+//# sourceMappingURL=PerformanceMonitor.js.map