@platform-x/hep-message-broker-client 1.0.1 → 1.1.2

package/src/Util/logger.ts

@@ -0,0 +1,219 @@
+import bunyan from 'bunyan';
+import config from '../config/index';
+import bformat from 'bunyan-format';
+import { getTraceId, getSpanId } from './requestTracer';
+import _ from 'lodash';
+export interface payLoadInterface {
+  statusCode?: number;
+  data?: any;
+}
+
+export interface LoggerInterface {
+  info(message: string, method: string): void;
+  warn(message: string, method: string, payload?: object): void;
+  error(message: string, method: string, payload?: object): void;
+  debug(message: string, method: string, payload?: object): void;
+}
+
+export class LoggerClass implements LoggerInterface {
+  private logger: bunyan;
+  private infoLevel: boolean = false;
+  private debugLevel: boolean = false;
+  private errorLevel: boolean = false;
+  private warnLevel: boolean = false;
+  private blockedKeywords = ['currentPassword', 'clientSecret', 'newPassword'];
+
+  constructor() {
+    this.mapLogLevels();
+    this.logger = bunyan.createLogger({
+      name: config.APP_NAME,
+      level: 'trace', // by default enabling all levels, controlled through env separately
+      stream: bformat({
+        outputMode: config.NODE_ENV === 'development' ? 'short' : 'bunyan',
+        levelInString: true,
+        color: true,
+      }),
+    });
+  }
+  /**
+   * It's written to handle JSON.circular error
+   * @param obj
+   * @returns
+   */
+  public customstringify(obj: any) {
+    let cache: any = [];
+    let str = JSON.stringify(obj, (key, value) => {
+      {
+        this.info(`Logger customstringify ${key}`, 'customstringify');
+        if (typeof value === 'object' && value !== null) {
+          if (cache.indexOf(value) !== -1) {
+            // Circular reference found, discard key
+            return;
+          }
+          // Store value in our collection 
+          cache.push(value);
+        }
+        return value;
+      }
+    });
+    cache = null; // reset the cache
+    return str;
+  }
+  /**
+   * for info log
+   * @param message
+   * @param payload
+   * @param method
+   * @returns
+   */
+  public info(message: string, method: string) {
+    if (!this.infoLevel) {
+      return;
+    }
+    let loggerParams = {
+      message,
+      method,
+      traceId: getTraceId(),
+    };
+    this.logger.info(` start ${JSON.stringify(loggerParams)}==end`);
+  }
+  /**
+   * for warn log
+   * @param message
+   * @param payload
+   * @param method
+   * @returns
+   */
+  public warn(message: string, method: string, payload?: any) {
+    if (!this.warnLevel) {
+      return;
+    }
+    let loggerParams = {
+      message,
+      method,
+      traceId: getTraceId(),
+      statusCode: payload?.statusCode,
+    };
+
+    let finalPayload = payload?.length ? payload : {};
+    this.logger.warn(
+      ` start ${JSON.stringify(loggerParams)} payload: ${this.customstringify(
+        this.sanitizeLog(finalPayload)
+      )}==end`
+    );
+  }
+  /**
+   * for error log
+   * @param message
+   * @param payload
+   * @param method
+   * @returns
+   */
+  public error(message: string, method: string, payload?: any) {
+    if (!this.errorLevel) {
+      return;
+    }
+
+    if (payload instanceof Error) {
+      payload = {
+        message,
+        method,
+        traceId: getTraceId(),
+        stack: payload?.stack,
+      };
+    }
+    let loggerParams = {
+      message,
+      method,
+      traceId: getTraceId(),
+      spanId: getSpanId(),
+      statusCode: payload?.statusCode,
+    };
+
+    let finalPayload = payload?.length ? payload : {};
+    this.logger.error(
+      ` start ${JSON.stringify(loggerParams)} payload: ${this.customstringify(
+        this.sanitizeLog(finalPayload)
+      )}==end`
+    );
+  }
+  /**
+   * for debug log
+   * @param message
+   * @param payload
+   * @param method
+   * @returns
+   */
+  public debug(message: string, method: string, payload?: any) {
+    if (!this.debugLevel) {
+      return;
+    }
+
+    let loggerParams = {
+      message,
+      method,
+      traceId: getTraceId(),
+      statusCode: payload?.statusCode,
+    };
+
+    let finalPayload = payload?.length ? payload : {};
+    this.logger.debug(
+      ` start ${JSON.stringify(loggerParams)} payload: ${this.customstringify(
+        this.sanitizeLog(finalPayload)
+      )}==end`
+    );
+  }
+  /**
+   * to map log levels and handle from config
+   */
+  private mapLogLevels() {
+    if (config.LOG_LEVELS.length) {
+      config.LOG_LEVELS.forEach((element: string) => {
+        const logLevel = element.trim();
+        if (logLevel === 'info') {
+          this.infoLevel = true;
+        } else if (logLevel === 'debug') {
+          this.debugLevel = true;
+        } else if (logLevel === 'error') {
+          this.errorLevel = true;
+        } else if (logLevel === 'warn') {
+          this.warnLevel = true;
+        }
+      });
+    }
+  }
+  /**
+   * to sanitize logs from unwanted fields to be shown
+   * @param request
+   * @returns
+   */
+  private sanitizeLog(request: any) {
+    try {
+      if (request) {
+        // let obj: any = {};
+        Object.keys(request).forEach((key) => {
+          let value = request[key];
+          if (request[key] === 'options') {
+            delete request.options;
+          } else {
+            if (
+              this.blockedKeywords.find(
+                (blockedKey: any) =>
+                  key.toLowerCase() === blockedKey.toLowerCase()
+              )
+            ) {
+              request[key] = 'XXXXXXXXXX';
+            } else {
+              request[key] = value;
+            }
+          }
+        });
+        return request;
+      }
+    } catch (err: any) {
+      this.error('Logger sanitize error', err);
+    }
+  }
+}
+
+export const Logger = new LoggerClass();

