arnavmq 0.14.1 → 0.15.0

package/.github/dependabot.yml

@@ -1,9 +1,4 @@
 version: 2
-registries:
-  npm-registry-registry-npmjs-org:
-    type: npm-registry
-    url: https://registry.npmjs.org
-    token: "${{secrets.NPM_REGISTRY_REGISTRY_NPMJS_ORG_TOKEN}}"
 
 updates:
 - package-ecosystem: npm
@@ -17,5 +12,3 @@ updates:
   - yosiat
   - shamil
   - ramhr
-  registries:
-  - npm-registry-registry-npmjs-org

package/.prettierignore

@@ -17,3 +17,4 @@
 /.idea/**
 /.github/**
 /samples/**
+.nyc_output/

package/README.md

@@ -137,9 +137,6 @@ const arnavmq = require('arnavmq')({
   // generate a hostname so we can track this connection on the broker (rabbitmq management plugin)
   hostname: process.env.HOSTNAME || process.env.USER || uuid.v4(),
 
-  // 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:
@@ -153,7 +150,7 @@ const arnavmq = require('arnavmq')({
 
 You can override any or no of the property above.
 
-**Note:** if you enable the debug mode using the `AMQP_DEBUG=true` env var, but you do not attach any transport logger, the module will fallback to console.
+**Note:** if you enable the debug mode using the `AMQP_DEBUG=true` env var, but you do not attach any logger, the module will fallback to console.
 
 ## Documentation & resources
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arnavmq",
-  "version": "0.14.1",
+  "version": "0.15.0",
   "description": "ArnavMQ is a RabbitMQ wrapper",
   "keywords": [
     "rabbitmq",
@@ -16,7 +16,7 @@
     "lint": "eslint . && prettier -c .",
     "format": "eslint --fix . && prettier --write .",
     "cover": "test -d .nyc_output && nyc report --reporter lcov",
-    "test": "dot-only-hunter test && nyc mocha --recursive --timeout=30000 --exit"
+    "test": "dot-only-hunter test && nyc mocha --recursive --exit"
   },
   "prettier": {
     "singleQuote": true,
@@ -48,7 +48,7 @@
     "mocha": "^10.0.0",
     "nyc": "^15.1.0",
     "prettier": "^2.8.3",
-    "sinon": "^14.0.1"
+    "sinon": "^15.0.1"
   },
   "engines": {
     "node": ">=14"

package/src/index.js

@@ -30,9 +30,6 @@ 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(),
 
-    // 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:
@@ -45,11 +42,8 @@ module.exports = (config) => {
     ...config,
   };
 
-  if (configuration.transport !== utils.emptyLogger) {
-    process.emitWarning(
-      "The 'transport' configuration option is deprecated. Please use the 'logger' option instead.",
-      'DeprecationWarning'
-    );
+  if (configuration.transport) {
+    throw new Error('Using removed deprecated "transport" option. Use the "logger" option instead.');
   }
 
   configuration.prefetch = parseInt(configuration.prefetch, 10) || 0;

package/src/modules/channels.js

@@ -26,68 +26,82 @@ class Channels {
     this._channels = new Map();
   }
 
-  get(queue, config) {
+  async get(queue, config) {
     // If we don't have custom prefetch create a new channel
     const defaultPrefetch = this._config.prefetch;
     const requestedPrefetch = config.prefetch || defaultPrefetch;
     if (typeof requestedPrefetch === 'number' && requestedPrefetch !== defaultPrefetch) {
-      return this._get(queue, config);
+      return await this._get(queue, config);
     }
 
-    return this.defaultChannel();
+    return await this.defaultChannel();
+  }
+
+  async defaultChannel() {
+    return await this._get(DEFAULT_CHANNEL, { prefetch: this._config.prefetch });
   }
 
   /**
    * Creates or returns an existing channel by it's key and config.
    * @return {Promise} A promise that resolve with an amqp.node channel object
    */
