@fluyappgocore/commons-backend 1.0.202

package/build/classes/BacklogManager.d.ts

@@ -0,0 +1,129 @@
+export declare type CircuitBreakerState = 'OPEN' | 'CLOSED' | 'HALF_OPEN';
+export interface CircuitBreakerEvent {
+    listenerName: string;
+    state: CircuitBreakerState;
+    previousState: CircuitBreakerState;
+    timestamp: Date;
+    failureRate: number;
+    failedCount: number;
+    processedCount: number;
+}
+export declare type CircuitBreakerCallback = (event: CircuitBreakerEvent) => void | Promise<void>;
+export interface BacklogConfig {
+    maxConcurrent: number;
+    rateLimitMs: number;
+    circuitBreakerThreshold: number;
+    circuitBreakerResetTime: number;
+    maxRetries: number;
+    backlogRecoveryBatchSize: number;
+    enableBacklogRecovery: boolean;
+    listenerName?: string;
+    onCircuitBreakerStateChange?: CircuitBreakerCallback;
+}
+export interface ProcessingStats {
+    processed: number;
+    failed: number;
+    retries: number;
+    circuitBreakerTrips: number;
+    lastProcessedAt: Date;
+    averageProcessingTime: number;
+}
+export declare class BacklogManager {
+    private config;
+    private stats;
+    private processingQueue;
+    private activeProcessing;
+    private circuitBreakerOpen;
+    private circuitBreakerOpenTime?;
+    private lastProcessTime;
+    private processingTimes;
+    private circuitBreakerState;
+    constructor(config?: Partial<BacklogConfig>);
+    /**
+     * Procesa un mensaje con rate limiting y circuit breaker
+     */
+    processMessage<T>(messageData: T, processor: (data: T) => Promise<void>, context?: string): Promise<boolean>;
+    /**
+     * Ejecuta el procesamiento con reintentos
+     */
+    private executeWithRetry;
+    /**
+     * Procesa el siguiente mensaje en cola
+     */
+    private processNextInQueue;
+    /**
+     * Actualiza métricas de éxito
+     */
+    private updateSuccessMetrics;
+    /**
+     * Actualiza métricas de fallo
+     */
+    private updateFailureMetrics;
+    /**
+     * Verifica si debe activar circuit breaker
+     */
+    private checkCircuitBreaker;
+    /**
+     * Notifica cambio de estado del circuit breaker
+     */
+    private notifyCircuitBreakerStateChange;
+    /**
+     * Verifica si debe resetear circuit breaker
+     */
+    private checkCircuitBreakerReset;
+    /**
+     * Obtiene estadísticas actuales
+     */
+    getStats(): ProcessingStats & {
+        queueSize: number;
+        activeProcessing: number;
+        circuitBreakerOpen: boolean;
+        config: BacklogConfig;
+    };
+    /**
+     * Resetea estadísticas
+     */
+    resetStats(): void;
+    /**
+     * Actualiza configuración en tiempo real
+     */
+    updateConfig(newConfig: Partial<BacklogConfig>): void;
+    /**
+     * Utility sleep function
+     */
+    private sleep;
+    /**
+     * Fuerza el cierre del circuit breaker (para testing/debugging)
+     */
+    forceCircuitBreakerOpen(): void;
+    /**
+     * Fuerza la apertura del circuit breaker (para testing/debugging)
+     */
+    forceCircuitBreakerClose(): void;
+    /**
+     * Registra un callback para cambios de estado del circuit breaker
+     */
+    onCircuitBreakerStateChange(callback: CircuitBreakerCallback): void;
+    /**
+     * Obtiene el estado actual del circuit breaker
+     */
+    getCircuitBreakerState(): CircuitBreakerState;
+    /**
+     * Verifica si el BacklogManager está en capacidad máxima
+     * Usado para control de flujo en eachBatch
+     */
+    isAtMaxCapacity(): boolean;
+    /**
+     * Obtiene la capacidad disponible actual
+     */
+    getAvailableCapacity(): number;
+    /**
+     * Verifica si puede procesar un número específico de mensajes
+     */
+    canProcessBatch(batchSize: number): boolean;
+    /**
+     * Espera hasta que haya capacidad disponible
+     * Usado en eachBatch para pausar el procesamiento
+     */
+    waitForCapacity(minCapacity?: number, timeoutMs?: number): Promise<boolean>;
+}

package/build/classes/BacklogManager.js