package/src/Util/requestTracer.ts

@@ -0,0 +1,28 @@
+import { NextFunction, Request, Response } from 'express';
+import cls from 'cls-hooked';
+import { v4 as uuidv4 } from 'uuid';
+
+const TRACE_ID_HEADER_NAME = 'Platform-X-Trace-Id';
+const nsid = `rtracer:${uuidv4()}`;
+const ns = cls.createNamespace(nsid);
+const traceIdKey = 'traceId';
+const spanIdKey = 'spanId';
+/**
+ * setTracers - to set the request tracers on the request
+ */
+export const setTracers = (req: Request, res: Response, next: NextFunction) => {
+  const headerName = TRACE_ID_HEADER_NAME.toLocaleLowerCase();
+  ns.bindEmitter(req);
+  ns.bindEmitter(res);
+  const traceId = req.headers[headerName] || uuidv4(); // to be passed in headers
+  const spanId = uuidv4(); // will be unique for services
+
+  ns.run(() => {
+    ns.set(traceIdKey, traceId);
+    ns.set(spanIdKey, spanId);
+    next();
+  });
+};
+
+export const getTraceId = () => ns.get(traceIdKey);
+export const getSpanId = () => ns.get(spanIdKey);

package/src/config/ConfigManager.ts

@@ -0,0 +1,35 @@
+import * as fs from "fs";
+import config from "./index";
+import { Logger } from '../Util/logger';
+
+class ConfigManager {
+    private static instance: ConfigManager;
+    private config: any;
+    private constructor() {
+        this.config = {};
+        this.loadConfig(config.RABBITMQ.CONFIG_PATH);
+    }
+
+    public static getInstance(): ConfigManager {
+        if (!ConfigManager.instance) {
+            ConfigManager.instance = new ConfigManager();
+        }
+        return ConfigManager.instance;
+    }
+
+    public loadConfig(configPath: string): void {
+        if (fs.existsSync(configPath)) {
+            // Do something
+            this.config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        }else{
+            Logger.error("Config file missing!", "loadConfig") 
+        }
+        
+    }
+
+    public getConfig(): any {
+        return this.config;
+    }
+}
+
+export default ConfigManager;

package/src/config/index.ts

