0xray 4.0.13 → 4.0.15

package/dist/monitoring/advanced-profiler.js

@@ -0,0 +1,232 @@
+import { EventEmitter } from "events";
+import { performance } from "perf_hooks";
+import { writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { resolveProfilesDir } from "../core/config-paths.js";
+export class AdvancedProfiler extends EventEmitter {
+    profiles = new Map();
+    activeProfiles = new Map();
+    profilingEnabled = true;
+    profileStoragePath;
+    reportTimer;
+    cleanupTimer;
+    isRunning = false;
+    constructor(storagePath = undefined) {
+        super();
+        this.profileStoragePath = storagePath || resolveProfilesDir();
+        this.ensureStorageDirectory();
+    }
+    start() {
+        if (this.isRunning)
+            return;
+        this.isRunning = true;
+        this.reportTimer = setInterval(() => {
+            this.generatePerformanceReport();
+        }, 5 * 60 * 1000);
+        this.cleanupTimer = setInterval(() => {
+            this.cleanupOldProfiles();
+        }, 24 * 60 * 60 * 1000);
+    }
+    stop() {
+        this.isRunning = false;
+        if (this.reportTimer) {
+            clearInterval(this.reportTimer);
+            this.reportTimer = undefined;
+        }
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+            this.cleanupTimer = undefined;
+        }
+    }
+    ensureStorageDirectory() {
+        if (!existsSync(this.profileStoragePath)) {
+            mkdirSync(this.profileStoragePath, { recursive: true });
+        }
+    }
+    startProfiling(operationId, agentName, operation, metadata = {}) {
+        if (!this.profilingEnabled)
+            return;
+        const profileData = {
+            agentName,
+            operation,
+            startTime: performance.now(),
+            memoryUsage: {
+                before: process.memoryUsage(),
+            },
+            success: false,
+            metadata,
+        };
+        this.activeProfiles.set(operationId, profileData);
+    }
+    endProfiling(operationId, success = true, error) {
+        const profileData = this.activeProfiles.get(operationId);
+        if (!profileData)
+            return;
+        profileData.endTime = performance.now();
+        profileData.duration = profileData.endTime - profileData.startTime;
+        profileData.memoryUsage.after = process.memoryUsage();
+        profileData.success = success;
+        if (error) {
+            profileData.error = error;
+        }
+        if (!this.profiles.has(profileData.agentName)) {
+            this.profiles.set(profileData.agentName, []);
+        }
+        this.profiles.get(profileData.agentName).push(profileData);
+        this.activeProfiles.delete(operationId);
+        this.emit("profileCompleted", profileData);
+        this.detectAnomalies(profileData);
+    }
+    detectAnomalies(profileData) {
+        if (!profileData.duration)
+            return;
+        const agentProfiles = this.profiles.get(profileData.agentName) || [];
+        if (agentProfiles.length < 10)
+            return;
+        const recentProfiles = agentProfiles.slice(-20);
+        const avgDuration = recentProfiles.reduce((sum, p) => sum + (p.duration || 0), 0) /
+            recentProfiles.length;
+        if (profileData.duration > avgDuration * 2) {
+            this.emit("performanceAnomaly", {
+                agentName: profileData.agentName,
+                operation: profileData.operation,
+                duration: profileData.duration,
+                averageDuration: avgDuration,
+                deviation: profileData.duration / avgDuration,
+            });
+        }
+        const memoryDelta = this.calculateMemoryDelta(profileData);
+        if (memoryDelta > 50 * 1024 * 1024) {
+            this.emit("memoryAnomaly", {
+                agentName: profileData.agentName,
+                operation: profileData.operation,
+                memoryDelta,
+                memoryBefore: profileData.memoryUsage.before,
+                memoryAfter: profileData.memoryUsage.after,
+            });
+        }
+    }
+    calculateMemoryDelta(profileData) {
+        if (!profileData.memoryUsage.after)
+            return 0;
+        const before = profileData.memoryUsage.before.heapUsed;
+        const after = profileData.memoryUsage.after.heapUsed;
+        return after - before;
+    }
+    getMetrics(agentName) {
+        let profiles = [];
+        if (agentName) {
+            profiles = this.profiles.get(agentName) || [];
+        }
+        else {
+            for (const agentProfiles of Array.from(this.profiles.values())) {
+                profiles.push(...agentProfiles);
+            }
+        }
+        if (profiles.length === 0) {
+            return {
+                totalOperations: 0,
+                successfulOperations: 0,
+                failedOperations: 0,
+                averageDuration: 0,
+                memoryDelta: 0,
+                slowestOperation: "",
+                fastestOperation: "",
+            };
+        }
+        const successfulProfiles = profiles.filter((p) => p.success);
+        const totalDuration = profiles.reduce((sum, p) => sum + (p.duration || 0), 0);
+        const memoryDeltas = profiles.map((p) => this.calculateMemoryDelta(p));
+        if (profiles.length === 0) {
+            return {
+                totalOperations: 0,
+                successfulOperations: 0,
+                failedOperations: 0,
+                averageDuration: 0,
+                memoryDelta: 0,
+                slowestOperation: "",
+                fastestOperation: "",
+            };
+        }
+        let slowestOp = profiles[0];
+        let fastestOp = profiles[0];
+        for (const profile of profiles) {
+            if ((profile.duration || 0) > (slowestOp.duration || 0)) {
+                slowestOp = profile;
+            }
+            if ((profile.duration || 0) < (fastestOp.duration || 0)) {
+                fastestOp = profile;
+            }
+        }
+        return {
+            totalOperations: profiles.length,
+            successfulOperations: successfulProfiles.length,
+            failedOperations: profiles.length - successfulProfiles.length,
+            averageDuration: totalDuration / profiles.length,
+            memoryDelta: memoryDeltas.reduce((sum, delta) => sum + delta, 0) /
+                memoryDeltas.length,
+            slowestOperation: slowestOp.operation,
+            fastestOperation: fastestOp.operation,
+        };
+    }
+    generatePerformanceReport() {
+        const report = {
+            timestamp: new Date().toISOString(),
+            agents: {},
+            system: this.getMetrics(),
+            recommendations: this.generateRecommendations(),
+        };
+        for (const agentName of Array.from(this.profiles.keys())) {
+            report.agents[agentName] = this.getMetrics(agentName);
+        }
+        const reportPath = join(this.profileStoragePath, `performance-report-${Date.now()}.json`);
+        writeFileSync(reportPath, JSON.stringify(report, null, 2));
+        this.emit("reportGenerated", reportPath);
+    }
+    generateRecommendations() {
+        const recommendations = [];
+        const systemMetrics = this.getMetrics();
+        if (systemMetrics.averageDuration > 5000) {
+            recommendations.push("Consider optimizing slow operations - average duration exceeds 5 seconds");
+        }
+        if (systemMetrics.failedOperations > systemMetrics.totalOperations * 0.1) {
+            recommendations.push("High failure rate detected - investigate error patterns");
+        }
+        if (systemMetrics.memoryDelta > 10 * 1024 * 1024) {
+            recommendations.push("Memory usage increasing significantly - check for leaks");
+        }
+        for (const [agentName, metrics] of Object.entries(this.getMetrics())) {
+            if (metrics.failedOperations > metrics.totalOperations * 0.2) {
+                recommendations.push(`Agent ${agentName} has high failure rate - review implementation`);
+            }
+        }
+        return recommendations;
+    }
+    cleanupOldProfiles() {
+        const cutoffTime = Date.now() - 7 * 24 * 60 * 60 * 1000;
+        for (const [agentName, profiles] of Array.from(this.profiles.entries())) {
+            const recentProfiles = profiles.filter((p) => p.startTime > cutoffTime);
+            if (recentProfiles.length !== profiles.length) {
+                this.profiles.set(agentName, recentProfiles);
+            }
+        }
+    }
+    enableProfiling() {
+        this.profilingEnabled = true;
+    }
+    disableProfiling() {
+        this.profilingEnabled = false;
+    }
+    clearProfiles() {
+        this.profiles.clear();
+        this.activeProfiles.clear();
+    }
+    exportProfiles() {
+        const exportData = {};
+        for (const [agentName, profiles] of Array.from(this.profiles.entries())) {
+            exportData[agentName] = [...profiles];
+        }
+        return exportData;
+    }
+}
+export const advancedProfiler = new AdvancedProfiler();

