@platform-x/hep-message-broker-client 1.1.3 → 1.1.6

package/dist/src/Util/constants.js

@@ -1,8 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SECRET_KEYS = void 0;
+exports.RABBITMQ_FEED_TYPE = exports.SECRET_KEYS = void 0;
 exports.SECRET_KEYS = {
     RABBITMQ_USER: 'RABBITMQ_USER',
     RABBITMQ_PASS: 'RABBITMQ_PASS',
 };
+exports.RABBITMQ_FEED_TYPE = {
+    OVR: 'OVR',
+    ETX: 'ETX'
+};
 //# sourceMappingURL=constants.js.map

package/dist/src/config/index.js

@@ -2,7 +2,7 @@
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
+var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y;
 Object.defineProperty(exports, "__esModule", { value: true });
 const dotenv_1 = __importDefault(require("dotenv"));
 dotenv_1.default.config();
@@ -24,15 +24,20 @@ exports.default = {
         RETRY_EXCHANGE: 'assets_metadata_generate_retry_exchange',
         MAX_RETRIES: Number((_f = (_e = process.env.RABBITMQ_MAX_RETRIES) === null || _e === void 0 ? void 0 : _e.trim()) !== null && _f !== void 0 ? _f : 1),
         HEARTBEAT: Number((_h = (_g = process.env.RABBITMQ_HEARTBEAT) === null || _g === void 0 ? void 0 : _g.trim()) !== null && _h !== void 0 ? _h : 5),
-        TTL: (_j = process.env.RABBITMQ_TTL) !== null && _j !== void 0 ? _j : "3000|6000|9000",
-        BACKOFF_TIME: Number((_l = (_k = process.env.BACKOFF_TIME) === null || _k === void 0 ? void 0 : _k.trim()) !== null && _l !== void 0 ? _l : 1000),
-        IS_ENABLED: (_m = process.env.RABBITMQ_IS_ENABLED) !== null && _m !== void 0 ? _m : 'true',
-        RABBITMQ_CONFIG: (_o = process.env.RABBITMQ_CONFIG) !== null && _o !== void 0 ? _o : '',
-        PREFETCH_COUNT: Number((_p = process.env.RABBITMQ_PREFETCH) !== null && _p !== void 0 ? _p : 50),
-        CONNECTION_ERROR: (_q = process.env.RABBITMQ_CONNECTION_ERROR) !== null && _q !== void 0 ? _q : false,
-        PUBLISHER_ERROR: (_r = process.env.RABBITMQ_PUBLISHER_ERROR) !== null && _r !== void 0 ? _r : false,
-        CONSUMER_ERROR: (_s = process.env.RABBITMQ_CONSUMER_ERROR) !== null && _s !== void 0 ? _s : false,
-        CONFIG_PATH: (_t = process.env.CONFIG_PATH) !== null && _t !== void 0 ? _t : '/etc/rabbitmq/rabbitMQConfig.json',
+        TTL: (_j = process.env.RABBITMQ_TTL) !== null && _j !== void 0 ? _j : "60000|120000|180000",
+        ETX_TTL: (_k = process.env.RABBITMQ_RETRY_DELAY_ETX_TTL) !== null && _k !== void 0 ? _k : "60000|120000|180000",
+        OVR_TTL: (_l = process.env.RABBITMQ_RETRY_DELAY_OVR_TTL) !== null && _l !== void 0 ? _l : "1000|2000|3000",
+        BACKOFF_TIME: Number((_o = (_m = process.env.BACKOFF_TIME) === null || _m === void 0 ? void 0 : _m.trim()) !== null && _o !== void 0 ? _o : 1000),
+        IS_ENABLED: (_p = process.env.RABBITMQ_IS_ENABLED) !== null && _p !== void 0 ? _p : 'true',
+        RABBITMQ_CONFIG: (_q = process.env.RABBITMQ_CONFIG) !== null && _q !== void 0 ? _q : '',
+        PREFETCH_COUNT: Number((_r = process.env.RABBITMQ_PREFETCH) !== null && _r !== void 0 ? _r : 50),
+        CONNECTION_ERROR: (_s = process.env.RABBITMQ_CONNECTION_ERROR) !== null && _s !== void 0 ? _s : false,
+        PUBLISHER_ERROR: (_t = process.env.RABBITMQ_PUBLISHER_ERROR) !== null && _t !== void 0 ? _t : false,
+        CONSUMER_ERROR: (_u = process.env.RABBITMQ_CONSUMER_ERROR) !== null && _u !== void 0 ? _u : false,
+        CONNECTION_RETRY_ERROR: (_v = process.env.RABBITMQ_RETRY_ENABLE_CONNECTION) !== null && _v !== void 0 ? _v : false,
+        PUBLISHER_RETRY_ERROR: (_w = process.env.RABBITMQ_RETRY_ENABLE_PUBLISH) !== null && _w !== void 0 ? _w : false,
+        CONSUMER_RETRY_ERROR: (_x = process.env.RABBITMQ_RETRY_ENABLE_CONSUMER) !== null && _x !== void 0 ? _x : false,
+        CONFIG_PATH: (_y = process.env.CONFIG_PATH) !== null && _y !== void 0 ? _y : '/etc/rabbitmq/rabbitMQConfig.json',
     }
 };
 //# sourceMappingURL=index.js.map

