mcp-wordpress 2.4.1 → 2.5.0

package/src/performance/MetricsCollector.ts

@@ -3,12 +3,11 @@
  * Integrates with existing client and cache systems
  */
 
-import {
-  PerformanceMonitor,
-  PerformanceMetrics,
-} from "./PerformanceMonitor.js";
+import { PerformanceMonitor, PerformanceMetrics } from "./PerformanceMonitor.js";
 import type { CacheStats } from "../cache/CacheManager.js";
 import type { ClientStats } from "../types/client.js";
+import { ConfigHelpers } from "../config/Config.js";
+import { LoggerFactory } from "../utils/logger.js";
 
 export interface CollectorConfig {
   enableRealTime: boolean;
@@ -30,7 +29,7 @@ export interface RequestMetadata {
 
 export interface ToolExecutionContext {
   toolName: string;
-  parameters: any;
+  parameters: Record<string, unknown>;
   startTime: number;
   siteId: string | undefined;
 }
@@ -43,13 +42,12 @@ export class MetricsCollector {
   private config: CollectorConfig;
   private activeRequests: Map<string, RequestMetadata> = new Map();
   private activeTools: Map<string, ToolExecutionContext> = new Map();
-  private clientInstances: Map<string, any> = new Map();
-  private cacheManagers: Map<string, any> = new Map();
+  private clientInstances: Map<string, unknown> = new Map();
+  private cacheManagers: Map<string, unknown> = new Map();
+  private logger = LoggerFactory.performance();
+  private realTimeInterval?: NodeJS.Timeout | undefined;
 
-  constructor(
-    monitor: PerformanceMonitor,
-    config: Partial<CollectorConfig> = {},
-  ) {
+  constructor(monitor: PerformanceMonitor, config: Partial<CollectorConfig> = {}) {
     this.monitor = monitor;
     this.config = {
       enableRealTime: true,
@@ -61,37 +59,36 @@ export class MetricsCollector {
       ...config,
     };
 
-    if (this.config.enableRealTime) {
+    // Only enable real-time collection in appropriate environments
+    if (this.config.enableRealTime && (ConfigHelpers.isDev() || ConfigHelpers.isProd())) {
       this.startRealTimeCollection();
+    } else if (ConfigHelpers.isTest() || ConfigHelpers.isCI()) {
+      this.logger.debug("Skipping real-time metrics collection in test/CI environment");
     }
   }
 
   /**
    * Register a WordPress client for monitoring
    */
-  registerClient(siteId: string, client: any): void {
+  registerClient(siteId: string, client: unknown): void {
     this.clientInstances.set(siteId, client);
 
     if (this.config.enableRequestInterception) {
-      this.interceptClientRequests(siteId, client);
+      this.interceptClientRequests(siteId, client as Record<string, unknown>);
     }
   }
 
   /**
    * Register a cache manager for monitoring
    */
-  registerCacheManager(siteId: string, cacheManager: any): void {
+  registerCacheManager(siteId: string, cacheManager: unknown): void {
     this.cacheManagers.set(siteId, cacheManager);
   }
 
   /**
    * Start tracking a tool execution
    */
-  startToolExecution(
-    toolName: string,
-    parameters: any,
-    siteId?: string,
-  ): string {
+  startToolExecution(toolName: string, parameters: Record<string, unknown>, siteId?: string): string {
     const executionId = `${toolName}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
 
     this.activeTools.set(executionId, {
@@ -122,12 +119,7 @@ export class MetricsCollector {
   /**
    * Record a raw request (bypass tool tracking)
    */
-  recordRawRequest(
-    responseTime: number,
-    success: boolean,
-    endpoint: string,
-    fromCache: boolean = false,
-  ): void {
+  recordRawRequest(responseTime: number, success: boolean, endpoint: string, fromCache: boolean = false): void {
     this.monitor.recordRequest(responseTime, success);
   }
 
@@ -158,8 +150,9 @@ export class MetricsCollector {
     };
 
     for (const [_siteId, cacheManager] of this.cacheManagers) {
-      if (cacheManager && typeof cacheManager.getStats === "function") {
-        const stats = cacheManager.getStats();
+      const manager = cacheManager as { getStats?: () => CacheStats };
+      if (manager && typeof manager.getStats === "function") {
+        const stats = manager.getStats();
         aggregated.hits += stats.hits || 0;
         aggregated.misses += stats.misses || 0;
         aggregated.evictions += stats.evictions || 0;
@@ -190,8 +183,9 @@ export class MetricsCollector {
     const responseTimes: number[] = [];
 
     for (const [_siteId, client] of this.clientInstances) {
-      if (client && typeof client.getStats === "function") {
-        const stats = client.getStats();
+      const clientObj = client as { getStats?: () => ClientStats };
+      if (clientObj && typeof clientObj.getStats === "function") {
+        const stats = clientObj.getStats();
         aggregated.totalRequests += stats.totalRequests || 0;
         aggregated.successfulRequests += stats.successfulRequests || 0;
         aggregated.failedRequests += stats.failedRequests || 0;
@@ -206,9 +200,7 @@ export class MetricsCollector {
 
     // Calculate overall average response time
     if (responseTimes.length > 0) {
-      aggregated.averageResponseTime =
-        responseTimes.reduce((sum, time) => sum + time, 0) /
-        responseTimes.length;
+      aggregated.averageResponseTime = responseTimes.reduce((sum, time) => sum + time, 0) / responseTimes.length;
     }
 
     return aggregated;
@@ -222,21 +214,23 @@ export class MetricsCollector {
     client?: ClientStats;
     isActive: boolean;
   } {
-    const result: any = { isActive: false };
+    const result: Record<string, unknown> = { isActive: false };
 
     const cacheManager = this.cacheManagers.get(siteId);
-    if (cacheManager && typeof cacheManager.getStats === "function") {
-      result.cache = cacheManager.getStats();
+    const cacheObj = cacheManager as { getStats?: () => CacheStats } | undefined;
+    if (cacheObj && typeof cacheObj.getStats === "function") {
+      result.cache = cacheObj.getStats();
       result.isActive = true;
     }
 
     const client = this.clientInstances.get(siteId);
-    if (client && typeof client.getStats === "function") {
-      result.client = client.getStats();
+    const clientObj = client as { getStats?: () => ClientStats } | undefined;
+    if (clientObj && typeof clientObj.getStats === "function") {
+      result.client = clientObj.getStats();
       result.isActive = true;
     }
 
-    return result;
+    return result as { cache?: CacheStats; client?: ClientStats; isActive: boolean };
   }
 
   /**
@@ -258,7 +252,13 @@ export class MetricsCollector {
     worstPerforming: string;
   } {
     const sites = Array.from(this.clientInstances.keys());
-    const comparison: any = {};
+    const comparison: Record<string, {
+      responseTime: number;
+      cacheHitRate: number;
+      errorRate: number;
+      requestCount: number;
+      ranking: number;
+    }> = {};
     const rankings: Array<{ site: string; score: number }> = [];
 
     for (const siteId of sites) {
@@ -266,18 +266,11 @@ export class MetricsCollector {
 
       const responseTime = metrics.client?.averageResponseTime || 0;
       const cacheHitRate = metrics.cache?.hitRate || 0;
-      const errorRate = metrics.client
-        ? metrics.client.failedRequests /
-          Math.max(metrics.client.totalRequests, 1)
-        : 0;
+      const errorRate = metrics.client ? metrics.client.failedRequests / Math.max(metrics.client.totalRequests, 1) : 0;
       const requestCount = metrics.client?.totalRequests || 0;
 
       // Calculate performance score (lower is better for response time and error rate)
-      const score =
-        responseTime / 1000 +
-        errorRate * 100 -
-        cacheHitRate * 50 +
-        requestCount * 0.001;
+      const score = responseTime / 1000 + errorRate * 100 - cacheHitRate * 50 + requestCount * 0.001;
 
       comparison[siteId] = {
         responseTime,
@@ -295,7 +288,10 @@ export class MetricsCollector {
 
     // Assign rankings
     rankings.forEach((item, index) => {
-      comparison[item.site].ranking = index + 1;
+      const siteData = comparison[item.site];
+      if (siteData) {
+        siteData.ranking = index + 1;
+      }
     });
 
     return {
@@ -321,49 +317,34 @@ export class MetricsCollector {
 
     // Critical issues
     if (metrics.requests.averageResponseTime > 5000) {
-      critical.push(
-        "Response times are critically high (>5s). Enable caching immediately.",
-      );
+      critical.push("Response times are critically high (>5s). Enable caching immediately.");
     }
 
-    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) {
-      critical.push(
-        "Error rate is critically high (>10%). Check WordPress connectivity.",
-      );
+      critical.push("Error rate is critically high (>10%). Check WordPress connectivity.");
     }
 
     // Recommended optimizations
     if (metrics.cache.hitRate < 0.8) {
-      recommended.push(
-        "Cache hit rate is below 80%. Consider cache warming or TTL adjustment.",
-      );
+      recommended.push("Cache hit rate is below 80%. Consider cache warming or TTL adjustment.");
     }
 
     if (metrics.requests.averageResponseTime > 2000) {
-      recommended.push(
-        "Response times could be improved. Consider enabling more aggressive caching.",
-      );
+      recommended.push("Response times could be improved. Consider enabling more aggressive caching.");
     }
 
     if (metrics.system.memoryUsage > 80) {
-      recommended.push(
-        "Memory usage is high. Consider increasing cache size limits or server resources.",
-      );
+      recommended.push("Memory usage is high. Consider increasing cache size limits or server resources.");
     }
 
     // Optional optimizations
     if (metrics.cache.totalSize < 100) {
-      optional.push(
-        "Cache utilization is low. Consider pre-warming with frequently accessed data.",
-      );
+      optional.push("Cache utilization is low. Consider pre-warming with frequently accessed data.");
     }
 
     if (Object.keys(metrics.tools.toolUsageCount).length > 10) {
-      optional.push(
-        "Many tools are being used. Consider creating custom workflows for common operations.",
-      );
+      optional.push("Many tools are being used. Consider creating custom workflows for common operations.");
     }
 
     return { critical, recommended, optional };
@@ -375,13 +356,13 @@ export class MetricsCollector {
   exportDetailedReport(): {
     timestamp: string;
     overview: PerformanceMetrics;
-    siteComparison: any;
+    siteComparison: Record<string, unknown>;
     aggregatedStats: {
       cache: CacheStats;
       client: ClientStats;
     };
-    optimizations: any;
-    alerts: any[];
+    optimizations: Record<string, unknown>;
+    alerts: unknown[];
   } {
     return {
       timestamp: new Date().toISOString(),
@@ -400,10 +381,43 @@ export class MetricsCollector {
    * Start real-time metric collection
    */
   private startRealTimeCollection(): void {
-    setInterval(() => {
-      this.updateCacheMetrics();
-      this.updateClientMetrics();
-    }, this.config.collectInterval);
+    // Skip in test/CI environments to prevent performance issues
+    if (ConfigHelpers.isTest() || ConfigHelpers.isCI()) {
+      return;
+    }
+
+    // Adjust collection frequency based on environment
+    const interval = ConfigHelpers.isDev()
+      ? Math.max(this.config.collectInterval * 2, 60000) // Longer intervals in dev
+      : this.config.collectInterval;
+
+    this.logger.info("Starting real-time metrics collection", {
+      interval: `${interval / 1000}s`,
+      environment: ConfigHelpers.get().get().app.nodeEnv,
+    });
+
+    this.realTimeInterval = setInterval(() => {
+      try {
+        this.updateCacheMetrics();
+        this.updateClientMetrics();
+        this.logger.debug("Real-time metrics updated");
+      } catch (error) {
+        this.logger.error("Failed to update real-time metrics", {
+          error: error instanceof Error ? error.message : String(error),
+        });
+      }
+    }, interval);
+  }
+
+  /**
+   * Stop real-time collection and cleanup resources
+   */
+  public destroy(): void {
+    if (this.realTimeInterval) {
+      clearInterval(this.realTimeInterval);
+      this.realTimeInterval = undefined;
+      this.logger.info("Real-time metrics collection stopped");
+    }
   }
 
   /**
@@ -411,7 +425,8 @@ export class MetricsCollector {
    */
   private updateCacheMetrics(): void {
     const aggregatedStats = this.getAggregatedCacheStats();
-    this.monitor.updateCacheMetrics(aggregatedStats);
+    // Type assertion: convert CacheStats to Record<string, unknown> via unknown
+    this.monitor.updateCacheMetrics(aggregatedStats as unknown as Record<string, unknown>);
   }
 
   /**
@@ -425,22 +440,29 @@ export class MetricsCollector {
   /**
    * Intercept client requests for automatic tracking
    */
-  private interceptClientRequests(siteId: string, client: any): void {
+  private interceptClientRequests(siteId: string, client: Record<string, unknown>): void {
     if (!client.request || typeof client.request !== "function") {
       return;
     }
 
     const originalRequest = client.request.bind(client);
 
-    client.request = async (...args: any[]) => {
+    const clientObj = client as {
+      request?: (...args: unknown[]) => Promise<unknown>;
+      originalRequest?: (...args: unknown[]) => Promise<unknown>;
+    };
+    if (!clientObj.request) return;
+
+    clientObj.originalRequest = clientObj.request;
+    clientObj.request = async (...args: unknown[]) => {
       const startTime = Date.now();
       const requestId = `${siteId}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
 
-      // Extract metadata
+      // Extract metadata with proper type assertions
       const metadata: RequestMetadata = {
         siteId,
-        endpoint: args[0] || "unknown",
-        method: args[1] || "GET",
+        endpoint: (args[0] as string) || "unknown",
+        method: (args[1] as string) || "GET",
         startTime,
         fromCache: false,
       };