comq 0.11.0 → 0.11.2

package/features/events.poison.feature

@@ -0,0 +1,22 @@
+Feature: Poison events
+
+  Background:
+    Given an active connection to the broker
+
+  @manual
+  Scenario: Sending a poison event
+
+    This scenario will cause an exception, run it once.
+
+    Given that events from the `poison` exchange are causing exceptions
+    Then an event is emitted to the `poison` exchange
+    And after 100ms
+
+  @manual
+  Scenario: Consuming poison events
+
+    After the poison event is sent, run this scenario five times
+    and verify that the poison event was discarded.
+
+    Given that events from the `poison` exchange are causing exceptions
+    And after 100ms

package/features/rpc.feature

@@ -31,15 +31,6 @@ Feature: Request-reply (RPC)
       null
       """
 
-  Scenario: Request causing an exception is discarded
-    Given function replying `throw_error` queue:
-    """
-    () => { throw new Error() }
-    """
-    When the consumer sends a request to the `throw_error` queue
-    Then the message is discarded
-    And the consumer does not receive the reply
-
   Scenario: Streaming requests
     Given a producer replying `ping` queue
     When the consumer sends 1k requests to the `ping` queue as a stream

package/features/steps/events.js

@@ -38,6 +38,17 @@ Given('(that )events are exclusively consumed from the {token} exchange',
     this.consumptionPromise = consume.call(this, undefined, exchange)
   })
 
+Given('(that )events from the {token} exchange are causing exceptions',
+  /**
+   * @param {string} exchange
+   * @this {comq.features.Context}
+   */
+  async function (exchange) {
+    await this.io.consume(exchange, 'exceptions', () => {
+      throw new Error('Expected exception')
+    })
+  })
+
 When('an event is emitted to the {token} exchange',
   /**
    * @param {string} exchange

package/features/steps/poison.js

@@ -9,7 +9,7 @@ Then('the message is discarded',
    * @this {comq.features.Context}
    */
   async function () {
-    if (this.events.discard !== true) await timeout(50)
+    if (this.events.discard !== true) await timeout(300)
 
     assert.equal(this.events.discard, true, 'The {message} was not discarded')
   })

package/lerna.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.11.0",
+  "version": "0.11.2",
   "conventionalCommits": true
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "comq",
-  "version": "0.11.0",
+  "version": "0.11.2",
   "description": "ComQ",
   "author": {
     "name": "Artem Gurtovoi",
@@ -48,7 +48,7 @@
   "scripts": {
     "prepare": "echo run: husky install",
     "test": "standard && jest",
-    "features": "cucumber-js --fail-fast",
+    "features": "cucumber-js --fail-fast -t 'not @manual'",
     "lint": "standard --fix --verbose | snazzy"
   },
   "standard": {

package/readme.md

@@ -164,7 +164,7 @@ await io.emit('numbers_added', { a: 1, b: 2 })
 
 Publish encoded Task to the `queue`.
 
-On the initial call, the `queue` is asserted on the Events channel using Event topology.
+On the initial call, the `queue` is asserted on the Events channel using [Event topology](#topology).
 
 `async IO.process(queue: string, processor): void`
 
@@ -176,7 +176,7 @@ The `queue` is asserted on the Events channel using Event topology.
 
 ## Pipelines
 
-Payloads for Requests and Events can be passed as a readable stream
+Payloads for Requests, Events and Tasks can be passed as a readable stream
 in [object mode](https://nodejs.org/api/stream.html#object-mode), enabling the handling of large amounts of data with
 the benefits of RabbitMQ back pressure and flow control.
 
@@ -186,6 +186,8 @@ Returns a readable stream of replies.
 
 `async IO.emit(exchange: string, stream: Readable, encoding?: string): void`
 
+`async IO.enqueue(queue: string, stream: Readable, encoding?: string): void`
+
 ```javascript
 function * generate () {
   yield { a: 1, b: 2 };
@@ -196,6 +198,10 @@ const events = Readable.from(generate())
 
 await io.emit('numbers_added', events)
 
+const tasks = Readable.from(generate())
+
+await io.enqueue('add_numbers', tasks)
+
 const requests = Readable.from(generate())
 
 for await (const reply of io.request('add_numbers', requests))
@@ -405,8 +411,9 @@ See [queue assertion options](https://amqp-node.github.io/amqplib/channel_api.ht
   manual [acknowledgment mode](https://www.rabbitmq.com/confirms.html#acknowledgment-modes),
   and Replies are consumed using automatic mode.
 
-If an incoming message causes an exception, then it is "negatively acknowledged" and requeued. If it
-causes an exception again, it will be discarded.
+If an incoming message causes an exception, the corresponding channel is sealed, the message is republished, and the
+exception is thrown.
+If the message causes exceptions five times in a row, it is discarded.
 
 > It is highly recommended to set up a dead letter exchange policy to analyze messages that caused
 > exceptions. Note that in some cases, if the problematic message is a Request, a Consumer will

package/source/channel.js

@@ -58,6 +58,8 @@ class Channel {
     if (this.#topology.confirms) this.#channel = await this.#connection.createConfirmChannel()
     else this.#channel = await this.#connection.createChannel()
 
+    await this.#channel.prefetch(this.#topology.prefetch)
+
     this.#channel.on('drain', this.#unpause)
     this.#channel.on('return', (message) => this.#diagnostics.emit('return', message))
   }
@@ -267,18 +269,29 @@ class Channel {
 
         this.#channel.ack(message)
       } catch (exception) {
-        if (exception.message === 'Channel closed') return // the message will be requeued by the broker
+        if (exception.message === 'Channel closed') { return } // the message is requeued by the broker
+
+        const redeliveries = message.properties.headers[REDELIVERY_HEADER] ?? 0
 
-        if (message.fields.redelivered) this.#discard(message, exception)
-        else this.#requeue(message)
+        if (redeliveries >= MAX_REDELIVERIES) this.#discard(message, exception)
+        else {
+          await this.#requeue(message, redeliveries)
+          throw exception
+        }
       }
     }
 
   /**
    * @param {comq.amqp.Message} message
+   * @param {number} attempt
    */
-  #requeue (message) {
-    this.#channel.nack(message, false, true)
+  async #requeue (message, attempt) {
+    this.#channel.ack(message)
+
+    message.properties.headers[REDELIVERY_HEADER] = attempt + 1
+
+    await this.seal()
+    await this.#publish(message.fields.exchange, message.fields.routingKey, message.content, message.properties)
   }
 
   /**
@@ -358,6 +371,9 @@ const EXCLUSIVE = { exclusive: true }
 
 const INTERRUPTION = /** @type {Error} */ Symbol('internal interruption')
 
+const MAX_REDELIVERIES = 5
+const REDELIVERY_HEADER = 'x-attempt'
+
 function noop () {}
 
 exports.create = create

package/test/channel.test.js

@@ -42,6 +42,13 @@ it('should return Channel', async () => {
   expect(channel).toBeDefined()
 })
 
+it('should set prefetch limit', async () => {
+  channel = await create(connection, topology)
+  chan = await getCreatedChannel()
+
+  expect(chan.prefetch).toHaveBeenCalledWith(topology.prefetch)
+})
+
 it.each([true, false])('should create channel (confirms: %s)', async (confirms) => {
   const method = `create${confirms ? 'Confirm' : ''}Channel`
 
@@ -134,32 +141,6 @@ describe('acknowledgments', () => {
     else expect(options).toMatchObject({ noAck: true })
   })
 
-  it.each(/** @type {[string, boolean][]} */ [
-    ['nack', true],
-    ['discard', false]
-  ])('should %s the message caused an exception', async (_, requeue) => {
-    topology.acknowledgments = true
-
-    channel = await create(connection, topology)
-    chan = await getCreatedChannel()
-
-    const consumer = /** @type {Function} */ jest.fn(async () => { throw new Error() })
-
-    await channel.consume(queue, consumer)
-
-    const callback = chan.consume.mock.calls[0][1]
-    const content = randomBytes(8)
-    const properties = {}
-    const fields = {}
-    const message = /** @type {comq.amqp.Message} */ { content, properties, fields }
-
-    if (!requeue) fields.redelivered = !requeue
-
-    await callback(message)
-
-    expect(chan.nack).toHaveBeenCalledWith(message, false, requeue)
-  })
-
   it('should ignore Channel ended exception', async () => {
     topology.acknowledgments = true
 
@@ -844,10 +825,7 @@ describe('diagnostics', () => {
     expect(resumed).toStrictEqual(true)
   })
 
-  it.each(/** @type {[string, boolean][]} */ [
-    ['', true],
-    [' not', false]
-  ])('should%s emit `discard` event', async (_, redelivered) => {
+  it('should emit `discard` event', async () => {
     jest.clearAllMocks()
 
     topology.acknowledgments = true
@@ -866,14 +844,12 @@ describe('diagnostics', () => {
 
     const callback = /** @type {Function} */ chan.consume.mock.calls[0][1]
     const content = randomBytes(8)
-    const properties = {}
-    const fields = { redelivered }
-    const message = /** @type {comq.amqp.Message} */ { content, properties, fields }
+    const properties = { headers: { 'x-attempt': 5 } }
+    const message = /** @type {comq.amqp.Message} */ { content, properties }
 
     await callback(message)
 
-    if (redelivered) expect(listener).toHaveBeenCalledWith(message, exception)
-    else expect(listener).not.toHaveBeenCalled()
+    expect(listener).toHaveBeenCalledWith(message, exception)
   })
 })