-  _get(key, config = {}) {
-    let channel = this._channels.get(key);
+  async _get(key, config = {}) {
+    const existingChannel = this._channels.get(key);
 
-    if (channel) {
-      if (!isSameConfig(channel.config, config)) {
-        return Promise.reject(new ChannelAlreadyExistsError(key, config));
+    if (existingChannel) {
+      if (!isSameConfig(existingChannel.config, config)) {
+        throw new ChannelAlreadyExistsError(key, config);
       }
 
       // cache handling, if channel already opened, return it
-      return channel.chann;
+      return await existingChannel.chann;
     }
 
-    channel = this._connection
-      .createChannel()
-      .then((_channel) => {
-        _channel.prefetch(config.prefetch);
+    const channelPromise = this._initNewChannel(key, config);
+    this._channels.set(key, { chann: channelPromise, config });
 
-        // on error we remove the channel so the next call will recreate it (auto-reconnect are handled by connection users)
-        _channel.on('close', () => {
-          this._channels.delete(key);
-        });
-        _channel.on('error', (error) => {
-          this._config.logger.error({
-            message: `Got channel error [${error.message}] for [${key}]`,
-            error,
-          });
-        });
+    return await channelPromise;
+  }
+
+  async _initNewChannel(key, config) {
+    let channel;
+    try {
+      channel = await this._connection.createChannel();
+
+      channel.prefetch(config.prefetch);
 
-        return _channel;
-      })
-      .catch((error) => {
+      // on error we remove the channel so the next call will recreate it (auto-reconnect are handled by connection users)
+      channel.on('close', () => {
         this._channels.delete(key);
+      });
+      channel.on('error', (error) => {
         this._config.logger.error({
-          message: `Failed to create channel for [${key}] - [${error.message}]`,
+          message: `Got channel error [${error.message}] for [${key}]`,
           error,
         });
-
-        return Promise.reject(error);
       });
 
-    this._channels.set(key, { chann: channel, config });
-
-    return channel;
-  }
+      return channel;
+    } catch (error) {
+      this._channels.delete(key);
+      this._config.logger.error({
+        message: `Failed to create channel for [${key}] - [${error.message}]`,
+        error,
+      });
 
-  defaultChannel() {
-    return this._get(DEFAULT_CHANNEL, { prefetch: this._config.prefetch });
+      // Should not happen, but just in case
+      if (channel) {
+        try {
+          await channel.close();
+        } catch (closeError) {
+          this._config.logger.error({
+            message: `Failed to cleanup channel after failed initialization for [${key}] - [${closeError.message}]`,
+            error: closeError,
+          });
+        }
+      }
+      throw error;
+    }
   }
 }
 

package/src/modules/connection.js

@@ -7,7 +7,7 @@ class Connection {
   constructor(config) {
     this._config = config;
 
-    this._connection = null; // Promise of amqp connection
+    this._connectionPromise = null; // Promise of amqp connection
     this._channels = null;
     this.startedAt = new Date().toISOString();
   }
@@ -16,39 +16,40 @@ class Connection {
    * Connect to the broker. We keep only 1 connection for each connection string provided in config, as advised by RabbitMQ
    * @return {Promise} A promise that resolve with an amqp.node connection object
    */
-  getConnection() {
+  async getConnection() {
     // cache handling, if connection already opened, return it
-    if (this._connection) {
-      return this._connection;
+    if (!this._connectionPromise) {
+      this._connectionPromise = this._connect();
     }
 
-    // prepare the connection internal object, and reset channel if connection has been closed
-    this._connection = amqp
-      .connect(this._config.host, {
+    return await this._connectionPromise;
+  }
+
+  async _connect() {
+    try {
+      const connection = await amqp.connect(this._config.host, {
         clientProperties: {
           hostname: this._config.hostname,
           arnavmq: packageVersion,
           startedAt: this.startedAt,
           connectedAt: new Date().toISOString(),
         },
-      })
-      .then((conn) => {
-        this._channels = new Channels(conn, this._config);
-        // on connection close, delete connection
-        conn.on('close', () => {
-          this._connection = null;
-          this._channels = null;
-        });
-        conn.on('error', this._onError.bind(this));
-        return conn;
-      })
-      .catch((e) => {
-        this._connection = null;
+      });
+
+      this._channels = new Channels(connection, this._config);
+      // on connection close, delete connection
+      connection.on('close', () => {
+        this._connectionPromise = null;
         this._channels = null;
-        throw e;
       });
+      connection.on('error', this._onError.bind(this));
 
-    return this._connection;
+      return connection;
+    } catch (error) {
+      this._connectionPromise = null;
+      this._channels = null;
+      throw error;
+    }
   }
 
   /**
@@ -56,19 +57,20 @@ class Connection {
    * @param {Error} error
    */
   _onError(error) {
-    this._config.transport.error(error);
     this._config.logger.error({
       message: error.message,
       error,
     });
   }
 
-  getChannel(queue, config) {
-    return this.getConnection().then(() => this._channels.get(queue, config));
+  async getChannel(queue, config) {
+    await this.getConnection();
+    return await this._channels.get(queue, config);
   }
 
-  getDefaultChannel() {
-    return this.getConnection().then(() => this._channels.defaultChannel());
+  async getDefaultChannel() {
+    await this.getConnection();
+    return await this._channels.defaultChannel();
   }
 
   /**
@@ -76,10 +78,9 @@ class Connection {
    * @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) {
-    this.getDefaultChannel().then((channel) => {
-      channel.on(on, func);
-    });
+  async addListener(on, func) {
+    const channel = await this.getDefaultChannel();
+    channel.on(on, func);
   }
 
   get config() {

package/src/modules/consumer.js

@@ -21,36 +21,28 @@ class Consumer {
 
   /**
    * Get a function to execute on incoming messages to handle RPC
-   * @param  {any} msg   An amqp.node message object
+   * @param  {any} messageProperties   An amqp.node message properties object, containing the rpc settings
    * @param  {string} queue The initial queue on which the handler received the message
-   * @return {function}       a function to use in a chaining on incoming messages
+   * @param  {any} reply the received message to reply the rpc if needed:
+   * @return {any}       object, string, number... the current received message
    */
-  checkRpc(msg, queue) {
-    /**
-     * When message contains a replyTo property, we try to send the answer back
-     * @param  {any} content the received message:
-     * @return {any}          object, string, number... the current received message
-     */
-    return (content) => {
-      if (msg.properties.replyTo) {
-        const options = {
-          correlationId: msg.properties.correlationId,
-          persistent: true,
-          durable: true,
-        };
-        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 },
-        });
+  async checkRpc(messageProperties, queue, reply) {
+    if (messageProperties.replyTo) {
+      const options = {
+        correlationId: messageProperties.correlationId,
+        persistent: true,
+        durable: true,
+      };
+      this._connection.config.logger.debug({
+        message: `${loggerAlias} [${queue}][${messageProperties.replyTo}] > ${reply}`,
+        params: { content: reply },
+      });
 
-        return this._connection.getDefaultChannel().then((channel) => {
-          return channel.sendToQueue(msg.properties.replyTo, parsers.out(content, options), options);
-        });
-      }
+      const defaultChannel = await this._connection.getDefaultChannel();
+      return await defaultChannel.sendToQueue(messageProperties.replyTo, parsers.out(reply, options), options);
+    }
 
-      return msg;
-    };
+    return messageProperties;
   }
 
   /**
@@ -66,7 +58,7 @@ class Consumer {
     return this.subscribe(queue, options, callback);
   }
 
-  subscribe(queue, options, callback) {
+  async subscribe(queue, options, callback) {
     const defaultOptions = {
       persistent: true,
       durable: true,
@@ -93,67 +85,128 @@ class Consumer {
     // ex: service-something with suffix :ci becomes service-suffix:ci etc.
     const suffixedQueue = `${queue}${this._connection.config.consumerSuffix || ''}`;
 
-    return this._connection
-      .getChannel(queue, options.channel || {})
-      .then((channel) => {
-        // when channel is closed, we want to be sure we recreate the queue ASAP so we trigger a reconnect by recreating the consumer
-        channel.addListener('close', () => {
-          this.subscribe(queue, options, callback);
-        });
+    const channel = await this._initializeChannel(queue, options || {}, callback);
+    if (!channel) {
+      // in case of any error creating the channel, wait for some time and then try to reconnect again (to avoid overflow)
+      await utils.timeoutPromise(this._connection.config.timeout);
+      return await this.subscribe(queue, options, callback);
+    }
 
-        return channel.assertQueue(suffixedQueue, options).then((q) => {
-          this._connection.config.transport.debug(loggerAlias, 'init', q.queue);
-          this._connection.config.logger.debug({
-            message: `${loggerAlias} init ${q.queue}`,
-            params: { queue: q.queue },
+    try {
+      await channel.assertQueue(suffixedQueue, options);
+    } catch (error) {
+      this._connection.config.logger.error({
+        message: `${loggerAlias} Failed to assert queue ${queue}: ${error.message}`,
+        error,
+        params: { queue },
+      });
+    }
+
+    this._connection.config.logger.debug({
+      message: `${loggerAlias} init ${queue}`,
+      params: { queue },
+    });
+
+    await this._consumeQueue(channel, queue, callback);
+    return true;
+  }
+
+  async _initializeChannel(queue, options, callback) {
+    let channel;
+    try {
+      channel = await this._connection.getChannel(queue, options.channel || {});
+      // when channel is closed, we want to be sure we recreate the queue ASAP so we trigger a reconnect by recreating the consumer
+      channel.addListener('close', () => {
+        this.subscribe(queue, options, callback);
+      });
+      return channel;
+    } catch (err) {
+      if (err instanceof ChannelAlreadyExistsError) {
+        throw err;
+      }
+
+      if (channel) {
+        try {
+          // Just in the odd chance the channel was open but the listener failed.
+          await channel.close();
+        } catch (closeError) {
+          this._connection.config.logger.error({
+            message: `${loggerAlias} Failed to close channel after initialization error ${queue}: ${closeError.message}`,
+            error: closeError,
+            params: { queue },
           });
+        }
+      }
+      return null;
+    }
+  }
 
-          channel.consume(
-            q.queue,
-            (msg) => {
-              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
-              Promise.resolve(parsers.in(msg))
-                .then((body) => callback(body, msg.properties))
-                .then(this.checkRpc(msg, q.queue))
-                .then(() => {
-                  channel.ack(msg);
-                })
-                .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, error);
-                  this._connection.config.logger.error({
-                    message: `${loggerAlias} Failed processing message from queue ${q.queue}: ${error.message}`,
-                    error,
-                    params: { queue: q.queue, message: messageString },
-                  });
-
-                  channel.reject(msg, this._connection.config.requeue);
-                });
-            },
-            { noAck: false }
-          );
-
-          return true;
+  async _consumeQueue(channel, queue, callback) {
+    const consumeFunc = async (msg) => {
+      if (!msg) {
+        // When forcefully cancelled by rabbitmq, consumer would receive a null message.
+        // https://amqp-node.github.io/amqplib/channel_api.html#channel_consume
+        this._connection.config.logger.warn({
+          message: `${loggerAlias} Consumer was cancelled by server for queue '${queue}'`,
+          error: null,
+          params: { queue },
         });
-        // in case of any error creating the channel, wait for some time and then try to reconnect again (to avoid overflow)
-      })
-      .catch((err) => {
-        if (err instanceof ChannelAlreadyExistsError) {
-          throw err;
-        } else {
-          return utils
-            .timeoutPromise(this._connection.config.timeout)
-            .then(() => this.subscribe(queue, options, callback));
+        return;
+      }
+
+      const messageString = msg.content.toString();
+      this._connection.config.logger.debug({
+        message: `${loggerAlias} [${queue}] < ${messageString}`,
+        params: { queue, message: messageString },
+      });
+
+      // main answer management chaining
+      // receive message, parse it, execute callback, check if should answer, ack/reject message
+      const body = parsers.in(msg);
+      try {
+        const res = await callback(body, msg.properties);
+        await this.checkRpc(msg.properties, queue, res);
+      } catch (error) {
+        // if something bad happened in the callback, reject the message so we can requeue it (or not)
+        this._connection.config.logger.error({
+          message: `${loggerAlias} Failed processing message from queue ${queue}: ${error.message}`,
+          error,
+          params: { queue, message: messageString },
+        });
+
+        try {
+          channel.reject(msg, this._connection.config.requeue);
+        } catch (rejectError) {
+          this._connection.config.logger.error({
+            message: `${loggerAlias} Failed to reject message after processing failure on queue ${queue}: ${rejectError.message}`,
+            error: rejectError,
+            params: { queue },
+          });
         }
+
+        return;
+      }
+
+      try {
+        channel.ack(msg);
+      } catch (ackError) {
+        this._connection.config.logger.error({
+          message: `${loggerAlias} Failed to ack message after processing finished on queue ${queue}: ${ackError.message}`,
+          error: ackError,
+          params: { queue },
+        });
+      }
+    };
+
+    try {
+      await channel.consume(queue, consumeFunc, { noAck: false });
+    } catch (error) {
+      this._connection.config.logger.error({
+        message: `${loggerAlias} Failed to start consuming from queue ${queue}: ${error.message}`,
+        error,
+        params: { queue },
       });
+    }
   }
 }
 

package/src/modules/producer.js

@@ -47,20 +47,19 @@ class Producer {
       const { correlationId } = msg.properties;
       const responsePromise = rpcQueue[correlationId];
 
+      // On timeout the waiter is deleted, so we need to handle the race when the response arrives too late.
       if (responsePromise === undefined) {
         const error = new Error(`Receiving RPC message from previous session: callback no more in memory. ${queue}`);
-        this._connection.config.transport.warn(loggerAlias, error);
         this._connection.config.logger.warn({
           message: `${loggerAlias} ${error.message}`,
           error,
-          params: { queue, rpcQueue },
+          params: { queue, correlationId },
         });
 
         return;
       }
 
       // if we found one, we execute the callback and delete it because it will never be received again anyway
-      this._connection.config.transport.info(loggerAlias, `[${queue}] < answer`);
       this._connection.config.logger.debug({
         message: `${loggerAlias} [${queue}] < answer`,
         params: { queue },
@@ -79,56 +78,55 @@ class Producer {
   /**
    * Create a RPC-ready queue
    * @param  {string} queue the queue name in which we send a RPC request
-   * @return {Promise}       Resolves when answer response queue is ready to receive messages
+   * @return {Promise}       Resolves with the the response queue name when the answer response queue is ready to receive messages
    */
-  createRpcQueue(queue) {
+  async createRpcQueue(queue) {
     this.amqpRPCQueues[queue] = this.amqpRPCQueues[queue] || {};
 
-    const rpcQueue = this.amqpRPCQueues[queue];
-    if (rpcQueue.queue) return Promise.resolve(rpcQueue.queue);
+    const rpcData = this.amqpRPCQueues[queue];
+    if (rpcData.resQueuePromise) {
+      return await rpcData.resQueuePromise;
+    }
+
+    rpcData.resQueuePromise = this._initializeRpcQueue(queue);
+    return await rpcData.resQueuePromise;
+  }
+
+  async _initializeRpcQueue(sourceQueue) {
+    const rpcQueue = this.amqpRPCQueues[sourceQueue];
 
     // we create the callback queue using base queue name + appending config hostname and :res for clarity
     // ie. if hostname is gateway-http and queue is service-oauth, response queue will be service-oauth:gateway-http:res
     // it is important to have different hostname or no hostname on each module sending message or there will be conflicts
-    const resQueue = `${queue}:${this._connection.config.hostname}:${process.pid}:res`;
-    rpcQueue.queue = this._connection
-      .getDefaultChannel()
-      .then((channel) =>
-        channel
-          .assertQueue(resQueue, {
-            durable: true,
-            exclusive: true,
-          })
-          .then((q) => {
-            rpcQueue.queue = q.queue;
-
-            // if channel is closed, we want to make sure we cleanup the queue so future calls will recreate it
-            this._connection.addListener('close', () => {
-              delete rpcQueue.queue;
-              this.createRpcQueue(queue);
-            });
-
-            return channel.consume(q.queue, this.maybeAnswer(queue), {
-              noAck: true,
-            });
-          })
-          .then(() => rpcQueue.queue)
-      )
-      .catch(() => {
-        delete rpcQueue.queue;
-        return utils.timeoutPromise(this._connection.config.timeout).then(() => this.createRpcQueue(queue));
+    const resQueue = `${sourceQueue}:${this._connection.config.hostname}:${process.pid}:res`;
+    try {
+      const channel = await this._connection.getDefaultChannel();
+      await channel.assertQueue(resQueue, { durable: true, exclusive: true });
+
+      // if channel is closed, we want to make sure we cleanup the queue so future calls will recreate it
+      this._connection.addListener('close', () => {
+        delete rpcQueue.resQueuePromise;
+        this.createRpcQueue(sourceQueue);
       });
 
-    return rpcQueue.queue;
+      await channel.consume(resQueue, this.maybeAnswer(sourceQueue), {
+        noAck: true,
+      });
+      return resQueue;
+    } catch (error) {
+      delete rpcQueue.resQueuePromise;
+      await utils.timeoutPromise(this._connection.config.timeout);
+      return await this.createRpcQueue(sourceQueue);
+    }
   }
 
   async publishOrSendToQueue(queue, msg, options) {
     const channel = await this._connection.getDefaultChannel();
 
     if (!options.routingKey) {
-      return channel.sendToQueue(queue, msg, options);
+      return await channel.sendToQueue(queue, msg, options);
     }
-    return channel.publish(queue, options.routingKey, msg, options);
+    return await channel.publish(queue, options.routingKey, msg, options);
   }
 
   /**
@@ -156,35 +154,34 @@ class Producer {
    * @param  {object} options contain rpc property (if true, enable rpc for this message)
    * @return {Promise}         Resolves when message is correctly sent, or when response is received when rpc is enabled
    */
-  checkRpc(queue, msg, options) {
+  async checkRpc(queue, msg, options) {
     // messages are persistent
     options.persistent = true;
 
     if (options.rpc) {
-      return this.createRpcQueue(queue).then(() => {
-        // generates a correlationId (random uuid) so we know which callback to execute on received response
-        const corrId = uuid.v4();
-        options.correlationId = corrId;
-        // reply to us if you receive this message!
-        options.replyTo = this.amqpRPCQueues[queue].queue;
-
-        // defered promise that will resolve when response is received
-        const responsePromise = pDefer();
-        this.amqpRPCQueues[queue][corrId] = responsePromise;
-
-        this.publishOrSendToQueue(queue, msg, options);
-
-        //  Using given timeout or default one
-        const timeout = options.timeout || this._connection.config.rpcTimeout || 0;
-        if (timeout > 0) {
-          this.prepareTimeoutRpc(queue, corrId, timeout);
-        }
-
-        return responsePromise.promise;
-      });
+      await this.createRpcQueue(queue);
+      // generates a correlationId (random uuid) so we know which callback to execute on received response
+      const corrId = uuid.v4();
+      options.correlationId = corrId;
+      // reply to us if you receive this message!
+      options.replyTo = await this.amqpRPCQueues[queue].resQueuePromise;
+
+      // deferred promise that will resolve when response is received
+      const responsePromise = pDefer();
+      this.amqpRPCQueues[queue][corrId] = responsePromise;
+
+      await this.publishOrSendToQueue(queue, msg, options);
+
+      // Using given timeout or default one
+      const timeout = options.timeout || this._connection.config.rpcTimeout || 0;
+      if (timeout > 0) {
+        this.prepareTimeoutRpc(queue, corrId, timeout);
+      }
+
+      return await responsePromise.promise;
     }
 
-    return this.publishOrSendToQueue(queue, msg, options);
+    return await this.publishOrSendToQueue(queue, msg, options);
   }
 
   /**
@@ -208,7 +205,7 @@ class Producer {
    * @return {Promise}         checkRpc response
    */
   /* eslint no-param-reassign: "off" */
-  publish(queue, msg, options) {
+  async publish(queue, msg, options) {
     // default options are persistent and durable because we do not want to miss any outgoing message
     // unless user specify it
     const settings = { persistent: true, durable: true, ...options };
@@ -220,35 +217,36 @@ class Producer {
       message = { ...msg };
     }
 
-    return this._sendToQueue(queue, message, settings, 0);
+    return await this._sendToQueue(queue, message, settings, 0);
   }
 
-  _sendToQueue(queue, message, settings, currentRetryNumber) {
+  async _sendToQueue(queue, message, settings, currentRetryNumber) {
     // undefined can't be serialized/buffered :p
-    if (!message) message = null;
+    if (!message) {
+      message = null;
+    }
 
-    this._connection.config.transport.info(loggerAlias, `[${queue}] > `, message);
     this._connection.config.logger.debug({
       message: `${loggerAlias} [${queue}] > ${message}`,
       params: { queue, message },
     });
 
-    return this.checkRpc(queue, parsers.out(message, settings), settings).catch((error) => {
+    try {
+      return await this.checkRpc(queue, parsers.out(message, settings), settings);
+    } 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, 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));
-    });
+      await utils.timeoutPromise(this._connection.config.timeout);
+      return await this._sendToQueue(queue, message, settings, currentRetryNumber + 1);
+    }
   }
 
   _shouldRetry(error, currentRetryNumber) {

package/src/modules/utils.js

@@ -10,17 +10,11 @@ const emptyLogger = {
 
 module.exports = {
   /**
-   * Default transport to prevent any printing in the terminal
+   * Default logger 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