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

package/src/messageBroker/rabbitmq/MessageBroker.ts

@@ -1,525 +0,0 @@
-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;
-        }
-    }
-}