mcp-wordpress 2.4.2 → 2.5.0

package/src/tools/performance.ts

@@ -2,12 +2,21 @@
  * Performance Monitoring MCP Tools for WordPress Server
  * Provides comprehensive performance insights and management
  */
+/**
+ * Performance Monitoring MCP Tools for WordPress Server
+ * Provides comprehensive performance insights and management
+ */
 
 import type { ToolDefinition } from "../server/ToolRegistry.js";
-import { PerformanceMonitor } from "../performance/PerformanceMonitor.js";
+import { PerformanceMonitor, type PerformanceMetrics, type PerformanceAlert } from "../performance/PerformanceMonitor.js";
 import { MetricsCollector } from "../performance/MetricsCollector.js";
-import { PerformanceAnalytics } from "../performance/PerformanceAnalytics.js";
+import { PerformanceAnalytics, type BenchmarkComparison, type PerformanceAnomaly } from "../performance/PerformanceAnalytics.js";
 import { toolWrapper } from "../utils/toolWrapper.js";
+import { ConfigHelpers } from "../config/Config.js";
+import { LoggerFactory } from "../utils/logger.js";
+import type { WordPressClient } from "../client/api.js";
+
+// Using existing performance interfaces from PerformanceMonitor/PerformanceAnalytics
 
 /**
  * Performance Tools Class
@@ -16,8 +25,10 @@ export default class PerformanceTools {
   private monitor: PerformanceMonitor;
   private collector: MetricsCollector;
   private analytics: PerformanceAnalytics;
+  private logger = LoggerFactory.performance();
+  private historicalDataInterval?: NodeJS.Timeout | undefined;
 
-  constructor(clients?: Map<string, any>) {
+  constructor(clients?: Map<string, unknown>) {
     // Initialize performance monitoring system
     this.monitor = new PerformanceMonitor({
       enableRealTimeMonitoring: true,
@@ -43,14 +54,17 @@ export default class PerformanceTools {
         this.collector.registerClient(siteId, client);
 
         // Register cache manager if client has one
-        if (client.cacheManager) {
-          this.collector.registerCacheManager(siteId, client.cacheManager);
+        const possibleCacheMgr = (client as Record<string, unknown>)?.cacheManager as unknown;
+        if (possibleCacheMgr) {
+          this.collector.registerCacheManager(siteId, possibleCacheMgr);
         }
       }
     }
 
-    // Start collecting metrics from historical data for analytics
-    this.startHistoricalDataCollection();
+    // Only start historical data collection in production environments
+    if (ConfigHelpers.isProd() || ConfigHelpers.isDev()) {
+      this.startHistoricalDataCollection();
+    }
   }
 
   /**
@@ -65,22 +79,19 @@ export default class PerformanceTools {
           {
             name: "site",
             type: "string",
-            description:
-              "Specific site ID for multi-site setups (optional for single site)",
+            description: "Specific site ID for multi-site setups (optional for single site)",
             required: false,
           },
           {
             name: "category",
             type: "string",
-            description:
-              "Category of metrics to return (overview, requests, cache, system, tools, all)",
+            description: "Category of metrics to return (overview, requests, cache, system, tools, all)",
             required: false,
           },
           {
             name: "format",
             type: "string",
-            description:
-              "Detail level of the response (summary, detailed, raw)",
+            description: "Detail level of the response (summary, detailed, raw)",
             required: false,
           },
         ],
@@ -93,15 +104,13 @@ export default class PerformanceTools {
           {
             name: "site",
             type: "string",
-            description:
-              "Specific site ID for multi-site setups (optional for single site)",
+            description: "Specific site ID for multi-site setups (optional for single site)",
             required: false,
           },
           {
             name: "timeframe",
             type: "string",
-            description:
-              "Time period for historical data (1h, 6h, 12h, 24h, 7d)",
+            description: "Time period for historical data (1h, 6h, 12h, 24h, 7d)",
             required: false,
           },
           {
@@ -127,15 +136,13 @@ export default class PerformanceTools {
           {
             name: "site",
             type: "string",
-            description:
-              "Specific site ID for multi-site setups (optional for single site)",
+            description: "Specific site ID for multi-site setups (optional for single site)",
             required: false,
           },
           {
             name: "category",
             type: "string",
-            description:
-              "Benchmark category (response_time, cache_performance, error_rate, system_resources, all)",
+            description: "Benchmark category (response_time, cache_performance, error_rate, system_resources, all)",
             required: false,
           },
           {
@@ -154,22 +161,19 @@ export default class PerformanceTools {
           {
             name: "site",
             type: "string",
-            description:
-              "Specific site ID for multi-site setups (optional for single site)",
+            description: "Specific site ID for multi-site setups (optional for single site)",
             required: false,
           },
           {
             name: "severity",
             type: "string",
-            description:
-              "Filter alerts by severity level (info, warning, error, critical)",
+            description: "Filter alerts by severity level (info, warning, error, critical)",
             required: false,
           },
           {
             name: "category",
             type: "string",
-            description:
-              "Filter alerts by category (performance, cache, system, wordpress)",
+            description: "Filter alerts by category (performance, cache, system, wordpress)",
             required: false,
           },
           {
@@ -194,22 +198,19 @@ export default class PerformanceTools {
           {
             name: "site",
             type: "string",
-            description:
-              "Specific site ID for multi-site setups (optional for single site)",
+            description: "Specific site ID for multi-site setups (optional for single site)",
             required: false,
           },
           {
             name: "focus",
             type: "string",
-            description:
-              "Optimization focus area (speed, reliability, efficiency, scaling)",
+            description: "Optimization focus area (speed, reliability, efficiency, scaling)",
             required: false,
           },
           {
             name: "priority",
             type: "string",
-            description:
-              "Implementation timeline (quick_wins, medium_term, long_term, all)",
+            description: "Implementation timeline (quick_wins, medium_term, long_term, all)",
             required: false,
           },
           {
@@ -234,8 +235,7 @@ export default class PerformanceTools {
           {
             name: "site",
             type: "string",
-            description:
-              "Specific site ID for multi-site setups (optional for single site)",
+            description: "Specific site ID for multi-site setups (optional for single site)",
             required: false,
           },
           {
@@ -271,21 +271,21 @@ export default class PerformanceTools {
   /**
    * Get real-time performance statistics
    */
