arnavmq 0.9.6 → 0.10.2

package/LICENSE

@@ -1,6 +1,7 @@
 The MIT License (MIT)
 
 Copyright (c) 2016 Dial Once
+Copyright (c) 2020 Bringg
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -115,8 +115,17 @@ You can specify a config object, properties and default values are:
     // generate a hostname so we can track this connection on the broker (rabbitmq management plugin)
     hostname: process.env.HOSTNAME || process.env.USER || uuid.v4(),
 
-    // the transport to use to debug. if provided, arnavmq will show some logs
+    // Deprecated. Use 'logger' instead. The transport to use to debug. If provided, arnavmq will show some logs
     transport: utils.emptyLogger
+
+    /**
+     * A logger object with a log function for each of the log levels ("debug", "info", "warn", or "error").
+     * Each log function receives one parameter containing a log event with the following fields:
+     * * message - A string message describing the event. Always present.
+     * * error - An 'Error' object in case one is present.
+     * * params - An optional object containing extra parameters that can provide extra context for the event.
+     */
+    logger: utils.emptyLogger
   });
 ```
 
@@ -128,9 +137,9 @@ You can override any or no of the property above.
 
 Find more about RabbitMQ in the links below:
 
-- http://www.rabbitmq.com/getstarted.html
-- https://www.cloudamqp.com/blog/2015-05-18-part1-rabbitmq-for-beginners-what-is-rabbitmq.html
-- http://spring.io/blog/2010/06/14/understanding-amqp-the-protocol-used-by-rabbitmq/
+- <http://www.rabbitmq.com/getstarted.html>
+- <https://www.cloudamqp.com/blog/2015-05-18-part1-rabbitmq-for-beginners-what-is-rabbitmq.html>
+- <http://spring.io/blog/2010/06/14/understanding-amqp-the-protocol-used-by-rabbitmq/>
 
 ## Tests
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arnavmq",
-  "version": "0.9.6",
+  "version": "0.10.2",
   "description": "ArnavMQ is a RabbitMQ wrapper",
   "keywords": [
     "rabbitmq",
@@ -28,10 +28,10 @@
   },
   "homepage": "https://github.com/bringg/node-arnavmq#readme",
   "dependencies": {
-    "amqplib": "^0.8.0",
+    "amqplib": "^0.10.0",
     "p-defer": "^3.0.0",
     "serialize-error": "^8.0.1",
-    "uuid": "^8.3.1"
+    "uuid": "^8.3.2"
   },
   "devDependencies": {
     "child-process-promise": "^2.2.1",

package/src/index.js

@@ -4,9 +4,7 @@ const connection = require('./modules/connection');
 
 /* eslint global-require: "off" */
 module.exports = (config) => {
-  let configuration = { ...config };
-
-  configuration = {
+  const configuration = {
     // amqp connection string
     host: 'amqp://localhost',
 
@@ -32,12 +30,25 @@ module.exports = (config) => {
     // generate a hostname so we can track this connection on the broker (rabbitmq management plugin)
     hostname: process.env.HOSTNAME || process.env.USER || uuid.v4(),
 
-    // the transport to use to debug. if provided, arnavmq will show some logs
+    // Deprecated. Use 'logger' instead. The transport to use to debug. If provided, arnavmq will show some logs
     transport: utils.emptyLogger,
 
-    ...configuration
+    /**
+     * A logger object with a log function for each of the log levels ("debug", "info", "warn", or "error").
+     * Each log function receives one parameter containing a log event with the following fields:
+     * * message - A string message describing the event. Always present.
+     * * error - An 'Error' object in case one is present.
+     * * params - An optional object containing extra parameters that can provide extra context for the event.
+     */
+    logger: utils.emptyLogger,
+
+    ...config
   };
 
+  if (configuration.transport !== utils.emptyLogger) {
+    process.emitWarning("The 'transport' configuration option is deprecated. Please use the 'logger' option instead.", 'DeprecationWarning');
+  }
+
   configuration.prefetch = parseInt(configuration.prefetch, 10) || 0;
   return require('./modules/arnavmq')(connection(configuration));
 };

package/src/modules/connection.js

@@ -40,7 +40,7 @@ class Connection {
       conn.on('close', () => {
         delete connection.conn;
       });
-      conn.on('error', this._config.transport.error);
+      conn.on('error', this._onError.bind(this));
       connection.conn = conn;
       return conn;
     }).catch((e) => {
@@ -71,7 +71,7 @@ class Connection {
 
         // on error we remove the channel so the next call will recreate it (auto-reconnect are handled by connection users)
         channel.on('close', () => { delete connection.chann; });
-        channel.on('error', this._config.transport.error);
+        channel.on('error', this._onError.bind(this));
 
         connection.chann = channel;
         return channel;
@@ -79,6 +79,18 @@ class Connection {
     return connection.chann;
   }
 
+  /**
+   * Log errors from connection/channel error events.
+   * @param {Error} error
+   */
+  _onError(error) {
+    this._config.transport.error(error);
+    this._config.logger.error({
+      message: error.message,
+      error
+    });
+  }
+
   /**
    * Connect to AMQP and create channel
    * @return {Promise} A promise that resolve with an amqp.node channel object
@@ -89,7 +101,7 @@ class Connection {
 
   /**
    * Register an event on the amqp.node channel
-   * @param {string} on   the channel event name to be binded with
+   * @param {string} on     the channel event name to be bound with
    * @param {function} func the callback function to execute when the event is called
    */
   addListener(on, func) {

package/src/modules/consumer.js

@@ -32,7 +32,11 @@ class Consumer {
     return (content) => {
       if (msg.properties.replyTo) {
         const options = { correlationId: msg.properties.correlationId, persistent: true, durable: true };
-        this._connection.config.transport.info(loggerAlias, `[${queue}][${msg.properties.replyTo}] >`, content);
+        this._connection.config.transport.debug(loggerAlias, `[${queue}][${msg.properties.replyTo}] >`, content);
+        this._connection.config.logger.debug({
+          message: `${loggerAlias} [${queue}][${msg.properties.replyTo}] > ${content}`,
+          params: { content }
+        });
         this.channel.sendToQueue(msg.properties.replyTo, parsers.out(content, options), options);
       }
 
@@ -42,7 +46,7 @@ class Consumer {
 
   /**
    * Create a durable queue on RabbitMQ and consumes messages from it - executing a callback function.
-   * Automaticaly answers with the callback response (can be a Promise)
+   * Automatically answers with the callback response (can be a Promise)
    * @param  {string}   queue    The RabbitMQ queue name
    * @param  {object}   options  (Optional) Options for the queue (durable, persistent, etc.)
    * @param  {Function} callback Callback function executed when a message is received on the queue name, can return a promise
@@ -73,10 +77,19 @@ class Consumer {
       });
 
       return this.channel.assertQueue(suffixedQueue, options).then((q) => {
-        this._connection.config.transport.info(loggerAlias, 'init', q.queue);
+        this._connection.config.transport.debug(loggerAlias, 'init', q.queue);
+        this._connection.config.logger.debug({
+          message: `${loggerAlias} init ${q.queue}`,
+          params: { queue: q.queue }
+        });
 
         this.channel.consume(q.queue, (msg) => {
-          this._connection.config.transport.info(loggerAlias, `[${q.queue}] < ${msg.content.toString()}`);
+          const messageString = msg.content.toString();
+          this._connection.config.transport.debug(loggerAlias, `[${q.queue}] < ${messageString}`);
+          this._connection.config.logger.debug({
+            message: `${loggerAlias} [${q.queue}] < ${messageString}`,
+            params: { queue: q.queue, message: messageString }
+          });
 
           // main answer management chaining
           // receive message, parse it, execute callback, check if should answer, ack/reject message
@@ -86,9 +99,15 @@ class Consumer {
             .then(() => {
               this.channel.ack(msg);
             })
-            .catch((err) => {
+            .catch((error) => {
               // if something bad happened in the callback, reject the message so we can requeue it (or not)
-              this._connection.config.transport.error(loggerAlias, err);
+              this._connection.config.transport.error(loggerAlias, error);
+              this._connection.config.logger.error({
+                message: `${loggerAlias} Failed processing message from queue ${q.queue}: ${error.message}`,
+                error,
+                params: { queue: q.queue, message: messageString }
+              });
+
               this.channel.reject(msg, this._connection.config.requeue);
             });
         }, { noAck: false });

package/src/modules/message-parsers.js

@@ -35,16 +35,18 @@ module.exports.in = (msg) => {
  */
 /* eslint no-param-reassign: "off" */
 module.exports.out = (content, options) => {
-  const falsie = [undefined, null];
-  if (!falsie.includes(content) && typeof content !== 'string') {
+  // If falsy
+  if (content == null) {
+    return Buffer.from([]);
+  }
+
+  if (typeof content !== 'string') {
     if (content.error instanceof Error) {
       content.error = serializeError(content.error);
     }
     // if content is not a string, we JSONify it (JSON.parse can handle numbers, etc. so we can skip all the checks)
     content = JSON.stringify(content);
     options.contentType = 'application/json';
-  } else if (falsie.includes(content)) {
-    return Buffer.from([]);
   }
 
   return Buffer.from(content, 'utf-8');

package/src/modules/producer.js

@@ -49,12 +49,16 @@ class Producer {
       const responsePromise = rpcQueue[correlationId];
 
       if (responsePromise === undefined) {
-        this._connection.config.transport.error(
+        const error = new Error(`Receiving RPC message from previous session: callback no more in memory. ${queue}`);
+        this._connection.config.transport.warn(
           loggerAlias,
-          new Error(
-            `Receiving RPC message from previous session: callback no more in memory. ${queue}`
-          )
+          error
         );
+        this._connection.config.logger.warn({
+          message: `${loggerAlias} ${error.message}`,
+          error,
+          params: { queue, rpcQueue }
+        });
 
         return;
       }
@@ -64,6 +68,10 @@ class Producer {
         loggerAlias,
         `[${queue}] < answer`
       );
+      this._connection.config.logger.debug({
+        message: `${loggerAlias} [${queue}] < answer`,
+        params: { queue }
+      });
 
       try {
         responsePromise.resolve(parsers.in(msg));
@@ -233,16 +241,25 @@ class Producer {
           `[${queue}] > `,
           message
         );
+        this._connection.config.logger.debug({
+          message: `${loggerAlias} [${queue}] > ${message}`,
+          params: { queue, message }
+        });
 
         return this.checkRpc(queue, parsers.out(message, settings), settings);
       })
-      .catch((err) => {
-        if (!this._shouldRetry(err, currentRetryNumber)) {
-          throw err;
+      .catch((error) => {
+        if (!this._shouldRetry(error, currentRetryNumber)) {
+          throw error;
         }
 
         // add timeout between retries because we don't want to overflow the CPU
-        this._connection.config.transport.error(loggerAlias, err);
+        this._connection.config.transport.error(loggerAlias, error);
+        this._connection.config.logger.error({
+          message: `${loggerAlias} Failed sending message to queue ${queue}: ${error.message}`,
+          error,
+          params: { queue, message }
+        });
         return utils
           .timeoutPromise(this._connection.config.timeout)
           .then(() => this._sendToQueue(queue, message, settings, currentRetryNumber + 1));

package/src/modules/utils.js

@@ -1,22 +1,32 @@
-/**
- * A function to generate a pause in promise chaining
- * @param  {number} timer How much ws to wait
- * @return {Promise}      A Promise that will resolve when timer is expired
- */
-module.exports.timeoutPromise = (timer) => new Promise((resolve) => {
-  setTimeout(resolve, timer);
-});
-
 function empty() {}
 
-/**
- * Default logger to prevent any printing in the terminal
- * @type {Object} - empty logger overwriting the console object methods
- */
-module.exports.emptyLogger = {
+const emptyLogger = {
   info: empty,
   debug: empty,
   warn: empty,
   error: empty,
   log: empty
 };
+
+module.exports = {
+  /**
+   * Default transport to prevent any printing in the terminal
+   * @type {Object} - empty logger overwriting the console object methods
+   */
+  emptyLogger,
+
+  /**
+   * @deprecated
+   * For backwards compatibility with the `transport` configuration.
+   */
+  emptyTransport: emptyLogger,
+
+  /**
+   * A function to generate a pause in promise chaining
+   * @param  {number} timer How much ws to wait
+   * @return {Promise}      A Promise that will resolve when timer is expired
+   */
+  timeoutPromise: (timer) => new Promise((resolve) => {
+    setTimeout(resolve, timer);
+  })
+};