@autofleet/rabbit 3.1.0 → 3.1.2

package/dist/index.js

@@ -128,15 +128,6 @@ class RabbitMq {
         const user = trace?.context?.get(consts_1.USER_OBJECT);
         const traceId = trace?.context?.get(consts_1.TRACING_HEADER);
         const outbreakTrace = zehut_1.outbreak.getCurrentContext();
-        const obj = Object.fromEntries(trace?.context);
-        const jsonString = JSON.stringify(obj);
-        logger_1.default.info('getPublishOptions', {
-            traceId,
-            user,
-            traceId2: outbreakTrace?.context?.get(consts_1.TRACING_HEADER),
-            traceContextSize: trace?.context?.size,
-            jsonString,
-        });
         return {
             timestamp: moment_1.default().unix(),
             headers: {
@@ -148,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
@@ -167,12 +158,30 @@ 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;
+            let isResolved = false;
             debug('rabbit: creating connection', { HOST, USERNAME, HEARTBEAT });
             const connection = await amqp_connection_manager_1.connect([`amqp://${USERNAME}:${PASSWORD}@${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 = {};
@@ -192,6 +201,7 @@ class RabbitMq {
                 await this.loadConsumers();
                 this.creatingConnection = false;
                 this.em.emit(consts_1.CONNECTION_CREATED_CONST, connection);
+                isResolved = true;
                 resolve(connection);
             });
         });
@@ -200,8 +210,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 });
@@ -211,6 +226,7 @@ class RabbitMq {
             });
             channel.once('connect', () => {
                 debug(`rabbit: channel ${name} CONNECTED`);
+                isResolved = true;
                 resolve(channel);
             });
         });
@@ -250,14 +266,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();
@@ -349,11 +363,13 @@ class RabbitMq {
                 }
                 const traceId = msg.properties.headers[consts_1.TRACING_HEADER];
                 const userId = msg.properties.headers[consts_1.USER_TRACING_HEADER];
-                logger_1.default.info('rabbit: consume', { traceId, userId, enableRabbitTrace });
                 const parsedMessage = RabbitMq.parseMsg(msg);
                 const releaseLock = await this.lockRedisIfNeeded(parsedMessage, optionsWithDefaults);
                 const trace = zehut_1.newTrace(zehut_1.traceTypes.RABBIT);
+                // setting also outbreak trace as part of legacy code
                 const outbreakTrace = zehut_1.outbreak.newTrace(zehut_1.traceTypes.RABBIT);
+                // enableRabbitTrace is a flag to protect from different flows that doesn't work with permission
+                // and we don't want to fail the flow because of it
                 if (userId && enableRabbitTrace) {
                     try {
                         await Promise.all([
@@ -366,24 +382,10 @@ class RabbitMq {
                         await this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg);
                     }
                 }
-                logger_1.default.info('rabbit consume - first trace', {
-                    trace,
-                    outbreakTrace,
-                    user: trace?.context?.get(consts_1.USER_OBJECT),
-                });
                 if (traceId) {
                     trace?.context?.set(consts_1.TRACING_HEADER, traceId);
                     outbreakTrace?.context.set(consts_1.TRACING_HEADER, traceId);
-                    logger_1.default.info('rabbit consume - second trace', {
-                        trace,
-                        outbreakTrace,
-                        user: trace?.context?.get(consts_1.USER_OBJECT),
-                        traceId: trace?.context?.get(consts_1.TRACING_HEADER),
-                    });
                 }
-                logger_1.default.info('rabbit consume - third trace', {
-                    trace: zehut_1.getCurrentPayload(),
-                });
                 if (auditContext) {
                     await auditContext(queue);
                 }

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.0",
+  "version": "3.1.2",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

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,
@@ -116,15 +117,6 @@ class RabbitMq implements IAfRabbitMq {
     const user = trace?.context?.get(USER_OBJECT);
     const traceId = trace?.context?.get(TRACING_HEADER);
     const outbreakTrace = outbreak.getCurrentContext();
-    const obj = Object.fromEntries(trace?.context);
-    const jsonString = JSON.stringify(obj);
-    logger.info('getPublishOptions', {
-      traceId,
-      user,
-      traceId2: outbreakTrace?.context?.get(TRACING_HEADER),
-      traceContextSize: trace?.context?.size,
-      jsonString,
-    });
     return {
       timestamp: moment().unix(),
       headers: {
@@ -268,7 +260,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
@@ -287,12 +279,32 @@ 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;
+      let isResolved = false;
       debug('rabbit: creating connection', { HOST, USERNAME, HEARTBEAT });
       const connection: AmqpConnectionManager = await connect([`amqp://${USERNAME}:${PASSWORD}@${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 = {};
@@ -311,6 +323,7 @@ class RabbitMq implements IAfRabbitMq {
         await this.loadConsumers();
         this.creatingConnection = false;
         this.em.emit(CONNECTION_CREATED_CONST, connection);
+        isResolved = true;
         resolve(connection);
       });
     });
@@ -321,8 +334,13 @@ class RabbitMq implements IAfRabbitMq {
       const connection: AmqpConnectionManager = await this.getConnection();
       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 });
@@ -332,6 +350,7 @@ class RabbitMq implements IAfRabbitMq {
       });
       channel.once('connect', () => {
         debug(`rabbit: channel ${name} CONNECTED`);
+        isResolved = true;
         resolve(channel);
       });
     });
@@ -375,14 +394,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) {
@@ -493,11 +510,13 @@ class RabbitMq implements IAfRabbitMq {
 
           const traceId = msg.properties.headers[TRACING_HEADER];
           const userId = msg.properties.headers[USER_TRACING_HEADER];
-          logger.info('rabbit: consume', { traceId, userId, enableRabbitTrace });
           const parsedMessage = RabbitMq.parseMsg(msg);
           const releaseLock = await this.lockRedisIfNeeded(parsedMessage, optionsWithDefaults);
           const trace = newTrace(traceTypes.RABBIT);
+          // setting also outbreak trace as part of legacy code
           const outbreakTrace = outbreak.newTrace(traceTypes.RABBIT);
+          // enableRabbitTrace is a flag to protect from different flows that doesn't work with permission
+          // and we don't want to fail the flow because of it
           if (userId && enableRabbitTrace) {
             try {
               await Promise.all([
@@ -510,27 +529,11 @@ class RabbitMq implements IAfRabbitMq {
             }
           }
 
-          logger.info('rabbit consume - first trace', {
-            trace,
-            outbreakTrace,
-            user: trace?.context?.get(USER_OBJECT),
-          });
-
           if (traceId) {
             (trace as any)?.context?.set(TRACING_HEADER, traceId);
             (outbreakTrace as any)?.context.set(TRACING_HEADER, traceId);
-            logger.info('rabbit consume - second trace', {
-              trace,
-              outbreakTrace,
-              user: trace?.context?.get(USER_OBJECT),
-              traceId: trace?.context?.get(TRACING_HEADER),
-              // traceId2: outbreakTrace?.context?.get(TRACING_HEADER),
-            });
           }
 
-          logger.info('rabbit consume - third trace', {
-            trace: getCurrentPayload(),
-          });
           if (auditContext) {
             await auditContext(queue);
           }

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,