-  private async getPerformanceStats(params: any): Promise<any> {
+  private async getPerformanceStats(_client: WordPressClient, params: Record<string, unknown>): Promise<unknown> {
     return toolWrapper(async () => {
-      const { site, category = "overview", format = "summary" } = params;
+      const { site, category = "overview", format = "summary" } = params as { site?: string; category?: string; format?: string };
 
       // Get current metrics
-      const metrics = this.collector.collectCurrentMetrics();
+  const metrics = this.collector.collectCurrentMetrics();
 
       // Get site-specific metrics if requested
       let siteMetrics = null;
       if (site) {
-        siteMetrics = this.collector.getSiteMetrics(site);
+  siteMetrics = this.collector.getSiteMetrics(site as string);
       }
 
       // Filter by category
-      const result: any = {};
+      const result: Record<string, unknown> = {};
 
       if (category === "overview" || category === "all") {
         result.overview = {
@@ -331,15 +331,14 @@ export default class PerformanceTools {
         result.tools = {
           mostUsedTool: metrics.tools.mostUsedTool,
           totalToolCalls: Object.values(metrics.tools.toolUsageCount).reduce(
-            (sum: number, count: any) => sum + count,
+            (sum: number, count: unknown) => sum + (typeof count === "number" ? count : 0),
             0,
           ),
           topTools: Object.entries(metrics.tools.toolUsageCount)
             .sort(([, a], [, b]) => (b as number) - (a as number))
             .slice(0, 5)
             .map(([tool, count]) => ({ tool, count })),
-          toolPerformance:
-            format === "detailed" ? metrics.tools.toolPerformance : undefined,
+          toolPerformance: format === "detailed" ? metrics.tools.toolPerformance : undefined,
         };
       }
 
@@ -371,42 +370,32 @@ export default class PerformanceTools {
   /**
    * Get historical performance data and trends
    */
-  private async getPerformanceHistory(params: any): Promise<any> {
+  private async getPerformanceHistory(_client: WordPressClient, params: Record<string, unknown>): Promise<unknown> {
     return toolWrapper(async () => {
-      const {
-        site,
-        timeframe = "24h",
-        metrics: requestedMetrics,
-        includeTrends = true,
-      } = params;
+      const { site, timeframe = "24h", metrics: requestedMetrics, includeTrends = true } = params as { site?: string; timeframe?: string; metrics?: string[]; includeTrends?: boolean };
 
       // Convert timeframe to milliseconds
       const timeframMs = this.parseTimeframe(timeframe);
       const startTime = Date.now() - timeframMs;
 
       // Get historical data
-      const historicalData = this.monitor.getHistoricalData(startTime);
+  const historicalData = this.monitor.getHistoricalData(startTime);
 
       // Analyze trends if requested
       let trends = null;
       if (includeTrends) {
         // Add current data for trend analysis
-        this.analytics.addDataPoint(this.collector.collectCurrentMetrics());
+  this.analytics.addDataPoint(this.collector.collectCurrentMetrics());
         trends = this.analytics.analyzeTrends();
 
         // Filter trends by requested metrics
         if (requestedMetrics && Array.isArray(requestedMetrics)) {
-          trends = trends.filter((trend) =>
-            requestedMetrics.includes(trend.metric),
-          );
+          trends = trends.filter((trend) => requestedMetrics.includes(trend.metric));
         }
       }
 
       // Process historical data for charting
-      const chartData = this.processHistoricalDataForChart(
-        historicalData,
-        requestedMetrics,
-      );
+  const chartData = this.processHistoricalDataForChart(historicalData, requestedMetrics as string[] | undefined);
 
       return {
         success: true,
@@ -416,21 +405,12 @@ export default class PerformanceTools {
           historicalData: chartData,
           trends: trends || [],
           summary: {
-            averageResponseTime: this.calculateAverage(
-              historicalData.map((d) => d.requests.averageResponseTime),
-            ),
-            averageCacheHitRate: this.calculateAverage(
-              historicalData.map((d) => d.cache.hitRate),
-            ),
+            averageResponseTime: this.calculateAverage(historicalData.map((d) => d.requests.averageResponseTime)),
+            averageCacheHitRate: this.calculateAverage(historicalData.map((d) => d.cache.hitRate)),
             averageErrorRate: this.calculateAverage(
-              historicalData.map((d) =>
-                d.requests.total > 0 ? d.requests.failed / d.requests.total : 0,
-              ),
-            ),
-            totalRequests: historicalData.reduce(
-              (sum, d) => sum + d.requests.total,
-              0,
+              historicalData.map((d) => (d.requests.total > 0 ? d.requests.failed / d.requests.total : 0)),
             ),
+            totalRequests: historicalData.reduce((sum, d) => sum + d.requests.total, 0),
           },
           metadata: {
             timestamp: new Date().toISOString(),
@@ -445,12 +425,12 @@ export default class PerformanceTools {
   /**
    * Get benchmark comparison
    */
-  private async getBenchmarkComparison(params: any): Promise<any> {
+  private async getBenchmarkComparison(_client: WordPressClient, params: Record<string, unknown>): Promise<unknown> {
     return toolWrapper(async () => {
-      const { site, category = "all", includeRecommendations = true } = params;
+      const { site, category = "all", includeRecommendations = true } = params as { site?: string; category?: string; includeRecommendations?: boolean };
 
       // Get benchmark comparisons
-      const benchmarks = this.analytics.benchmarkPerformance();
+  const benchmarks = this.analytics.benchmarkPerformance() as BenchmarkComparison[];
 
       // Filter by category if specified
       let filteredBenchmarks = benchmarks;
@@ -461,11 +441,9 @@ export default class PerformanceTools {
           error_rate: "Error Rate",
           system_resources: "Memory Usage",
         };
-        const targetCategory = categoryMap[category];
+  const targetCategory = categoryMap[category as string];
         if (targetCategory) {
-          filteredBenchmarks = benchmarks.filter(
-            (b) => b.category === targetCategory,
-          );
+          filteredBenchmarks = benchmarks.filter((b) => b.category === targetCategory);
         }
       }
 
@@ -494,8 +472,7 @@ export default class PerformanceTools {
               benchmark.improvement > 0
                 ? {
                     needed: benchmark.improvement,
-                    description:
-                      this.getBenchmarkImprovementDescription(benchmark),
+                    description: this.getBenchmarkImprovementDescription(benchmark),
                   }
                 : null,
           })),
@@ -515,18 +492,12 @@ export default class PerformanceTools {
   /**
    * Get performance alerts and anomalies
    */
-  private async getPerformanceAlerts(params: any): Promise<any> {
+  private async getPerformanceAlerts(_client: WordPressClient, params: Record<string, unknown>): Promise<unknown> {
     return toolWrapper(async () => {
-      const {
-        site,
-        severity,
-        category,
-        limit = 20,
-        includeAnomalies = true,
-      } = params;
+      const { site, severity, category, limit = 20, includeAnomalies = true } = params as { site?: string; severity?: string; category?: string; limit?: number; includeAnomalies?: boolean };
 
       // Get alerts from monitor
-      let alerts = this.monitor.getAlerts(severity);
+  let alerts = this.monitor.getAlerts(severity) as PerformanceAlert[];
 
       // Filter by category if specified
       if (category) {
@@ -534,12 +505,12 @@ export default class PerformanceTools {
       }
 
       // Limit results
-      alerts = alerts.slice(-limit);
+  alerts = alerts.slice(-(limit as number));
 
       // Get anomalies if requested
-      let anomalies: any[] = [];
+      let anomalies: PerformanceAnomaly[] = [];
       if (includeAnomalies) {
-        anomalies = this.analytics.getAnomalies(severity);
+        anomalies = this.analytics.getAnomalies(severity) as PerformanceAnomaly[];
       }
 
       // Calculate alert summary
@@ -575,10 +546,7 @@ export default class PerformanceTools {
           summary: {
             alerts: alertSummary,
             anomalies: anomalySummary,
-            overallStatus: this.calculateAlertStatus(
-              alertSummary,
-              anomalySummary,
-            ),
+            overallStatus: this.calculateAlertStatus(alertSummary, anomalySummary),
           },
           metadata: {
             timestamp: new Date().toISOString(),
@@ -593,21 +561,15 @@ export default class PerformanceTools {
   /**
    * Get optimization recommendations
    */
-  private async getOptimizationRecommendations(params: any): Promise<any> {
+  private async getOptimizationRecommendations(_client: WordPressClient, params: Record<string, unknown>): Promise<unknown> {
     return toolWrapper(async () => {
-      const {
-        site,
-        focus = "speed",
-        priority = "all",
-        includeROI = true,
-        includePredictions = true,
-      } = params;
+      const { site, focus = "speed", priority = "all", includeROI = true, includePredictions = true } = params as { site?: string; focus?: string; priority?: string; includeROI?: boolean; includePredictions?: boolean };
 
       // Generate optimization plan
       const optimizationPlan = this.analytics.generateOptimizationPlan();
 
       // Filter by priority
-      let recommendations = [];
+  let recommendations: Array<{ priority: string; impact: string; implementationEffort: string; [key: string]: unknown }> = [];
       if (priority === "quick_wins" || priority === "all") {
         recommendations.push(
           ...optimizationPlan.quickWins.map((r) => ({
@@ -634,20 +596,18 @@ export default class PerformanceTools {
       }
 
       // Filter by focus area
-      if (focus !== "speed") {
+  if (focus !== "speed") {
         const focusMap: Record<string, string[]> = {
           reliability: ["reliability"],
           efficiency: ["cost", "performance"],
           scaling: ["performance", "reliability"],
         };
         const targetImpacts = focusMap[focus] || [];
-        recommendations = recommendations.filter((r) =>
-          targetImpacts.includes(r.impact),
-        );
+        recommendations = recommendations.filter((r) => targetImpacts.includes(r.impact));
       }
 
       // Get predictions if requested
-      let predictions = null;
+  let predictions: Record<string, unknown> | null = null;
       if (includePredictions) {
         predictions = this.analytics.predictPerformance(60); // 1 hour prediction
       }
@@ -683,21 +643,15 @@ export default class PerformanceTools {
   /**
    * Export comprehensive performance report
    */
-  private async exportPerformanceReport(params: any): Promise<any> {
+  private async exportPerformanceReport(_client: WordPressClient, params: Record<string, unknown>): Promise<unknown> {
     return toolWrapper(async () => {
-      const {
-        site,
-        format = "json",
-        includeHistorical = true,
-        includeAnalytics = true,
-        timeRange = "24h",
-      } = params;
+      const { site, format = "json", includeHistorical = true, includeAnalytics = true, timeRange = "24h" } = params as { site?: string; format?: string; includeHistorical?: boolean; includeAnalytics?: boolean; timeRange?: string };
 
       // Generate comprehensive analytics report
       const report = this.analytics.exportAnalyticsReport();
 
       // Add additional data based on parameters
-      const exportData: any = {
+  const exportData: { currentMetrics: PerformanceMetrics; [key: string]: unknown } = {
         metadata: {
           generatedAt: new Date().toISOString(),
           site: site || "all",
@@ -706,7 +660,7 @@ export default class PerformanceTools {
           version: "1.0.0",
         },
         summary: report.summary,
-        currentMetrics: this.collector.collectCurrentMetrics(),
+  currentMetrics: this.collector.collectCurrentMetrics(),
       };
 
       if (includeHistorical) {
@@ -738,7 +692,7 @@ export default class PerformanceTools {
       }
 
       // Format output based on requested format
-      let formattedOutput: any;
+      let formattedOutput: unknown;
       if (format === "csv") {
         formattedOutput = this.convertToCSV(exportData);
       } else if (format === "summary") {
@@ -762,14 +716,13 @@ export default class PerformanceTools {
 
   // Helper methods
 
-  private calculateHealthStatus(metrics: any): string {
+  private calculateHealthStatus(metrics: PerformanceMetrics): string {
     let score = 100;
 
     if (metrics.requests.averageResponseTime > 2000) score -= 30;
     else if (metrics.requests.averageResponseTime > 1000) score -= 15;
 
-    const errorRate =
-      metrics.requests.failed / Math.max(metrics.requests.total, 1);
+    const errorRate = metrics.requests.failed / Math.max(metrics.requests.total, 1);
     if (errorRate > 0.05) score -= 30;
     else if (errorRate > 0.02) score -= 15;
 
@@ -785,7 +738,7 @@ export default class PerformanceTools {
     return "Critical";
   }
 
-  private calculatePerformanceScore(metrics: any): number {
+  private calculatePerformanceScore(metrics: PerformanceMetrics): number {
     let score = 100;
 
     // Response time scoring
@@ -794,8 +747,7 @@ export default class PerformanceTools {
     else if (metrics.requests.averageResponseTime > 800) score -= 10;
 
     // Error rate scoring
-    const errorRate =
-      metrics.requests.failed / Math.max(metrics.requests.total, 1);
+    const errorRate = metrics.requests.failed / Math.max(metrics.requests.total, 1);
     if (errorRate > 0.1) score -= 30;
     else if (errorRate > 0.05) score -= 20;
     else if (errorRate > 0.02) score -= 10;
@@ -812,11 +764,9 @@ export default class PerformanceTools {
     return Math.max(0, Math.min(100, score));
   }
 
-  private calculateCacheEfficiency(cacheMetrics: any): string {
+  private calculateCacheEfficiency(cacheMetrics: PerformanceMetrics["cache"]): string {
     const efficiency =
-      cacheMetrics.hitRate * 100 +
-      (cacheMetrics.totalSize > 0 ? 10 : 0) -
-      (cacheMetrics.evictions > 100 ? 10 : 0);
+      cacheMetrics.hitRate * 100 + (cacheMetrics.totalSize > 0 ? 10 : 0) - (cacheMetrics.evictions > 100 ? 10 : 0);
 
     if (efficiency >= 95) return "Excellent";
     if (efficiency >= 85) return "Good";
@@ -848,22 +798,13 @@ export default class PerformanceTools {
     return map[timeframe] || map["24h"];
   }
 
-  private processHistoricalDataForChart(
-    data: any[],
-    requestedMetrics?: string[],
-  ): any {
+  private processHistoricalDataForChart(data: PerformanceMetrics[], requestedMetrics?: string[]): Record<string, unknown> {
     if (!data.length) return {};
 
-    const allMetrics = [
-      "responseTime",
-      "cacheHitRate",
-      "errorRate",
-      "memoryUsage",
-      "requestVolume",
-    ];
+    const allMetrics = ["responseTime", "cacheHitRate", "errorRate", "memoryUsage", "requestVolume"];
     const metricsToProcess = requestedMetrics || allMetrics;
 
-    const result: any = {};
+    const result: Record<string, unknown> = {};
 
     for (const metric of metricsToProcess) {
       result[metric] = data.map((point, index) => ({
@@ -876,17 +817,14 @@ export default class PerformanceTools {
     return result;
   }
 
-  private extractMetricValue(dataPoint: any, metric: string): number {
+  private extractMetricValue(dataPoint: PerformanceMetrics, metric: string): number {
     switch (metric) {
       case "responseTime":
         return dataPoint.requests.averageResponseTime;
       case "cacheHitRate":
         return dataPoint.cache.hitRate * 100;
       case "errorRate":
-        return (
-          (dataPoint.requests.failed / Math.max(dataPoint.requests.total, 1)) *
-          100
-        );
+        return (dataPoint.requests.failed / Math.max(dataPoint.requests.total, 1)) * 100;
       case "memoryUsage":
         return dataPoint.system.memoryUsage;
       case "requestVolume":
@@ -912,19 +850,17 @@ export default class PerformanceTools {
     return statusMap[status] || status;
   }
 
-  private getBenchmarkImprovementDescription(benchmark: any): string {
+  private getBenchmarkImprovementDescription(benchmark: BenchmarkComparison): string {
     const improvements: Record<string, string> = {
       "Response Time": `Reduce by ${benchmark.improvement.toFixed(0)}ms`,
       "Cache Hit Rate": `Increase by ${benchmark.improvement.toFixed(1)}%`,
       "Error Rate": `Reduce by ${benchmark.improvement.toFixed(2)}%`,
       "Memory Usage": `Reduce by ${benchmark.improvement.toFixed(0)}%`,
     };
-    return (
-      improvements[benchmark.category] || `Improve by ${benchmark.improvement}`
-    );
+    return improvements[benchmark.category] || `Improve by ${benchmark.improvement}`;
   }
 
-  private calculateOverallRanking(benchmarks: any[]): {
+  private calculateOverallRanking(benchmarks: BenchmarkComparison[]): {
     percentile: number;
     status: string;
   } {
@@ -932,8 +868,7 @@ export default class PerformanceTools {
     const excellentCount = statuses.filter((s) => s === "excellent").length;
     const goodCount = statuses.filter((s) => s === "good").length;
 
-    const percentile =
-      ((excellentCount + goodCount * 0.8) / statuses.length) * 100;
+    const percentile = ((excellentCount + goodCount * 0.8) / statuses.length) * 100;
 
     let status = "Needs Improvement";
     if (percentile >= 90) status = "Top Performer";
@@ -943,24 +878,22 @@ export default class PerformanceTools {
     return { percentile: Math.round(percentile), status };
   }
 
-  private formatAlertMessage(alert: any): string {
+  private formatAlertMessage(alert: PerformanceAlert): string {
     return `${alert.severity.toUpperCase()}: ${alert.message} (${alert.metric}: ${alert.actualValue} vs threshold: ${alert.threshold})`;
   }
 
-  private formatAnomalyDescription(anomaly: any): string {
-    const direction =
-      anomaly.actualValue > anomaly.expectedValue ? "higher" : "lower";
+  private formatAnomalyDescription(anomaly: PerformanceAnomaly): string {
+    const direction = anomaly.actualValue > anomaly.expectedValue ? "higher" : "lower";
     return `${anomaly.metric} is ${Math.abs(anomaly.deviation).toFixed(1)}% ${direction} than expected (${anomaly.expectedValue.toFixed(2)} vs ${anomaly.actualValue.toFixed(2)})`;
   }
 
-  private calculateAlertStatus(alertSummary: any, anomalySummary: any): string {
+  private calculateAlertStatus(alertSummary: { critical: number; error: number; warning: number }, anomalySummary: { critical: number; major: number; moderate: number; minor: number }): string {
     const critical = alertSummary.critical + anomalySummary.critical;
     const high = alertSummary.error + anomalySummary.major;
 
     if (critical > 0) return "Critical Issues Detected";
     if (high > 2) return "High Priority Issues";
-    if (alertSummary.warning + anomalySummary.moderate > 5)
-      return "Performance Warnings";
+    if (alertSummary.warning + anomalySummary.moderate > 5) return "Performance Warnings";
     return "System Healthy";
   }
 
@@ -983,10 +916,10 @@ export default class PerformanceTools {
     return map[effort] || effort;
   }
 
-  private calculateEstimatedImpact(recommendations: any[]): string {
-    const highImpact = recommendations.filter((r) =>
-      ["critical", "high"].includes(r.priority),
-    ).length;
+  private calculateEstimatedImpact(
+    recommendations: Array<{ priority: string }>,
+  ): string {
+    const highImpact = recommendations.filter((r) => ["critical", "high"].includes(r.priority)).length;
     const totalImpact = recommendations.length;
 
     if (highImpact >= 3) return "Significant Performance Gains Expected";
@@ -995,7 +928,7 @@ export default class PerformanceTools {
     return "System Already Optimized";
   }
 
-  private convertToCSV(data: any): string {
+  private convertToCSV(data: { currentMetrics: PerformanceMetrics }): string {
     // Simplified CSV conversion for current metrics
     const metrics = data.currentMetrics;
     const csv = [
@@ -1012,7 +945,7 @@ export default class PerformanceTools {
     return csv.join("\n");
   }
 
-  private createSummaryReport(data: any): any {
+  private createSummaryReport(data: { currentMetrics: PerformanceMetrics; analytics?: { insights?: unknown[] } }): Record<string, unknown> {
     const metrics = data.currentMetrics;
     return {
       summary: `Performance Report - ${new Date().toISOString()}`,
@@ -1024,16 +957,48 @@ export default class PerformanceTools {
         errorRate: `${((metrics.requests.failed / Math.max(metrics.requests.total, 1)) * 100).toFixed(2)}%`,
       },
       recommendations: data.analytics?.insights?.slice(0, 3) || [],
-      nextSteps:
-        "Review detailed metrics and implement high-priority optimizations",
+      nextSteps: "Review detailed metrics and implement high-priority optimizations",
     };
   }
 
   private startHistoricalDataCollection(): void {
-    // Collect metrics every 30 seconds for analytics
-    setInterval(() => {
-      const currentMetrics = this.collector.collectCurrentMetrics();
-      this.analytics.addDataPoint(currentMetrics);
-    }, 30000);
+    // Skip in test environments to prevent performance issues
+    if (ConfigHelpers.isTest() || ConfigHelpers.isCI()) {
+      this.logger.debug("Skipping historical data collection in test/CI environment");
+      return;
+    }
+
+    // Adjust collection frequency based on environment
+    const interval = ConfigHelpers.isDev() ? 60000 : 30000; // 1 minute in dev, 30 seconds in prod
+
+    this.logger.info("Starting historical data collection", {
+      interval: `${interval / 1000}s`,
+      environment: ConfigHelpers.get().get().app.nodeEnv,
+    });
+
+    this.historicalDataInterval = setInterval(() => {
+      try {
+        const currentMetrics = this.collector.collectCurrentMetrics();
+        this.analytics.addDataPoint(currentMetrics);
+        this.logger.debug("Historical metrics collected", {
+          timestamp: new Date().toISOString(),
+        });
+      } catch (error) {
+        this.logger.error("Failed to collect historical metrics", {
+          error: error instanceof Error ? error.message : String(error),
+        });
+      }
+    }, interval);
+  }
+
+  /**
+   * Stop historical data collection and cleanup resources
+   */
+  public destroy(): void {
+    if (this.historicalDataInterval) {
+      clearInterval(this.historicalDataInterval);
+      this.historicalDataInterval = undefined;
+      this.logger.info("Historical data collection stopped");
+    }
   }
 }