@autofleet/rabbit 2.0.4-beta5 → 2.0.4

package/dist/index.d.ts

@@ -22,6 +22,9 @@ export interface AfRabbitOptions {
 declare class RabbitMq implements IAfRabbitMq {
     static parseMsg(msg: any): any;
     static validateName(type: string, name: string): void;
+    static getPublishOptions(): {
+        timestamp: number;
+    };
     PUBLISH_TIMEOUT: number;
     PUBLISH_ERROR_MSG: string;
     DISCONNECT_MSG: string;
@@ -32,11 +35,7 @@ declare class RabbitMq implements IAfRabbitMq {
     creatingConnection: boolean;
     exchanges: ExchangesCache;
     options: AfRabbitOptions | undefined;
-    logger: any;
-    constructor({ options, logger }?: {
-        options?: AfRabbitOptions;
-        logger?: any;
-    });
+    constructor(options?: AfRabbitOptions);
     ack: (channel: ChannelWrapper) => (msg: any) => Promise<void>;
     nack: (channel: ChannelWrapper, queue: string, options: any, deadQueueOptions: Options.AssertQueue) => (msg: any, { skipRetry, }?: any) => Promise<void>;
     getConnection(): Promise<AmqpConnectionManager>;

package/dist/index.js

@@ -34,6 +34,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 /* eslint-disable @typescript-eslint/ban-ts-comment,@typescript-eslint/ban-types,@typescript-eslint/no-unused-vars,consistent-return,no-async-promise-executor,no-param-reassign,no-empty */
 // eslint-disable-next-line max-classes-per-file
 const bluebird = __importStar(require("bluebird"));
+const moment_1 = __importDefault(require("moment"));
 const amqp_connection_manager_1 = require("amqp-connection-manager");
 const events_1 = require("events");
 const outbreak_1 = require("@autofleet/outbreak");
@@ -45,20 +46,9 @@ const defaultOptions = {
     deadMessageTtl: DEFAULT_DEAD_TTL_TWO_DAYS,
 };
 const assertExchangeFanout = (c, exchangeName) => c.assertExchange(exchangeName, 'fanout');
-const callbackWithTimeout = (callback, args, timeout, timeoutMessage = 'Timeout while ack message') => __awaiter(void 0, void 0, void 0, function* () {
-    yield new bluebird.Promise((resolve, reject) => __awaiter(void 0, void 0, void 0, function* () {
-        try {
-            yield callback(...args);
-            return resolve();
-        }
-        catch (e) {
-            return reject(e);
-        }
-    })).timeout(timeout, timeoutMessage);
-});
 const connectionCreatedConst = 'connectionCreated';
 class RabbitMq {
-    constructor({ options, logger } = {}) {
+    constructor(options) {
         this.PUBLISH_TIMEOUT = Number(process.env.RABBITMQ_PUBLISH_TIMEOUT) || 60000;
         this.PUBLISH_ERROR_MSG = `rabbit: publish timeout(${this.PUBLISH_TIMEOUT}ms) has pass, exchange: `;
         this.DISCONNECT_MSG = 'rabbit: connection disconnect';
@@ -88,7 +78,6 @@ class RabbitMq {
         this.creatingConnection = false;
         this.exchanges = {};
         this.options = options;
-        this.logger = logger;
     }
     static parseMsg(msg) {
         let { content } = msg;
@@ -104,6 +93,11 @@ class RabbitMq {
             throw new rabbitError_1.default(`error while using ${type} with no name`);
         }
     }
+    static getPublishOptions() {
+        return {
+            timestamp: moment_1.default().unix() * 1000,
+        };
+    }
     getConnection() {
         return __awaiter(this, void 0, void 0, function* () {
             return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
@@ -204,30 +198,10 @@ class RabbitMq {
                 yield c.assertQueue(queue);
                 yield c.prefetch(limit, true);
                 return Promise.all([
-                    c.consume(queue, (msg) => __awaiter(this, void 0, void 0, function* () {
-                        var _a;
+                    c.consume(queue, (msg) => {
                         outbreak_1.newTrace(outbreak_1.traceTypes.RABBIT);
-                        if (optionsWithDefaults.timeout) {
-                            const args = [
-                                RabbitMq.parseMsg(msg),
-                                this.ack(channel),
-                                this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }),
-                            ];
-                            try {
-                                yield callbackWithTimeout(callback, args, optionsWithDefaults.timeout, optionsWithDefaults.timeoutMessage);
-                            }
-                            catch (e) {
-                                (_a = this.logger) === null || _a === void 0 ? void 0 : _a.error('message nacked because of error in callbackWithTimeout', {
-                                    error: e,
-                                    msg,
-                                });
-                                this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl });
-                            }
-                        }
-                        else {
-                            callback(RabbitMq.parseMsg(msg), this.ack(channel), this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
-                        }
-                    })),
+                        callback(RabbitMq.parseMsg(msg), this.ack(channel), this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
+                    }),
                 ]);
             }));
         });
@@ -261,7 +235,7 @@ class RabbitMq {
             yield this.assertExchange(exchange);
             return new bluebird.Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
                 try {
-                    yield channel.publish(exchange, '', Buffer.from(JSON.stringify(content)));
+                    yield channel.publish(exchange, '', Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions());
                     return resolve();
                 }
                 catch (e) {
@@ -275,7 +249,7 @@ class RabbitMq {
             RabbitMq.validateName('queue', queue);
             const channel = yield this.assertChannel();
             yield this.assertQueue(queue, options);
-            return channel.sendToQueue(queue, Buffer.from(JSON.stringify(content)));
+            return channel.sendToQueue(queue, Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions());
         });
     }
 }

package/package.json

@@ -1,14 +1,13 @@
 {
   "name": "@autofleet/rabbit",
-  "version": "2.0.4-beta5",
+  "version": "2.0.4",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
     "postinstall": "echo '\\033[0;31m\nWARNING: in case of migrating to new version of @autofleet/rabbit \nyou might have to delete existing queues or the deployment will fail.\\033[0m\n'",
     "start": "ts-node  src/index.ts",
     "example": "ts-node  src/example.ts",
-    "build": "rm -rf dist && tsc",
-    "prepublish": "npm run build",
+    "build": "tsc",
     "linter": "./node_modules/.bin/eslint .",
     "test": "jest --forceExit",
     "test-local": "RABBITMQ_SERVICE_HOST=10.132.0.98:5672 jest --forceExit",
@@ -20,7 +19,8 @@
     "@types/amqplib": "^0.5.16",
     "amqp-connection-manager": "^3.2.1",
     "amqplib": "^0.6.0",
-    "bluebird": "^3.7.2"
+    "bluebird": "^3.7.2",
+    "moment": "^2.29.1"
   },
   "devDependencies": {
     "@autofleet/outbreak": "*",

package/src/index.ts

@@ -1,6 +1,7 @@
 /* eslint-disable @typescript-eslint/ban-ts-comment,@typescript-eslint/ban-types,@typescript-eslint/no-unused-vars,consistent-return,no-async-promise-executor,no-param-reassign,no-empty */
 // eslint-disable-next-line max-classes-per-file
 import * as bluebird from 'bluebird';
+import moment from 'moment';
 import { ConfirmChannel, Options } from 'amqplib';
 import { AmqpConnectionManager, ChannelWrapper, connect } from 'amqp-connection-manager';
 import { EventEmitter } from 'events';
@@ -37,17 +38,6 @@ const defaultOptions = {
 
 const assertExchangeFanout = (c: any, exchangeName: string) => c.assertExchange(exchangeName, 'fanout');
 
-const callbackWithTimeout = async (callback: any, args: any[], timeout: number, timeoutMessage = 'Timeout while ack message') => {
-  await new bluebird.Promise(async (resolve, reject) => {
-    try {
-      await callback(...args);
-      return resolve();
-    } catch (e) {
-      return reject(e);
-    }
-  }).timeout(timeout, timeoutMessage);
-};
-
 const connectionCreatedConst = 'connectionCreated';
 class RabbitMq implements IAfRabbitMq {
   static parseMsg(msg: any) {
@@ -70,6 +60,12 @@ class RabbitMq implements IAfRabbitMq {
     }
   }
 
+  static getPublishOptions() {
+    return {
+      timestamp: moment().unix() * 1000,
+    };
+  }
+
   PUBLISH_TIMEOUT = Number(process.env.RABBITMQ_PUBLISH_TIMEOUT) || 60000;
 
   PUBLISH_ERROR_MSG = `rabbit: publish timeout(${this.PUBLISH_TIMEOUT}ms) has pass, exchange: `;
@@ -90,16 +86,13 @@ class RabbitMq implements IAfRabbitMq {
 
   options: AfRabbitOptions | undefined;
 
-  logger: any;
-
-  constructor({ options, logger }: { options?: AfRabbitOptions, logger?: any} = {}) {
+  constructor(options?: AfRabbitOptions) {
     this.em = new EventEmitter();
     this.channel = null;
     this.connection = null;
     this.creatingConnection = false;
     this.exchanges = {};
     this.options = options;
-    this.logger = logger;
   }
 
   public ack = (channel: ChannelWrapper) => async (msg: any) => {
@@ -228,26 +221,9 @@ class RabbitMq implements IAfRabbitMq {
       return Promise.all([
         c.consume(
           queue,
-          async (msg: any) => {
+          (msg: any) => {
             newTrace(traceTypes.RABBIT);
-            if (optionsWithDefaults.timeout) {
-              const args = [
-                RabbitMq.parseMsg(msg),
-                this.ack(channel),
-                this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }),
-              ];
-              try {
-                await callbackWithTimeout(callback, args, optionsWithDefaults.timeout, optionsWithDefaults.timeoutMessage);
-              } catch (e) {
-                this.logger?.error('message nacked because of error in callbackWithTimeout', {
-                  error: e,
-                  msg,
-                });
-                this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl });
-              }
-            } else {
-              callback(RabbitMq.parseMsg(msg), this.ack(channel), this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
-            }
+            callback(RabbitMq.parseMsg(msg), this.ack(channel), this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }));
           },
         ),
       ]);
@@ -285,7 +261,7 @@ class RabbitMq implements IAfRabbitMq {
     await this.assertExchange(exchange);
     return new bluebird.Promise(async (resolve, reject) => {
       try {
-        await channel.publish(exchange, '', Buffer.from(JSON.stringify(content)));
+        await channel.publish(exchange, '', Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions());
         return resolve();
       } catch (e) {
         reject(e);
@@ -297,7 +273,7 @@ class RabbitMq implements IAfRabbitMq {
     RabbitMq.validateName('queue', queue);
     const channel: ChannelWrapper = await this.assertChannel();
     await this.assertQueue(queue, options);
-    return channel.sendToQueue(queue, Buffer.from(JSON.stringify(content)));
+    return channel.sendToQueue(queue, Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions());
   }
 }