keuss 1.6.10 → 1.6.13

package/Pipeline/Queue.js

@@ -167,6 +167,10 @@ class PipelinedMongoQueue extends Queue {
       this._embed_update_for_payload (upd, opts.update);
     }
 
+    if (opts.hdrs) {
+      _.each (opts.hdrs, (v, k) => upd.$set['hdrs.' + k] = v);
+    }
+
     this._col.updateOne (q, upd, {}, (err, result) => {
       if (err) return callback (err);
       callback (null, result && (result.modifiedCount == 1));
@@ -274,9 +278,15 @@ class PipelinedMongoQueue extends Queue {
 
 
   //////////////////////////////////////////////
-  // redefnition
+  // redefinition from Queue
   _move_to_deadletter (obj, cb) {
-    this.pl_step (obj._id, this._factory.deadletter_queue (), {}, (err, res) => {
+    const hdrs = {
+      'x-dl-from-queue': this.name (),
+      'x-dl-t': new Date().toISOString (),
+      'x-dl-tries': obj.tries
+    };
+
+    this.pl_step (obj._id, this._factory.deadletter_queue (), {hdrs}, (err, res) => {
       if (err) return cb (err);
       this._stats.incr ('get');
       this._factory.deadletter_queue ()._stats.incr ('put');

package/Queue.js

@@ -433,14 +433,14 @@ class Queue {
     let id = (obj._id ? obj._id : obj);
 
     if (
-      (obj.tries) &&
-      (this._factory.deadletter_queue ()) &&
-      (this._factory.max_ko ()) &&
-      (obj.tries > this._factory.max_ko ())
+      (obj.tries) &&                            // only if we got tries
+      (this._factory.deadletter_queue ()) &&    // AND the factory has a deadletter queue
+      (this._factory.max_ko ()) &&              // AND thee's a max ko attempts 
+      (obj.tries > this._factory.max_ko ()) &&  // AND we got enough tries
+      (this.name () != '__deadletter__')        // and this queue is not deadletter already
     ) {
       debug ('%s: too many retries (%d), moving to deadletter', obj._id, obj.tries);
       this._move_to_deadletter (obj, cb);
-      // TODO add from-what-queue to deadletter elements
     }
     else {
       this.rollback (id, next_t, (err, res) => {
@@ -537,13 +537,15 @@ class Queue {
   //////////////////////////////////
     async.parallel ({
       type:          cb => cb (null, this.type()),
+      capabilities:  cb => cb (null, this.capabilities ()),
+      factory:       cb => cb (null, this._factory.to_descriptor_obj ()),
       stats:         cb => this.stats (cb),
       paused:        cb => this.paused (cb),
       next_mature_t: cb => this.next_t (cb),
       size:          cb => this.size (cb),
       totalSize:     cb => this.totalSize (cb),
       schedSize:     cb => this.schedSize (cb),
-      resvSize:      cb => this.resvSize (cb)
+      resvSize:      cb => this.resvSize (cb)     
     }, cb);
   }
 
@@ -710,15 +712,23 @@ class Queue {
   /////////////////////////////////////////////
   _move_to_deadletter (obj, cb) {
     // commit and move to deadletter
-    // ALSO NOT IN deadletter queue (to void loop)
     // commit element in origin queue, push in deadletter afterwards
+    const opts = {
+      hdrs: _.clone (obj.hdrs || {})
+    };
+
+    // add some extra x-dl-* headers
+    opts.hdrs['x-dl-from-queue'] = this.name ();
+    opts.hdrs['x-dl-t'] = new Date().toISOString ();
+    opts.hdrs['x-dl-tries'] = obj.tries;
+
     this.commit (obj._id, err => {
       if (err) {
         debug ('while committing %s prior to moving to deadletter: %j', obj._id, err);
         return cb (err);
       }
 
-      this._factory.deadletter_queue ().push (obj.payload, (err, res) => {
+      this._factory.deadletter_queue ().push (obj.payload, opts, (err, res) => {
         if (err) {
           debug ('while moving %s to deadletter: %j', obj._id, err);
           return cb (err, 'deadletter');

package/TODO

@@ -9,7 +9,6 @@ prio 1
   + add some commonplace transforms (etl-like)
   + create a server for that, allow processor code defined externally
 
-
 prio 0
 -----------------------------------------------------------------
 * bridges?

package/backends/bucket-mongo-safe.js

@@ -133,11 +133,13 @@ class Bucket {
         q: q
       });
 
-      if ((res && res.result && res.result.n) != 1) return cb({
-        err: 'Bucket flush: exactly one must be deleted',
-        e: err,
-        q: q
-      });
+      if ((res && res.deletedCount) != 1) {
+        return cb({
+          err: 'Bucket flush: exactly one must be deleted',
+          e: err,
+          q: q
+        });
+      }
 
       debug ('Bucket: deleted whole bucket %o', q);
       cb (null, null);
@@ -216,7 +218,7 @@ class Bucket {
           q: q
         });
 
-        if ((res && res.result && res.result.nModified) != 1) return cb({
+        if (res && (res.modifiedCount != 1)) return cb({
           err: 'Bucket flush: exactly one must be updated',
           e: err,
           q: q,
@@ -650,17 +652,15 @@ class BucketMongoSafeQueue extends Queue {
   //////////////////////////////////
   // queue size including non-mature elements
   totalSize (callback) {
-    this._col.aggregate ([
+    const cursor = this._col.aggregate ([
       {$group:{_id:'t', v: {$sum: '$n'}}}
-    ], (err, cursor) => {
-      if (err) return callback (err);
+    ]);
 
-      cursor.toArray ((err, res) => {
-        debug ('calculating totalSize: aggregation pipeline returns %o', res);
-        if (err) return callback (err);
-        if (res.length == 0) return callback (null, 0);
-        callback (null, res[0].v);
-      });
+    cursor.toArray ((err, res) => {
+      debug ('calculating totalSize: aggregation pipeline returns %o', res);
+      if (err) return callback (err);
+      if (res.length == 0) return callback (null, 0);
+      callback (null, res[0].v);
     });
   }
 
@@ -668,18 +668,16 @@ class BucketMongoSafeQueue extends Queue {
   //////////////////////////////////
   // queue size NOT including non-mature elements
   size (callback) {
-    this._col.aggregate ([
+    const cursor = this._col.aggregate ([
       {$match: {mature: {$lte: Queue.now ()}}},
       {$group:{_id:'t', v: {$sum: '$n'}}}
-    ], (err, cursor) => {
-      if (err) return callback (err);
+    ]);
 
-      cursor.toArray ((err, res) => {
-        debug ('calculating size: aggregation pipeline returns %o', res);
-        if (err) return callback (err);
-        if (res.length == 0) return callback (null, 0);
-        callback (null, res[0].v);
-      });
+    cursor.toArray ((err, res) => {
+      debug ('calculating size: aggregation pipeline returns %o', res);
+      if (err) return callback (err);
+      if (res.length == 0) return callback (null, 0);
+      callback (null, res[0].v);
     });
   }
 
@@ -687,42 +685,39 @@ class BucketMongoSafeQueue extends Queue {
   //////////////////////////////////
   // queue size of non-mature elements only
   schedSize (callback) {
-    this._col.aggregate ([
+    const cursor = this._col.aggregate ([
       {$match: {
         mature: {$gt: Queue.now ()},
         reserved: {$exists: false}
       }},
       {$group:{_id:'t', v: {$sum: '$n'}}}
-    ], (err, cursor) => {
-      if (err) return callback (err);
+    ]);
 
-      cursor.toArray ((err, res) => {
-        debug ('calculating schedSize: aggregation pipeline returns %o', res);
-        if (err) return callback (err);
-        if (res.length == 0) return callback (null, 0);
-        callback (null, res[0].v);
-      });
+    cursor.toArray ((err, res) => {
+      debug ('calculating schedSize: aggregation pipeline returns %o', res);
+      if (err) return callback (err);
+      if (res.length == 0) return callback (null, 0);
+      callback (null, res[0].v);
     });
   }
 
+
   //////////////////////////////////
   // queue size of non-mature elements only
   resvSize (callback) {
-    this._col.aggregate ([
+    const cursor = this._col.aggregate ([
       {$match: {
         mature: {$gt: Queue.now ()},
         reserved: {$exists: true}
       }},
       {$group:{_id:'t', v: {$sum: '$n'}}}
-    ], (err, cursor) => {
-      if (err) return callback (err);
+    ]);
 
-      cursor.toArray ((err, res) => {
-        debug ('calculating resvSize: aggregation pipeline returns %o', res);
-        if (err) return callback (err);
-        if (res.length == 0) return callback (null, 0);
-        callback (null, res[0].v);
-      });
+    cursor.toArray ((err, res) => {
+      debug ('calculating resvSize: aggregation pipeline returns %o', res);
+      if (err) return callback (err);
+      if (res.length == 0) return callback (null, 0);
+      callback (null, res[0].v);
     });
   }
 
@@ -730,7 +725,11 @@ class BucketMongoSafeQueue extends Queue {
   /////////////////////////////////////////
   // get element from queue
   next_t (callback) {
-    this._col.find ({}).limit(1).sort ({mature:1}).project ({mature:1}).next ((err, result) => {
+    this._col.findOne ({}, {
+      sort:       {mature:1},
+      projection: {mature: 1}
+    },
+    (err, result) => {
       if (err) return callback (err);
       debug ('obtaining next_t: got %o', result && result.mature);
       callback (null, result && result.mature);
@@ -738,7 +737,6 @@ class BucketMongoSafeQueue extends Queue {
   }
 
 
-
   //////////////////////////////////////////////
   // remove by id
   remove (id, callback) {

package/backends/bucket-mongo.js

@@ -205,16 +205,14 @@ class BucketMongoQueue extends Queue {
   // queue size including non-mature elements
   totalSize (callback) {
   //////////////////////////////////
-    this._col.aggregate ([
+    const cursor = this._col.aggregate ([
       {$group:{_id:'t', v: {$sum: '$n'}}}
-    ], (err, cursor) => {
-      if (err) return callback (err);
+    ]);
 
-      cursor.toArray ((err, res) => {
-        if (err) return callback (err);
-        if (res.length == 0) return callback (null, 0);
-        callback (null, res[0].v);
-      });
+    cursor.toArray ((err, res) => {
+      if (err) return callback (err);
+      if (res.length == 0) return callback (null, 0);
+      callback (null, res[0].v);
     });
   }
 

package/examples/snippets/06-random-consumer-producer.js

@@ -26,10 +26,10 @@ var factory_opts = {
 };
 
 // test dimensions: elems to produce and consume, number of consumers, number of producers
-const num_elems = 10000000;
+const num_elems = 1000000;
 const num_producers = 3;
 const num_consumers = 7;
-const commit_likelihood = 95;
+const commit_likelihood = 75;
 
 // stats holder
 var selfs = {
@@ -223,12 +223,12 @@ MQ (factory_opts, function (err, factory) {
   var q = factory.queue ('test_queue_456', q_opts);
 
   var timer = setInterval (() => {
-    console.log ('**** state: %j', _.map (shareds, (v, k) => {return {cnt: v.push_count || v.pop_count, max: v.push_max || v.pop_max }}));
+    console.log ('**** state: %o', _.map (shareds, (v, k) => {return {cnt: v.push_count || v.pop_count, max: v.push_max || v.pop_max }}));
    
     console.log ('das pop %d, ko %d, ok %d', das_pop, das_ko, das_ok);
 
     q.status ((err ,res) => {
-      console.log ('**** status: %j', res);
+      console.log ('**** status: %o', res);
     });
   }, 2000);
 
@@ -263,7 +263,7 @@ MQ (factory_opts, function (err, factory) {
     clearInterval (timer);
     
     q.status ((err ,res) => {
-      console.log ('**** status: %j', res);
+      console.log ('**** status: %o', res);
       q.drain (() => factory.close ());
     });
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "keuss",
-  "version": "1.6.10",
+  "version": "1.6.13",
   "keywords": [
     "queue",
     "persistent",
@@ -26,19 +26,19 @@
   },
   "license": "GPL-3.0",
   "dependencies": {
-    "@nodebb/mubsub": "~1.7.1",
+    "@nodebb/mubsub": "~1.8.0",
     "async": "~3.2.3",
     "async-lock": "~1.3.1",
-    "debug": "~4.3.3",
-    "ioredis": "~4.28.5",
+    "debug": "~4.3.4",
+    "ioredis": "~5.0.4",
     "lodash": "~4.17.21",
     "mitt": "~3.0.0",
-    "mongodb": "~3.6.12",
+    "mongodb": "~4.5.0",
     "uuid": "~8.3.2"
   },
   "devDependencies": {
     "chance": "~1.1.8",
-    "mocha": "~9.2.1",
+    "mocha": "~9.2.2",
     "should": "~13.2.3"
   },
   "scripts": {

package/test/backends_bucket-at-least-once.js

@@ -52,6 +52,7 @@ describe ('bucket-at-least-once with ' + MQ_item.label + ' queue backend', funct
       function (cb) {q.totalSize (cb)},
       function (cb) {q.next_t (cb)},
     ], function(err, results) {
+      if (err) return done (err);
       results.should.eql ([{get: 0, put: 0, reserve: 0, commit: 0, rollback: 0, deadletter: 0}, 0, 0, null])
       done();
     });
@@ -67,15 +68,15 @@ describe ('bucket-at-least-once with ' + MQ_item.label + ' queue backend', funct
       function (cb) {setTimeout (cb, 1111)},
       function (cb) {q.size (function (err, size) {
         size.should.equal (2);
-        cb();
+        cb(err);
       })},
       function (cb) {q.stats (function (err, res) {
         res.should.eql ({get: 0, put: 2, reserve: 0, commit: 0, rollback: 0, deadletter: 0});
-        cb();
+        cb(err);
       })},
       function (cb) {q.next_t (function (err, res) {
         res.getTime().should.be.approximately(new Date().getTime(), 2000);
-        cb();
+        cb(err);
       })},
       function (cb) {q.pop ('c1', function (err, ret) {
         ret.payload.should.eql ({elem:1, pl:'twetrwte'});
@@ -83,11 +84,11 @@ describe ('bucket-at-least-once with ' + MQ_item.label + ' queue backend', funct
       })},
       function (cb) {q.size (function (err, size) {
         size.should.equal (0);
-        cb();
+        cb(err);
       })},
       function (cb) {q.stats (function (err, res) {
         res.should.eql ({get: 1, put: 2, reserve: 0, commit: 0, rollback: 0, deadletter: 0});
-        cb();
+        cb(err);
       })},
       function (cb) {q.pop ('c2', function (err, ret) {
         ret.payload.should.eql ({elem:2, pl:'twetrwte'});
@@ -95,13 +96,14 @@ describe ('bucket-at-least-once with ' + MQ_item.label + ' queue backend', funct
       })},
       function (cb) {q.size (function (err, size) {
         size.should.equal (0);
-        cb();
+        cb(err);
       })},
       function (cb) {q.stats (function (err, res) {
         res.should.eql ({get: 2, put: 2, reserve: 0, commit: 0, rollback: 0, deadletter: 0});
-        cb();
+        cb(err);
       })},
     ], function(err, results) {
+      if (err) return done (err);
       q.drain();
       done();
     });
@@ -136,13 +138,14 @@ describe ('bucket-at-least-once with ' + MQ_item.label + ' queue backend', funct
       })},
       function (cb) {q.size (function (err, size) {
         size.should.equal (0);
-        cb();
+        cb(err);
       })},
       function (cb) {q.stats (function (err, res) {
         res.should.eql ({get: 2, put: 2, reserve: 0, commit: 0, rollback: 0, deadletter: 0});
-        cb();
+        cb(err);
       })},
     ], function(err, results) {
+      if (err) return done (err);
       q.drain();
       done();
     });
@@ -159,18 +162,18 @@ describe ('bucket-at-least-once with ' + MQ_item.label + ' queue backend', funct
       (cb) => q.push ({elem:4, pl:'twetrwte'}, cb),
       (cb) => setTimeout (cb, 666),
 
-      (cb) => q.size ((err, size) => {size.should.equal (4); cb(); }),
-      (cb) => q.stats ((err, res) => {res.should.eql ({get: 0, put: 4, reserve: 0, commit: 0, rollback: 0, deadletter: 0}); cb(); }),
+      (cb) => q.size ((err, size) => {size.should.equal (4); cb(err); }),
+      (cb) => q.stats ((err, res) => {res.should.eql ({get: 0, put: 4, reserve: 0, commit: 0, rollback: 0, deadletter: 0}); cb(err); }),
 
       (cb) => q.push ({elem:5, pl:'twetrwte'}, cb),
       (cb) => q.push ({elem:6, pl:'twetrwte'}, cb),
       (cb) => q.push ({elem:7, pl:'twetrwte'}, cb),
       (cb) => setTimeout (cb, 666),
 
-      (cb) => q.size ((err, size) => {size.should.equal (7); cb(); }),
-      (cb) => q.stats ((err, res) => {res.should.eql ({get: 0, put: 7, reserve: 0, commit: 0, rollback: 0, deadletter: 0}); cb(); }),
+      (cb) => q.size ((err, size) => {size.should.equal (7); cb(err); }),
+      (cb) => q.stats ((err, res) => {res.should.eql ({get: 0, put: 7, reserve: 0, commit: 0, rollback: 0, deadletter: 0}); cb(err); }),
 
-      (cb) => q.next_t ((err, res) => {res.getTime().should.be.approximately(new Date().getTime(), 2000); cb(); }),
+      (cb) => q.next_t ((err, res) => {res.getTime().should.be.approximately(new Date().getTime(), 2000); cb(err); }),
 
       (cb) => {q.pop ('c1', (err, ret) => {ret.payload.should.eql ({elem:1, pl:'twetrwte'}); cb (err); })},
       (cb) => {q.pop ('c1', (err, ret) => {ret.payload.should.eql ({elem:2, pl:'twetrwte'}); cb (err); })},
@@ -180,9 +183,10 @@ describe ('bucket-at-least-once with ' + MQ_item.label + ' queue backend', funct
       (cb) => {q.pop ('c1', (err, ret) => {ret.payload.should.eql ({elem:6, pl:'twetrwte'}); cb (err); })},
       (cb) => {q.pop ('c1', (err, ret) => {ret.payload.should.eql ({elem:7, pl:'twetrwte'}); cb (err); })},
 
-      (cb) => q.size ((err, size) => {size.should.equal (0); cb(); }),
-      (cb) => q.stats ((err, res) => {res.should.eql ({get: 7, put: 7, reserve: 0, commit: 0, rollback: 0, deadletter: 0}); cb(); }),
+      (cb) => q.size ((err, size) => {size.should.equal (0); cb(err); }),
+      (cb) => q.stats ((err, res) => {res.should.eql ({get: 7, put: 7, reserve: 0, commit: 0, rollback: 0, deadletter: 0}); cb(err); }),
     ], function(err, results) {
+      if (err) return done (err);
       q.drain();
       done();
     });
@@ -199,19 +203,19 @@ describe ('bucket-at-least-once with ' + MQ_item.label + ' queue backend', funct
       (cb) => q.push ({elem:4, pl:'twetrwte'}, {delay: 4}, cb),
       (cb) => setTimeout (cb, 700),
 
-      (cb) => q.next_t ((err, res) => {res.getTime().should.be.approximately(new Date().getTime() + 3300, 100); cb(); }),
+      (cb) => q.next_t ((err, res) => {res.getTime().should.be.approximately(new Date().getTime() + 3300, 100); cb(err); }),
 
       (cb) => q.push ({elem:5, pl:'twetrwte'}, {delay: 2}, cb),
       (cb) => q.push ({elem:6, pl:'twetrwte'}, {delay: 1}, cb),
       (cb) => q.push ({elem:7, pl:'twetrwte'}, {delay: 2}, cb),
       (cb) => setTimeout (cb, 700),
 
-      (cb) => q.next_t ((err, res) => {res.getTime().should.be.approximately(new Date().getTime() + 1300, 100); cb(); }),
+      (cb) => q.next_t ((err, res) => {res.getTime().should.be.approximately(new Date().getTime() + 1300, 100); cb(err); }),
 
-      (cb) => q.size ((err, size) => {size.should.equal (0); cb(); }),
-      (cb) => q.totalSize ((err, size) => {size.should.equal (7); cb(); }),
-      (cb) => q.schedSize ((err, size) => {size.should.equal (7); cb(); }),
-      (cb) => q.stats ((err, res) => {res.should.eql ({get: 0, put: 7, reserve: 0, commit: 0, rollback: 0, deadletter: 0}); cb(); }),
+      (cb) => q.size ((err, size) => {size.should.equal (0); cb(err); }),
+      (cb) => q.totalSize ((err, size) => {size.should.equal (7); cb(err); }),
+      (cb) => q.schedSize ((err, size) => {size.should.equal (7); cb(err); }),
+      (cb) => q.stats ((err, res) => {res.should.eql ({get: 0, put: 7, reserve: 0, commit: 0, rollback: 0, deadletter: 0}); cb(err); }),
 
       (cb) => {q.pop ('c1', (err, ret) => {ret.payload.should.eql ({elem:5, pl:'twetrwte'}); cb (err); })},
       (cb) => {q.pop ('c1', (err, ret) => {ret.payload.should.eql ({elem:6, pl:'twetrwte'}); cb (err); })},
@@ -221,9 +225,10 @@ describe ('bucket-at-least-once with ' + MQ_item.label + ' queue backend', funct
       (cb) => {q.pop ('c1', (err, ret) => {ret.payload.should.eql ({elem:3, pl:'twetrwte'}); cb (err); })},
       (cb) => {q.pop ('c1', (err, ret) => {ret.payload.should.eql ({elem:4, pl:'twetrwte'}); cb (err); })},
 
-      (cb) => q.size ((err, size) => {size.should.equal (0); cb(); }),
-      (cb) => q.stats ((err, res) => {res.should.eql ({get: 7, put: 7, reserve: 0, commit: 0, rollback: 0, deadletter: 0}); cb(); }),
+      (cb) => q.size ((err, size) => {size.should.equal (0); cb(err); }),
+      (cb) => q.stats ((err, res) => {res.should.eql ({get: 7, put: 7, reserve: 0, commit: 0, rollback: 0, deadletter: 0}); cb(err); }),
     ], function(err, results) {
+      if (err) return done (err);
       q.drain();
       done();
     });
@@ -238,19 +243,20 @@ describe ('bucket-at-least-once with ' + MQ_item.label + ' queue backend', funct
       (cb) => q.push ({elem:2, pl:'twetrwte'}, cb),
       (cb) => setTimeout (cb, 700),
 
-      (cb) => q.size ((err, size) => {size.should.equal (2); cb(); }),
-      (cb) => q.stats ((err, res) => {res.should.eql ({get: 0, put: 2, reserve: 0, commit: 0, rollback: 0, deadletter: 0}); cb(); }),
+      (cb) => q.size ((err, size) => {size.should.equal (2); cb(err); }),
+      (cb) => q.stats ((err, res) => {res.should.eql ({get: 0, put: 2, reserve: 0, commit: 0, rollback: 0, deadletter: 0}); cb(err); }),
 
       (cb) => q.push ({elem:3, pl:'twetrwte'}, cb),
       (cb) => setTimeout (cb, 700),
 
-      (cb) => q.size ((err, size) => {size.should.equal (3); cb(); }),
-      (cb) => q.stats ((err, res) => {res.should.eql ({get: 0, put: 3, reserve: 0, commit: 0, rollback: 0, deadletter: 0}); cb(); }),
+      (cb) => q.size ((err, size) => {size.should.equal (3); cb(err); }),
+      (cb) => q.stats ((err, res) => {res.should.eql ({get: 0, put: 3, reserve: 0, commit: 0, rollback: 0, deadletter: 0}); cb(err); }),
 
-      (cb) => q.next_t ((err, res) => {res.getTime().should.be.approximately(new Date().getTime() - 1400, 100); cb(); }),
+      (cb) => q.next_t ((err, res) => {res.getTime().should.be.approximately(new Date().getTime() - 1400, 100); cb(err); }),
 
       (cb) => {
         q.pop ('c1', {reserve: true}, (err, ret) => {
+          if (err) return cb (err);
           ret.payload.should.eql ({elem:1, pl:'twetrwte'});
           q.ko (ret._id, (new Date().getTime() + 5000 ), (err, res) => {
             should (res).equal (true);
@@ -263,6 +269,7 @@ describe ('bucket-at-least-once with ' + MQ_item.label + ' queue backend', funct
 
       (cb) => {
         q.pop ('c1', {reserve: true}, (err, ret) => {
+          if (err) return cb (err);
           ret.payload.should.eql ({elem:3, pl:'twetrwte'});
           q.ko (ret._id, (new Date().getTime() + 3000 ), (err, res) => {
             should (res).equal (true);
@@ -273,18 +280,19 @@ describe ('bucket-at-least-once with ' + MQ_item.label + ' queue backend', funct
 
       (cb) => setTimeout (cb, 700),
 
-      (cb) => q.next_t ((err, res) => {res.getTime().should.be.approximately(new Date().getTime() + 2500, 500); cb(); }),
+      (cb) => q.next_t ((err, res) => {res.getTime().should.be.approximately(new Date().getTime() + 2500, 500); cb(err); }),
 
-      (cb) => q.size ((err, size) => {size.should.equal (0); cb(); }),
-      (cb) => q.totalSize ((err, size) => {size.should.equal (2); cb(); }),
-      (cb) => q.schedSize ((err, size) => {size.should.equal (2); cb(); }),
+      (cb) => q.size ((err, size) => {size.should.equal (0); cb(err); }),
+      (cb) => q.totalSize ((err, size) => {size.should.equal (2); cb(err); }),
+      (cb) => q.schedSize ((err, size) => {size.should.equal (2); cb(err); }),
 
       (cb) => {q.pop ('c1', (err, ret) => {ret.payload.should.eql ({elem:3, pl:'twetrwte'}); cb (err); })},
       (cb) => {q.pop ('c1', (err, ret) => {ret.payload.should.eql ({elem:1, pl:'twetrwte'}); cb (err); })},
 
-      (cb) => q.size ((err, size) => {size.should.equal (0); cb(); }),
-      (cb) => q.stats ((err, res) => {res.should.eql ({get: 3, put: 3, reserve: 2, commit: 0, rollback: 2, deadletter: 0}); cb(); }),
+      (cb) => q.size ((err, size) => {size.should.equal (0); cb(err); }),
+      (cb) => q.stats ((err, res) => {res.should.eql ({get: 3, put: 3, reserve: 2, commit: 0, rollback: 2, deadletter: 0}); cb(err); }),
     ], function(err, results) {
+      if (err) return done (err);
       q.drain();
       done();
     });

package/test/backends_deadletter.js

@@ -111,6 +111,8 @@ function release_mq_factory (q, factory, cb) {
         pl: 'twetrwte'
       };
 
+      const hdrs = {aaa: 'qw', bbb: '666'};
+
       async.waterfall ([
         cb => get_mq_factory (MQ, factory_opts, cb),
         (factory, cb) => {
@@ -120,7 +122,7 @@ function release_mq_factory (q, factory, cb) {
 
           async.race ([
             cb => async.series([
-              cb => q.push (pl, cb),
+              cb => q.push (pl, {hdrs}, cb),
               cb => pop (q, stage, cb),
               cb => reject (q, stage, (err) => {tries++;cb()}),
               cb => pop (q, stage, cb),
@@ -139,6 +141,13 @@ function release_mq_factory (q, factory, cb) {
             }),
             cb => factory.deadletter_queue().pop('c2', (err, res) => {
               res.payload.should.eql (pl);
+              res.hdrs.should.match ({
+                aaa: "qw",
+                bbb: "666",
+                'x-dl-from-queue': "test_queue_deadletter",
+                'x-dl-t': /.+/,
+                'x-dl-tries': 4
+              });
               tries.should.equal (5);
               cb (err);
             })