@autofleet/rabbit 3.1.1 → 3.2.0

package/dist/index.d.ts

@@ -29,6 +29,7 @@ export interface AfRabbitOptions {
      * @default false
      */
     dontRetryAssert?: boolean;
+    rabbitHost?: string;
 }
 declare type newChannelOpts = {
     name?: string;
@@ -43,6 +44,7 @@ declare class RabbitMq implements IAfRabbitMq {
     static validateName(type: string, name: string): void;
     static getPublishOptions(customHeaders?: CustomMessageHeaders): {
         timestamp: number;
+        timeout: number;
         headers: {
             "x-af-user-id": any;
             "x-trace-id": any;
@@ -62,6 +64,9 @@ declare class RabbitMq implements IAfRabbitMq {
     options: AfRabbitOptions | undefined;
     redisClient: any;
     redisLock?: RedisLockType;
+    userName: string;
+    password: string;
+    host: string;
     /** Array of consumers tags used for canceling consumption */
     consumersTags: Array<[ConfirmChannel, string]>;
     private consumers;

package/dist/index.js

@@ -18,14 +18,10 @@ const consts_1 = require("./lib/consts");
 const types_1 = require("./lib/types");
 // const debug = nodeDebug('af-rabbitmq')
 const debug = logger_1.default.info;
-const USERNAME = process.env.RABBITMQ_USERNAME || 'guest';
-const PASSWORD = process.env.RABBITMQ_PASSWORD || 'guest';
-const HOST = process.env.RABBITMQ_SERVICE_HOST || 'localhost';
+const PUBLISH_TIMEOUT = 1000 * 10;
 const HEARTBEAT = '60';
 class RabbitMq {
     constructor(options, redisConfig) {
-        // PUBLISH_TIMEOUT = Number(process.env.RABBITMQ_PUBLISH_TIMEOUT) || 60000;
-        // PUBLISH_ERROR_MSG = `rabbit: publish timeout(${this.PUBLISH_TIMEOUT}ms) has pass, exchange: `;
         this.DISCONNECT_MSG = 'rabbit: connection disconnect';
         this.RECONNECT_MSG = 'rabbit: connection disconnect - reconnecting';
         this.consumers = [];
@@ -84,6 +80,9 @@ class RabbitMq {
                 });
             }
         };
+        this.userName = process.env.RABBITMQ_USERNAME || 'guest';
+        this.password = process.env.RABBITMQ_PASSWORD || 'guest';
+        this.host = options?.rabbitHost || process.env.RABBITMQ_SERVICE_HOST || 'localhost';
         this.em = new events_1.EventEmitter();
         this.channel = null;
         this.connection = null;
@@ -130,6 +129,7 @@ class RabbitMq {
         const outbreakTrace = zehut_1.outbreak.getCurrentContext();
         return {
             timestamp: moment_1.default().unix(),
+            timeout: PUBLISH_TIMEOUT,
             headers: {
                 creationTimestamp: moment_1.default().valueOf(),
                 ...customHeaders,
@@ -139,7 +139,7 @@ class RabbitMq {
         };
     }
     async getConnection() {
-        return new Promise(async (resolve) => {
+        return new Promise(async (resolve, reject) => {
             if (this.blockReconnect) {
                 debug('rabbit: block reconnect');
                 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -158,18 +158,34 @@ class RabbitMq {
             if (this.creatingConnection) {
                 debug('rabbit: creating connection emi');
                 this.em.once(consts_1.CONNECTION_CREATED_CONST, resolve);
+                this.em.once(consts_1.CONNECTION_FAILED_CONST, reject);
                 return;
             }
             this.creatingConnection = true;
-            debug('rabbit: creating connection', { HOST, USERNAME, HEARTBEAT });
-            const connection = await amqp_connection_manager_1.connect([`amqp://${USERNAME}:${PASSWORD}@${HOST}?heartbeat=${HEARTBEAT}}`]);
+            let isResolved = false;
+            debug('rabbit: creating connection', { host: this.host, userName: this.userName, HEARTBEAT });
+            const connection = await amqp_connection_manager_1.connect([`amqp://${this.userName}:${this.password}@${this.host}?heartbeat=${HEARTBEAT}}`]);
             this.connection = connection;
+            this.connection.on('error', (err) => {
+                logger_1.default.error('rabbit: connection error', { err });
+                if (!isResolved) {
+                    isResolved = true;
+                    reject(err);
+                    this.em.emit(consts_1.CONNECTION_FAILED_CONST, err);
+                }
+            });
+            this.connection.on('connectFailed', (err) => {
+                logger_1.default.error('rabbit: connection connectFailed', { err });
+                if (!isResolved) {
+                    isResolved = true;
+                    reject(err);
+                    this.em.emit(consts_1.CONNECTION_FAILED_CONST, err);
+                }
+            });
             this.connection.on('disconnect', ({ err }) => {
                 debug('rabbit: connection closed');
                 this.exchanges = {};
                 this.queues = {};
-                this.connection = null;
-                this.channel = null;
                 if (this.options?.disableReconnect) {
                     logger_1.default.error(`${this.DISCONNECT_MSG}${err && ` - ${err}`}`);
                     this.blockReconnect = true;
@@ -183,6 +199,7 @@ class RabbitMq {
                 await this.loadConsumers();
                 this.creatingConnection = false;
                 this.em.emit(consts_1.CONNECTION_CREATED_CONST, connection);
+                isResolved = true;
                 resolve(connection);
             });
         });
@@ -191,8 +208,13 @@ class RabbitMq {
         return new Promise(async (resolve, reject) => {
             const connection = await this.getConnection();
             const channel = connection.createChannel({});
+            let isResolved = false;
             channel.on('error', (err) => {
                 logger_1.default.error(`rabbit: channel ${name} error`, { err });
+                if (!isResolved) {
+                    isResolved = true;
+                    reject(err);
+                }
             });
             channel.on('close', (...args) => {
                 logger_1.default.error(`rabbit: channel ${name} closed`, { args });
@@ -202,6 +224,7 @@ class RabbitMq {
             });
             channel.once('connect', () => {
                 debug(`rabbit: channel ${name} CONNECTED`);
+                isResolved = true;
                 resolve(channel);
             });
         });
@@ -212,10 +235,9 @@ class RabbitMq {
                 return resolve(this.channel);
             }
             try {
-                const channel = await this.getNewChannel({
-                    onClose: () => {
-                        this.channel = null;
-                    },
+                const channel = await this.getNewChannel({});
+                channel.on('error', (err) => {
+                    logger_1.default.error('rabbit: channel error', { err });
                 });
                 this.channel = channel;
                 resolve(channel);
@@ -241,14 +263,12 @@ class RabbitMq {
         return channel.checkQueue(queue);
     }
     async deleteQueue(queue) {
-        return new Promise(async (resolve, reject) => {
-            RabbitMq.validateName('queue', queue);
-            const channel = await this.assertChannel();
-            logger_1.default.info('rabbit: deleting queue', { queue });
-            const deleteQueueRes = await channel.deleteQueue(queue);
-            debug('queue deleted', deleteQueueRes);
-            resolve(deleteQueueRes);
-        });
+        RabbitMq.validateName('queue', queue);
+        const channel = await this.assertChannel();
+        logger_1.default.info('rabbit: deleting queue', { queue });
+        const deleteQueueRes = await channel.deleteQueue(queue);
+        debug('queue deleted', deleteQueueRes);
+        return deleteQueueRes;
     }
     async bindQueue(queue, exchange) {
         const channel = await this.assertChannel();
@@ -414,12 +434,18 @@ class RabbitMq {
     }
     async sendToQueue(queue, content, options, customHeaders, isBlocking) {
         const callback = async () => {
-            RabbitMq.validateName('queue', queue);
-            await this.assertChannel();
-            await this.assertQueue(queue, options);
-            const res = await this.channel?.sendToQueue(queue, Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
-            debug(`rabbit: sending to queue ${queue}`, { res });
-            return res;
+            try {
+                RabbitMq.validateName('queue', queue);
+                await this.assertChannel();
+                await this.assertQueue(queue, options);
+                const res = await this.channel?.sendToQueue(queue, Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
+                debug(`rabbit: sending to queue ${queue}`, { res });
+                return res;
+            }
+            catch (e) {
+                logger_1.default.error(`rabbit: failed to send to queue ${queue}`, { e });
+                throw e;
+            }
         };
         if (isBlocking) {
             return callback();

package/dist/lib/consts.d.ts

@@ -6,6 +6,7 @@ export declare const USER_TRACING_HEADER = "x-af-user-id";
 export declare const USER_OBJECT = "userObject";
 export declare const DEFAULT_USE_CONSUME_WITH_LOCK = false;
 export declare const CONNECTION_CREATED_CONST = "connectionCreated";
+export declare const CONNECTION_FAILED_CONST = "connectionFailed";
 export declare const DEFAULT_OPTIONS: {
     limit: number;
     retries: number;

package/dist/lib/consts.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_OPTIONS = exports.CONNECTION_CREATED_CONST = exports.DEFAULT_USE_CONSUME_WITH_LOCK = exports.USER_OBJECT = exports.USER_TRACING_HEADER = exports.TRACING_HEADER = exports.RETRY_HEADER = exports.DEFAULT_LOCK_TIMEOUT = exports.DEFAULT_DEAD_TTL_TWO_DAYS = void 0;
+exports.DEFAULT_OPTIONS = exports.CONNECTION_FAILED_CONST = exports.CONNECTION_CREATED_CONST = exports.DEFAULT_USE_CONSUME_WITH_LOCK = exports.USER_OBJECT = exports.USER_TRACING_HEADER = exports.TRACING_HEADER = exports.RETRY_HEADER = exports.DEFAULT_LOCK_TIMEOUT = exports.DEFAULT_DEAD_TTL_TWO_DAYS = void 0;
 exports.DEFAULT_DEAD_TTL_TWO_DAYS = 60000 * 60 * 12;
 exports.DEFAULT_LOCK_TIMEOUT = 1000 * 5;
 exports.RETRY_HEADER = 'x-retry-count';
@@ -9,6 +9,7 @@ exports.USER_TRACING_HEADER = 'x-af-user-id';
 exports.USER_OBJECT = 'userObject';
 exports.DEFAULT_USE_CONSUME_WITH_LOCK = false;
 exports.CONNECTION_CREATED_CONST = 'connectionCreated';
+exports.CONNECTION_FAILED_CONST = 'connectionFailed';
 exports.DEFAULT_OPTIONS = {
     limit: 1,
     retries: 1,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/rabbit",
-  "version": "3.1.1",
+  "version": "3.2.0",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -9,7 +9,7 @@
     "example": "ts-node  src/example.ts",
     "build": "rm -rf dist && tsc",
     "linter": "./node_modules/.bin/eslint .",
-    "test": "jest --forceExit",
+    "test": "jest  --runInBand --forceExit",
     "test-local": "RABBITMQ_SERVICE_HOST=localhost:5672 jest --forceExit",
     "coverage": "jest --coverage --forceExit && rm -rf ./coverage",
     "dev": "nodemon"
@@ -37,6 +37,7 @@
     "eslint-config-airbnb-typescript": "^12.0.0",
     "eslint-plugin-import": "^2.22.1",
     "jest": "^27.0.5",
+    "node-tcp-proxy": "^0.0.28",
     "ts-jest": "^27.0.3",
     "ts-node": "^8.6.2",
     "typescript": "^3.8.3"

package/src/index.ts

@@ -17,6 +17,7 @@ import getRedisInstance, { RedisConfig } from './lib/redis';
 import { assertExchangeFanout, rand, wrapSetImmediate } from './lib/utils';
 import {
   CONNECTION_CREATED_CONST,
+  CONNECTION_FAILED_CONST,
   DEFAULT_LOCK_TIMEOUT,
   DEFAULT_OPTIONS,
   RETRY_HEADER,
@@ -37,6 +38,7 @@ import {
 // const debug = nodeDebug('af-rabbitmq')
 const debug = logger.info;
 
+const PUBLISH_TIMEOUT = 1000 * 10;
 export interface IAfRabbitMq {
   ack: any;
   nack: any;
@@ -64,6 +66,8 @@ export interface AfRabbitOptions {
    * @default false
    */
   dontRetryAssert?: boolean;
+
+  rabbitHost?: string;
 }
 
 type newChannelOpts = {
@@ -82,12 +86,6 @@ type AfConsumer = {
   options: ConsumeOptions | undefined;
 }
 
-const USERNAME: string = process.env.RABBITMQ_USERNAME || 'guest';
-
-const PASSWORD: string = process.env.RABBITMQ_PASSWORD || 'guest';
-
-const HOST: string = process.env.RABBITMQ_SERVICE_HOST || 'localhost';
-
 const HEARTBEAT = '60';
 
 class RabbitMq implements IAfRabbitMq {
@@ -118,6 +116,7 @@ class RabbitMq implements IAfRabbitMq {
     const outbreakTrace = outbreak.getCurrentContext();
     return {
       timestamp: moment().unix(),
+      timeout: PUBLISH_TIMEOUT,
       headers: {
         creationTimestamp: moment().valueOf(),
         ...customHeaders,
@@ -127,10 +126,6 @@ class RabbitMq implements IAfRabbitMq {
     };
   }
 
-  // PUBLISH_TIMEOUT = Number(process.env.RABBITMQ_PUBLISH_TIMEOUT) || 60000;
-
-  // PUBLISH_ERROR_MSG = `rabbit: publish timeout(${this.PUBLISH_TIMEOUT}ms) has pass, exchange: `;
-
   DISCONNECT_MSG = 'rabbit: connection disconnect';
 
   RECONNECT_MSG = 'rabbit: connection disconnect - reconnecting';
@@ -155,12 +150,24 @@ class RabbitMq implements IAfRabbitMq {
 
   redisLock?: RedisLockType;
 
+  userName: string;
+
+  password: string;
+
+  host: string;
+
   /** Array of consumers tags used for canceling consumption */
   consumersTags: Array<[ConfirmChannel, string]>;
 
   private consumers: Array<AfConsumer> = [];
 
   constructor(options?: AfRabbitOptions, redisConfig?: RedisConfig) {
+    this.userName = process.env.RABBITMQ_USERNAME || 'guest';
+
+    this.password = process.env.RABBITMQ_PASSWORD || 'guest';
+
+    this.host = options?.rabbitHost || process.env.RABBITMQ_SERVICE_HOST || 'localhost';
+
     this.em = new EventEmitter();
     this.channel = null;
     this.connection = null;
@@ -259,7 +266,7 @@ class RabbitMq implements IAfRabbitMq {
   }
 
   async getConnection() {
-    return new Promise<AmqpConnectionManager>(async (resolve) => {
+    return new Promise<AmqpConnectionManager>(async (resolve, reject) => {
       if (this.blockReconnect) {
         debug('rabbit: block reconnect');
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -278,18 +285,36 @@ class RabbitMq implements IAfRabbitMq {
       if (this.creatingConnection) {
         debug('rabbit: creating connection emi');
         this.em.once(CONNECTION_CREATED_CONST, resolve);
+        this.em.once(CONNECTION_FAILED_CONST, reject);
         return;
       }
       this.creatingConnection = true;
-      debug('rabbit: creating connection', { HOST, USERNAME, HEARTBEAT });
-      const connection: AmqpConnectionManager = await connect([`amqp://${USERNAME}:${PASSWORD}@${HOST}?heartbeat=${HEARTBEAT}}`]);
+      let isResolved = false;
+      debug('rabbit: creating connection', { host: this.host, userName: this.userName, HEARTBEAT });
+      const connection: AmqpConnectionManager = await connect([`amqp://${this.userName}:${this.password}@${this.host}?heartbeat=${HEARTBEAT}}`]);
       this.connection = connection;
+      this.connection.on('error', (err) => {
+        logger.error('rabbit: connection error', { err });
+        if (!isResolved) {
+          isResolved = true;
+          reject(err);
+          this.em.emit(CONNECTION_FAILED_CONST, err);
+        }
+      });
+
+      this.connection.on('connectFailed', (err) => {
+        logger.error('rabbit: connection connectFailed', { err });
+        if (!isResolved) {
+          isResolved = true;
+          reject(err);
+          this.em.emit(CONNECTION_FAILED_CONST, err);
+        }
+      });
+
       this.connection.on('disconnect', ({ err }) => {
         debug('rabbit: connection closed');
         this.exchanges = {};
         this.queues = {};
-        this.connection = null;
-        this.channel = null;
         if (this.options?.disableReconnect) {
           logger.error(`${this.DISCONNECT_MSG}${err && ` - ${err}`}`);
           this.blockReconnect = true;
@@ -302,6 +327,7 @@ class RabbitMq implements IAfRabbitMq {
         await this.loadConsumers();
         this.creatingConnection = false;
         this.em.emit(CONNECTION_CREATED_CONST, connection);
+        isResolved = true;
         resolve(connection);
       });
     });
@@ -310,10 +336,16 @@ class RabbitMq implements IAfRabbitMq {
   async getNewChannel({ name = rand().toString(), onClose = null }: newChannelOpts = {}) {
     return new Promise<ChannelWrapper>(async (resolve, reject) => {
       const connection: AmqpConnectionManager = await this.getConnection();
-      const channel = connection.createChannel({});
+      const channel = connection.createChannel({
+      });
 
+      let isResolved = false;
       channel.on('error', (err) => {
         logger.error(`rabbit: channel ${name} error`, { err });
+        if (!isResolved) {
+          isResolved = true;
+          reject(err);
+        }
       });
       channel.on('close', (...args) => {
         logger.error(`rabbit: channel ${name} closed`, { args });
@@ -323,6 +355,7 @@ class RabbitMq implements IAfRabbitMq {
       });
       channel.once('connect', () => {
         debug(`rabbit: channel ${name} CONNECTED`);
+        isResolved = true;
         resolve(channel);
       });
     });
@@ -336,9 +369,9 @@ class RabbitMq implements IAfRabbitMq {
 
       try {
         const channel = await this.getNewChannel({
-          onClose: () => {
-            this.channel = null;
-          },
+        });
+        channel.on('error', (err) => {
+          logger.error('rabbit: channel error', { err });
         });
         this.channel = channel;
         resolve(channel);
@@ -366,14 +399,12 @@ class RabbitMq implements IAfRabbitMq {
   }
 
   private async deleteQueue(queue: string) {
-    return new Promise(async (resolve, reject) => {
-      RabbitMq.validateName('queue', queue);
-      const channel: ChannelWrapper = await this.assertChannel();
-      logger.info('rabbit: deleting queue', { queue });
-      const deleteQueueRes = await channel.deleteQueue(queue);
-      debug('queue deleted', deleteQueueRes);
-      resolve(deleteQueueRes);
-    });
+    RabbitMq.validateName('queue', queue);
+    const channel: ChannelWrapper = await this.assertChannel();
+    logger.info('rabbit: deleting queue', { queue });
+    const deleteQueueRes = await channel.deleteQueue(queue);
+    debug('queue deleted', deleteQueueRes);
+    return deleteQueueRes;
   }
 
   async bindQueue(queue: string, exchange: string) {
@@ -578,14 +609,19 @@ class RabbitMq implements IAfRabbitMq {
     isBlocking?: boolean,
   ): Promise<boolean | undefined> {
     const callback = async (): Promise<boolean | undefined> => {
-      RabbitMq.validateName('queue', queue);
-      await this.assertChannel();
-      await this.assertQueue(queue, options);
-      const res = await this.channel?.sendToQueue(queue,
-        Buffer.from(JSON.stringify(content)),
-        RabbitMq.getPublishOptions(customHeaders));
-      debug(`rabbit: sending to queue ${queue}`, { res });
-      return res;
+      try {
+        RabbitMq.validateName('queue', queue);
+        await this.assertChannel();
+        await this.assertQueue(queue, options);
+        const res = await this.channel?.sendToQueue(queue,
+          Buffer.from(JSON.stringify(content)),
+          RabbitMq.getPublishOptions(customHeaders));
+        debug(`rabbit: sending to queue ${queue}`, { res });
+        return res;
+      } catch (e) {
+        logger.error(`rabbit: failed to send to queue ${queue}`, { e });
+        throw e;
+      }
     };
     if (isBlocking) {
       return callback();

package/src/lib/consts.ts

@@ -6,6 +6,7 @@ export const USER_TRACING_HEADER = 'x-af-user-id';
 export const USER_OBJECT = 'userObject';
 export const DEFAULT_USE_CONSUME_WITH_LOCK = false;
 export const CONNECTION_CREATED_CONST = 'connectionCreated';
+export const CONNECTION_FAILED_CONST = 'connectionFailed';
 export const DEFAULT_OPTIONS = {
   limit: 1,
   retries: 1,