@@ -0,0 +1,31 @@
+import dotenv from 'dotenv';
+dotenv.config();
+process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+
+export default {
+  LOG_LEVELS: ['info', 'error', 'warn', 'debug'],
+  NODE_ENV: 'development',
+  APP_NAME: 'hep-message-broker-client',
+  RABBITMQ: {
+    USER: process.env.RABBITMQ_USER??'root',
+    PASS: process.env.RABBITMQ_PASS??'root',
+    HOST: process.env.RABBITMQ_HOST??'127.0.0.1',
+    PORT: process.env.RABBITMQ_PORT??'5672',
+    MAIN_QUEUE: 'main_queue',
+    MAIN_EXCHANGE: 'assets_metadata_generate_exchange',
+    DLX_QUEUE: 'dead_letter_queue',
+    DLX_EXCHANGE: 'assets_dlx_exchange',
+    RETRY_QUEUE: 'retry_queue',
+    RETRY_EXCHANGE: 'assets_metadata_generate_retry_exchange',
+    MAX_RETRIES: Number(process.env.RABBITMQ_MAX_RETRIES?.trim() ?? 1),
+    HEARTBEAT: Number(process.env.RABBITMQ_HEARTBEAT?.trim() ?? 5),
+    TTL:process.env.RABBITMQ_TTL??"3000|6000|9000",
+    BACKOFF_TIME:Number(process.env.BACKOFF_TIME?.trim() ?? 1000),
+    IS_ENABLED: process.env.RABBITMQ_IS_ENABLED ?? 'true',
+    RABBITMQ_CONFIG: process.env.RABBITMQ_CONFIG ?? '',
+    PREFETCH_COUNT: Number(process.env.RABBITMQ_PREFETCH ?? 50),
+    CONNECTION_ERROR:process.env.RABBITMQ_CONNECTION_ERROR ?? false,
+    PUBLISHER_ERROR:process.env.RABBITMQ_PUBLISHER_ERROR ?? false,
+    CONSUMER_ERROR:process.env.RABBITMQ_CONSUMER_ERROR ?? false,
+    CONFIG_PATH: process.env.CONFIG_PATH ?? '/etc/rabbitmq/rabbitMQConfig.json',
+  }}

package/src/index.ts

@@ -0,0 +1,73 @@
+
+import { MessageBrokerClient } from "./messageBroker/rabbitmq/MessageBrokerClient";
+// const messageBrokerClient = new MessageBrokerClient();
+// let initial_message = {
+//     message: {
+//         'queue_name': 'image_thumbnail_request_queue',
+//         'body': {
+//             'url': 'https://dev.dam.hcl-x.com/server/api/core/bitstreams/43817aff-ebb7-47d2-be0e-fb4db1ab267a/content',
+//             'file_name': 'Kudos (1)',
+//             'destination_path': '1721365841379/public/png',
+//             'visibility': 'public', 
+//             'urgency': 0,
+//             'folder_name': '',
+//             'bitstream_id': '43817aff-ebb7-47d2-be0e-fb4db1ab267a',
+//             'ext': 'png',
+//             'asset_type': 'Image',
+//             'item_id': 'b1ff157e-a04f-4f8c-83b5-3a2ead732101',
+//         },
+//         'item_id': 'b1ff157e-a04f-4f8c-83b5-3a2ead732101',
+//         "language": "en",
+//         'retries': 0,
+//     },
+//     corelationId: 'lgkdkfgkkfd',
+//     version: 0,
+//     trace: '',
+// };
+
+// let initial_message = { 
+//     "message":{ 
+//       "queue_name":"summary_request_queue", 
+//       "body":{ 
+// 			"input": "€ !~!@#$%^&*()_++_<><?:{}[];,./ Hi everyone, good afternoon. Hope you all are doing good. Myself Akshima, Daitishin from Hetzial Healthcare. So today I am going to discuss about weight loss platy. We all must be aware about what is a weight loss platy. This is a term which we all come across when we are focusing on our weight loss journey. ",     
+// 			"language": "hi",     
+// 			"max_length": 20,     
+// 			"min_length": 10 
+//       }, 
+//       "language": "en", 
+// 	  "correlationId":"", 
+//       "retries": 0 
+//     }
+// };  
+ 
+// console.log(initial_message)
+// async function testConnection() {
+    // await messageBrokerClient.initialize().then(async () => { 
+    //    return ''; 
+        // setInterval(() => {
+            // messageBrokerClient.initializeConsumers();
+            // messageBrokerClient.publishMessage( { queueName: 'summary_request_queue', exchangeName:"assets_metadata_generate_exchange", message: initial_message })
+        
+    // }, 1);
+//     }); 
+// }
+ 
+// testConnection(); 
+
+
+
+
+
+
+
+export { MessageBrokerClient };
+let injectedSecretService: any = null;
+export const initIAMSecretsMessageBroker = (secretServiceIns: any) =>{
+  injectedSecretService = secretServiceIns;
+}
+export const getIAMSecrets = async() =>{
+  if (!injectedSecretService) {
+    throw new Error("IAM secrets not initialized");
+  }
+  return await injectedSecretService.getSecretKeys(); // returns cached data
+}

