@fluyappgocore/commons-backend 1.0.202

package/build/events/BatchEnhancedListener.js

@@ -0,0 +1,307 @@
+"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.BatchEnhancedListener = void 0;
+var BacklogManager_1 = require("../classes/BacklogManager");
+/**
+ * 🔥 BULLETPROOF: BatchEnhancedListener con control de flujo real en la entrada
+ *
+ * DIFERENCIAS CLAVE vs EnhancedListener:
+ * ✅ Control de flujo en la ENTRADA del consumer (eachBatch)
+ * ✅ NUNCA más mensajes en memoria de los que puede procesar
+ * ✅ Pausa automática cuando BacklogManager está saturado
+ * ✅ Resolución manual de offsets para mejor control de errores
+ * ✅ Heartbeat automático para mantener conexión viva
+ */
+var BatchEnhancedListener = /** @class */ (function () {
+    function BatchEnhancedListener(client, listenerName, backlogConfig, batchConfig) {
+        this.client = client;
+        this.listenerName = listenerName;
+        // Configuración específica por tipo de listener
+        var defaultConfig = this.getDefaultBacklogConfig();
+        this.backlogManager = new BacklogManager_1.BacklogManager(__assign(__assign(__assign({}, defaultConfig), backlogConfig), { listenerName: listenerName }));
+        // Guardar configuración de batch para usar en listen()
+        this.batchConfig = __assign({ maxBytesPerPartition: 10240, maxBytes: 102400 }, batchConfig);
+        console.log("\uD83D\uDE80 Batch Enhanced listener " + listenerName + " initialized with flow control");
+    }
+    /**
+     * Configuración por defecto que puede ser sobrescrita por cada listener
+     */
+    BatchEnhancedListener.prototype.getDefaultBacklogConfig = function () {
+        return {
+            maxConcurrent: 3,
+            rateLimitMs: 200,
+            circuitBreakerThreshold: 5,
+            circuitBreakerResetTime: 30000,
+            maxRetries: 2,
+            backlogRecoveryBatchSize: 25,
+            enableBacklogRecovery: true,
+        };
+    };
+    /**
+     * 🔥 BULLETPROOF: Listen usando eachBatch con control de flujo real
+     */
+    BatchEnhancedListener.prototype.listen = function (fromBeginning) {
+        var _this = this;
+        console.log("\uD83C\uDFA7 Starting batch enhanced listener: " + this.listenerName);
+        var topic = this.topic;
+        var consumer = this.client.consumer({
+            groupId: this.groupName,
+            // Configuraciones adicionales para mejor control
+            sessionTimeout: 30000,
+            heartbeatInterval: 3000,
+            maxWaitTimeInMs: 5000,
+            // Limitar el fetch para no saturar memoria - CONFIGURACIÓN ULTRA CONSERVADORA
+            maxBytesPerPartition: this.batchConfig.maxBytesPerPartition || 10240,
+            maxBytes: this.batchConfig.maxBytes || 102400,
+        });
+        consumer
+            .connect()
+            .then(function () { return __awaiter(_this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, consumer.subscribe({ topic: topic, fromBeginning: fromBeginning })];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, consumer.run({
+                                // 🔥 CLAVE: eachBatchAutoResolve = false para control manual
+                                eachBatchAutoResolve: false,
+                                eachBatch: function (payload) { return __awaiter(_this, void 0, void 0, function () {
+                                    return __generator(this, function (_a) {
+                                        switch (_a.label) {
+                                            case 0: return [4 /*yield*/, this.processBatch(payload)];
+                                            case 1:
+                                                _a.sent();
+                                                return [2 /*return*/];
+                                        }
+                                    });
+                                }); },
+                            })];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); })
+            .catch(function (error) {
+            console.error("\uD83D\uDCA5 KAFKA ERROR in " + _this.listenerName + ":", error);
+        });
+        // Iniciar monitoreo de estadísticas cada 30 segundos
+        setInterval(function () {
+            _this.logStats();
+        }, 30000);
+    };
+    /**
+     * 🔥 BULLETPROOF: Procesa batch con control de flujo real
+     */
+    BatchEnhancedListener.prototype.processBatch = function (payload) {
+        return __awaiter(this, void 0, void 0, function () {
+            var batch, resolveOffset, heartbeat, isRunning, isStale, _i, _a, message, hasCapacity, parsedData, success, error_1;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        batch = payload.batch, resolveOffset = payload.resolveOffset, heartbeat = payload.heartbeat, isRunning = payload.isRunning, isStale = payload.isStale;
+                        console.log("\uD83D\uDCE6 Processing batch: " + batch.messages.length + " messages for " + this.listenerName);
+                        _i = 0, _a = batch.messages;
+                        _b.label = 1;
+                    case 1:
+                        if (!(_i < _a.length)) return [3 /*break*/, 11];
+                        message = _a[_i];
+                        _b.label = 2;
+                    case 2:
+                        if (!this.backlogManager.isAtMaxCapacity()) return [3 /*break*/, 5];
+                        console.log("\u23F8\uFE0F  " + this.listenerName + " pausing batch - at max capacity");
+                        return [4 /*yield*/, this.backlogManager.waitForCapacity(1, 10000)];
+                    case 3:
+                        hasCapacity = _b.sent();
+                        if (!hasCapacity) {
+                            console.error("\u274C " + this.listenerName + " timeout waiting for capacity");
+                            // No resolver offset para reintentar este mensaje
+                            return [2 /*return*/];
+                        }
+                        // Mantener conexión viva
+                        return [4 /*yield*/, heartbeat()];
+                    case 4:
+                        // Mantener conexión viva
+                        _b.sent();
+                        // Verificar si el consumer sigue activo
+                        if (!isRunning() || isStale()) {
+                            console.warn("\u26A0\uFE0F  " + this.listenerName + " consumer not running or stale");
+                            return [2 /*return*/];
+                        }
+                        return [3 /*break*/, 2];
+                    case 5:
+                        _b.trys.push([5, 7, , 8]);
+                        parsedData = this.parseMessage(message);
+                        return [4 /*yield*/, this.backlogManager.processMessage({ data: parsedData, msg: message }, function (_a) {
+                                var data = _a.data, msg = _a.msg;
+                                return __awaiter(_this, void 0, void 0, function () {
+                                    return __generator(this, function (_b) {
+                                        switch (_b.label) {
+                                            case 0: return [4 /*yield*/, this.processMessage(data, msg)];
+                                            case 1:
+                                                _b.sent();
+                                                return [2 /*return*/];
+                                        }
+                                    });
+                                });
+                            }, this.listenerName + ":" + this.topic + ":" + message.offset)];
+                    case 6:
+                        success = _b.sent();
+                        if (success) {
+                            // ✅ Solo resolver offset si el procesamiento fue exitoso
+                            resolveOffset(message.offset);
+                            console.log("\u2705 " + this.listenerName + " processed message offset " + message.offset);
+                        }
+                        else {
+                            // ❌ No resolver offset para reintentar luego
+                            console.error("\u274C " + this.listenerName + " failed to process message offset " + message.offset);
+                            return [3 /*break*/, 11]; // Salir del batch para reintentar desde este punto
+                        }
+                        return [3 /*break*/, 8];
+                    case 7:
+                        error_1 = _b.sent();
+                        console.error("\uD83D\uDCA5 " + this.listenerName + " critical error processing message:", error_1);
+                        // No resolver offset para reintentar
+                        return [3 /*break*/, 11];
+                    case 8: 
+                    // Mantener conexión viva
+                    return [4 /*yield*/, heartbeat()];
+                    case 9:
+                        // Mantener conexión viva
+                        _b.sent();
+                        _b.label = 10;
+                    case 10:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 11:
+                        console.log("\uD83D\uDCE6 Batch completed for " + this.listenerName);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Parse message helper
+     */
+    BatchEnhancedListener.prototype.parseMessage = function (msg) {
+        var data = msg.value || "{}";
+        return typeof data === "string" ? JSON.parse(data) : JSON.parse(data.toString("utf8"));
+    };
+    /**
+     * Log de estadísticas del BacklogManager
+     */
+    BatchEnhancedListener.prototype.logStats = function () {
+        var stats = this.backlogManager.getStats();
+        if (stats.processed > 0 || stats.failed > 0) {
+            console.log("\uD83D\uDCCA " + this.listenerName + " Batch Stats:", {
+                processed: stats.processed,
+                failed: stats.failed,
+                retries: stats.retries,
+                queueSize: stats.queueSize,
+                activeProcessing: stats.activeProcessing,
+                availableCapacity: this.backlogManager.getAvailableCapacity(),
+                circuitBreakerOpen: stats.circuitBreakerOpen,
+                avgProcessingTime: stats.averageProcessingTime.toFixed(0) + "ms",
+                successRate: ((stats.processed / (stats.processed + stats.failed)) * 100).toFixed(1) + "%",
+            });
+        }
+    };
+    /**
+     * Obtener estadísticas del listener
+     */
+    BatchEnhancedListener.prototype.getStats = function () {
+        return __assign(__assign({ listenerName: this.listenerName, topic: this.topic, groupName: this.groupName }, this.backlogManager.getStats()), { availableCapacity: this.backlogManager.getAvailableCapacity(), isAtMaxCapacity: this.backlogManager.isAtMaxCapacity() });
+    };
+    /**
+     * Actualizar configuración del BacklogManager en tiempo real
+     */
+    BatchEnhancedListener.prototype.updateBacklogConfig = function (newConfig) {
+        this.backlogManager.updateConfig(newConfig);
+        console.log("\uD83D\uDD27 " + this.listenerName + " batch backlog config updated");
+    };
+    /**
+     * Resetear estadísticas
+     */
+    BatchEnhancedListener.prototype.resetStats = function () {
+        this.backlogManager.resetStats();
+        console.log("\uD83D\uDD04 " + this.listenerName + " batch stats reset");
+    };
+    /**
+     * Forzar circuit breaker (para debugging)
+     */
+    BatchEnhancedListener.prototype.forceCircuitBreaker = function (open) {
+        if (open) {
+            this.backlogManager.forceCircuitBreakerOpen();
+            console.log("\uD83D\uDD34 " + this.listenerName + " batch circuit breaker forced OPEN");
+        }
+        else {
+            this.backlogManager.forceCircuitBreakerClose();
+            console.log("\uD83D\uDFE2 " + this.listenerName + " batch circuit breaker forced CLOSED");
+        }
+    };
+    /**
+     * Registra un callback para cambios de estado del circuit breaker
+     * @param callback Función que se ejecuta cuando cambia el estado del circuit breaker
+     */
+    BatchEnhancedListener.prototype.onCircuitBreakerStateChange = function (callback) {
+        this.backlogManager.onCircuitBreakerStateChange(callback);
+        console.log("\uD83D\uDD14 " + this.listenerName + " circuit breaker callback registered");
+    };
+    /**
+     * Obtiene el nombre del listener
+     */
+    BatchEnhancedListener.prototype.getListenerName = function () {
+        return this.listenerName;
+    };
+    return BatchEnhancedListener;
+}());
+exports.BatchEnhancedListener = BatchEnhancedListener;

package/build/events/EnhancedListener.d.ts

@@ -0,0 +1,75 @@
+import { TicketTopics, AgentTopics, EntityTreeTopics, AgentCrudTopics, MatchTopics, TicketTrackingTopics, AgentTrackingTopics, ManualMatchTopics, MonitorTopics, UserTopics, DeleteTrackingTopics, AuditTopics, NotificationTopics, TicketNoteTopics, TopicsTopics, TicketxTopicsTopics, DeviceTopics, PlanningTopics, WaitingTopics, PaymentsTopics, SubscriptionTopics } from "@fluyappgo/commons";
+import { Listener } from "./baseListener";
+import { BacklogManager } from "../classes/BacklogManager";
+import { MonitorableListener } from "../classes/BacklogMonitor";
+interface Event {
+    topic: TicketTopics | AgentTopics | EntityTreeTopics | AgentCrudTopics | MatchTopics | TicketTrackingTopics | AgentTrackingTopics | ManualMatchTopics | MonitorTopics | UserTopics | DeleteTrackingTopics | AuditTopics | NotificationTopics | TicketNoteTopics | TopicsTopics | TicketxTopicsTopics | DeviceTopics | PlanningTopics | WaitingTopics | PaymentsTopics | SubscriptionTopics;
+    data: any;
+    keyKafka: number;
+    groupName: string;
+}
+/**
+ * EnhancedListener con BacklogManager integrado
+ * Extiende baseListener y agrega capacidades de manejo de backlog
+ */
+export declare abstract class EnhancedListener<T extends Event> extends Listener<T> implements MonitorableListener {
+    protected backlogManager: BacklogManager;
+    protected listenerName: string;
+    abstract processMessage(data: T["data"], msg: any): Promise<void>;
+    constructor(client: any, listenerName: string, backlogConfig?: any);
+    /**
+     * Configuración por defecto que puede ser sobrescrita por cada listener
+     */
+    protected getDefaultBacklogConfig(): {
+        maxConcurrent: number;
+        rateLimitMs: number;
+        circuitBreakerThreshold: number;
+        circuitBreakerResetTime: number;
+        maxRetries: number;
+        backlogRecoveryBatchSize: number;
+        enableBacklogRecovery: boolean;
+    };
+    /**
+     * Override del método onMessage para integrar BacklogManager
+     */
+    onMessage(data: T["data"], msg: any): void;
+    /**
+     * Override del método listen para agregar monitoreo
+     */
+    listen(fromBeginning: boolean): void;
+    /**
+     * Log de estadísticas del BacklogManager
+     */
+    private logStats;
+    /**
+     * Obtener estadísticas del listener
+     */
+    getStats(): {
+        processed: number;
+        failed: number;
+        retries: number;
+        circuitBreakerTrips: number;
+        lastProcessedAt: Date;
+        averageProcessingTime: number;
+        queueSize: number;
+        activeProcessing: number;
+        circuitBreakerOpen: boolean;
+        config: import("../classes/BacklogManager").BacklogConfig;
+        listenerName: string;
+        topic: T["topic"];
+        groupName: string;
+    };
+    /**
+     * Actualizar configuración del BacklogManager en tiempo real
+     */
+    updateBacklogConfig(newConfig: any): void;
+    /**
+     * Resetear estadísticas
+     */
+    resetStats(): void;
+    /**
+     * Forzar circuit breaker (para debugging)
+     */
+    forceCircuitBreaker(open: boolean): void;
+}
+export {};

package/build/events/EnhancedListener.js

@@ -0,0 +1,185 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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.EnhancedListener = void 0;
+var baseListener_1 = require("./baseListener");
+var BacklogManager_1 = require("../classes/BacklogManager");
+/**
+ * EnhancedListener con BacklogManager integrado
+ * Extiende baseListener y agrega capacidades de manejo de backlog
+ */
+var EnhancedListener = /** @class */ (function (_super) {
+    __extends(EnhancedListener, _super);
+    function EnhancedListener(client, listenerName, backlogConfig) {
+        var _this = _super.call(this, client) || this;
+        _this.listenerName = listenerName;
+        // Configuración específica por tipo de listener
+        var defaultConfig = _this.getDefaultBacklogConfig();
+        _this.backlogManager = new BacklogManager_1.BacklogManager(__assign(__assign({}, defaultConfig), backlogConfig));
+        console.log("\uD83D\uDE80 Enhanced listener " + listenerName + " initialized with BacklogManager");
+        return _this;
+    }
+    /**
+     * Configuración por defecto que puede ser sobrescrita por cada listener
+     */
+    EnhancedListener.prototype.getDefaultBacklogConfig = function () {
+        return {
+            maxConcurrent: 3,
+            rateLimitMs: 200,
+            circuitBreakerThreshold: 5,
+            circuitBreakerResetTime: 30000,
+            maxRetries: 2,
+            backlogRecoveryBatchSize: 25,
+            enableBacklogRecovery: true,
+        };
+    };
+    /**
+     * Override del método onMessage para integrar BacklogManager
+     */
+    EnhancedListener.prototype.onMessage = function (data, msg) {
+        var _this = this;
+        // Usar BacklogManager para procesar el mensaje
+        this.backlogManager
+            .processMessage({ data: data, msg: msg }, function (_a) {
+            var data = _a.data, msg = _a.msg;
+            return __awaiter(_this, void 0, void 0, function () {
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0: return [4 /*yield*/, this.processMessage(data, msg)];
+                        case 1:
+                            _b.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        }, this.listenerName + ":" + this.topic)
+            .catch(function (error) {
+            console.error("\uD83D\uDCA5 Critical error in " + _this.listenerName + ":", error);
+        });
+    };
+    /**
+     * Override del método listen para agregar monitoreo
+     */
+    EnhancedListener.prototype.listen = function (fromBeginning) {
+        var _this = this;
+        console.log("\uD83C\uDFA7 Starting enhanced listener: " + this.listenerName);
+        // Iniciar monitoreo de estadísticas cada 30 segundos
+        setInterval(function () {
+            _this.logStats();
+        }, 30000);
+        // Llamar al método padre
+        _super.prototype.listen.call(this, fromBeginning);
+    };
+    /**
+     * Log de estadísticas del BacklogManager
+     */
+    EnhancedListener.prototype.logStats = function () {
+        var stats = this.backlogManager.getStats();
+        if (stats.processed > 0 || stats.failed > 0) {
+            console.log("\uD83D\uDCCA " + this.listenerName + " Stats:", {
+                processed: stats.processed,
+                failed: stats.failed,
+                retries: stats.retries,
+                queueSize: stats.queueSize,
+                activeProcessing: stats.activeProcessing,
+                circuitBreakerOpen: stats.circuitBreakerOpen,
+                avgProcessingTime: stats.averageProcessingTime.toFixed(0) + "ms",
+                successRate: ((stats.processed / (stats.processed + stats.failed)) * 100).toFixed(1) + "%",
+            });
+        }
+    };
+    /**
+     * Obtener estadísticas del listener
+     */
+    EnhancedListener.prototype.getStats = function () {
+        return __assign({ listenerName: this.listenerName, topic: this.topic, groupName: this.groupName }, this.backlogManager.getStats());
+    };
+    /**
+     * Actualizar configuración del BacklogManager en tiempo real
+     */
+    EnhancedListener.prototype.updateBacklogConfig = function (newConfig) {
+        this.backlogManager.updateConfig(newConfig);
+        console.log("\uD83D\uDD27 " + this.listenerName + " backlog config updated");
+    };
+    /**
+     * Resetear estadísticas
+     */
+    EnhancedListener.prototype.resetStats = function () {
+        this.backlogManager.resetStats();
+        console.log("\uD83D\uDD04 " + this.listenerName + " stats reset");
+    };
+    /**
+     * Forzar circuit breaker (para debugging)
+     */
+    EnhancedListener.prototype.forceCircuitBreaker = function (open) {
+        if (open) {
+            this.backlogManager.forceCircuitBreakerOpen();
+            console.log("\uD83D\uDD34 " + this.listenerName + " circuit breaker forced OPEN");
+        }
+        else {
+            this.backlogManager.forceCircuitBreakerClose();
+            console.log("\uD83D\uDFE2 " + this.listenerName + " circuit breaker forced CLOSED");
+        }
+    };
+    return EnhancedListener;
+}(baseListener_1.Listener));
+exports.EnhancedListener = EnhancedListener;

package/build/events/baseListener.d.ts

@@ -0,0 +1,19 @@
+import { KafkaMessage } from "kafkajs";
+import { TicketTopics, AgentTopics, EntityTreeTopics, AgentCrudTopics, MatchTopics, TicketTrackingTopics, AgentTrackingTopics, ManualMatchTopics, MonitorTopics, UserTopics, DeleteTrackingTopics, AuditTopics, NotificationTopics, TicketNoteTopics, TopicsTopics, TicketxTopicsTopics, DeviceTopics, PlanningTopics, WaitingTopics, PaymentsTopics, SubscriptionTopics } from "@fluyappgo/commons";
+interface Event {
+    topic: TicketTopics | AgentTopics | EntityTreeTopics | AgentCrudTopics | MatchTopics | TicketTrackingTopics | AgentTrackingTopics | ManualMatchTopics | MonitorTopics | UserTopics | DeleteTrackingTopics | AuditTopics | NotificationTopics | TicketNoteTopics | TopicsTopics | TicketxTopicsTopics | DeviceTopics | PlanningTopics | WaitingTopics | PaymentsTopics | SubscriptionTopics;
+    data: any;
+    keyKafka: number;
+    groupName: string;
+}
+export declare function shouldRestart(error: Error): boolean;
+export declare abstract class Listener<T extends Event> {
+    abstract topic: T["topic"];
+    abstract groupName: string;
+    private client;
+    abstract onMessage(data: T["data"], msg: any): void;
+    constructor(client: any);
+    listen(fromBeginning: boolean): void;
+    parseMessage(msg: KafkaMessage): any;
+}
+export {};