package/dist/monitoring/memory-monitor.d.ts

@@ -0,0 +1,113 @@
+import { EventEmitter } from "events";
+export interface MemoryStats {
+    heapUsed: number;
+    heapTotal: number;
+    external: number;
+    rss: number;
+    timestamp: number;
+    sessionId?: string;
+}
+export interface MemoryLeakAlert {
+    type: "leak_detected" | "high_usage" | "spike_detected";
+    severity: "low" | "medium" | "high" | "critical";
+    message: string;
+    details: {
+        currentUsage: number;
+        threshold: number;
+        trend: "increasing" | "stable" | "decreasing";
+        recommendations: string[];
+    };
+}
+export interface MemoryMonitorConfig {
+    checkInterval: number;
+    alertThresholds: {
+        warning: number;
+        critical: number;
+        leakDetection: {
+            growthRate: number;
+            sustainedPeriod: number;
+        };
+    };
+    enableFrameworkLogging: boolean;
+    sessionTracking: boolean;
+}
+export interface MemorySummary {
+    current: MemoryStats;
+    peak: MemoryStats;
+    average: number;
+    trend: "increasing" | "stable" | "decreasing";
+}
+export declare class MemoryMonitor extends EventEmitter {
+    private config;
+    private monitoringInterval;
+    private statsHistory;
+    private maxHistorySize;
+    private leakDetectionEnabled;
+    private lastLeakCheck;
+    private leakCheckInterval;
+    private listenersInitialized;
+    constructor(config?: Partial<MemoryMonitorConfig>);
+    /**
+     * Start memory monitoring
+     */
+    start(): void;
+    /**
+     * Stop memory monitoring
+     */
+    stop(): void;
+    /**
+     * Get current memory statistics
+     */
+    getCurrentStats(): MemoryStats;
+    /**
+     * Check memory usage and detect issues
+     */
+    private checkMemory;
+    /**
+     * Check memory usage against thresholds
+     */
+    private checkThresholds;
+    /**
+     * Detect potential memory leaks
+     */
+    private detectMemoryLeaks;
+    /**
+     * Calculate memory usage trend
+     */
+    private calculateTrend;
+    /**
+     * Emit memory alert
+     */
+    private emitAlert;
+    /**
+     * Log memory stats to framework log
+     */
+    private logFrameworkMemory;
+    /**
+     * Get memory usage history
+     */
+    getHistory(hours?: number): MemoryStats[];
+    /**
+     * Get memory usage summary
+     */
+    getSummary(): MemorySummary;
+    /**
+     * Force garbage collection (if available)
+     */
+    forceGC(): boolean;
+    /**
+     * Internal logging method - writes to framework log only
+     */
+    private log;
+    /**
+     * Safely add an alert listener, preventing duplicates
+     */
+    addAlertListener(callback: (alert: MemoryLeakAlert) => void): void;
+}
+export declare const memoryMonitor: MemoryMonitor;
+export declare function getMemoryUsage(): MemoryStats;
+export declare function logMemoryUsage(): MemoryStats;
+export declare function checkMemoryHealth(): {
+    healthy: boolean;
+    issues: string[];
+};