@@ -0,0 +1,417 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BacklogManager = void 0;
+var BacklogManager = /** @class */ (function () {
+    function BacklogManager(config) {
+        var _this = this;
+        if (config === void 0) { config = {}; }
+        this.processingQueue = [];
+        this.activeProcessing = 0;
+        this.circuitBreakerOpen = false;
+        this.lastProcessTime = 0;
+        this.processingTimes = [];
+        this.circuitBreakerState = 'CLOSED';
+        this.config = {
+            maxConcurrent: config.maxConcurrent || 5,
+            rateLimitMs: config.rateLimitMs || 100,
+            circuitBreakerThreshold: config.circuitBreakerThreshold || 10,
+            circuitBreakerResetTime: config.circuitBreakerResetTime || 60000,
+            maxRetries: config.maxRetries || 3,
+            backlogRecoveryBatchSize: config.backlogRecoveryBatchSize || 50,
+            enableBacklogRecovery: config.enableBacklogRecovery || true
+        };
+        this.stats = {
+            processed: 0,
+            failed: 0,
+            retries: 0,
+            circuitBreakerTrips: 0,
+            lastProcessedAt: new Date(),
+            averageProcessingTime: 0
+        };
+        // Auto-reset circuit breaker
+        setInterval(function () {
+            _this.checkCircuitBreakerReset();
+        }, 10000);
+    }
+    /**
+     * Procesa un mensaje con rate limiting y circuit breaker
+     */
+    BacklogManager.prototype.processMessage = function (messageData, processor, context) {
+        if (context === void 0) { context = 'unknown'; }
+        return __awaiter(this, void 0, void 0, function () {
+            var now, timeSinceLastProcess;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        // Circuit breaker check
+                        if (this.circuitBreakerOpen) {
+                            console.log("\uD83D\uDEAB Circuit breaker open for " + context + ", skipping message");
+                            return [2 /*return*/, false];
+                        }
+                        now = Date.now();
+                        timeSinceLastProcess = now - this.lastProcessTime;
+                        if (!(timeSinceLastProcess < this.config.rateLimitMs)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.sleep(this.config.rateLimitMs - timeSinceLastProcess)];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        // Concurrency control
+                        if (this.activeProcessing >= this.config.maxConcurrent) {
+                            console.log("\u23F3 Max concurrency reached for " + context + ", queuing message");
+                            return [2 /*return*/, new Promise(function (resolve) {
+                                    _this.processingQueue.push(function () { return __awaiter(_this, void 0, void 0, function () {
+                                        var result;
+                                        return __generator(this, function (_a) {
+                                            switch (_a.label) {
+                                                case 0: return [4 /*yield*/, this.executeWithRetry(messageData, processor, context)];
+                                                case 1:
+                                                    result = _a.sent();
+                                                    resolve(result);
+                                                    return [2 /*return*/];
+                                            }
+                                        });
+                                    }); });
+                                })];
+                        }
+                        return [4 /*yield*/, this.executeWithRetry(messageData, processor, context)];
+                    case 3: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Ejecuta el procesamiento con reintentos
+     */
+    BacklogManager.prototype.executeWithRetry = function (messageData, processor, context, attempt) {
+        if (attempt === void 0) { attempt = 1; }
+        return __awaiter(this, void 0, void 0, function () {
+            var startTime, processingTime, error_1, processingTime, backoffDelay;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.activeProcessing++;
+                        startTime = Date.now();
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, 7, 8]);
+                        return [4 /*yield*/, processor(messageData)];
+                    case 2:
+                        _a.sent();
+                        processingTime = Date.now() - startTime;
+                        this.updateSuccessMetrics(processingTime);
+                        console.log("\u2705 " + context + " processed successfully (" + processingTime + "ms)");
+                        return [2 /*return*/, true];
+                    case 3:
+                        error_1 = _a.sent();
+                        processingTime = Date.now() - startTime;
+                        console.error("\u274C " + context + " failed (attempt " + attempt + "/" + this.config.maxRetries + "):", error_1);
+                        if (!(attempt < this.config.maxRetries)) return [3 /*break*/, 6];
+                        this.stats.retries++;
+                        backoffDelay = Math.min(1000 * Math.pow(2, attempt - 1), 10000);
+                        return [4 /*yield*/, this.sleep(backoffDelay)];
+                    case 4:
+                        _a.sent();
+                        return [4 /*yield*/, this.executeWithRetry(messageData, processor, context, attempt + 1)];
+                    case 5: return [2 /*return*/, _a.sent()];
+                    case 6:
+                        // Max retries exceeded
+                        this.updateFailureMetrics();
+                        this.checkCircuitBreaker();
+                        return [2 /*return*/, false];
+                    case 7:
+                        this.activeProcessing--;
+                        this.lastProcessTime = Date.now();
+                        this.processNextInQueue();
+                        return [7 /*endfinally*/];
+                    case 8: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Procesa el siguiente mensaje en cola
+     */
+    BacklogManager.prototype.processNextInQueue = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var nextProcessor;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(this.processingQueue.length > 0 && this.activeProcessing < this.config.maxConcurrent)) return [3 /*break*/, 2];
+                        nextProcessor = this.processingQueue.shift();
+                        if (!nextProcessor) return [3 /*break*/, 2];
+                        return [4 /*yield*/, nextProcessor()];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Actualiza métricas de éxito
+     */
+    BacklogManager.prototype.updateSuccessMetrics = function (processingTime) {
+        this.stats.processed++;
+        this.stats.lastProcessedAt = new Date();
+        // Mantener últimos 100 tiempos para promedio
+        this.processingTimes.push(processingTime);
+        if (this.processingTimes.length > 100) {
+            this.processingTimes.shift();
+        }
+        this.stats.averageProcessingTime =
+            this.processingTimes.reduce(function (a, b) { return a + b; }, 0) / this.processingTimes.length;
+    };
+    /**
+     * Actualiza métricas de fallo
+     */
+    BacklogManager.prototype.updateFailureMetrics = function () {
+        this.stats.failed++;
+    };
+    /**
+     * Verifica si debe activar circuit breaker
+     */
+    BacklogManager.prototype.checkCircuitBreaker = function () {
+        var recentFailureRate = this.stats.failed / (this.stats.processed + this.stats.failed);
+        console.log(recentFailureRate, this.stats.failed, this.stats.processed);
+        console.log(recentFailureRate > 0.5 && this.stats.failed >= this.config.circuitBreakerThreshold);
+        console.log(this.stats.failed >= this.config.circuitBreakerThreshold);
+        console.log(this.config);
+        if (recentFailureRate > 0.5 && this.stats.failed >= this.config.circuitBreakerThreshold) {
+            var previousState = this.circuitBreakerState;
+            this.circuitBreakerOpen = true;
+            this.circuitBreakerOpenTime = new Date();
+            this.circuitBreakerState = 'OPEN';
+            this.stats.circuitBreakerTrips++;
+            console.log("\uD83D\uDD34 Circuit breaker activated! Failure rate: " + (recentFailureRate * 100).toFixed(1) + "%");
+            // Notificar cambio de estado
+            this.notifyCircuitBreakerStateChange(previousState, 'OPEN', recentFailureRate);
+        }
+    };
+    /**
+     * Notifica cambio de estado del circuit breaker
+     */
+    BacklogManager.prototype.notifyCircuitBreakerStateChange = function (previousState, newState, failureRate) {
+        if (this.config.onCircuitBreakerStateChange && previousState !== newState) {
+            var event_1 = {
+                listenerName: this.config.listenerName || 'unknown',
+                state: newState,
+                previousState: previousState,
+                timestamp: new Date(),
+                failureRate: failureRate,
+                failedCount: this.stats.failed,
+                processedCount: this.stats.processed
+            };
+            try {
+                var result = this.config.onCircuitBreakerStateChange(event_1);
+                if (result instanceof Promise) {
+                    result.catch(function (err) { return console.error('Error in circuit breaker callback:', err); });
+                }
+            }
+            catch (err) {
+                console.error('Error in circuit breaker callback:', err);
+            }
+        }
+    };
+    /**
+     * Verifica si debe resetear circuit breaker
+     */
+    BacklogManager.prototype.checkCircuitBreakerReset = function () {
+        if (this.circuitBreakerOpen && this.circuitBreakerOpenTime) {
+            var timeSinceOpen = Date.now() - this.circuitBreakerOpenTime.getTime();
+            if (timeSinceOpen >= this.config.circuitBreakerResetTime) {
+                var previousState = this.circuitBreakerState;
+                var failureRate = this.stats.failed / (this.stats.processed + this.stats.failed);
+                this.circuitBreakerOpen = false;
+                this.circuitBreakerOpenTime = undefined;
+                this.circuitBreakerState = 'CLOSED';
+                // Reset failure stats for fresh start
+                this.stats.failed = Math.floor(this.stats.failed * 0.5);
+                console.log("\uD83D\uDFE2 Circuit breaker reset after " + timeSinceOpen + "ms");
+                // Notificar cambio de estado
+                this.notifyCircuitBreakerStateChange(previousState, 'CLOSED', failureRate);
+            }
+        }
+    };
+    /**
+     * Obtiene estadísticas actuales
+     */
+    BacklogManager.prototype.getStats = function () {
+        return __assign(__assign({}, this.stats), { queueSize: this.processingQueue.length, activeProcessing: this.activeProcessing, circuitBreakerOpen: this.circuitBreakerOpen, config: this.config });
+    };
+    /**
+     * Resetea estadísticas
+     */
+    BacklogManager.prototype.resetStats = function () {
+        this.stats = {
+            processed: 0,
+            failed: 0,
+            retries: 0,
+            circuitBreakerTrips: 0,
+            lastProcessedAt: new Date(),
+            averageProcessingTime: 0
+        };
+        this.processingTimes = [];
+    };
+    /**
+     * Actualiza configuración en tiempo real
+     */
+    BacklogManager.prototype.updateConfig = function (newConfig) {
+        this.config = __assign(__assign({}, this.config), newConfig);
+        console.log("\uD83D\uDD27 BacklogManager config updated:", newConfig);
+    };
+    /**
+     * Utility sleep function
+     */
+    BacklogManager.prototype.sleep = function (ms) {
+        return new Promise(function (resolve) { return setTimeout(resolve, ms); });
+    };
+    /**
+     * Fuerza el cierre del circuit breaker (para testing/debugging)
+     */
+    BacklogManager.prototype.forceCircuitBreakerOpen = function () {
+        var previousState = this.circuitBreakerState;
+        var failureRate = this.stats.failed / (this.stats.processed + this.stats.failed) || 0;
+        this.circuitBreakerOpen = true;
+        this.circuitBreakerOpenTime = new Date();
+        this.circuitBreakerState = 'OPEN';
+        this.stats.circuitBreakerTrips++;
+        this.notifyCircuitBreakerStateChange(previousState, 'OPEN', failureRate);
+    };
+    /**
+     * Fuerza la apertura del circuit breaker (para testing/debugging)
+     */
+    BacklogManager.prototype.forceCircuitBreakerClose = function () {
+        var previousState = this.circuitBreakerState;
+        var failureRate = this.stats.failed / (this.stats.processed + this.stats.failed) || 0;
+        this.circuitBreakerOpen = false;
+        this.circuitBreakerOpenTime = undefined;
+        this.circuitBreakerState = 'CLOSED';
+        this.notifyCircuitBreakerStateChange(previousState, 'CLOSED', failureRate);
+    };
+    /**
+     * Registra un callback para cambios de estado del circuit breaker
+     */
+    BacklogManager.prototype.onCircuitBreakerStateChange = function (callback) {
+        this.config.onCircuitBreakerStateChange = callback;
+    };
+    /**
+     * Obtiene el estado actual del circuit breaker
+     */
+    BacklogManager.prototype.getCircuitBreakerState = function () {
+        return this.circuitBreakerState;
+    };
+    /**
+     * Verifica si el BacklogManager está en capacidad máxima
+     * Usado para control de flujo en eachBatch
+     */
+    BacklogManager.prototype.isAtMaxCapacity = function () {
+        console.log(this.activeProcessing, this.config.maxConcurrent, this.processingQueue.length, this.config.backlogRecoveryBatchSize, this.circuitBreakerOpen);
+        console.log(this.activeProcessing >= this.config.maxConcurrent);
+        console.log(this.processingQueue.length >= this.config.backlogRecoveryBatchSize);
+        console.log(this.circuitBreakerOpen);
+        return this.activeProcessing >= this.config.maxConcurrent ||
+            this.processingQueue.length >= this.config.backlogRecoveryBatchSize ||
+            this.circuitBreakerOpen;
+    };
+    /**
+     * Obtiene la capacidad disponible actual
+     */
+    BacklogManager.prototype.getAvailableCapacity = function () {
+        if (this.circuitBreakerOpen) {
+            return 0;
+        }
+        var processingCapacity = Math.max(0, this.config.maxConcurrent - this.activeProcessing);
+        var queueCapacity = Math.max(0, this.config.backlogRecoveryBatchSize - this.processingQueue.length);
+        return Math.min(processingCapacity, queueCapacity);
+    };
+    /**
+     * Verifica si puede procesar un número específico de mensajes
+     */
+    BacklogManager.prototype.canProcessBatch = function (batchSize) {
+        return this.getAvailableCapacity() >= batchSize && !this.circuitBreakerOpen;
+    };
+    /**
+     * Espera hasta que haya capacidad disponible
+     * Usado en eachBatch para pausar el procesamiento
+     */
+    BacklogManager.prototype.waitForCapacity = function (minCapacity, timeoutMs) {
+        if (minCapacity === void 0) { minCapacity = 1; }
+        if (timeoutMs === void 0) { timeoutMs = 30000; }
+        return __awaiter(this, void 0, void 0, function () {
+            var startTime;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        startTime = Date.now();
+                        _a.label = 1;
+                    case 1:
+                        if (!(this.getAvailableCapacity() < minCapacity && !this.circuitBreakerOpen)) return [3 /*break*/, 3];
+                        if (Date.now() - startTime > timeoutMs) {
+                            console.warn("\u23F0 Timeout waiting for capacity after " + timeoutMs + "ms");
+                            return [2 /*return*/, false];
+                        }
+                        // Esperar un poco antes de verificar de nuevo
+                        return [4 /*yield*/, this.sleep(200)];
+                    case 2:
+                        // Esperar un poco antes de verificar de nuevo
+                        _a.sent();
+                        return [3 /*break*/, 1];
+                    case 3: return [2 /*return*/, !this.circuitBreakerOpen];
+                }
+            });
+        });
+    };
+    return BacklogManager;
+}());
+exports.BacklogManager = BacklogManager;