package/dist/src/index.js

@@ -9,9 +9,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getIAMSecrets = exports.initIAMSecretsMessageBroker = exports.MessageBrokerClient = void 0;
+exports.getIAMSecrets = exports.initIAMSecretsMessageBroker = exports.MessageBroker = exports.MessageBrokerClient = void 0;
 const MessageBrokerClient_1 = require("./messageBroker/rabbitmq/MessageBrokerClient");
 Object.defineProperty(exports, "MessageBrokerClient", { enumerable: true, get: function () { return MessageBrokerClient_1.MessageBrokerClient; } });
+const MessageBroker_1 = require("./messageBroker/rabbitmq/MessageBroker");
+Object.defineProperty(exports, "MessageBroker", { enumerable: true, get: function () { return MessageBroker_1.MessageBroker; } });
 let injectedSecretService = null;
 const initIAMSecretsMessageBroker = (secretServiceIns) => {
     injectedSecretService = secretServiceIns;

package/dist/src/messageBroker/rabbitmq/MessageBroker.js

@@ -0,0 +1,535 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageBroker = void 0;
+const amqp = __importStar(require("amqplib"));
+const config_1 = __importDefault(require("../../config"));
+const ConfigManager_1 = __importDefault(require("../../config/ConfigManager"));
+const logger_1 = require("../../Util/logger");
+const constants_1 = require("../../Util/constants");
+const __1 = require("../..");
+const { RABBITMQ } = config_1.default;
+let configManager = ConfigManager_1.default.getInstance();
+let maxRetries = RABBITMQ.MAX_RETRIES;
+let retryDelay = (_a = RABBITMQ === null || RABBITMQ === void 0 ? void 0 : RABBITMQ.TTL) === null || _a === void 0 ? void 0 : _a.split("|");
+let prefetchCount = RABBITMQ.PREFETCH_COUNT;
+let configData = {};
+class MessageBroker {
+    constructor() {
+        this.connection = null;
+        this.channel = null;
+    }
+    /**
+     * Description: Checks if the RabbitMQ connection and channel are established.
+     * @returns boolean indicating the connection status
+     */
+    isConnected() {
+        return this.connection !== null && this.channel !== null;
+    }
+    /**
+     * Description: Checks if the connection and channel are alive. If not, recreates them.
+     * Also recreates the channel if its underlying socket/stream is destroyed.
+     */
+    checkConnectionAndChannel() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            logger_1.Logger.info('Reached: checkConnectionAndChannel', 'checkConnectionAndChannel');
+            if (!this.isConnected()) {
+                logger_1.Logger.warn('No active connection found. Recreating connection...', 'checkConnectionAndChannel');
+                yield this.createConnection();
+                return;
+            }
+            // Check if the channel's underlying stream is still alive
+            const channelConn = (_a = this.channel) === null || _a === void 0 ? void 0 : _a.connection;
+            if (!this.channel || !channelConn || ((_b = channelConn.stream) === null || _b === void 0 ? void 0 : _b.destroyed)) {
+                logger_1.Logger.warn('Channel is dead. Recreating channel...', 'checkConnectionAndChannel');
+                yield this.recreateChannel();
+            }
+        });
+    }
+    /**
+     * Description: Recreates the channel on the existing connection.
+     */
+    recreateChannel() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.channel = yield this.connection.createConfirmChannel();
+                yield this.channel.prefetch(prefetchCount);
+                logger_1.Logger.info('Channel recreated successfully', 'recreateChannel');
+            }
+            catch (error) {
+                logger_1.Logger.error(`Failed to recreate channel: ${error.message}`, 'recreateChannel');
+                throw error;
+            }
+        });
+    }
+    /**
+     * Initialize RabbitMQ connection and channel with configurable retry attempts.
+     * Waits for a configurable delay between each retry.
+     */
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                configData = configManager.getConfig();
+                logger_1.Logger.info('Reached to createConnection', 'createConnection');
+                let attempt = 0;
+                while (attempt < maxRetries) {
+                    try {
+                        if (RABBITMQ.CONNECTION_RETRY_ERROR === 'true' || RABBITMQ.CONNECTION_RETRY_ERROR === true) {
+                            throw new Error("Error in connection");
+                        }
+                        return yield this.createConnection();
+                    }
+                    catch (error) {
+                        attempt++;
+                        logger_1.Logger.error(`Attempt ${attempt} - Failed to connect to RabbitMQ: ${error.message}`, 'initialize');
+                        if (attempt < maxRetries - 1) {
+                            logger_1.Logger.info(`Retrying to connect to RabbitMQ in ${retryDelay / 1000} seconds...`, 'initialize');
+                            yield new Promise(res => setTimeout(res, retryDelay));
+                        }
+                    }
+                }
+                throw new Error(`Failed to connect to RabbitMQ after ${maxRetries} attempts`);
+            }
+            catch (error) {
+                logger_1.Logger.error("Connection to RabbitMQ failed.", 'createConnection');
+                logger_1.Logger.error(`Failed to connect to RabbitMQ: ${error.message}`, 'createConnection');
+                throw error; // Rethrow the error after logging
+            }
+        });
+    }
+    /**
+     * Description: Establishes a connection to RabbitMQ and creates a channel. Also registers exchanges, queues, and bindings based on the configuration data.
+     * @returns An object containing the RabbitMQ connection and channel.
+     */
+    createConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                logger_1.Logger.info('Attempting to connect to RabbitMQ', 'createConnection');
+                configManager.loadConfig(RABBITMQ === null || RABBITMQ === void 0 ? void 0 : RABBITMQ.CONFIG_PATH);
+                const secret = yield (0, __1.getIAMSecrets)();
+                let url = `amqp://${secret === null || secret === void 0 ? void 0 : secret[constants_1.SECRET_KEYS.RABBITMQ_USER]}:${secret === null || secret === void 0 ? void 0 : secret[constants_1.SECRET_KEYS.RABBITMQ_PASS]}@${RABBITMQ === null || RABBITMQ === void 0 ? void 0 : RABBITMQ.HOST}`;
+                //console.log(SECRET_KEYS.RABBITMQ_USER, SECRET_KEYS.RABBITMQ_PASS);
+                //const url = `amqp://${RABBITMQ.USER}:${RABBITMQ.PASS}@${RABBITMQ.HOST}:${RABBITMQ.PORT}`;
+                this.connection = yield amqp.connect(url, { heartbeat: RABBITMQ.HEARTBEAT });
+                this.channel = yield this.connection.createConfirmChannel();
+                this.connectionEventHandler(); // Event handlers for connection 'error' and 'close'
+                yield this.channel.prefetch(prefetchCount);
+                yield this.registerQueueAndExchange();
+                logger_1.Logger.info(`Connected to RabbitMQ`, 'createConnection');
+                return { connection: this.connection, channel: this.channel };
+            }
+            catch (error) {
+                logger_1.Logger.error(`Failed to connect to RabbitMQ: ${error.message}`, 'createConnection');
+                throw error;
+            }
+        });
+    }
+    /**
+     * Description: Registers 'close' and 'error' event handlers on the current connection.
+     * - 'error' only logs (amqplib always fires 'close' after 'error', so reconnect is handled there).
+     * - 'close' nullifies connection/channel, then attempts reconnect with exponential backoff.
+     * - connectionRetry resets on each successful connection via createConnection().
+     */
+    connectionEventHandler() {
+        try {
+            if (!this.connection)
+                return;
+            this.connection.on('error', (err) => {
+                logger_1.Logger.error(`RabbitMQ connection error: ${err.message}`, 'connectionEventHandler');
+            });
+            this.connection.on('close', () => __awaiter(this, void 0, void 0, function* () {
+                logger_1.Logger.warn('RabbitMQ connection closed', 'connectionEventHandler');
+                this.connection = null;
+                this.channel = null;
+                yield this.handleReconnect();
+            }));
+        }
+        catch (error) {
+            logger_1.Logger.error(`Error in connectionEventHandler: ${error.message}`, 'connectionEventHandler');
+        }
+    }
+    /**
+     * Description: Attempts to reconnect to RabbitMQ with exponential backoff.
+     * Resets connectionRetry on success so future disconnections can recover.
+     */
+    handleReconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            let connectionRetry = 1;
+            const retryDelays = RABBITMQ.TTL.split('|').map(Number);
+            while (connectionRetry <= maxRetries) {
+                const delay = (_a = retryDelays[connectionRetry - 1]) !== null && _a !== void 0 ? _a : retryDelays[retryDelays.length - 1];
+                logger_1.Logger.info(`Reconnect attempt ${connectionRetry} of ${maxRetries} in ${delay / 1000}s...`, 'handleReconnect');
+                yield new Promise(res => setTimeout(res, delay));
+                try {
+                    yield this.createConnection();
+                    connectionRetry = 1;
+                    logger_1.Logger.info('Reconnected to RabbitMQ successfully', 'handleReconnect');
+                    return;
+                }
+                catch (error) {
+                    logger_1.Logger.error(`Reconnect attempt ${connectionRetry} failed: ${error.message}`, 'handleReconnect');
+                    connectionRetry++;
+                }
+            }
+            logger_1.Logger.error('Max reconnection attempts reached. No longer trying to reconnect.', 'handleReconnect');
+        });
+    }
+    /**
+     * Description: Registers exchanges, queues, and bindings in RabbitMQ based on the provided configuration data.
+     */
+    registerQueueAndExchange() {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.Logger.info('Reached to registerQueueAndExchange', 'registerQueueAndExchange');
+            try {
+                const { exchanges = [], queues = [], bindings = {} } = configData;
+                // Create all exchanges
+                for (const exchange of exchanges) {
+                    yield this.createExchange(exchange);
+                    logger_1.Logger.info(`${exchange.name} exchange registered`, 'registerQueueAndExchange');
+                }
+                // Create all queues
+                for (const queue of queues) {
+                    yield this.createQueue(queue);
+                    logger_1.Logger.info(`${queue.name} queue registered`, 'registerQueueAndExchange');
+                }
+                // Bind all queues to exchanges with routing keys
+                for (const exchangeName in bindings) {
+                    for (const binding of bindings[exchangeName]) {
+                        yield this.bindQueueAndExchanges(exchangeName, binding.queue, binding.routingKey);
+                        logger_1.Logger.info(`${binding.queue} bound to exchange ${exchangeName} with routing key ${binding.routingKey}`, 'registerQueueAndExchange');
+                    }
+                }
+            }
+            catch (error) {
+                logger_1.Logger.error("Error on registering queue, exchange and binding", 'registerQueueAndExchange', error.message);
+                throw error;
+            }
+        });
+    }
+    /**
+     * Description: Binds a RabbitMQ queue to an exchange with a specified routing key.
+     * @param exchangeName
+     * @param queueName
+     * @param routingKey
+     */
+    bindQueueAndExchanges(exchangeName, queueName, routingKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.Logger.info('Reached to bindQueueAndExchanges', 'bindQueueAndExchanges');
+            try {
+                yield this.channel.bindQueue(queueName, exchangeName, routingKey);
+                logger_1.Logger.info(`Queue ${queueName} bound to exchange ${exchangeName} with routing key ${routingKey}`, 'bindQueueAndExchanges');
+            }
+            catch (error) {
+                logger_1.Logger.error(`Failed to bind queue ${queueName} to exchange ${exchangeName}: ${error.message}`, 'bindQueueAndExchanges');
+                throw error;
+            }
+        });
+    }
+    /**
+     * Description: Creates a RabbitMQ exchange with the specified configuration.
+     * @param exchangeData
+     */
+    createExchange(exchangeData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.Logger.info('Reached to createExchange', 'createExchange');
+            try {
+                yield this.channel.assertExchange(exchangeData === null || exchangeData === void 0 ? void 0 : exchangeData.name, exchangeData === null || exchangeData === void 0 ? void 0 : exchangeData.type, { durable: exchangeData === null || exchangeData === void 0 ? void 0 : exchangeData.durable, autoDelete: exchangeData === null || exchangeData === void 0 ? void 0 : exchangeData.autoDelete, arguments: exchangeData === null || exchangeData === void 0 ? void 0 : exchangeData.arguments });
+                logger_1.Logger.info(`${exchangeData === null || exchangeData === void 0 ? void 0 : exchangeData.name} exchange created`, 'createExchange');
+            }
+            catch (error) {
+                logger_1.Logger.error(`Failed to create ${exchangeData === null || exchangeData === void 0 ? void 0 : exchangeData.name} exchange: ${error.message}`, 'createExchange');
+                throw error;
+            }
+        });
+    }
+    /**
+     * Description: Creates a RabbitMQ queue with the specified configuration.
+     * @param queueData
+     */
+    createQueue(queueData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.Logger.info('Reached to createQueue', 'createQueue');
+            try {
+                yield this.channel.assertQueue(queueData === null || queueData === void 0 ? void 0 : queueData.name, { durable: queueData === null || queueData === void 0 ? void 0 : queueData.durable, exclusive: queueData === null || queueData === void 0 ? void 0 : queueData.exclusive, autoDelete: queueData === null || queueData === void 0 ? void 0 : queueData.autoDelete, arguments: queueData === null || queueData === void 0 ? void 0 : queueData.arguments });
+                logger_1.Logger.info(`${queueData === null || queueData === void 0 ? void 0 : queueData.name} queue created`, 'createQueue');
+            }
+            catch (error) {
+                logger_1.Logger.error(`Failed to create ${queueData === null || queueData === void 0 ? void 0 : queueData.name} queue: ${error.message}`, 'createQueue');
+                throw error;
+            }
+        });
+    }
+    /**
+     * Description: Publishes a message to a RabbitMQ exchange with configurable retry attempts.
+     * On each failed attempt, waits using exponential backoff based on TTL config.
+     * After all retries are exhausted, sends the message to the dead letter queue.
+     * @param exchangeName - The target exchange name
+     * @param queueName - The routing key / queue name
+     * @param message - The message payload to publish
+     * @returns true if published successfully
+     */
+    publishMessageToExchange(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            logger_1.Logger.info('Reached to publishMessageToExchange', 'publishMessageToExchange');
+            const { exchangeName, queueName, message } = request;
+            const retryDelayConfig = ((_a = message === null || message === void 0 ? void 0 : message.message) === null || _a === void 0 ? void 0 : _a.feed_type) === constants_1.RABBITMQ_FEED_TYPE.OVR ? RABBITMQ.OVR_TTL : RABBITMQ.ETX_TTL;
+            const retryDelay = retryDelayConfig.split('|').map(Number);
+            let attempt = 0;
+            while (attempt < maxRetries) {
+                try {
+                    yield this.checkConnectionAndChannel();
+                    const messageBuffer = Buffer.from(JSON.stringify(message));
+                    const sent = this.channel.publish(exchangeName, queueName, messageBuffer, { persistent: true });
+                    //if(attempt < 1){ sent = false}else{sent = true} // --- IGNORE ---
+                    if (sent && (RABBITMQ.PUBLISHER_RETRY_ERROR !== 'true' && RABBITMQ.PUBLISHER_RETRY_ERROR !== true)) {
+                        logger_1.Logger.info(`Message published successfully on attempt ${attempt + 1}`, 'publishMessageToExchange');
+                        return true;
+                    }
+                    else {
+                        throw new Error('Channel publish returned false — buffer full');
+                    }
+                }
+                catch (error) {
+                    attempt++;
+                    logger_1.Logger.error(`Attempt ${attempt} of ${maxRetries} failed in ${retryDelay[attempt - 1] / 1000}s...: ${error.message}`, 'publishMessageToExchange');
+                    if (attempt >= maxRetries) {
+                        logger_1.Logger.error('Max retries reached. Sending message to Dead Letter Queue...', 'publishMessageToExchange');
+                        yield this.sendToDeadLetterQueue({ message, attempt });
+                        logger_1.Logger.error(`Failed to publish message to exchange ${exchangeName} after ${maxRetries} attempts`, 'publishMessageToExchange');
+                        return false;
+                    }
+                    // Exponential backoff using TTL array
+                    const delay = (_b = retryDelay[attempt - 1]) !== null && _b !== void 0 ? _b : retryDelay[retryDelay.length - 1];
+                    logger_1.Logger.info(`Retrying in ${delay / 1000}s...`, 'publishMessageToExchange');
+                    yield new Promise(res => setTimeout(res, delay));
+                }
+            }
+            return false;
+        });
+    }
+    /**
+     * Description: Sends a failed message to the dead letter queue after all retries are exhausted.
+     * @param request - The request object containing the message payload and the number of attempts made
+     */
+    sendToDeadLetterQueue(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { message, attempt } = request;
+            try {
+                yield this.checkConnectionAndChannel(); // Ensure connection and channel are alive before sending to DLQ
+                const dlqQueue = RABBITMQ.DLX_QUEUE;
+                const messageBuffer = Buffer.from(JSON.stringify(message));
+                const sent = this.channel.sendToQueue(dlqQueue, messageBuffer, {
+                    persistent: true,
+                    headers: { 'x-retry-count': attempt },
+                });
+                if (sent) {
+                    logger_1.Logger.info(`Message sent to DLQ: ${dlqQueue} (attempts: ${attempt})`, 'sendToDeadLetterQueue');
+                }
+                else {
+                    logger_1.Logger.error(`Failed to send message to DLQ: ${dlqQueue} — buffer full`, 'sendToDeadLetterQueue');
+                }
+            }
+            catch (error) {
+                logger_1.Logger.error(`Error sending message to DLQ: ${error.message}`, 'sendToDeadLetterQueue');
+            }
+        });
+    }
+    /**
+     * Description: Initializes consumers for all queues listed in `consume_queues` config.
+     * @param classInstance - Object whose methods will be called as handlers
+     * @param consumerHandler - Method name on classInstance to process each message
+     * @param consumerErrorHandler - Method name on classInstance called when all retries fail
+     */
+    initializeConsumers(classInstance, consumerHandler, consumerErrorHandler) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                logger_1.Logger.info('Reached in initialize consumers', 'initializeConsumers');
+                const consumeQueues = configData === null || configData === void 0 ? void 0 : configData.consume_queues;
+                for (const queueName in consumeQueues) {
+                    if (Object.prototype.hasOwnProperty.call(consumeQueues, queueName)) {
+                        yield this.consumeMessage(queueName, classInstance, consumerHandler, consumerErrorHandler);
+                    }
+                }
+            }
+            catch (error) {
+                logger_1.Logger.error('Error initializing consumers:', 'initializeConsumers', error.message);
+                throw new Error(error.message);
+            }
+        });
+    }
+    /**
+     * Description: Consumes messages from a queue with retry logic.
+     *  - Success → ack
+     *  - Failure + retries left → send to retry queue with incremented x-retry-count & TTL backoff, ack original
+     *  - Failure + retries exhausted → DLQ + error handler + nack (no requeue)
+     *  - Unhandled exception → DLQ + error handler + nack
+     * @param queueName - Queue to consume from
+     * @param classInstance - Object whose methods will be called as handlers
+     * @param consumerHandler - Method name invoked to process each message
+     * @param consumerErrorHandler - Method name invoked when all retries fail
+     */
+    consumeMessage(queueName, classInstance, consumerHandler, consumerErrorHandler) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.Logger.info(`Reached: Consuming messages from queue ${queueName}`, 'consumeMessage');
+            yield this.checkConnectionAndChannel();
+            yield this.channel.consume(queueName, (message) => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+                if (!message)
+                    return;
+                const msgData = JSON.parse(message.content.toString());
+                const headers = message.properties.headers || {};
+                const retryCount = headers['x-retry-count'] || 0;
+                const retryMessageTTL = headers['x-message-ttl'] || 0;
+                const feedType = (_b = (_a = msgData === null || msgData === void 0 ? void 0 : msgData.message) === null || _a === void 0 ? void 0 : _a.feed_type) !== null && _b !== void 0 ? _b : msgData === null || msgData === void 0 ? void 0 : msgData.feed_type;
+                const retryDelayTTL = feedType === constants_1.RABBITMQ_FEED_TYPE.OVR ? RABBITMQ.OVR_TTL : RABBITMQ.ETX_TTL;
+                const retryDelay = retryDelayTTL.split('|').map(Number);
+                // Consuming delay for retry messages based on x-message-ttl header.
+                if (retryMessageTTL) {
+                    logger_1.Logger.info(`Delaying message processing by ${retryMessageTTL / 1000} seconds... for queue ${queueName}`, 'consumeMessage');
+                    yield new Promise((resolve) => setTimeout(resolve, retryMessageTTL));
+                }
+                const data = {
+                    queue_name: queueName,
+                    body: (_d = (_c = msgData === null || msgData === void 0 ? void 0 : msgData.message) === null || _c === void 0 ? void 0 : _c.body) !== null && _d !== void 0 ? _d : msgData === null || msgData === void 0 ? void 0 : msgData.body,
+                    trace: (_f = (_e = msgData === null || msgData === void 0 ? void 0 : msgData.message) === null || _e === void 0 ? void 0 : _e.trace) !== null && _f !== void 0 ? _f : msgData === null || msgData === void 0 ? void 0 : msgData.trace,
+                    retries: (_h = (_g = msgData === null || msgData === void 0 ? void 0 : msgData.message) === null || _g === void 0 ? void 0 : _g.retries) !== null && _h !== void 0 ? _h : msgData === null || msgData === void 0 ? void 0 : msgData.retries,
+                    version: (_k = (_j = msgData === null || msgData === void 0 ? void 0 : msgData.message) === null || _j === void 0 ? void 0 : _j.version) !== null && _k !== void 0 ? _k : msgData === null || msgData === void 0 ? void 0 : msgData.version,
+                    feed_type: (_m = (_l = msgData === null || msgData === void 0 ? void 0 : msgData.message) === null || _l === void 0 ? void 0 : _l.feed_type) !== null && _m !== void 0 ? _m : msgData === null || msgData === void 0 ? void 0 : msgData.feed_type,
+                };
+                try {
+                    let success = false;
+                    if (RABBITMQ.CONSUMER_RETRY_ERROR !== 'true' && RABBITMQ.CONSUMER_RETRY_ERROR !== true) {
+                        if (typeof classInstance[consumerHandler] === 'function') {
+                            logger_1.Logger.info('Consumer handler call for processing the request', 'consumeMessage');
+                            success = yield classInstance[consumerHandler]({ queueName, message: msgData });
+                        }
+                        else {
+                            logger_1.Logger.error(`Method ${consumerHandler} not found on classInstance`, 'consumeMessage');
+                        }
+                    }
+                    if (success) {
+                        logger_1.Logger.info('Acknowledge the successful processing', 'consumeMessage');
+                        this.channel.ack(message);
+                    }
+                    else {
+                        if (retryCount >= maxRetries) {
+                            logger_1.Logger.error('Max retries reached. Sending message to Dead Letter Queue.', 'consumeMessage');
+                            yield this.sendToDeadLetterQueue({ message: data, attempt: retryCount });
+                            if (typeof classInstance[consumerErrorHandler] === 'function') {
+                                classInstance[consumerErrorHandler](data);
+                            }
+                            else {
+                                logger_1.Logger.error(`Method ${consumerErrorHandler} not found on classInstance`, 'consumeMessage');
+                            }
+                            this.channel.nack(message, false, false);
+                        }
+                        else {
+                            const nextAttempt = retryCount + 1;
+                            if ((data === null || data === void 0 ? void 0 : data.retries) >= 0) {
+                                data.retries = nextAttempt;
+                            }
+                            const delayIndex = nextAttempt - 1 < retryDelay.length ? nextAttempt - 1 : retryDelay.length - 1;
+                            const delay = Number(retryDelay[delayIndex]);
+                            logger_1.Logger.info(`Retrying in ${delay / 1000} seconds... (attempt ${nextAttempt} of ${maxRetries} ${data.feed_type})`, 'consumeMessage');
+                            yield this.sendMessageToRetryQueue({ attempt: nextAttempt, data, retryDelayMs: delay, queueName });
+                            this.channel.ack(message);
+                        }
+                    }
+                }
+                catch (error) {
+                    logger_1.Logger.error('Error processing message', 'consumeMessage', { message: error.message });
+                    yield this.sendToDeadLetterQueue({ message: data, attempt: retryCount });
+                    if (typeof classInstance[consumerErrorHandler] === 'function') {
+                        classInstance[consumerErrorHandler](data);
+                    }
+                    else {
+                        logger_1.Logger.error(`Method ${consumerErrorHandler} not found on classInstance`, 'consumeMessage');
+                    }
+                    this.channel.nack(message, false, false);
+                }
+            }));
+        });
+    }
+    /**
+     * Description: Sends a message to a retry queue with an incremented retry count and appropriate TTL for delayed reprocessing.
+     * @param request
+     * @returns boolean indicating if the message was sent to the retry queue successfully
+     */
+    sendMessageToRetryQueue(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { attempt, data, retryDelayMs, queueName } = request;
+            logger_1.Logger.info(`Sending message to retry queue: ${queueName} (attempt: ${attempt}, delay: ${retryDelayMs}ms)`, 'sendMessageToRetryQueue');
+            try {
+                yield this.checkConnectionAndChannel(); // connection check before sending to retry queue
+                const messageBuffer = Buffer.from(JSON.stringify(data));
+                const sent = this.channel.sendToQueue(queueName, messageBuffer, {
+                    headers: {
+                        'x-retry-count': attempt,
+                        'x-message-ttl': retryDelayMs
+                    },
+                });
+                if (sent) {
+                    logger_1.Logger.info(`Message sent to retry queue: ${queueName} (attempt: ${attempt})`, 'sendMessageToRetryQueue');
+                }
+                else {
+                    logger_1.Logger.error(`Failed to send message to retry queue: ${queueName} — buffer full`, 'sendMessageToRetryQueue');
+                }
+                return sent;
+            }
+            catch (error) {
+                logger_1.Logger.error(`Error sending message to retry queue: ${error.message}`, 'sendMessageToRetryQueue');
+                throw error;
+            }
+        });
+    }
+}
+exports.MessageBroker = MessageBroker;
+//# sourceMappingURL=MessageBroker.js.map

