xypriss 1.0.0 → 1.1.0

package/dist/cjs/cluster/modules/LoadBalancer.js

@@ -0,0 +1,1123 @@
+'use strict';
+
+var events = require('events');
+var crypto = require('crypto');
+var Logger = require('../../server/utils/Logger.js');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var crypto__namespace = /*#__PURE__*/_interopNamespaceDefault(crypto);
+
+/**
+ * XyPrissJS  Load Balancer
+ * Intelligent load balancing with adaptive strategies, performance optimization,
+ * and advanced health-aware routing
+ */
+/**
+ * Advanced load balancer with multiple strategies and intelligent routing
+ */
+class LoadBalancer extends events.EventEmitter {
+    constructor(config) {
+        super();
+        this.connectionCounts = new Map();
+        this.requestCounts = new Map();
+        this.responseTimesHistory = new Map();
+        this.performanceMetrics = new Map();
+        this.healthScores = new Map();
+        this.circuitBreakers = new Map();
+        this.strategies = new Map();
+        this.lastSelectedWorker = "";
+        this.roundRobinIndex = 0;
+        this.adaptiveWeights = new Map();
+        this.metricsWindow = 300000; // 5 minutes
+        // Performance tracking
+        this.requestLatencies = new Map();
+        this.errorCounts = new Map();
+        this.throughputCounters = new Map();
+        // Historical trends tracking
+        this.historicalTrends = {
+            requestsPerMinute: [],
+            averageResponseTimes: [],
+            errorRates: [],
+        };
+        this.config = config;
+        // Initialize load balancer configuration
+        this.loadBalancer = {
+            strategy: config.loadBalancing?.strategy || "adaptive",
+            weights: new Map(),
+            connections: new Map(),
+            lastSelected: "",
+            selector: this.createSelector(),
+        };
+        this.initializeStrategies();
+        this.setupLoadBalancing();
+        // Setup periodic cleanup and recalculation
+        this.cleanupInterval = setInterval(() => {
+            this.performPeriodicMaintenance();
+        }, 30000); // Every 30 seconds
+    }
+    /**
+     * Initialize all available load balancing strategies
+     */
+    initializeStrategies() {
+        this.strategies.set("round-robin", {
+            name: "round-robin",
+            selector: (workers) => this.roundRobinSelection(workers),
+            healthAware: false,
+            performanceAware: false,
+        });
+        this.strategies.set("least-connections", {
+            name: "least-connections",
+            selector: (workers) => this.leastConnectionsSelection(workers),
+            healthAware: true,
+            performanceAware: false,
+        });
+        this.strategies.set("ip-hash", {
+            name: "ip-hash",
+            selector: (workers, request) => this.ipHashSelection(workers, request),
+            healthAware: true,
+            performanceAware: false,
+        });
+        this.strategies.set("weighted", {
+            name: "weighted",
+            selector: (workers) => this.weightedSelection(workers),
+            healthAware: true,
+            performanceAware: false,
+        });
+        this.strategies.set("least-response-time", {
+            name: "least-response-time",
+            selector: (workers) => this.leastResponseTimeSelection(workers),
+            healthAware: true,
+            performanceAware: true,
+        });
+        this.strategies.set("adaptive", {
+            name: "adaptive",
+            selector: (workers, request) => this.adaptiveSelection(workers, request),
+            healthAware: true,
+            performanceAware: true,
+        });
+        this.strategies.set("resource-based", {
+            name: "resource-based",
+            selector: (workers) => this.resourceBasedSelection(workers),
+            healthAware: true,
+            performanceAware: true,
+        });
+    }
+    /**
+     * Setup load balancing with intelligent defaults
+     */
+    setupLoadBalancing() {
+        // Initialize weights if provided
+        if (this.config.loadBalancing?.weights) {
+            this.config.loadBalancing.weights.forEach((weight, index) => {
+                this.loadBalancer.weights.set(`worker_${index}`, weight);
+                this.adaptiveWeights.set(`worker_${index}`, weight);
+            });
+        }
+        this.setupConnectionTracking();
+    }
+    /**
+     * Setup connection tracking for load balancing decisions
+     */
+    setupConnectionTracking() {
+        // More intelligent cleanup with sliding window
+        this.cleanupMetrics();
+    }
+    /**
+     * Perform periodic maintenance tasks
+     */
+    performPeriodicMaintenance() {
+        this.cleanupMetrics();
+        this.updateHealthScores();
+        this.updateAdaptiveWeights();
+        this.checkCircuitBreakers();
+        this.updateHistoricalTrends();
+        this.emitMetricsUpdate();
+    }
+    /**
+     * Clean up old metrics data
+     */
+    cleanupMetrics() {
+        Date.now() - this.metricsWindow;
+        // Clean response times with sliding window
+        this.responseTimesHistory.forEach((times, workerId) => {
+            if (times.length > 1000) {
+                // Increased history size
+                this.responseTimesHistory.set(workerId, times.slice(-500));
+            }
+        });
+        // Clean latency data
+        this.requestLatencies.forEach((latencies, workerId) => {
+            if (latencies.length > 1000) {
+                this.requestLatencies.set(workerId, latencies.slice(-500));
+            }
+        });
+        // Reset hourly counters
+        if (Date.now() % 3600000 < 30000) {
+            // Every hour, within 30s window
+            this.connectionCounts.clear();
+            this.requestCounts.clear();
+            this.errorCounts.clear();
+        }
+    }
+    /**
+     * Update health scores based on recent performance
+     */
+    updateHealthScores() {
+        this.performanceMetrics.forEach((metrics, workerId) => {
+            const health = this.healthScores.get(workerId) || {
+                status: "healthy",
+                score: 100,
+                lastCheck: Date.now(),
+                consecutiveFailures: 0,
+            };
+            // Calculate health score based on multiple factors
+            let score = 100;
+            // Response time factor (0-40 points)
+            if (metrics.avgResponseTime > 0) {
+                score -= Math.min(40, (metrics.avgResponseTime / 1000) * 10);
+            }
+            // Error rate factor (0-30 points)
+            score -= metrics.errorRate * 30;
+            // Resource usage factor (0-20 points)
+            const resourcePenalty = ((metrics.cpuUsage + metrics.memoryUsage) / 200) * 20;
+            score -= resourcePenalty;
+            // Throughput bonus (0-10 points)
+            if (metrics.throughput > 0) {
+                score += Math.min(10, metrics.throughput / 10);
+            }
+            health.score = Math.max(0, Math.min(100, score));
+            health.lastCheck = Date.now();
+            // Update status based on score
+            if (health.score >= 80)
+                health.status = "healthy";
+            else if (health.score >= 60)
+                health.status = "warning";
+            else if (health.score >= 30)
+                health.status = "critical";
+            else
+                health.status = "down";
+            this.healthScores.set(workerId, health);
+        });
+    }
+    /**
+     * Update adaptive weights based on performance
+     */
+    updateAdaptiveWeights() {
+        const totalHealthScore = Array.from(this.healthScores.values()).reduce((sum, health) => sum + health.score, 0);
+        if (totalHealthScore === 0)
+            return;
+        this.healthScores.forEach((health, workerId) => {
+            // Calculate adaptive weight based on health score and performance
+            const baseWeight = this.loadBalancer.weights.get(workerId) || 1;
+            const healthWeight = (health.score / 100) * baseWeight;
+            // Apply performance multiplier
+            const metrics = this.performanceMetrics.get(workerId);
+            let performanceMultiplier = 1;
+            if (metrics) {
+                // Boost weight for low response time and high throughput
+                performanceMultiplier = Math.max(0.1, (1 - metrics.errorRate) *
+                    Math.min(2, 1000 / Math.max(1, metrics.avgResponseTime)) *
+                    Math.min(1.5, metrics.throughput / 100));
+            }
+            this.adaptiveWeights.set(workerId, healthWeight * performanceMultiplier);
+        });
+    }
+    /**
+     * Check and update circuit breaker states
+     */
+    checkCircuitBreakers() {
+        const now = Date.now();
+        this.circuitBreakers.forEach((breaker, workerId) => {
+            if (breaker.state === "open" && now >= breaker.nextAttempt) {
+                breaker.state = "half-open";
+                this.emit("circuit-breaker:half-open", workerId);
+            }
+        });
+    }
+    /**
+     * Create selector function based on strategy
+     */
+    createSelector() {
+        return (workers, request) => {
+            return this.selectWorker(workers, request);
+        };
+    }
+    /**
+     * Select optimal worker based on configured strategy
+     */
+    selectWorker(workers, request) {
+        if (workers.length === 0) {
+            throw new Error("No workers available for load balancing");
+        }
+        // Filter workers based on circuit breaker state
+        let availableWorkers = workers.filter((worker) => {
+            const breaker = this.circuitBreakers.get(worker.workerId);
+            return !breaker || breaker.state !== "open";
+        });
+        // If no workers available due to circuit breakers, allow one half-open attempt
+        if (availableWorkers.length === 0) {
+            const halfOpenWorkers = workers.filter((worker) => {
+                const breaker = this.circuitBreakers.get(worker.workerId);
+                return breaker && breaker.state === "half-open";
+            });
+            availableWorkers =
+                halfOpenWorkers.length > 0
+                    ? [halfOpenWorkers[0]]
+                    : [workers[0]];
+        }
+        // Apply health filtering for health-aware strategies
+        const strategy = this.strategies.get(this.loadBalancer.strategy);
+        if (strategy?.healthAware) {
+            const healthyWorkers = availableWorkers.filter((worker) => {
+                const health = this.healthScores.get(worker.workerId);
+                return !health || health.status !== "down";
+            });
+            if (healthyWorkers.length > 0) {
+                availableWorkers = healthyWorkers;
+            }
+        }
+        const selectedWorkerId = strategy?.selector(availableWorkers, request) ||
+            this.roundRobinSelection(availableWorkers);
+        this.updateSelectionTracking(selectedWorkerId);
+        this.loadBalancer.lastSelected = selectedWorkerId;
+        return selectedWorkerId;
+    }
+    /**
+     * Least response time selection strategy
+     */
+    leastResponseTimeSelection(workers) {
+        let bestWorker = workers[0];
+        let bestScore = Infinity;
+        for (const worker of workers) {
+            const avgResponseTime = this.getAverageResponseTime(worker.workerId);
+            const activeRequests = worker.requests?.activeRequests || 0;
+            // Score based on response time and current load
+            const score = avgResponseTime * (1 + activeRequests * 0.1);
+            if (score < bestScore) {
+                bestScore = score;
+                bestWorker = worker;
+            }
+        }
+        return bestWorker.workerId;
+    }
+    /**
+     * Adaptive selection strategy that combines multiple factors
+     */
+    adaptiveSelection(workers, request) {
+        let bestWorker = workers[0];
+        let bestScore = -Infinity;
+        for (const worker of workers) {
+            const health = this.healthScores.get(worker.workerId);
+            const metrics = this.performanceMetrics.get(worker.workerId);
+            const activeRequests = worker.requests?.activeRequests || 0;
+            const adaptiveWeight = this.adaptiveWeights.get(worker.workerId) || 1;
+            // Calculate composite score
+            let score = 0;
+            // Health score (0-40 points)
+            if (health) {
+                score += (health.score / 100) * 40;
+            }
+            else {
+                score += 20; // Default moderate score for unknown health
+            }
+            // Performance score (0-30 points)
+            if (metrics) {
+                const responseTimeFactor = Math.max(0, 30 - metrics.avgResponseTime / 100);
+                const errorRateFactor = (1 - metrics.errorRate) * 15;
+                const throughputFactor = Math.min(15, metrics.throughput / 10);
+                score +=
+                    responseTimeFactor + errorRateFactor + throughputFactor;
+            }
+            // Load factor (0-20 points)
+            const maxRequests = Math.max(1, ...workers.map((w) => w.requests?.activeRequests || 1));
+            const loadFactor = (1 - activeRequests / maxRequests) * 20;
+            score += loadFactor;
+            // Adaptive weight factor (0-10 points)
+            score +=
+                (adaptiveWeight /
+                    Math.max(...Array.from(this.adaptiveWeights.values()))) *
+                    10;
+            // Add some randomness to prevent thundering herd (±2 points)
+            score += (Math.random() - 0.5) * 4;
+            if (score > bestScore) {
+                bestScore = score;
+                bestWorker = worker;
+            }
+        }
+        return bestWorker.workerId;
+    }
+    /**
+     * Resource-based selection considering CPU and memory usage
+     */
+    resourceBasedSelection(workers) {
+        let bestWorker = workers[0];
+        let bestScore = Infinity;
+        for (const worker of workers) {
+            const metrics = this.performanceMetrics.get(worker.workerId);
+            if (!metrics)
+                continue;
+            // Score based on resource usage (lower is better)
+            const resourceScore = (metrics.cpuUsage + metrics.memoryUsage) / 2;
+            const loadScore = (worker.requests?.activeRequests || 0) * 10;
+            const totalScore = resourceScore + loadScore;
+            if (totalScore < bestScore) {
+                bestScore = totalScore;
+                bestWorker = worker;
+            }
+        }
+        return bestWorker.workerId;
+    }
+    /**
+     *  round-robin selection with health awareness
+     */
+    roundRobinSelection(workers) {
+        this.roundRobinIndex;
+        let attempts = 0;
+        do {
+            const worker = workers[this.roundRobinIndex % workers.length];
+            this.roundRobinIndex = (this.roundRobinIndex + 1) % workers.length;
+            const health = this.healthScores.get(worker.workerId);
+            if (!health || health.status !== "down") {
+                return worker.workerId;
+            }
+            attempts++;
+        } while (attempts < workers.length);
+        // Fallback to first worker if all are down
+        return workers[0].workerId;
+    }
+    /**
+     *  least connections selection with performance weighting
+     */
+    leastConnectionsSelection(workers) {
+        let minScore = Infinity;
+        let selectedWorker = workers[0];
+        for (const worker of workers) {
+            const connections = this.connectionCounts.get(worker.workerId) || 0;
+            const activeRequests = worker.requests?.activeRequests || 0;
+            const avgResponseTime = this.getAverageResponseTime(worker.workerId);
+            // Weighted score considering connections, active requests, and response time
+            const score = connections + activeRequests + avgResponseTime / 100;
+            if (score < minScore) {
+                minScore = score;
+                selectedWorker = worker;
+            }
+        }
+        return selectedWorker.workerId;
+    }
+    /**
+     *  IP hash selection with consistent hashing
+     */
+    ipHashSelection(workers, request) {
+        if (!request?.ip) {
+            return this.adaptiveSelection(workers, request);
+        }
+        const sessionKey = this.config.loadBalancing?.sessionAffinityKey;
+        const hashInput = sessionKey && request[sessionKey]
+            ? request[sessionKey]
+            : request.ip;
+        // Use consistent hashing with virtual nodes
+        const virtualNodes = 150; // Number of virtual nodes per worker
+        const ring = [];
+        workers.forEach((worker) => {
+            for (let i = 0; i < virtualNodes; i++) {
+                const virtualKey = `${worker.workerId}:${i}`;
+                const hash = this.hashString(virtualKey);
+                ring.push({ hash, workerId: worker.workerId });
+            }
+        });
+        ring.sort((a, b) => a.hash - b.hash);
+        const requestHash = this.hashString(hashInput);
+        const node = ring.find((n) => n.hash >= requestHash) || ring[0];
+        return node.workerId;
+    }
+    /**
+     *  weighted selection with dynamic weights
+     */
+    weightedSelection(workers) {
+        const useAdaptive = this.loadBalancer.strategy === "adaptive";
+        const weightMap = useAdaptive
+            ? this.adaptiveWeights
+            : this.loadBalancer.weights;
+        const totalWeight = workers.reduce((sum, worker) => {
+            const weight = weightMap.get(worker.workerId) || 1;
+            return sum + Math.max(0.1, weight); // Minimum weight to prevent zero
+        }, 0);
+        if (totalWeight === 0) {
+            return this.roundRobinSelection(workers);
+        }
+        const random = Math.random() * totalWeight;
+        let currentWeight = 0;
+        for (const worker of workers) {
+            const weight = Math.max(0.1, weightMap.get(worker.workerId) || 1);
+            currentWeight += weight;
+            if (random <= currentWeight) {
+                return worker.workerId;
+            }
+        }
+        return workers[0].workerId;
+    }
+    /**
+     * Hash string to number for consistent hashing
+     */
+    hashString(str) {
+        const hash = crypto__namespace.createHash("md5").update(str).digest("hex");
+        return parseInt(hash.substring(0, 8), 16);
+    }
+    /**
+     * Update selection tracking for analytics
+     */
+    updateSelectionTracking(workerId) {
+        const currentConnections = this.connectionCounts.get(workerId) || 0;
+        this.connectionCounts.set(workerId, currentConnections + 1);
+        const currentRequests = this.requestCounts.get(workerId) || 0;
+        this.requestCounts.set(workerId, currentRequests + 1);
+        this.loadBalancer.connections.set(workerId, currentConnections + 1);
+        // Update throughput counter
+        const now = Date.now();
+        const throughputData = this.throughputCounters.get(workerId) || {
+            count: 0,
+            timestamp: now,
+        };
+        if (now - throughputData.timestamp > 1000) {
+            // Reset every second
+            const throughput = throughputData.count /
+                ((now - throughputData.timestamp) / 1000);
+            this.updatePerformanceMetric(workerId, "throughput", throughput);
+            this.throughputCounters.set(workerId, { count: 1, timestamp: now });
+        }
+        else {
+            throughputData.count++;
+        }
+    }
+    /**
+     * Update performance metrics for a worker
+     */
+    updatePerformanceMetric(workerId, metric, value) {
+        const current = this.performanceMetrics.get(workerId) || {
+            avgResponseTime: 0,
+            throughput: 0,
+            errorRate: 0,
+            cpuUsage: 0,
+            memoryUsage: 0,
+            activeConnections: 0,
+        };
+        current[metric] = value;
+        this.performanceMetrics.set(workerId, current);
+    }
+    /**
+     * Record response time with  analytics
+     */
+    recordResponseTime(workerId, responseTime) {
+        // Record in history
+        if (!this.responseTimesHistory.has(workerId)) {
+            this.responseTimesHistory.set(workerId, []);
+        }
+        const times = this.responseTimesHistory.get(workerId);
+        times.push(responseTime);
+        // Record in latencies for more detailed analysis
+        if (!this.requestLatencies.has(workerId)) {
+            this.requestLatencies.set(workerId, []);
+        }
+        const latencies = this.requestLatencies.get(workerId);
+        latencies.push(responseTime);
+        // Update average response time
+        const avgResponseTime = times.reduce((sum, time) => sum + time, 0) / times.length;
+        this.updatePerformanceMetric(workerId, "avgResponseTime", avgResponseTime);
+        // Cleanup old data
+        if (times.length > 1000) {
+            times.splice(0, times.length - 500);
+        }
+        if (latencies.length > 1000) {
+            latencies.splice(0, latencies.length - 500);
+        }
+    }
+    /**
+     * Record error for circuit breaker and error rate tracking
+     */
+    recordError(workerId) {
+        // Update error count
+        const currentErrors = this.errorCounts.get(workerId) || 0;
+        this.errorCounts.set(workerId, currentErrors + 1);
+        // Update circuit breaker
+        let breaker = this.circuitBreakers.get(workerId);
+        if (!breaker) {
+            breaker = {
+                failures: 0,
+                lastFailure: 0,
+                state: "closed",
+                nextAttempt: 0,
+            };
+            this.circuitBreakers.set(workerId, breaker);
+        }
+        breaker.failures++;
+        breaker.lastFailure = Date.now();
+        // Open circuit breaker if failure threshold exceeded
+        const failureThreshold = this.config.loadBalancing?.circuitBreakerThreshold || 5;
+        if (breaker.failures >= failureThreshold &&
+            breaker.state === "closed") {
+            breaker.state = "open";
+            breaker.nextAttempt =
+                Date.now() +
+                    (this.config.loadBalancing?.circuitBreakerTimeout || 60000);
+            this.emit("circuit-breaker:opened", workerId);
+        }
+        // Calculate error rate
+        const totalRequests = this.requestCounts.get(workerId) || 1;
+        const errorRate = Math.min(1, currentErrors / totalRequests);
+        this.updatePerformanceMetric(workerId, "errorRate", errorRate);
+    }
+    /**
+     * Record successful request (for circuit breaker recovery)
+     */
+    recordSuccess(workerId) {
+        const breaker = this.circuitBreakers.get(workerId);
+        if (breaker) {
+            if (breaker.state === "half-open") {
+                breaker.state = "closed";
+                breaker.failures = 0;
+                this.emit("circuit-breaker:closed", workerId);
+            }
+            else if (breaker.state === "closed") {
+                breaker.failures = Math.max(0, breaker.failures - 1);
+            }
+        }
+    }
+    /**
+     * Get average response time for a worker
+     */
+    getAverageResponseTime(workerId) {
+        const times = this.responseTimesHistory.get(workerId);
+        if (!times || times.length === 0)
+            return 0;
+        return times.reduce((sum, time) => sum + time, 0) / times.length;
+    }
+    /**
+     * Get response time percentiles
+     */
+    getResponseTimePercentiles(workerId, percentiles = [50, 90, 95, 99]) {
+        const times = this.responseTimesHistory.get(workerId);
+        if (!times || times.length === 0)
+            return {};
+        const sorted = [...times].sort((a, b) => a - b);
+        const result = {};
+        percentiles.forEach((p) => {
+            const index = Math.ceil((p / 100) * sorted.length) - 1;
+            result[p] = sorted[Math.max(0, index)];
+        });
+        return result;
+    }
+    /**
+     * Update load balancing strategy with  options
+     */
+    async updateStrategy(strategy, options) {
+        if (!this.strategies.has(strategy)) {
+            throw new Error(`Unknown load balancing strategy: ${strategy}`);
+        }
+        this.loadBalancer.strategy = strategy;
+        if (options?.weights && Array.isArray(options.weights)) {
+            this.loadBalancer.weights.clear();
+            options.weights.forEach((weight, index) => {
+                this.loadBalancer.weights.set(`worker_${index}`, weight);
+            });
+        }
+        if (options?.circuitBreakerThreshold) {
+            this.config.loadBalancing = this.config.loadBalancing || {};
+            this.config.loadBalancing.circuitBreakerThreshold =
+                options.circuitBreakerThreshold;
+        }
+        this.loadBalancer.selector = this.createSelector();
+        this.emit("loadbalancer:updated", strategy, this.getWeights());
+    }
+    /**
+     * Get  distribution statistics
+     */
+    getDistributionStats() {
+        const totalRequests = Array.from(this.requestCounts.values()).reduce((sum, count) => sum + count, 0);
+        const distribution = {};
+        this.requestCounts.forEach((count, workerId) => {
+            distribution[workerId] = count;
+        });
+        const averageResponseTimes = {};
+        const healthScores = {};
+        const errorRates = {};
+        const circuitBreakerStates = {};
+        const responseTimePercentiles = {};
+        this.responseTimesHistory.forEach((_, workerId) => {
+            averageResponseTimes[workerId] =
+                this.getAverageResponseTime(workerId);
+            responseTimePercentiles[workerId] =
+                this.getResponseTimePercentiles(workerId);
+        });
+        this.healthScores.forEach((health, workerId) => {
+            healthScores[workerId] = health.score;
+        });
+        this.performanceMetrics.forEach((metrics, workerId) => {
+            errorRates[workerId] = metrics.errorRate;
+        });
+        this.circuitBreakers.forEach((breaker, workerId) => {
+            circuitBreakerStates[workerId] = breaker.state;
+        });
+        return {
+            strategy: this.loadBalancer.strategy,
+            totalRequests,
+            distribution,
+            efficiency: this.getLoadDistributionEfficiency(),
+            averageResponseTimes,
+            healthScores,
+            errorRates,
+            circuitBreakerStates,
+            responseTimePercentiles,
+        };
+    }
+    /**
+     * Get current load balance status with  metrics
+     */
+    getLoadBalanceStatus() {
+        const connections = {};
+        this.connectionCounts.forEach((count, workerId) => {
+            connections[workerId] = count;
+        });
+        const health = {};
+        this.healthScores.forEach((score, workerId) => {
+            health[workerId] = score;
+        });
+        const performance = {};
+        this.performanceMetrics.forEach((metrics, workerId) => {
+            performance[workerId] = metrics;
+        });
+        const adaptiveWeights = {};
+        this.adaptiveWeights.forEach((weight, workerId) => {
+            adaptiveWeights[workerId] = weight;
+        });
+        return { connections, health, performance, adaptiveWeights };
+    }
+    /**
+     *  load distribution efficiency calculation
+     */
+    getLoadDistributionEfficiency() {
+        const connections = Array.from(this.connectionCounts.values());
+        if (connections.length === 0)
+            return 100;
+        const total = connections.reduce((sum, count) => sum + count, 0);
+        const average = total / connections.length;
+        if (average === 0)
+            return 100;
+        // Calculate Gini coefficient for more accurate distribution measurement
+        const sortedConnections = connections.sort((a, b) => a - b);
+        let giniSum = 0;
+        sortedConnections.forEach((count, i) => {
+            giniSum += (2 * (i + 1) - connections.length - 1) * count;
+        });
+        const giniCoefficient = giniSum / (connections.length * total);
+        // Convert Gini coefficient to efficiency score (0-100, higher is better)
+        // Gini of 0 = perfect equality = 100% efficiency
+        // Gini of 1 = maximum inequality = 0% efficiency
+        return Math.max(0, 100 * (1 - Math.abs(giniCoefficient)));
+    }
+    /**
+     * Advanced redistribute load with strategy-specific optimizations
+     */
+    async redistributeLoad() {
+        // Reset connection counts
+        this.connectionCounts.clear();
+        this.roundRobinIndex = 0;
+        // Reset circuit breakers for healthy redistribution
+        this.circuitBreakers.forEach((breaker, workerId) => {
+            if (breaker.state === "open") {
+                breaker.state = "half-open";
+            }
+        });
+        // Recalculate adaptive weights
+        this.updateAdaptiveWeights();
+        Logger.logger.info("cluster", `Load redistributed across workers using ${this.loadBalancer.strategy} strategy`);
+        this.emit("load:redistributed", {
+            strategy: this.loadBalancer.strategy,
+            timestamp: Date.now(),
+            efficiency: this.getLoadDistributionEfficiency(),
+        });
+    }
+    /**
+     * Get worker weights (static and adaptive)
+     */
+    getWeights() {
+        const staticWeights = {};
+        const adaptiveWeights = {};
+        this.loadBalancer.weights.forEach((weight, workerId) => {
+            staticWeights[workerId] = weight;
+        });
+        this.adaptiveWeights.forEach((weight, workerId) => {
+            adaptiveWeights[workerId] = weight;
+        });
+        return { static: staticWeights, adaptive: adaptiveWeights };
+    }
+    /**
+     * Select worker using the configured strategy (public interface)
+     */
+    selectWorkerForRequest(workers, request) {
+        return this.loadBalancer.selector(workers, request);
+    }
+    /**
+     * Get comprehensive load balancer configuration
+     */
+    getConfiguration() {
+        const currentStrategy = this.strategies.get(this.loadBalancer.strategy);
+        return {
+            strategy: this.loadBalancer.strategy,
+            weights: new Map(this.loadBalancer.weights),
+            connections: new Map(this.loadBalancer.connections),
+            lastSelected: this.loadBalancer.lastSelected,
+            selector: this.loadBalancer.selector,
+            availableStrategies: Array.from(this.strategies.keys()),
+            healthAware: currentStrategy?.healthAware || false,
+            performanceAware: currentStrategy?.performanceAware || false,
+            circuitBreakerEnabled: this.circuitBreakers.size > 0,
+            metricsWindow: this.metricsWindow,
+        };
+    }
+    /**
+     * Emit periodic metrics update
+     */
+    emitMetricsUpdate() {
+        this.emit("metrics:updated", {
+            timestamp: Date.now(),
+            distribution: this.getDistributionStats(),
+            status: this.getLoadBalanceStatus(),
+            efficiency: this.getLoadDistributionEfficiency(),
+        });
+    }
+    /**
+     * Get worker ranking based on current strategy
+     */
+    getWorkerRanking(workers) {
+        const rankings = workers.map((worker) => {
+            const health = this.healthScores.get(worker.workerId) || null;
+            const performance = this.performanceMetrics.get(worker.workerId) || null;
+            let score = 0;
+            // Calculate score based on current strategy
+            switch (this.loadBalancer.strategy) {
+                case "adaptive":
+                    score = this.calculateAdaptiveScore(worker, health, performance);
+                    break;
+                case "least-response-time":
+                    score = 1000 - this.getAverageResponseTime(worker.workerId);
+                    break;
+                case "least-connections":
+                    score =
+                        1000 -
+                            (this.connectionCounts.get(worker.workerId) || 0);
+                    break;
+                case "resource-based":
+                    if (performance) {
+                        score =
+                            200 -
+                                (performance.cpuUsage + performance.memoryUsage);
+                    }
+                    break;
+                default:
+                    score = Math.random() * 100; // Random for round-robin, etc.
+            }
+            return {
+                workerId: worker.workerId,
+                rank: 0, // Will be set after sorting
+                score,
+                health,
+                performance,
+            };
+        });
+        // Sort by score (descending) and assign ranks
+        rankings.sort((a, b) => b.score - a.score);
+        rankings.forEach((ranking, index) => {
+            ranking.rank = index + 1;
+        });
+        return rankings;
+    }
+    /**
+     * Calculate adaptive score for worker ranking
+     */
+    calculateAdaptiveScore(worker, health, performance) {
+        let score = 0;
+        // Health contribution (40%)
+        if (health) {
+            score += health.score * 0.4;
+        }
+        else {
+            score += 50 * 0.4; // Default moderate score
+        }
+        // Performance contribution (40%)
+        if (performance) {
+            const responseTimeScore = Math.max(0, 100 - performance.avgResponseTime / 10);
+            const errorRateScore = (1 - performance.errorRate) * 100;
+            const throughputScore = Math.min(100, performance.throughput);
+            score +=
+                ((responseTimeScore + errorRateScore + throughputScore) / 3) *
+                    0.4;
+        }
+        // Load contribution (20%)
+        const activeRequests = worker.requests?.activeRequests || 0;
+        const loadScore = Math.max(0, 100 - activeRequests * 5);
+        score += loadScore * 0.2;
+        return Math.max(0, Math.min(100, score));
+    }
+    /**
+     * Enable/disable specific workers
+     */
+    setWorkerEnabled(workerId, enabled) {
+        if (enabled) {
+            // Remove from circuit breaker or reset it
+            const breaker = this.circuitBreakers.get(workerId);
+            if (breaker) {
+                breaker.state = "closed";
+                breaker.failures = 0;
+            }
+        }
+        else {
+            // Force circuit breaker open
+            this.circuitBreakers.set(workerId, {
+                failures: 999,
+                lastFailure: Date.now(),
+                state: "open",
+                nextAttempt: Date.now() + 86400000, // 24 hours
+            });
+        }
+        this.emit("worker:toggled", { workerId, enabled });
+    }
+    /**
+     * Set IPC Manager reference for worker communication
+     */
+    setIPCManager(ipcManager) {
+        this.ipcManager = ipcManager;
+    }
+    /**
+     * Perform  worker health ping using IPC communication
+     */
+    async performWorkerHealthPing(worker) {
+        const existingHealth = this.healthScores.get(worker.workerId) || {
+            status: "healthy",
+            score: 100,
+            lastCheck: Date.now(),
+            consecutiveFailures: 0,
+        };
+        try {
+            if (this.ipcManager) {
+                // Send health ping via IPC with timeout
+                const startTime = Date.now();
+                const response = await Promise.race([
+                    this.ipcManager.sendRequest(worker.workerId, "health_ping", {}, 3000),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error("Health ping timeout")), 3000)),
+                ]);
+                const responseTime = Date.now() - startTime;
+                if (response && response.status === "healthy") {
+                    existingHealth.consecutiveFailures = 0;
+                    existingHealth.score = Math.min(100, existingHealth.score + 2);
+                    existingHealth.status =
+                        responseTime < 1000 ? "healthy" : "warning";
+                }
+                else {
+                    existingHealth.consecutiveFailures++;
+                    existingHealth.score = Math.max(0, existingHealth.score - 10);
+                    existingHealth.status = "warning";
+                }
+            }
+            else {
+                // Fallback to basic health check based on worker metrics
+                if (worker.health.status === "healthy") {
+                    existingHealth.consecutiveFailures = 0;
+                    existingHealth.score = Math.min(100, existingHealth.score + 1);
+                    existingHealth.status = "healthy";
+                }
+                else {
+                    existingHealth.consecutiveFailures++;
+                    existingHealth.score = Math.max(0, existingHealth.score - 5);
+                    existingHealth.status = "warning";
+                }
+            }
+        }
+        catch (error) {
+            // Health ping failed
+            existingHealth.consecutiveFailures++;
+            existingHealth.score = Math.max(0, existingHealth.score - 15);
+            existingHealth.status =
+                existingHealth.consecutiveFailures >= 3
+                    ? "critical"
+                    : "warning";
+        }
+        return existingHealth;
+    }
+    /**
+     * Update historical trends data
+     */
+    updateHistoricalTrends() {
+        const now = new Date();
+        // Calculate current metrics
+        const totalRequests = Array.from(this.requestCounts.values()).reduce((sum, count) => sum + count, 0);
+        const totalErrors = Array.from(this.errorCounts.values()).reduce((sum, count) => sum + count, 0);
+        const allResponseTimes = Array.from(this.responseTimesHistory.values()).flat();
+        const avgResponseTime = allResponseTimes.length > 0
+            ? allResponseTimes.reduce((sum, time) => sum + time, 0) /
+                allResponseTimes.length
+            : 0;
+        const errorRate = totalRequests > 0 ? totalErrors / totalRequests : 0;
+        // Add to historical trends
+        this.historicalTrends.requestsPerMinute.push({
+            timestamp: now,
+            value: totalRequests,
+        });
+        this.historicalTrends.averageResponseTimes.push({
+            timestamp: now,
+            value: avgResponseTime,
+        });
+        this.historicalTrends.errorRates.push({
+            timestamp: now,
+            value: errorRate,
+        });
+        // Keep only last 1000 entries for each trend
+        const maxEntries = 1000;
+        if (this.historicalTrends.requestsPerMinute.length > maxEntries) {
+            this.historicalTrends.requestsPerMinute =
+                this.historicalTrends.requestsPerMinute.slice(-maxEntries);
+        }
+        if (this.historicalTrends.averageResponseTimes.length > maxEntries) {
+            this.historicalTrends.averageResponseTimes =
+                this.historicalTrends.averageResponseTimes.slice(-maxEntries);
+        }
+        if (this.historicalTrends.errorRates.length > maxEntries) {
+            this.historicalTrends.errorRates =
+                this.historicalTrends.errorRates.slice(-maxEntries);
+        }
+    }
+    /**
+     * Perform health check on all workers
+     */
+    async performHealthCheck(workers) {
+        const healthResults = {};
+        for (const worker of workers) {
+            try {
+                //  worker health ping implementation using IPC
+                const health = await this.performWorkerHealthPing(worker);
+                health.lastCheck = Date.now();
+                // Update health based on recent metrics
+                const performance = this.performanceMetrics.get(worker.workerId);
+                if (performance) {
+                    if (performance.errorRate > 0.1) {
+                        // 10% error rate threshold
+                        health.consecutiveFailures++;
+                        health.score = Math.max(0, health.score - 20);
+                    }
+                    else {
+                        health.consecutiveFailures = 0;
+                        health.score = Math.min(100, health.score + 5);
+                    }
+                }
+                // Update status based on consecutive failures
+                if (health.consecutiveFailures >= 3) {
+                    health.status = "critical";
+                }
+                else if (health.consecutiveFailures >= 1) {
+                    health.status = "warning";
+                }
+                else {
+                    health.status = "healthy";
+                }
+                this.healthScores.set(worker.workerId, health);
+                healthResults[worker.workerId] = health;
+            }
+            catch (error) {
+                const health = {
+                    status: "down",
+                    score: 0,
+                    lastCheck: Date.now(),
+                    consecutiveFailures: 999,
+                };
+                this.healthScores.set(worker.workerId, health);
+                healthResults[worker.workerId] = health;
+            }
+        }
+        this.emit("health-check:completed", healthResults);
+        return healthResults;
+    }
+    /**
+     * Get detailed analytics for monitoring dashboards
+     */
+    getAnalytics() {
+        const totalRequests = Array.from(this.requestCounts.values()).reduce((sum, count) => sum + count, 0);
+        const totalErrors = Array.from(this.errorCounts.values()).reduce((sum, count) => sum + count, 0);
+        const allResponseTimes = Array.from(this.responseTimesHistory.values())
+            .flat()
+            .filter((time) => time > 0);
+        const averageResponseTime = allResponseTimes.length > 0
+            ? allResponseTimes.reduce((sum, time) => sum + time, 0) /
+                allResponseTimes.length
+            : 0;
+        const errorRate = totalRequests > 0 ? totalErrors / totalRequests : 0;
+        const workers = Array.from(this.requestCounts.keys()).map((workerId) => {
+            const requests = this.requestCounts.get(workerId) || 0;
+            const responseTime = this.getAverageResponseTime(workerId);
+            const errors = this.errorCounts.get(workerId) || 0;
+            const workerErrorRate = requests > 0 ? errors / requests : 0;
+            const health = this.healthScores.get(workerId);
+            const performance = this.performanceMetrics.get(workerId);
+            return {
+                workerId,
+                requests,
+                responseTime,
+                errorRate: workerErrorRate,
+                healthScore: health?.score || 0,
+                status: health?.status || "unknown",
+                throughput: performance?.throughput || 0,
+            };
+        });
+        return {
+            overview: {
+                totalRequests,
+                averageResponseTime,
+                errorRate,
+                efficiency: this.getLoadDistributionEfficiency(),
+            },
+            workers,
+            trends: {
+                requestsPerMinute: this.historicalTrends.requestsPerMinute.map((t) => t.value),
+                averageResponseTimes: this.historicalTrends.averageResponseTimes.map((t) => t.value),
+                errorRates: this.historicalTrends.errorRates.map((t) => t.value),
+            },
+        };
+    }
+    /**
+     * Cleanup resources when shutting down
+     */
+    destroy() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+        }
+        this.connectionCounts.clear();
+        this.requestCounts.clear();
+        this.responseTimesHistory.clear();
+        this.performanceMetrics.clear();
+        this.healthScores.clear();
+        this.circuitBreakers.clear();
+        this.requestLatencies.clear();
+        this.errorCounts.clear();
+        this.throughputCounters.clear();
+        this.adaptiveWeights.clear();
+        this.removeAllListeners();
+        Logger.logger.info("cluster", " Load Balancer destroyed");
+    }
+}
+
+exports.LoadBalancer = LoadBalancer;
+//# sourceMappingURL=LoadBalancer.js.map