@autofleet/rabbit 3.0.0-alpha → 3.0.1-alpha

package/dist/index.js

@@ -143,13 +143,13 @@ class RabbitMq {
                 return resolve();
             }
             if (this.connection !== null) {
-                debug('rabbit: connection already exist');
                 if (this.options?.disableReconnect || this.connection?.isConnected()) {
+                    debug('rabbit: connection - is connected');
                     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
                     // @ts-ignore
                     return resolve(this.connection);
                 }
-                debug('rabbit: connection already exist - reconnecting');
+                debug('rabbit: connection - reconnecting');
             }
             if (this.creatingConnection) {
                 debug('rabbit: creating connection emi');
@@ -183,7 +183,7 @@ class RabbitMq {
             });
         });
     }
-    async getNewChannel({ name = '', onClose = null } = {}) {
+    async getNewChannel({ name = utils_1.rand().toString(), onClose = null } = {}) {
         return new Promise(async (resolve, reject) => {
             const connection = await this.getConnection();
             const channel = connection.createChannel({});
@@ -319,14 +319,14 @@ class RabbitMq {
     async consumeFromRabbit(queue, callback, options) {
         const optionsWithDefaults = { ...consts_1.DEFAULT_OPTIONS, ...options };
         RabbitMq.validateName('queue', queue);
-        const { limit, deadMessageTtl, useConsumeWithLock, lockTimeout, } = optionsWithDefaults;
+        const { limit, deadMessageTtl, useConsumeWithLock, lockTimeout, auditContext, } = optionsWithDefaults;
         if (useConsumeWithLock) {
             if (!this.redisLock) {
                 throw new Error('Usage of consumeWithLock requires RedisInstance');
             }
             logger_1.default.info(`rabbit: Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
         }
-        const channel = await this.getNewChannel({ name: `consume-${queue}` });
+        const channel = await this.getNewChannel({ name: `consume-queue-${queue}` });
         return channel.addSetup(async (c) => {
             await c.assertQueue(queue, options ? { messageTtl: options.messageTtl } : undefined);
             await c.prefetch(limit, true);
@@ -339,6 +339,9 @@ class RabbitMq {
                     const trace = outbreak_1.newTrace(outbreak_1.traceTypes.RABBIT);
                     trace?.context?.set(consts_1.TRACING_HEADER, traceId);
                 }
+                if (auditContext) {
+                    auditContext(queue);
+                }
                 const parsedMessage = RabbitMq.parseMsg(msg);
                 const releaseLock = await this.lockRedisIfNeeded(parsedMessage, optionsWithDefaults);
                 const shouldConsume = await this.shouldConsumeMessageByTimestamp(parsedMessage);
@@ -367,7 +370,7 @@ class RabbitMq {
         RabbitMq.validateName('exchange', exchange);
         RabbitMq.validateName('queue', queue);
         const { limit, deadMessageTtl } = optionsWithDefaults;
-        const channel = await this.getNewChannel();
+        const channel = await this.getNewChannel({ name: `consume-exchange-${exchange}-queue-${queue}` });
         return channel.addSetup(async (c) => {
             const assertExchange = await utils_1.assertExchangeFanout(c, exchange);
             await c.assertQueue(queue);

package/dist/lib/consts.d.ts

@@ -10,4 +10,5 @@ export declare const DEFAULT_OPTIONS: {
     deadMessageTtl: number;
     lockTimeout: number;
     useConsumeWithLock: boolean;
+    auditContext: null;
 };

package/dist/lib/consts.js

@@ -13,4 +13,5 @@ exports.DEFAULT_OPTIONS = {
     deadMessageTtl: exports.DEFAULT_DEAD_TTL_TWO_DAYS,
     lockTimeout: exports.DEFAULT_LOCK_TIMEOUT,
     useConsumeWithLock: exports.DEFAULT_USE_CONSUME_WITH_LOCK,
+    auditContext: null,
 };

package/dist/lib/types.d.ts

@@ -17,6 +17,7 @@ export interface ConsumeOptions {
     limit?: number;
     lockTimeout?: number;
     useConsumeWithLock?: boolean;
+    auditContext?: any;
 }
 export declare type CallbackFunction = (msg: ConsumeMessage, ack: any, nack: any) => Promise<any>;
 export declare type newChannelOpts = {

package/dist/lib/utils.d.ts

@@ -2,3 +2,4 @@ import { ChannelWrapper } from 'amqp-connection-manager';
 import { ConfirmChannel } from 'amqplib';
 export declare const assertExchangeFanout: (c: ChannelWrapper | ConfirmChannel, exchangeName: string) => Promise<import("amqplib").Replies.AssertExchange>;
 export declare const wrapSetImmediate: (callback: () => any) => Promise<any>;
+export declare const rand: () => number;

package/dist/lib/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.wrapSetImmediate = exports.assertExchangeFanout = void 0;
+exports.rand = exports.wrapSetImmediate = exports.assertExchangeFanout = void 0;
 exports.assertExchangeFanout = async (c, exchangeName) => c.assertExchange(exchangeName, 'fanout');
 exports.wrapSetImmediate = (callback) => new Promise((resolve, reject) => {
     setImmediate(async () => {
@@ -13,3 +13,4 @@ exports.wrapSetImmediate = (callback) => new Promise((resolve, reject) => {
         }
     });
 });
+exports.rand = () => Math.floor(Math.random() * 100000);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/rabbit",
-  "version": "3.0.0-alpha",
+  "version": "3.0.1-alpha",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/src/index.ts

@@ -12,7 +12,7 @@ import { getCurrentContext, newTrace, traceTypes } from '@autofleet/outbreak';
 import logger from './logger';
 import RabbitError from './lib/rabbitError';
 import getRedisInstance, { RedisConfig } from './lib/redis';
-import { assertExchangeFanout, wrapSetImmediate } from './lib/utils';
+import { assertExchangeFanout, rand, wrapSetImmediate } from './lib/utils';
 import {
   CONNECTION_CREATED_CONST,
   DEFAULT_LOCK_TIMEOUT,
@@ -259,13 +259,13 @@ class RabbitMq implements IAfRabbitMq {
         return resolve();
       }
       if (this.connection !== null) {
-        debug('rabbit: connection already exist');
         if (this.options?.disableReconnect || this.connection?.isConnected()) {
+          debug('rabbit: connection - is connected');
           // eslint-disable-next-line @typescript-eslint/ban-ts-comment
           // @ts-ignore
           return resolve(this.connection);
         }
-        debug('rabbit: connection already exist - reconnecting');
+        debug('rabbit: connection - reconnecting');
       }
       if (this.creatingConnection) {
         debug('rabbit: creating connection emi');
@@ -299,7 +299,7 @@ class RabbitMq implements IAfRabbitMq {
     });
   }
 
-  async getNewChannel({ name = '', onClose = null }: newChannelOpts = {}) {
+  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({});
@@ -455,7 +455,7 @@ class RabbitMq implements IAfRabbitMq {
     const optionsWithDefaults = { ...DEFAULT_OPTIONS, ...options };
     RabbitMq.validateName('queue', queue);
     const {
-      limit, deadMessageTtl, useConsumeWithLock, lockTimeout,
+      limit, deadMessageTtl, useConsumeWithLock, lockTimeout, auditContext,
     } = optionsWithDefaults;
     if (useConsumeWithLock) {
       if (!this.redisLock) {
@@ -463,7 +463,7 @@ class RabbitMq implements IAfRabbitMq {
       }
       logger.info(`rabbit: Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
     }
-    const channel: ChannelWrapper = await this.getNewChannel({ name: `consume-${queue}` });
+    const channel: ChannelWrapper = await this.getNewChannel({ name: `consume-queue-${queue}` });
     return channel.addSetup(async (c: ConfirmChannel) => {
       await c.assertQueue(queue, options ? { messageTtl: options.messageTtl } : undefined);
       await c.prefetch(limit, true);
@@ -480,6 +480,10 @@ class RabbitMq implements IAfRabbitMq {
             (trace as any)?.context?.set(TRACING_HEADER, traceId);
           }
 
+          if (auditContext) {
+            auditContext(queue);
+          }
+
           const parsedMessage = RabbitMq.parseMsg(msg);
           const releaseLock = await this.lockRedisIfNeeded(parsedMessage, optionsWithDefaults);
           const shouldConsume = await this.shouldConsumeMessageByTimestamp(parsedMessage);
@@ -512,7 +516,7 @@ class RabbitMq implements IAfRabbitMq {
     RabbitMq.validateName('exchange', exchange);
     RabbitMq.validateName('queue', queue);
     const { limit, deadMessageTtl } = optionsWithDefaults;
-    const channel: ChannelWrapper = await this.getNewChannel();
+    const channel: ChannelWrapper = await this.getNewChannel({ name: `consume-exchange-${exchange}-queue-${queue}` });
 
     return channel.addSetup(async (c: ConfirmChannel) => {
       const assertExchange = await assertExchangeFanout(c, exchange);

package/src/lib/consts.ts

@@ -10,4 +10,5 @@ export const DEFAULT_OPTIONS = {
   deadMessageTtl: DEFAULT_DEAD_TTL_TWO_DAYS,
   lockTimeout: DEFAULT_LOCK_TIMEOUT,
   useConsumeWithLock: DEFAULT_USE_CONSUME_WITH_LOCK,
+  auditContext: null,
 };

package/src/lib/types.ts

@@ -21,6 +21,7 @@ export interface ConsumeOptions {
   limit?: number;
   lockTimeout?: number;
   useConsumeWithLock?: boolean;
+  auditContext?: any;
 }
 
 export type CallbackFunction = (msg: ConsumeMessage, ack: any, nack: any) => Promise<any>

package/src/lib/utils.ts

@@ -12,3 +12,4 @@ export const wrapSetImmediate = (callback: () => any) => new Promise<any>((resol
     }
   });
 });
+export const rand = () => Math.floor(Math.random() * 100000);