package/src/messageBroker/BaseRabbitMQClient.ts

@@ -0,0 +1,30 @@
+import * as amqp from 'amqplib';
+import ConfigManager from '../config/ConfigManager';
+import config from '../config';
+import ConnectionManager from './ConnectionManager';
+
+class BaseRabbitMQClient{
+    public readonly configManager: ConfigManager;
+    public readonly connectionManager: ConnectionManager = new ConnectionManager();
+    protected connection: amqp.Connection | undefined;
+    protected channel: amqp.Channel | undefined;
+    protected configData: any = {};
+    constructor() {
+        this.configManager = ConfigManager.getInstance();
+        this.configData = this.configManager.getConfig();
+        this.channel = this.connectionManager.getChannel();
+        this.connection = this.connectionManager.getConnection();
+        this.init();
+    }
+
+     /**
+     * Function for load the config data
+     */
+     private init() {
+        this.configManager.loadConfig(config?.RABBITMQ?.CONFIG_PATH);
+        this.configData = this.configManager.getConfig();
+    }
+    
+}
+
+export default BaseRabbitMQClient;

package/src/messageBroker/ConnectionManager.ts

@@ -0,0 +1,182 @@
+// Import the amqplib library for RabbitMQ
+import * as amqp from 'amqplib';
+import { Logger } from '../Util/logger';
+import ConfigManager from '../config/ConfigManager';
+import config from '../config';
+let isConnectionOpen = false;
+let MAX_RETRIES: number = 1;
+
+
+interface ConnectionWrapper {
+    connection: amqp.Connection,
+    channel: amqp.Channel
+}
+
+class ConnectionManager {
+    private static instance: ConnectionManager;
+    private readonly configManager: ConfigManager;
+    protected connection: amqp.Connection | undefined;
+    protected channel: amqp.Channel | undefined;
+    protected configData: any = {};
+    constructor() {
+        this.configManager = ConfigManager.getInstance();
+        this.init();
+    }
+    
+    /**
+     * Function for get channel
+     */
+    public getChannel():amqp.Channel | undefined{
+        return this.channel;
+    }
+
+    /**
+     * Function for get channel
+     */
+    public getConnection():amqp.Connection | undefined{
+        return this.connection;
+    }
+
+    /**
+     * Function for create and return intance
+     * @returns
+     */
+    public static async getInstance(): Promise<ConnectionManager> {
+        if (!ConnectionManager.instance) {
+            ConnectionManager.instance = new ConnectionManager();
+        }
+        return ConnectionManager.instance;
+    }
+
+    /**
+      * Function to connect create to RabbitMQ
+      */
+    public async createConnection(): Promise<ConnectionWrapper> {
+        try {
+            Logger.info('Reached to createConnection', 'createConnection');
+            this.configManager.loadConfig(config?.RABBITMQ?.CONFIG_PATH);
+            let url: string = `amqp://${this.configData?.username}:${this.configData?.password}@${this.configData?.host}`;
+            // Create a connection to RabbitMQ server
+            this.connection = await amqp.connect(url, { heartbeat: this.configData?.heartbeat });
+            isConnectionOpen = true;
+            // check the connection status
+            this.bindConnectionEventHandler();
+            // create channel
+            this.channel = await this.connection.createConfirmChannel();
+            Logger.info('RabbitMQ connected successfully! ', 'createConnection');
+            // create exchange and queue and bind with exchange
+            await this.setupQueuesAndExchanges();
+            const connectionWrapper: ConnectionWrapper = { connection: this.connection, channel: this.channel }
+            return connectionWrapper;
+        } catch (error) {
+            // Log and rethrow any errors that occur during connection
+            Logger.error('Failed to connect to RabbitMQ', 'connection', (error as Error)?.message);
+            return { connection: null, channel: null } as unknown as ConnectionWrapper;
+        }
+    }
+
+    /**
+     * Function for bind connection event handler on close and error setupQueuesAndExchanges
+     * @returns 
+     */
+    private bindConnectionEventHandler():boolean {
+        try {
+            this.connection?.on('close', (err: any) => {
+                Logger.error(`RabbitMQ: bindConnectionEventHandler:close`, `Connection closed`, err);
+                isConnectionOpen = false;
+            });
+            this.connection?.on('error', (err: any) => {
+                Logger.error(`RabbitMQ: bindConnectionEventHandler:error`, `Connection error`, err);
+                isConnectionOpen = false;
+            });
+            return isConnectionOpen;
+        } catch (error) {
+            isConnectionOpen = false;
+            return isConnectionOpen;
+        }
+
+    }
+
+    /**
+      * Function to check the status of the connection
+      * @returns boolean
+    */
+    public async isConnected(): Promise<boolean> {
+        return isConnectionOpen;
+    };
+
+
+    /**
+        * Function to initialize the connection, channel and setup the queues and exchanges
+        * @param reqData
+        * @returns 
+    */
+    public async initialize() {
+        Logger.info('Reached to initialize', 'initialize');
+        let retries: number = 0;
+        MAX_RETRIES = this.configData?.max_retries;
+        // Retrie times connection
+        while (retries < MAX_RETRIES) {
+            try {
+                await this.createConnection();
+                return { connection:this.connection, channel:this.channel };
+            } catch (err) {
+                retries++;
+                Logger.error('initialize:Failed to connect to RabbitMQ', `Attempt ${retries} of ${MAX_RETRIES}.`);
+                if (retries >= MAX_RETRIES) {
+                    Logger.error('Max retries reached, cannot connect to RabbitMQ.', 'initialize');
+                    return { connection:this.connection, channel:this.channel };
+                }
+                // Wait before retrying (e.g., 10 seconds)
+                await new Promise(resolve => setTimeout(resolve, 10000));
+            }
+        }
+    };
+
+    /**
+      * Function to setup the queues and exchanges
+      * @params array
+      * @rtrun 
+    */
+    private async setupQueuesAndExchanges():Promise<void> {
+        Logger.info('Reached to setupQueuesAndExchanges', 'setupQueuesAndExchanges');
+        try {
+            let exchanges: any = this.configData.exchanges;
+            let queues: any = this.configData.queues;
+            let bindings: any = this.configData.bindings;
+            // Declare the exchange with dlx 
+            for (let data of exchanges) {
+                await this.channel?.assertExchange(data?.name, data.type, { durable: data.durable, autoDelete: data.autoDelete });
+                Logger.info(`${data?.name} exchange created`, 'setupQueuesAndExchanges');
+            }
+
+            // Declare the queues with dlx
+            for (let data of queues) {
+                await this.channel?.assertQueue(data?.name, { durable: data.durable, exclusive: data.exclusive, autoDelete: data.autoDelete, arguments: data.arguments });
+                Logger.info(`${data?.name} queue created `, 'setupQueuesAndExchanges');
+            }
+
+            // Declare the bindings for queues and exchanges with routing keys
+            for (let obj in bindings) {
+                bindings[obj]?.forEach(async (key: any) => {
+                    await this.channel?.bindQueue(key?.queue, obj, key?.routingKey);
+                    Logger.info(`${key?.queue} bind with exchange name ${obj} and routing key ${key?.routingKey}`, 'setupQueuesAndExchanges');
+                })
+            }
+        } catch (error) {
+            Logger.error("Error on setup queues, exchanges and binding", 'setupQueuesAndExchanges', (error as Error).message);
+            throw error;
+        }
+    };
+
+    /**
+     * Function for load the config data
+     */
+    private init() {
+        this.configManager.loadConfig(config?.RABBITMQ?.CONFIG_PATH);
+        this.configData = this.configManager.getConfig();
+    }
+
+}
+
+export default ConnectionManager;

