rascal 19.0.0 → 20.1.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Change Log
 
+## 20.1.0
+- Ignore and remove immediateNack header based on the xDeath header. See https://github.com/onebeyond/rascal/issues/237
+
+## 20.0.0
+- Replaced superagent with native node http client as per https://github.com/onebeyond/rascal/issues/234
+
 ## 19.0.0
 - I am not aware of any breaking changes in this release, but emitting error events asynchronously could have subtle side effects, hence the major release
 - Deprecate session 'cancelled' event in favour of 'cancel' (both will work)

package/README.md

@@ -464,7 +464,7 @@ The AMQP protocol doesn't support assertion or checking of vhosts, so Rascal use
 }
 ```
 
-Rascal uses [superagent](https://github.com/visionmedia/superagent) under the hood. URL configuration is also supported.
+Rascal uses [http.request](https://nodejs.org/api/http.html#httprequesturl-options-callback) under the hood. URL configuration is also supported.
 
 ```json
 {
@@ -489,11 +489,11 @@ Rascal uses [superagent](https://github.com/visionmedia/superagent) under the ho
 }
 ```
 
-You can also supply your own agent via the broker components. Use this when you need to set [TLS options](https://visionmedia.github.io/superagent/#tls-options).
+You can also supply your own agent via the broker components. Use this when you need to set [TLS options](https://nodejs.org/api/https.html#httpsrequesturl-options-callback).
 
 ```js
-const superagent = require('superagent-defaults');
-const agent = superagent().on('request', (req) => console.log(req.url));
+const https = require('https');
+const agent = new https.Agent(options);
 const components = { agent };
 const broker = await Broker.create(config, components);
 ```
@@ -1534,7 +1534,7 @@ As mentioned previously, dead lettering invalid messages is a good strategy with
 ackOrNack(err, { strategy: 'republish', immediateNack: true });
 ```
 
-If you ever want to resend the message to the same queue you will have to remove the `properties.headers.rascal.<queue>.immediateNack` header first.
+Prior to Rascal v20.1.0, if you wanted to resend the message to the original queue you had to remove the `properties.headers.rascal.<queue>.immediateNack` header first. From v20.1.0, Rascal will ignore and remove the immediateNack header if the message's xDeath header indicates that the message was dead lettered after it was republished with immediateNack.
 
 ##### Forward
 

package/lib/amqp/SubscriberError.js

@@ -3,10 +3,11 @@ const format = require('util').format;
 const _ = require('lodash');
 const async = require('async');
 const setTimeoutUnref = require('../utils/setTimeoutUnref');
+const { EMPTY_X_DEATH } = require('./XDeath');
 
 module.exports = function SubscriptionRecovery(broker, vhost) {
   this.handle = function (session, message, err, recoveryOptions, next) {
-    debug('Handling subscriber error for message: %s', message.properties.messageId);
+    debug('Handling subscriber error for message: %s with error: %s', message.properties.messageId, err.message);
 
     async.eachSeries(
       [].concat(recoveryOptions || []).concat({ strategy: 'fallback-nack' }),
@@ -84,7 +85,11 @@ module.exports = function SubscriptionRecovery(broker, vhost) {
           _.set(publishOptions, 'headers.rascal.error.code', err.code);
           _.set(publishOptions, 'headers.rascal.restoreRoutingHeaders', _.has(strategyConfig, 'restoreRoutingHeaders') ? strategyConfig.restoreRoutingHeaders : true);
 
-          if (strategyConfig.immediateNack) _.set(publishOptions, ['headers', 'rascal', 'recovery', originalQueue, 'immediateNack'], true);
+          if (strategyConfig.immediateNack) {
+            const xDeathRecords = message.properties.headers['x-death'] || [];
+            const xDeath = xDeathRecords.find(({ queue, reason }) => queue === originalQueue && reason === 'rejected') || EMPTY_X_DEATH;
+            _.set(publishOptions, ['headers', 'rascal', 'recovery', originalQueue], { immediateNack: true, xDeath });
+          }
 
           const ackMessage = () => {
             session._ack(message, (err) => {

package/lib/amqp/Subscription.js

@@ -8,6 +8,7 @@ const SubscriberSession = require('./SubscriberSession');
 const SubscriberError = require('./SubscriberError');
 const backoff = require('../backoff');
 const setTimeoutUnref = require('../utils/setTimeoutUnref');
+const { EMPTY_X_DEATH } = require('./XDeath');
 
 module.exports = {
   create(broker, vhost, counter, config, next) {
@@ -95,7 +96,11 @@ function Subscription(broker, vhost, subscriptionConfig, counter) {
     session._incrementUnacknowledgeMessageCount(message.fields.consumerTag);
 
     decorateWithRoutingHeaders(message);
-    if (immediateNack(message)) return ackOrNack(session, message, true);
+    if (immediateNack(message)) {
+      debug('Immediately nacking message: %s from queue: %s', message.properties.messageId, config.queue);
+      ackOrNack(session, message, new Error('Immediate nack'));
+      return;
+    }
 
     decorateWithRedeliveries(message, (err) => {
       if (err) return handleRedeliveriesError(err, session, message);
@@ -208,8 +213,24 @@ function Subscription(broker, vhost, subscriptionConfig, counter) {
   }
 
   function immediateNack(message) {
-    if (_.get(message, ['properties', 'headers', 'rascal', 'recovery', message.properties.headers.rascal.originalQueue, 'immediateNack'])) return true;
-    return false;
+    const originalQueue = message.properties.headers.rascal.originalQueue;
+    const xDeathRecords = message.properties.headers['x-death'] || [];
+    const currentXDeath = xDeathRecords.find(({ queue, reason }) => queue === originalQueue && reason === 'rejected') || EMPTY_X_DEATH;
+    const previousXDeath = _.get(message, ['properties', 'headers', 'rascal', 'recovery', originalQueue, 'xDeath'], EMPTY_X_DEATH);
+    const hasImmediateNackHeader = _.has(message, ['properties', 'headers', 'rascal', 'recovery', originalQueue, 'immediateNack']);
+    if (!hasImmediateNackHeader) return false;
+    debug('Message %s has been marked for immediate nack. Previous xDeath is %o. Current xDeath is %o.', message.properties.messageId, previousXDeath, currentXDeath);
+    // See https://github.com/rabbitmq/rabbitmq-server/issues/11331
+    // RabbitMQ v3.13 stopped updating the xDeath record's count property.
+    // RabbitMQ v3.12 does not update the xDeath record's time property.
+    // Therefore having test them both
+    if (currentXDeath.count > previousXDeath.count || currentXDeath.time.value > previousXDeath.time.value) {
+      debug('Message %s has been replayed after being dead lettered. Removing immediate nack.', message.properties.messageId);
+      _.unset(message, ['properties', 'headers', 'rascal', 'recovery', originalQueue, 'immediateNack']);
+      _.unset(message, ['properties', 'headers', 'rascal', 'recovery', originalQueue, 'xDeath']);
+      return false;
+    }
+    return true;
   }
 
   function getAckOrNack(session, message) {

package/lib/amqp/XDeath.js

@@ -0,0 +1,5 @@
+const EMPTY_X_DEATH = { count: 0, time: { value: 0 } };
+
+module.exports = {
+  EMPTY_X_DEATH,
+};

package/lib/config/configure.js

@@ -1,13 +1,14 @@
 const debug = require('debug')('rascal:config:configure');
 const format = require('util').format;
 const url = require('url');
-const { URL } = require('node:url');
 const _ = require('lodash');
 const uuid = require('uuid').v4;
 const XRegExp = require('xregexp');
 const baseline = require('./baseline');
 const fqn = require('./fqn');
 
+const { URL } = url;
+
 module.exports = _.curry((rascalConfig, next) => {
   rascalConfig = _.defaultsDeep(rascalConfig, baseline);
 

package/lib/management/Client.js

@@ -1,16 +1,14 @@
+const http = require('http');
 const debug = require('debug')('rascal:management:client');
 const format = require('util').format;
-const _ = require('lodash');
-const defaultAgent = require('superagent');
 
-function Client(suppliedAgent) {
-  const agent = suppliedAgent || defaultAgent;
+function Client(agent) {
   const self = this;
 
   this.assertVhost = function (name, config, next) {
     debug('Asserting vhost: %s', name);
-    const options = getVhostOptions(name, config);
-    self._request('put', options.url, options.timeout, (err) => {
+    const url = getUrl(name, config);
+    self._request('PUT', url, config.options, (err) => {
       if (!err) return next();
       const _err = err.status ? new Error(format('Failed to assert vhost: %s. %s returned status %d', name, config.loggableUrl, err.status)) : err;
       return next(_err);
@@ -19,8 +17,8 @@ function Client(suppliedAgent) {
 
   this.checkVhost = function (name, config, next) {
     debug('Checking vhost: %s', name);
-    const options = getVhostOptions(name, config);
-    self._request('get', options.url, options.timeout, (err) => {
+    const url = getUrl(name, config);
+    self._request('GET', url, config.options, (err) => {
       if (!err) return next();
       const _err = err.status ? new Error(format('Failed to check vhost: %s. %s returned status %d', name, config.loggableUrl, err.status)) : err;
       return next(_err);
@@ -29,26 +27,29 @@ function Client(suppliedAgent) {
 
   this.deleteVhost = function (name, config, next) {
     debug('Deleting vhost: %s', name);
-    const options = getVhostOptions(name, config);
-    self._request('delete', options.url, options.timeout, (err) => {
+    const url = getUrl(name, config);
+    self._request('DELETE', url, config.options, (err) => {
       if (!err) return next();
       const _err = err.status ? new Error(format('Failed to delete vhost: %s. %s returned status %d', name, config.loggableUrl, err.status)) : err;
       return next(_err);
     });
   };
 
-  this._request = function (method, url, timeout, next) {
-    agent[method](url)
-      .timeout({ deadline: timeout })
-      .then(() => {
-        next();
-      })
-      .catch(next);
+  this._request = function (method, url, options, next) {
+    const req = http.request(url, { ...options, method, agent }, (res) => {
+      if (res.statusCode >= 300) {
+        const err = Object.assign(new Error('HTTP Error'), { status: res.statusCode });
+        return next(err);
+      }
+      res.on('data', () => {});
+      res.on('end', () => next());
+    });
+    req.on('error', next);
+    req.end();
   };
 
-  function getVhostOptions(name, config) {
-    const url = format('%s/%s/%s', config.url, 'api/vhosts', name);
-    return _.defaultsDeep({ url }, config.options);
+  function getUrl(name, config) {
+    return format('%s/%s/%s', config.url, 'api/vhosts', name);
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rascal",
-  "version": "19.0.0",
+  "version": "20.1.0",
   "description": "A config driven wrapper for amqplib supporting multi-host connections, automatic error recovery, redelivery flood protection, transparent encryption / decryption,  channel pooling and publication timeouts",
   "main": "index.js",
   "dependencies": {
@@ -12,7 +12,6 @@
     "lru-cache": "^7.10.1",
     "safe-json-parse": "^4.0.0",
     "stashback": "^2.0.1",
-    "superagent": "^8.0.9",
     "uuid": "^8.3.2",
     "xregexp": "^5.1.0"
   },
@@ -27,7 +26,6 @@
     "lint-staged": "^11.2.4",
     "nyc": "^15.1.0",
     "random-readable": "^1.0.1",
-    "superagent-defaults": "^0.1.14",
     "zunit": "^4.0.0"
   },
   "peerDependencies": {
@@ -42,7 +40,7 @@
     "lint:fix": "eslint --fix .",
     "lint-staged": "lint-staged",
     "coverage": "nyc --report html --reporter lcov --reporter text-summary zUnit",
-    "docker": "docker run -d --name rascal-rabbitmq -p 5672:5672 -p 15672:15672 rabbitmq:3-management",
+    "docker": "docker run -d --name rascal-rabbitmq -p 5672:5672 -p 15672:15672 rabbitmq:3.12.9-management-alpine",
     "prepare": "husky install"
   },
   "lint-staged": {