package/dist/monitoring/memory-monitor.js

@@ -0,0 +1,315 @@
+import { EventEmitter } from "events";
+import * as fs from "fs";
+import { featuresConfigLoader } from "../core/features-config.js";
+/**
+ * Memory Monitor - Comprehensive memory tracking and leak detection
+ * Integrates with framework logging system
+ * Uses alerting config from features.json for thresholds
+ */
+const defaultAlertingConfig = {
+    enabled: true,
+    performance_degradation_threshold: 20,
+    error_rate_threshold: 5,
+    cost_threshold_daily: 10,
+};
+// Get alerting config from features.json
+let alertingConfig = defaultAlertingConfig;
+try {
+    alertingConfig = featuresConfigLoader.getAlertingConfig();
+}
+catch (e) {
+    // Use defaults if config not available
+}
+export class MemoryMonitor extends EventEmitter {
+    config;
+    monitoringInterval = null;
+    statsHistory = [];
+    maxHistorySize = 1000;
+    leakDetectionEnabled = true;
+    lastLeakCheck = Date.now();
+    leakCheckInterval = 60 * 1000; // CRITICAL FIX: Check every minute instead of 5 minutes
+    listenersInitialized = false;
+    constructor(config = {}) {
+        super();
+        // Increase max listeners to prevent warnings in test environments
+        this.setMaxListeners(50);
+        this.config = {
+            checkInterval: 30000,
+            alertThresholds: {
+                warning: 50, // CRITICAL FIX: Lower warning threshold to 50MB
+                critical: 100, // CRITICAL FIX: Lower critical threshold to 100MB
+                leakDetection: {
+                    growthRate: 5, // CRITICAL FIX: Lower leak detection threshold to 5MB/min
+                    sustainedPeriod: 2, // CRITICAL FIX: Shorter sustained period (2 minutes)
+                },
+            },
+            enableFrameworkLogging: true,
+            sessionTracking: true,
+            ...config,
+        };
+    }
+    /**
+     * Start memory monitoring
+     */
+    start() {
+        this.log("🔍 Starting Memory Monitor...");
+        this.monitoringInterval = setInterval(() => {
+            this.checkMemory();
+        }, this.config.checkInterval);
+        this.checkMemory();
+    }
+    /**
+     * Stop memory monitoring
+     */
+    stop() {
+        if (this.monitoringInterval) {
+            clearInterval(this.monitoringInterval);
+        }
+        this.monitoringInterval = null;
+        this.log("🛑 Memory Monitor stopped");
+    }
+    /**
+     * Get current memory statistics
+     */
+    getCurrentStats() {
+        const memUsage = process.memoryUsage();
+        return {
+            heapUsed: Math.round((memUsage.heapUsed / 1024 / 1024) * 100) / 100,
+            heapTotal: Math.round((memUsage.heapTotal / 1024 / 1024) * 100) / 100,
+            external: Math.round((memUsage.external / 1024 / 1024) * 100) / 100,
+            rss: Math.round((memUsage.rss / 1024 / 1024) * 100) / 100,
+            timestamp: Date.now(),
+        };
+    }
+    /**
+     * Check memory usage and detect issues
+     */
+    checkMemory() {
+        const stats = this.getCurrentStats();
+        this.statsHistory.push(stats);
+        if (this.statsHistory.length > this.maxHistorySize) {
+            this.statsHistory.shift();
+        }
+        this.checkThresholds(stats);
+        if (this.leakDetectionEnabled &&
+            Date.now() - this.lastLeakCheck > this.leakCheckInterval) {
+            this.detectMemoryLeaks();
+            this.lastLeakCheck = Date.now();
+        }
+        if (this.config.enableFrameworkLogging) {
+            this.logFrameworkMemory(stats);
+        }
+    }
+    /**
+     * Check memory usage against thresholds
+     */
+    checkThresholds(stats) {
+        const heapMB = stats.heapUsed;
+        if (heapMB >= this.config.alertThresholds.critical) {
+            this.emitAlert({
+                type: "high_usage",
+                severity: "critical",
+                message: `Critical memory usage: ${heapMB.toFixed(2)}MB (threshold: ${this.config.alertThresholds.critical}MB)`,
+                details: {
+                    currentUsage: heapMB,
+                    threshold: this.config.alertThresholds.critical,
+                    trend: this.calculateTrend(),
+                    recommendations: [
+                        "Force garbage collection if available",
+                        "Check for memory leaks in caches and event listeners",
+                        "Consider reducing concurrent operations",
+                        "Monitor large data structures (Maps, Sets, Arrays)",
+                    ],
+                },
+            });
+        }
+        else if (heapMB >= this.config.alertThresholds.warning) {
+            this.emitAlert({
+                type: "high_usage",
+                severity: "high",
+                message: `High memory usage: ${heapMB.toFixed(2)}MB (threshold: ${this.config.alertThresholds.warning}MB)`,
+                details: {
+                    currentUsage: heapMB,
+                    threshold: this.config.alertThresholds.warning,
+                    trend: this.calculateTrend(),
+                    recommendations: [
+                        "Monitor memory growth rate",
+                        "Check for inefficient algorithms",
+                        "Consider memory optimization techniques",
+                    ],
+                },
+            });
+        }
+    }
+    /**
+     * Detect potential memory leaks
+     */
+    detectMemoryLeaks() {
+        if (this.statsHistory.length < 10)
+            return;
+        const recentStats = this.statsHistory.slice(-20);
+        if (recentStats.length < 2)
+            return;
+        const timeSpan = recentStats[recentStats.length - 1].timestamp -
+            recentStats[0].timestamp;
+        const timeSpanMinutes = timeSpan / (1000 * 60);
+        if (timeSpanMinutes < 1)
+            return;
+        const startUsage = recentStats[0].heapUsed;
+        const endUsage = recentStats[recentStats.length - 1].heapUsed;
+        const growthRate = (endUsage - startUsage) / timeSpanMinutes;
+        if (growthRate > this.config.alertThresholds.leakDetection.growthRate) {
+            const sustainedPeriod = this.config.alertThresholds.leakDetection.sustainedPeriod;
+            if (timeSpanMinutes >= sustainedPeriod) {
+                this.emitAlert({
+                    type: "leak_detected",
+                    severity: growthRate > 50 ? "critical" : "high", // CRITICAL FIX: More aggressive alerting
+                    message: `Potential memory leak detected: ${growthRate.toFixed(2)}MB/min growth rate over ${timeSpanMinutes.toFixed(1)} minutes`,
+                    details: {
+                        currentUsage: endUsage,
+                        threshold: this.config.alertThresholds.leakDetection.growthRate,
+                        trend: "increasing",
+                        recommendations: [
+                            "Check for uncleansed event listeners",
+                            "Review timer/interval cleanup",
+                            "Inspect cache growth in Map/Set structures",
+                            "Monitor object retention in closures",
+                            "Consider memory profiling tools",
+                        ],
+                    },
+                });
+            }
+        }
+    }
+    /**
+     * Calculate memory usage trend
+     */
+    calculateTrend() {
+        if (this.statsHistory.length < 5)
+            return "stable";
+        const recent = this.statsHistory.slice(-5);
+        const older = this.statsHistory.slice(-10, -5);
+        const recentAvg = recent.reduce((sum, s) => sum + s.heapUsed, 0) / recent.length;
+        const olderAvg = older.reduce((sum, s) => sum + s.heapUsed, 0) / older.length;
+        const diff = recentAvg - olderAvg;
+        const threshold = 5;
+        if (diff > threshold)
+            return "increasing";
+        if (diff < -threshold)
+            return "decreasing";
+        return "stable";
+    }
+    /**
+     * Emit memory alert
+     */
+    emitAlert(alert) {
+        this.emit("alert", alert);
+        const severityEmoji = {
+            low: "ℹ️",
+            medium: "⚠️",
+            high: "🔴",
+            critical: "🚨",
+        };
+        this.log(`${severityEmoji[alert.severity]} MEMORY ALERT: ${alert.message}`);
+        alert.details.recommendations.forEach((rec) => {
+            this.log(`  💡 ${rec}`);
+        });
+    }
+    /**
+     * Log memory stats to framework log
+     */
+    logFrameworkMemory(stats) {
+        const logEntry = `🧠 Memory: ${stats.heapUsed.toFixed(1)}MB heap, ${stats.heapTotal.toFixed(1)}MB total, ${stats.external.toFixed(1)}MB external, ${stats.rss.toFixed(1)}MB RSS`;
+        this.log(logEntry);
+    }
+    /**
+     * Get memory usage history
+     */
+    getHistory(hours = 1) {
+        const cutoff = Date.now() - hours * 60 * 60 * 1000;
+        return this.statsHistory.filter((stat) => stat.timestamp >= cutoff);
+    }
+    /**
+     * Get memory usage summary
+     */
+    getSummary() {
+        const current = this.getCurrentStats();
+        const peak = this.statsHistory.reduce((max, stat) => (stat.heapUsed > max.heapUsed ? stat : max), this.statsHistory[0] || current);
+        const average = this.statsHistory.length > 0
+            ? this.statsHistory.reduce((sum, stat) => sum + stat.heapUsed, 0) /
+                this.statsHistory.length
+            : current.heapUsed;
+        return {
+            current,
+            peak,
+            average: Math.round(average * 100) / 100,
+            trend: this.calculateTrend(),
+        };
+    }
+    /**
+     * Force garbage collection (if available)
+     */
+    forceGC() {
+        if (global.gc) {
+            const before = this.getCurrentStats().heapUsed;
+            global.gc();
+            const after = this.getCurrentStats().heapUsed;
+            const freed = before - after;
+            this.log(`🗑️ GC: Freed ${freed.toFixed(2)}MB (${before.toFixed(2)}MB → ${after.toFixed(2)}MB)`);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Internal logging method - writes to framework log only
+     */
+    log(message) {
+        try {
+            const logDir = "./logs/monitoring";
+            const logFile = `${logDir}/memory-monitor-${new Date().toISOString().split("T")[0]}.log`;
+            if (!fs.existsSync(logDir)) {
+                fs.mkdirSync(logDir, { recursive: true });
+            }
+            const logEntry = `[${new Date().toISOString()}] ${message}\n`;
+            fs.appendFileSync(logFile, logEntry);
+        }
+        catch (error) {
+            // Silent fail - don't spam console with logging errors
+        }
+    }
+    /**
+     * Safely add an alert listener, preventing duplicates
+     */
+    addAlertListener(callback) {
+        // Check if this exact callback already exists
+        const existingListeners = this.listeners("alert");
+        const alreadyAdded = existingListeners.some((listener) => listener === callback);
+        if (!alreadyAdded) {
+            this.on("alert", callback);
+        }
+    }
+}
+// Export singleton instance
+export const memoryMonitor = new MemoryMonitor();
+// Helper functions
+export function getMemoryUsage() {
+    return memoryMonitor.getCurrentStats();
+}
+export function logMemoryUsage() {
+    // Memory usage logging - return current stats
+    return memoryMonitor.getCurrentStats();
+}
+export function checkMemoryHealth() {
+    const summary = memoryMonitor.getSummary();
+    const issues = [];
+    if (summary.current.heapUsed > 300) {
+        issues.push(`High heap usage: ${summary.current.heapUsed}MB`);
+    }
+    if (summary.trend === "increasing") {
+        issues.push("Memory usage trending upward");
+    }
+    return {
+        healthy: issues.length === 0,
+        issues,
+    };
+}