package/src/messageBroker/MessageBrokerClient.ts

@@ -0,0 +1,88 @@
+import config from '../config';
+import ConfigManager from '../config/ConfigManager';
+import ConnectionManager from './ConnectionManager';
+import { IMessageBrokerClient } from './interface/IMessageBrokerClient';
+import MessageProducer from './MessageProducer';
+import { RabbitMQClient } from './RabbitMQClient';
+import RetryManager from './RetryManager';
+import { PublishMessageInputType } from './types/PublishMessageInputType';
+const connectionManager =  ConnectionManager.getInstance();
+export class MessageBrokerClient implements IMessageBrokerClient {
+  private readonly rabbitMQClient: RabbitMQClient;
+  private readonly messageProducer: MessageProducer;
+  private readonly configManager: ConfigManager;
+  // private readonly retryManager: RetryManager<T>;
+  private readonly isEnabledRabbitMQ: boolean = false;
+  private readonly configData: any = {};
+  constructor() {
+    this.rabbitMQClient = new RabbitMQClient();
+    this.messageProducer = new MessageProducer();
+    this.isEnabledRabbitMQ = config?.RABBITMQ?.IS_ENABLED === 'true';
+    this.configManager = ConfigManager.getInstance();
+    this.configData = this.configManager.getConfig();
+  }
+
+  /**
+   * Function to initialize the RabbitMQ connection
+   */
+  async initialize(): Promise<void> {
+    if(this.isEnabledRabbitMQ){
+      this.rabbitMQClient.initialize();
+    }
+  }
+
+  /**
+   * Function to close the connection and channel
+   */
+  disconnect(): void {
+    if(this.isEnabledRabbitMQ){
+      this.rabbitMQClient.disconnect();
+    }
+  }
+
+  /**
+   * Function to publish a message with retry
+   * @param request 
+   * @returns 
+   */
+  publishMessage(request:PublishMessageInputType): Promise<boolean> {
+    if(this.isEnabledRabbitMQ){
+      const boundPublishMessage = this.messageProducer.publishMessage.bind(this);
+      const boundConsumerHandler = this.messageProducer.messageHandler.bind(this);
+      let retry_delay = this.configData?.retry_delay;
+      let max_retries = this.configData?.max_retries;
+      // Instantiate RetryManager
+      const retryManager = RetryManager.getInstance<PublishMessageInputType>(max_retries, retry_delay);
+      retryManager.performActionWithRetry(boundPublishMessage, request, boundConsumerHandler)
+    }
+    return Promise.resolve(false);
+  }
+
+  /**
+   * Function to publish a message with retry to exchange
+   * @param request 
+   * @returns 
+   */
+  publishMessageToExchange(request:PublishMessageInputType): Promise<boolean> {
+    if(this.isEnabledRabbitMQ){
+      const boundPublishMessage = this.messageProducer.publishMessageToExchange.bind(this);
+      const boundConsumerHandler = this.messageProducer.messageHandler.bind(this);
+      let retry_delay = this.configData?.retry_delay;
+      let max_retries = this.configData?.max_retries;
+      // Instantiate RetryManager
+      const retryManager = RetryManager.getInstance<PublishMessageInputType>(max_retries, retry_delay);
+      retryManager.performActionWithRetry(boundPublishMessage, request, boundConsumerHandler)
+    }
+    return Promise.resolve(false);
+  }
+  /***
+   * Function to check if the connection is established
+   */
+  async isConnected(): Promise<boolean> {
+    if(this.isEnabledRabbitMQ){
+      return (await connectionManager) ? (await connectionManager).isConnected() : Promise.resolve(false);
+    }
+    return Promise.resolve(false);
+  }
+
+}