@platform-x/hep-message-broker-client 1.1.14 → 1.1.16

package/src/messageBroker/rabbitmq/MessageBroker.ts

@@ -0,0 +1,525 @@
+import * as amqp from 'amqplib';
+import config from '../../config';
+import ConfigManager from '../../config/ConfigManager';
+import { Logger } from '../../Util/logger';
+import { RABBITMQ_FEED_TYPE, SECRET_KEYS } from '../../Util/constants';
+import { getIAMSecrets } from '../..';
+
+const { RABBITMQ } = config;
+
+let configManager: ConfigManager = ConfigManager.getInstance();
+let maxRetries = RABBITMQ.MAX_RETRIES;
+let retryDelay: any = RABBITMQ?.TTL?.split("|"); 
+let prefetchCount = RABBITMQ.PREFETCH_COUNT;
+let configData: any = {};
+
+export class MessageBroker {
+
+    private connection: amqp.Connection | null = null;
+    private channel: amqp.Channel | null = null;
+
+    /**
+     * Description: Checks if the RabbitMQ connection and channel are established.
+     * @returns boolean indicating the connection status
+     */
+    public isConnected(): boolean {
+        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.
+     */
+    public async checkConnectionAndChannel(): Promise<void> {
+        Logger.info('Reached: checkConnectionAndChannel', 'checkConnectionAndChannel');
+        if (!this.isConnected()) {
+            Logger.warn('No active connection found. Recreating connection...', 'checkConnectionAndChannel');
+            await this.createConnection();
+            return;
+        }
+        // Check if the channel's underlying stream is still alive
+        const channelConn: any = (this.channel as any)?.connection;
+        if (!this.channel || !channelConn || channelConn.stream?.destroyed) {
+            Logger.warn('Channel is dead. Recreating channel...', 'checkConnectionAndChannel');
+            await this.recreateChannel();
+        }
+    }
+
+    /**
+     * Description: Recreates the channel on the existing connection.
+     */
+    private async recreateChannel(): Promise<void> {
+        try {
+            this.channel = await this.connection!.createConfirmChannel();
+            await this.channel.prefetch(prefetchCount);
+            Logger.info('Channel recreated successfully', 'recreateChannel');
+        } catch (error) {
+            Logger.error(`Failed to recreate channel: ${(error as Error).message}`, 'recreateChannel');
+            throw error;
+        }
+    }
+
+    /**
+     * Initialize RabbitMQ connection and channel with configurable retry attempts.
+     * Waits for a configurable delay between each retry.
+     */
+    public async initialize(): Promise<{ connection: amqp.Connection; channel: amqp.Channel }> {
+        try {
+            configData = configManager.getConfig();
+            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 await this.createConnection();
+                } catch (error) {
+                    attempt++;
+                    Logger.error(`Attempt ${attempt} - Failed to connect to RabbitMQ: ${(error as Error).message}`, 'initialize');
+                    if (attempt < maxRetries - 1) {
+                        Logger.info(`Retrying to connect to RabbitMQ in ${retryDelay / 1000} seconds...`, 'initialize');
+                        await new Promise(res => setTimeout(res, retryDelay));
+                    }
+                }
+            }
+            throw new Error(`Failed to connect to RabbitMQ after ${maxRetries} attempts`);
+        } catch (error: any) {
+            Logger.error("Connection to RabbitMQ failed.", 'createConnection');
+            Logger.error(`Failed to connect to RabbitMQ: ${(error as 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.
+     */
+    public async createConnection():Promise<{ connection: amqp.Connection; channel: amqp.Channel }>{
+        try {
+            Logger.info('Attempting to connect to RabbitMQ', 'createConnection');
+            configManager.loadConfig(RABBITMQ?.CONFIG_PATH);
+            const secret = await getIAMSecrets();
+            let url: string = `amqp://${secret?.[SECRET_KEYS.RABBITMQ_USER]}:${secret?.[SECRET_KEYS.RABBITMQ_PASS]}@${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 = await amqp.connect(url, { heartbeat: RABBITMQ.HEARTBEAT });
+            this.channel = await this.connection.createConfirmChannel();
+
+            this.connectionEventHandler(); // Event handlers for connection 'error' and 'close'
+
+            await this.channel.prefetch(prefetchCount);
+            await this.registerQueueAndExchange();
+            
+            Logger.info(`Connected to RabbitMQ`, 'createConnection');
+            return { connection: this.connection, channel: this.channel };
+        } catch (error) {
+            Logger.error(`Failed to connect to RabbitMQ: ${(error as 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().
+     */
+    private connectionEventHandler(): void {
+        try {
+            if (!this.connection) return;
+            this.connection.on('error', (err: Error) => {
+                Logger.error(`RabbitMQ connection error: ${err.message}`, 'connectionEventHandler');
+            });
+            this.connection.on('close', async () => {
+                Logger.warn('RabbitMQ connection closed', 'connectionEventHandler');
+                this.connection = null;
+                this.channel = null;
+                await this.handleReconnect();
+            });
+        } catch(error) {
+            Logger.error(`Error in connectionEventHandler: ${(error as Error).message}`, 'connectionEventHandler');
+        }
+    }
+
+    /**
+     * Description: Attempts to reconnect to RabbitMQ with exponential backoff.
+     * Resets connectionRetry on success so future disconnections can recover.
+     */
+    private async handleReconnect(): Promise<void> {
+        let connectionRetry:number = 1;
+        const retryDelays = RABBITMQ.TTL.split('|').map(Number);
+
+        while (connectionRetry <= maxRetries) {
+            const delay = retryDelays[connectionRetry - 1] ?? retryDelays[retryDelays.length - 1];
+            Logger.info(`Reconnect attempt ${connectionRetry} of ${maxRetries} in ${delay / 1000}s...`, 'handleReconnect');
+            await new Promise(res => setTimeout(res, delay));
+
+            try {
+                await this.createConnection();
+                connectionRetry = 1;
+                Logger.info('Reconnected to RabbitMQ successfully', 'handleReconnect');
+                return;
+            } catch (error) {
+                Logger.error(`Reconnect attempt ${connectionRetry} failed: ${(error as Error).message}`, 'handleReconnect');
+                connectionRetry++;
+            }
+        }
+        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.
+     */
+    public async registerQueueAndExchange(){
+        Logger.info('Reached to registerQueueAndExchange', 'registerQueueAndExchange');
+        try {
+          const { exchanges = [], queues = [], bindings = {} } = configData;
+
+          // Create all exchanges
+          for (const exchange of exchanges) {
+            await this.createExchange(exchange);
+            Logger.info(`${exchange.name} exchange registered`, 'registerQueueAndExchange');
+          }
+
+          // Create all queues
+          for (const queue of queues) {
+            await this.createQueue(queue);
+            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]) {
+              await this.bindQueueAndExchanges(exchangeName, binding.queue, binding.routingKey, binding.options);
+              Logger.info(`${binding.queue} bound to exchange ${exchangeName} with routing key ${binding.routingKey}`, 'registerQueueAndExchange');
+            }
+          }
+        } catch (error) {
+          Logger.error("Error on registering queue, exchange and binding", 'registerQueueAndExchange', (error as Error).message);
+          throw error;
+        }
+      }
+
+
+    /**
+     * Description: Binds a RabbitMQ queue to an exchange with a specified routing key.
+     * @param exchangeName 
+     * @param queueName 
+     * @param routingKey 
+     */  
+    private async bindQueueAndExchanges(exchangeName: string, queueName: string, routingKey: string, options: any) {
+        Logger.info('Reached to bindQueueAndExchanges', 'bindQueueAndExchanges');
+        try {
+            if(options) {
+                await this.channel!.bindQueue(queueName, exchangeName, routingKey, options);
+                Logger.info(`Queue ${queueName} bound to exchange ${exchangeName} with routing key ${routingKey} and options ${JSON.stringify(options)}`, 'bindQueueAndExchanges');
+                return;
+            }
+            await this.channel!.bindQueue(queueName, exchangeName, routingKey);
+            Logger.info(`Queue ${queueName} bound to exchange ${exchangeName} with routing key ${routingKey}`, 'bindQueueAndExchanges');
+        } catch (error) {
+            Logger.error(`Failed to bind queue ${queueName} to exchange ${exchangeName}: ${(error as Error).message}`, 'bindQueueAndExchanges');
+            throw error;
+        }
+    }
+
+    /**
+     * Description: Creates a RabbitMQ exchange with the specified configuration.
+     * @param exchangeData 
+     */
+    private async createExchange(exchangeData: any) {  
+        Logger.info('Reached to createExchange', 'createExchange');
+        try {
+            await this.channel!.assertExchange(exchangeData?.name, exchangeData?.type, { durable: exchangeData?.durable, autoDelete: exchangeData?.autoDelete, arguments: exchangeData?.arguments });
+            Logger.info(`${exchangeData?.name} exchange created`, 'createExchange');
+        } catch (error) {
+            Logger.error(`Failed to create ${exchangeData?.name} exchange: ${(error as Error).message}`, 'createExchange');
+            throw error;
+        }
+    }
+
+    /**
+     * Description: Creates a RabbitMQ queue with the specified configuration.
+     * @param queueData 
+     */
+    private async createQueue(queueData: any) {
+        Logger.info('Reached to createQueue', 'createQueue');
+        try {
+            await this.channel!.assertQueue(queueData?.name, { durable: queueData?.durable, exclusive: queueData?.exclusive, autoDelete: queueData?.autoDelete, arguments: queueData?.arguments });
+            Logger.info(`${queueData?.name} queue created`, 'createQueue');
+        } catch (error) {
+            Logger.error(`Failed to create ${queueData?.name} queue: ${(error as 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
+     */
+    public async publishMessageToExchange(request: { exchangeName: string; queueName: string; message: any }): Promise<boolean> {
+        Logger.info('Reached to publishMessageToExchange', 'publishMessageToExchange');
+        const { exchangeName, queueName, message } = request;
+        const retryDelayConfig = message?.message?.feed_type === RABBITMQ_FEED_TYPE.OVR ? RABBITMQ.OVR_TTL : RABBITMQ.ETX_TTL;
+        const retryDelay = retryDelayConfig.split('|').map(Number);
+
+        let attempt = 0;
+        while (attempt < maxRetries) {
+            try {
+                await 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.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.error(`Attempt ${attempt} of ${maxRetries} failed in ${retryDelay[attempt - 1] / 1000}s...: ${(error as Error).message}`, 'publishMessageToExchange');
+
+                if (attempt >= maxRetries) {
+                    Logger.error('Max retries reached. Sending message to Dead Letter Queue...', 'publishMessageToExchange');
+                    await this.sendToDeadLetterQueue({ message, attempt });
+                    Logger.error(`Failed to publish message to exchange ${exchangeName} after ${maxRetries} attempts`, 'publishMessageToExchange');
+                    return false;
+                }
+
+                // Exponential backoff using TTL array
+                const delay = retryDelay[attempt - 1] ?? retryDelay[retryDelay.length - 1];
+                Logger.info(`Retrying in ${delay / 1000}s...`, 'publishMessageToExchange');
+                await new Promise(res => setTimeout(res, delay));
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Description: Publishes a message directly to a RabbitMQ queue 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 request - The request object containing the queue name and the message payload
+     * @returns true if the message was published successfully, false otherwise
+     */
+    public async publishMessage(request: { queueName: string; message: any }): Promise<boolean> {
+        Logger.info('Reached to publishMessage', 'publishMessage');
+        const { queueName, message } = request;
+        const retryDelayConfig = message?.message?.feed_type === RABBITMQ_FEED_TYPE.OVR ? RABBITMQ.OVR_TTL : RABBITMQ.ETX_TTL;
+        const retryDelay = retryDelayConfig.split('|').map(Number);
+
+        let attempt = 0;
+        while (attempt < maxRetries) {
+            try {
+                await this.checkConnectionAndChannel();
+                const messageBuffer = Buffer.from(JSON.stringify(message));
+                const sent = this.channel!.sendToQueue(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.info(`Message published successfully on attempt ${attempt + 1}`, 'publishMessage');
+                    return true;
+                } else {
+                    throw new Error('Channel publish returned false — buffer full');
+                }
+            } catch (error) {
+                attempt++;
+                Logger.error(`Attempt ${attempt} of ${maxRetries} failed in ${retryDelay[attempt - 1] / 1000}s...: ${(error as Error).message}`, 'publishMessage');
+
+                if (attempt >= maxRetries) {
+                    Logger.error('Max retries reached. Sending message to Dead Letter Queue...', 'publishMessage');
+                    await this.sendToDeadLetterQueue({ message, attempt });
+                    Logger.error(`Failed to publish message to queue ${queueName} after ${maxRetries} attempts`, 'publishMessage');
+                    return false;
+                }
+
+                // Exponential backoff using TTL array
+                const delay = retryDelay[attempt - 1] ?? retryDelay[retryDelay.length - 1];
+                Logger.info(`Retrying in ${delay / 1000}s...`, 'publishMessage');
+                await 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
+     */
+    private async sendToDeadLetterQueue(request: { message: any; attempt: number }): Promise<void> {
+        const { message, attempt } = request;
+        try {
+            await this.checkConnectionAndChannel(); // Ensure connection and channel are alive before sending to DLQ
+            const dlqQueue = RABBITMQ.DLX_QUEUE_ETG;
+            const messageBuffer = Buffer.from(JSON.stringify(message));
+            const sent = this.channel!.sendToQueue(dlqQueue, messageBuffer, {
+                persistent: true,
+                headers: { 'x-retry-count': attempt },
+            });
+            if (sent) {
+                Logger.info(`Message sent to DLQ: ${dlqQueue} (attempts: ${attempt})`, 'sendToDeadLetterQueue');
+            } else {
+                Logger.error(`Failed to send message to DLQ: ${dlqQueue} — buffer full`, 'sendToDeadLetterQueue');
+            }
+        } catch (error) {
+            Logger.error(`Error sending message to DLQ: ${(error as 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
+     */
+    public async initializeConsumers(classInstance: any, consumerHandler: string, consumerErrorHandler: string): Promise<void> {
+        try {
+            Logger.info('Reached in initialize consumers', 'initializeConsumers');
+            const consumeQueues = configData?.consume_queues;
+            for (const queueName in consumeQueues) {
+                if (Object.prototype.hasOwnProperty.call(consumeQueues, queueName)) {
+                    await this.consumeMessage(queueName, classInstance, consumerHandler, consumerErrorHandler);
+                }
+            }
+        } catch (error: unknown) {
+            Logger.error('Error initializing consumers:', 'initializeConsumers', (error as Error).message);
+            throw new Error((error as 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
+     */
+    public async consumeMessage(
+        queueName: string,
+        classInstance: any,
+        consumerHandler: string,
+        consumerErrorHandler: string
+    ): Promise<void> {
+        Logger.info(`Reached: Consuming messages from queue ${queueName}`, 'consumeMessage');
+
+        await this.checkConnectionAndChannel();
+
+        await this.channel!.consume(queueName, async (message: any) => {
+            if (!message) return;
+
+            const msgData: any = JSON.parse(message.content.toString());
+            const headers = message.properties.headers || {};
+            const retryCount: number = headers['x-retry-count'] || 0;
+
+            const feedType = msgData?.message?.feed_type ?? msgData?.feed_type;
+            const retryDelayTTL = feedType === RABBITMQ_FEED_TYPE.OVR ? RABBITMQ.OVR_TTL : RABBITMQ.ETX_TTL;
+            const retryDelay:any = retryDelayTTL.split('|').map(Number);
+
+            const data: any = {
+                queue_name: queueName,
+                body: msgData?.message?.body ?? msgData?.body,
+                trace: msgData?.message?.trace ?? msgData?.trace,
+                retries: msgData?.message?.retries ?? msgData?.retries,
+                version: msgData?.message?.version ?? msgData?.version,
+                feed_type: msgData?.message?.feed_type ?? msgData?.feed_type,
+            };
+
+            try {
+                let success: any = {};
+
+                if (RABBITMQ.CONSUMER_RETRY_ERROR !== 'true' && RABBITMQ.CONSUMER_RETRY_ERROR !== true) {
+                    if (typeof classInstance[consumerHandler] === 'function') {
+                        Logger.info('Consumer handler call for processing the request', 'consumeMessage');
+                        success = await classInstance[consumerHandler]({ queueName, message: msgData });
+                    } else {
+                        Logger.error(`Method ${consumerHandler} not found on classInstance`, 'consumeMessage');
+                    }
+                }
+                if(success?.isMatch === true){
+                    if (success?.status) {
+                        Logger.info('Acknowledge the successful processing', 'consumeMessage');
+                        this.channel!.ack(message);
+                    } else {
+                        if (retryCount >= maxRetries) {
+                            Logger.error('Max retries reached. Sending message to Dead Letter Queue.', 'consumeMessage');
+                            await this.sendToDeadLetterQueue({ message: data, attempt: retryCount });
+
+                            if (typeof classInstance[consumerErrorHandler] === 'function') {
+                                classInstance[consumerErrorHandler](data);
+                            } else {
+                                Logger.error(`Method ${consumerErrorHandler} not found on classInstance`, 'consumeMessage');
+                            }
+                            this.channel!.nack(message, false, false);
+                        } else {
+                            const nextAttempt = retryCount + 1;
+                            if (data?.retries >= 0) {
+                                data.retries = nextAttempt;
+                            }
+                            const delayIndex = nextAttempt - 1 < retryDelay.length ? nextAttempt - 1 : retryDelay.length - 1;
+                            const delay = Number(retryDelay[delayIndex]);
+                            Logger.info(`Retrying in ${delay / 1000} seconds... (attempt ${nextAttempt} of ${maxRetries} ${data.feed_type})`, 'consumeMessage');
+                            await this.sendMessageToRetryQueue({ attempt: nextAttempt, data, retryDelayMs: delay, queueName });
+                            this.channel!.ack(message);
+                        }
+                    }
+            }
+            } catch (error) {
+                Logger.error('Error processing message', 'consumeMessage', { message: (error as Error).message });
+                await this.sendToDeadLetterQueue({ message: data, attempt: retryCount });
+
+                if (typeof classInstance[consumerErrorHandler] === 'function') {
+                    classInstance[consumerErrorHandler](data);
+                } else {
+                    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
+     */
+    private async sendMessageToRetryQueue(request: { attempt: number; data: any; retryDelayMs: number; queueName: string }): Promise<boolean> {
+        const { attempt, data, retryDelayMs, queueName } = request;
+        Logger.info(`Sending message to retry queue: ${queueName} (attempt: ${attempt}, delay: ${retryDelayMs}ms)`, 'sendMessageToRetryQueue');
+        try {
+            await this.checkConnectionAndChannel(); 
+            const retryQueueName = RABBITMQ.DLX_QUEUE_ETG_RETRY;
+            const messageBuffer = Buffer.from(JSON.stringify(data));
+            const sent = this.channel!.sendToQueue(retryQueueName, messageBuffer, {
+                headers: {
+                    'x-retry-count': attempt,
+                    toQueue: queueName,
+                },
+                expiration: retryDelayMs.toString(),
+                persistent: true,
+                mandatory: true
+            });
+            if (sent) {
+                Logger.info(`Message sent to retry queue: ${queueName} (attempt: ${attempt})`, 'sendMessageToRetryQueue');
+            } else {
+                Logger.error(`Failed to send message to retry queue: ${queueName} — buffer full`, 'sendMessageToRetryQueue');
+            }
+        return sent;
+        } catch (error) {
+            Logger.error(`Error sending message to retry queue: ${(error as Error).message}`, 'sendMessageToRetryQueue');
+            throw error;
+        }
+    }
+}