package/build/classes/BacklogMonitor.d.ts

@@ -0,0 +1,102 @@
+export interface MonitorableListener {
+    groupName: string;
+    topic: string;
+    getStats(): {
+        listenerName: string;
+        topic: string;
+        groupName: string;
+        processed: number;
+        failed: number;
+        retries: number;
+        queueSize: number;
+        activeProcessing: number;
+        circuitBreakerOpen: boolean;
+        averageProcessingTime: number;
+        lastProcessedAt: Date;
+        config: any;
+    };
+    updateBacklogConfig(newConfig: any): void;
+    resetStats(): void;
+    forceCircuitBreaker(open: boolean): void;
+}
+export interface ListenerStats {
+    listenerName: string;
+    topic: string;
+    groupName: string;
+    processed: number;
+    failed: number;
+    retries: number;
+    queueSize: number;
+    activeProcessing: number;
+    circuitBreakerOpen: boolean;
+    averageProcessingTime: number;
+    successRate: number;
+    lastProcessedAt: Date;
+    config: any;
+}
+export interface SystemStats {
+    totalListeners: number;
+    activeListeners: number;
+    totalProcessed: number;
+    totalFailed: number;
+    totalRetries: number;
+    totalQueueSize: number;
+    totalActiveProcessing: number;
+    circuitBreakersOpen: number;
+    overallSuccessRate: number;
+    systemHealth: 'healthy' | 'degraded' | 'critical';
+}
+export declare class BacklogMonitor {
+    private static instance;
+    private listeners;
+    private constructor();
+    static getInstance(): BacklogMonitor;
+    /**
+     * Registra un listener para monitoreo (EnhancedListener o BatchEnhancedListener)
+     */
+    registerListener(listener: MonitorableListener): void;
+    /**
+     * Desregistra un listener
+     */
+    unregisterListener(groupName: string, topic: string): void;
+    /**
+     * Obtiene estadísticas de un listener específico
+     */
+    getListenerStats(groupName: string, topic: string): ListenerStats | null;
+    /**
+     * Obtiene estadísticas de todos los listeners
+     */
+    getAllListenersStats(): ListenerStats[];
+    /**
+     * Obtiene estadísticas del sistema completo
+     */
+    getSystemStats(): SystemStats;
+    /**
+     * Actualiza configuración de un listener específico
+     */
+    updateListenerConfig(groupName: string, topic: string, newConfig: any): boolean;
+    /**
+     * Actualiza configuración de todos los listeners
+     */
+    updateAllListenersConfig(newConfig: any): number;
+    /**
+     * Resetea estadísticas de un listener específico
+     */
+    resetListenerStats(groupName: string, topic: string): boolean;
+    /**
+     * Resetea estadísticas de todos los listeners
+     */
+    resetAllStats(): number;
+    /**
+     * Fuerza circuit breaker para un listener específico
+     */
+    forceCircuitBreaker(groupName: string, topic: string, open: boolean): boolean;
+    /**
+     * Obtiene resumen de salud del sistema
+     */
+    getHealthSummary(): {
+        status: string;
+        message: string;
+        details: any;
+    };
+}