package/dist/src/messageBroker/rabbitmq/MessageBrokerClient.js

@@ -691,7 +691,6 @@ class MessageBrokerClient {
                 logger_1.Logger.info('Reached to createConnection', 'createConnection');
                 configManager.loadConfig(RABBITMQ === null || RABBITMQ === void 0 ? void 0 : RABBITMQ.CONFIG_PATH);
                 const secret = yield (0, __1.getIAMSecrets)();
-                console.log('rabbit user' + (secret === null || secret === void 0 ? void 0 : secret[constants_1.SECRET_KEYS.RABBITMQ_USER]) + 'rabit pass' + (secret === null || secret === void 0 ? void 0 : secret[constants_1.SECRET_KEYS.RABBITMQ_PASS]));
                 let url = `amqp://${secret === null || secret === void 0 ? void 0 : secret[constants_1.SECRET_KEYS.RABBITMQ_USER]}:${secret === null || secret === void 0 ? void 0 : secret[constants_1.SECRET_KEYS.RABBITMQ_PASS]}@${RABBITMQ === null || RABBITMQ === void 0 ? void 0 : RABBITMQ.HOST}`;
                 // Create a connection to RabbitMQ server
                 connection = yield amqp.connect(url, { heartbeat: RABBITMQ === null || RABBITMQ === void 0 ? void 0 : RABBITMQ.HEARTBEAT });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@platform-x/hep-message-broker-client",
-    "version": "1.1.3",
+    "version": "1.1.6",
     "description": "platform-x hep-message-broker service",
     "main": "./dist/src/index.js",
     "scripts": {