comq 0.23.0 → 0.24.1

package/features/steps/networks.js

@@ -48,9 +48,19 @@ class Network {
   /**
    * Only the tunnels that are already open go silent: a connection established
    * afterwards is forwarded as usual, just as it is once a machine is awake.
+   *
+   * The broker notices a silent connection by its heartbeat as soon as the client does. One
+   * that is to be held by the broker for as long as the scenario needs is kept heard from:
+   * heartbeats are sent to the broker in the client's stead, until the network lets it go.
+   *
+   * @param {boolean} [heard] whether the broker goes on hearing heartbeats
    */
-  silence () {
-    for (const tunnel of this.#tunnels) tunnel.silent = true
+  silence (heard = false) {
+    for (const tunnel of this.#tunnels) {
+      tunnel.silent = true
+
+      if (heard) tunnel.heartbeat ??= setInterval(() => tunnel.upstream.write(HEARTBEAT), HEARTBEAT_MS)
+    }
   }
 
   /**
@@ -65,6 +75,17 @@ class Network {
     this.#refusing = false
   }
 
+  /**
+   * Takes the broker away from whoever is connected through this network: the tunnels that are
+   * open are closed at both ends, and a connection attempted from now on is refused until the
+   * network admits it.
+   */
+  cut () {
+    this.refuse()
+
+    for (const tunnel of this.#tunnels) this.#collapse(tunnel)
+  }
+
   /**
    * Closes the tunnels that went silent, at both ends, so the broker learns that the
    * connection it was still holding is gone — the moment its heartbeat would otherwise tell it.
@@ -117,10 +138,18 @@ class Network {
    * @param {comq.features.Tunnel} tunnel
    */
   #collapse (tunnel) {
+    clearInterval(tunnel.heartbeat)
+
     this.#tunnels.delete(tunnel)
     tunnel.client.destroy()
     tunnel.upstream.destroy()
   }
 }
 
+/** An AMQP heartbeat frame: type 8, channel 0, no payload, and the frame end. */
+const HEARTBEAT = Buffer.from([8, 0, 0, 0, 0, 0, 0, 0xCE])
+
+/** Often enough for the shortest heartbeat a scenario asks for. */
+const HEARTBEAT_MS = 250
+
 exports.Network = Network

package/features/steps/parking.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const assert = require('node:assert')
-const amqplib = require('amqplib')
+const amqplib = require('@toa.io/amqplib')
 const { Given, When, Then } = require('@cucumber/cucumber')
 
 const { getAddress, USER, PASSWORD } = require('./brokers')
@@ -58,7 +58,7 @@ Then('a message parked from the {token} exchange is in the parking queue',
  * Runs `read` against a connection of its own, so that what it does to the parking
  * queue is not what comq is doing to it.
  *
- * @param {(channel: import('amqplib').Channel) => Promise<void>} read
+ * @param {(channel: import('@toa.io/amqplib').Channel) => Promise<void>} read
  */
 async function reading (read) {
   const connection = await amqplib.connect(`amqp://${USER}:${PASSWORD}@${getAddress(0)}`)
@@ -77,9 +77,9 @@ async function reading (read) {
  * every scenario before this one left in it, so everything that does not match is given
  * back; the match is left unacknowledged, for the caller to take or to return.
  *
- * @param {import('amqplib').Channel} channel
- * @param {(message: import('amqplib').GetMessage) => boolean} matches
- * @returns {Promise<import('amqplib').GetMessage | undefined>}
+ * @param {import('@toa.io/amqplib').Channel} channel
+ * @param {(message: import('@toa.io/amqplib').GetMessage) => boolean} matches
+ * @returns {Promise<import('@toa.io/amqplib').GetMessage | undefined>}
  */
 async function pick (channel, matches) {
   const deadline = Date.now() + DEADLINE

package/features/steps/retransmission.js

@@ -0,0 +1,165 @@
+'use strict'
+
+const assert = require('node:assert')
+const { Promex } = require('promex')
+const { Given, When, Then, After } = require('@cucumber/cucumber')
+
+const { connect } = require('../../')
+const { getAddress, USER, PASSWORD, BROKERS_AMOUNT } = require('./brokers')
+const { timeout, until } = require('../../test/helpers')
+
+Given('a producer on another connection counting the requests to the {token} queue, answering when told',
+  /**
+   * Connected to every broker directly, so that nothing done to the consumer's network reaches it.
+   * It takes every Request as it comes, counts how many times it has been handed each of them, and
+   * holds the replies back until it is told to answer: whatever the consumer re-sends by then is
+   * counted, however quickly the first attempt would have been answered.
+   *
+   * @param {string} queue
+   * @this {comq.features.Context}
+   */
+  async function (queue) {
+    const urls = Array.from({ length: BROKERS_AMOUNT }, (_, n) =>
+      `amqp://${USER}:${PASSWORD}@${getAddress(n)}`)
+
+    this.producer = await connect(...urls)
+    this.executions = new Map()
+    this.answering = new Promex()
+
+    await this.producer.reply(queue, async ({ id }) => {
+      this.executions.set(id, (this.executions.get(id) ?? 0) + 1)
+
+      await this.answering
+
+      return id
+    })
+  })
+
+When('the producer answers',
+  /**
+   * @this {comq.features.Context}
+   */
+  function () {
+    this.answering.resolve()
+  })
+
+When('the consumer sends {number} numbered requests to the {token} queue',
+  /**
+   * @param {number} amount
+   * @param {string} queue
+   * @this {comq.features.Context}
+   */
+  function (amount, queue) {
+    this.numbered = Array.from({ length: amount }, (_, id) => {
+      const reply = this.io.request(queue, { id })
+
+      // asserted on by a later step, and an unhandled rejection would end the run before it
+      reply.catch(() => undefined)
+
+      return reply
+    })
+  })
+
+When('the consumer\'s connection to broker {number} is cut',
+  /**
+   * The broker is taken away from the consumer alone: the connection closes at both ends, and the
+   * consumer is refused until it is restored. Returns once the consumer has noticed, so that what
+   * it sends next goes to the other broker.
+   *
+   * @param {number} broker
+   * @this {comq.features.Context}
+   */
+  async function (broker) {
+    let lost = false
+
+    this.io.diagnose('close', (_error, index) => { if (index === broker) lost = true })
+    this.networks[broker].cut()
+
+    assert.equal(await until(() => lost, 10_000), true,
+      `The consumer's connection to broker ${broker} was not lost`)
+  })
+
+When('the consumer\'s connection to broker {number} is restored',
+  /**
+   * Returns once the consumer's channels to that broker have recovered, which is when the
+   * requests it may have lost with it are re-sent.
+   *
+   * @param {number} broker
+   * @this {comq.features.Context}
+   */
+  async function (broker) {
+    const recovered = new Set()
+
+    this.io.diagnose('recover', (type, index) => { if (index === broker) recovered.add(type) })
+    this.networks[broker].admit()
+
+    const restored = () => recovered.has('request') && recovered.has('reply')
+
+    assert.equal(await until(restored, 20_000), true,
+      `The consumer's channels to broker ${broker} have not recovered`)
+  })
+
+When('the consumer\'s network to broker {number} goes silent',
+  /**
+   * @param {number} broker
+   * @this {comq.features.Context}
+   */
+  function (broker) {
+    this.networks[broker].silence()
+  })
+
+Then('every numbered request is answered within {number} seconds',
+  /**
+   * @param {number} seconds
+   * @this {comq.features.Context}
+   */
+  async function (seconds) {
+    const answered = new Array(this.numbered.length).fill(false)
+
+    this.numbered.forEach((reply, id) => reply.then(() => { answered[id] = true }, () => undefined))
+
+    await until(() => answered.every(Boolean), seconds * 1000)
+
+    const unanswered = answered.flatMap((yes, id) => yes ? [] : [id])
+
+    assert.deepEqual(unanswered, [], `Requests ${unanswered.join(', ')} are not answered`)
+
+    for (const [id, reply] of this.numbered.entries()) assert.equal(await reply, id, 'Reply mismatch')
+  })
+
+Then('every numbered request has been executed {word}',
+  /**
+   * A re-sent Request is taken as soon as it arrives, so a moment is given for any copy still on
+   * its way to the producer to be counted.
+   *
+   * @param {'once' | 'twice'} times
+   * @this {comq.features.Context}
+   */
+  async function (times) {
+    const expected = TIMES[times]
+
+    await timeout(SETTLE_MS)
+
+    const executed = this.numbered.map((_, id) => this.executions.get(id) ?? 0)
+    const wrong = executed.flatMap((count, id) => count === expected ? [] : [`${id}: ${count}`])
+
+    assert.deepEqual(wrong, [], `Requests executed other than ${times} (id: times): ${wrong.join(', ')}`)
+  })
+
+After(
+  /**
+   * @this {comq.features.Context}
+   */
+  async function () {
+    this.answering?.resolve()
+    await this.producer?.close()
+
+    this.producer = undefined
+    this.executions = undefined
+    this.answering = undefined
+    this.numbered = undefined
+  })
+
+const TIMES = { once: 1, twice: 2 }
+
+const SETTLE_MS = 1000

package/features/steps/rpc.js

@@ -88,12 +88,6 @@ Given('idle timeout is set to {number}ms',
     global.COMQ_TESTING_IDLE_INTERVAL = value
   })
 
-Given('watchdog interval is set to {number}ms with {number}s AMQP heartbeat',
-  function (watchdog, heartbeat) {
-    global.COMQ_TESTING_WATCHDOG_INTERVAL = watchdog
-    global.COMQ_TESTING_AMQP_HEARTBEAT = heartbeat
-  })
-
 Given('a producer replying {token} queue',
   /**
    * @param {string} queue

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "comq",
-  "version": "0.23.0",
+  "version": "0.24.1",
   "description": "ComQ",
   "author": {
     "name": "Artem Gurtovoi",
@@ -34,7 +34,6 @@
     "@semantic-release/npm": "^13.1.2",
     "@semantic-release/release-notes-generator": "^14.1.0",
     "@testcontainers/rabbitmq": "^12.1.0",
-    "@types/amqplib": "^0.10.8",
     "@types/jest": "^30.0.0",
     "conventional-changelog-conventionalcommits": "^8.0.0",
     "fast-glob": "^3.3.3",
@@ -49,13 +48,16 @@
     "testcontainers": "^12.0.4"
   },
   "dependencies": {
-    "amqplib": "^2.0.1",
+    "@toa.io/amqplib": "^0.1.0",
     "promex": "^0.1.1",
     "reretry": "^0.1.0"
   },
+  "engines": {
+    "node": ">=24.0.0"
+  },
   "scripts": {
     "prepare": "husky",
-    "test": "standard && jest",
+    "test": "standard && NODE_OPTIONS=--experimental-vm-modules jest",
     "features": "cucumber-js --fail-fast -t 'not @manual'",
     "features:fast": "cucumber-js --fail-fast -t 'not @manual and not @heavy'",
     "benchmark": "node benchmarks/run.js",
@@ -65,5 +67,19 @@
     "env": [
       "jest"
     ]
+  },
+  "overrides": {
+    "test-exclude": "^8.0.0",
+    "rimraf": "^6.1.3",
+    "archiver-utils": {
+      "glob": "^13.0.6"
+    }
+  },
+  "allowScripts": {
+    "@parcel/watcher": false,
+    "cpu-features": false,
+    "protobufjs": false,
+    "ssh2": false,
+    "unrs-resolver": false
   }
 }

package/readme.md

@@ -6,8 +6,8 @@ for distributed, eventually consistent systems running on Node.js.
 ## Features
 
 - [Dynamic topology](#topology)
-- [Request](#request)-[reply](#reply) (RPC), with a [timeout](#timeout)
-- [Addressed requests](#addressed-requests) to the one connection holding a Key
+- [Request](#request)-[reply](#reply) (RPC)
+- [Addressed requests](#addressed-requests) to the one connection holding a Key, with a [timeout](#timeout)
 - Events ([pub](#emission)/[sub](#consumption)), fanned out or [routed](#routing)
 - [Tasks](#tasks)
 - [Pipelines](#pipelines)
@@ -107,51 +107,22 @@ await io.reply('add_numbers', ({ a, b }) => (a + b))
 
 ## Request
 
-`async IO.request(queue: string, payload: any, options?: string | RequestOptions): any`
+`async IO.request(queue: string, payload: any, encoding?: string): any`
 
 Send encoded Request message with `replyTo` and `correlationId` properties set and
-return decoded Reply content. The promise stays pending until the Reply arrives, or until the
-[timeout](#timeout) passes.
+return decoded Reply content. The promise stays pending until the Reply arrives, however long
+that takes: a Request has no timeout and cannot be withdrawn. One no Producer can answer is
+[parked](#parked-messages), and can still be answered while its caller waits.
 
 On the initial call, the queue for Requests is asserted, and so is the one this `IO` receives
 every Reply on.
 
-`options` is the encoding, or an object:
-
-| Option     | Type          | Default            |
-|------------|---------------|--------------------|
-| `encoding` | `string`      | `application/json` |
-| `timeout`  | `number`, ms  | none               |
-| `signal`   | `AbortSignal` | none               |
-
 ### Example
 
 ```javascript
 const sum = await io.request('add_numbers', { a: 1, b: 2 })
 ```
 
-### Timeout
-
-A Request with a `timeout` rejects once it passes, with the `TimeoutError` of
-[`AbortSignal.timeout`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/timeout_static).
-It is published with that much
-[expiration](https://www.rabbitmq.com/docs/ttl#per-message-ttl-in-publishers), so a Request no
-Producer has taken by then is dropped by the broker and never processed. A Request a Producer has
-already taken is processed to the end, and its Reply is discarded. A Request re-sent after a lost
-connection carries the time it has left.
-
-A `signal` rejects the Request with its reason once aborted, within the `timeout` where both are
-given. It ends the wait and leaves the Request where it is: in its queue until the `timeout`
-passes, or, without a `timeout`, until a Producer takes it. A Request abandoned by its `signal` may
-therefore still be processed.
-
-A Request that failed and waits for its [next attempt](#retries) loses its expiration on the way
-back to its queue, so it may be processed after its caller has stopped waiting.
-
-```javascript
-const sum = await io.request('add_numbers', { a: 1, b: 2 }, { timeout: 5000 })
-```
-
 ## Consumption
 
 `async IO.consume(exchange: string, group?: string, consumer): void`
@@ -231,7 +202,7 @@ await io.route('records', 'store.customers', { id: 2 }) // not delivered to the
 
 `async IO.back(exchange: string, key: string, producer): void`
 
-`async IO.call(exchange: string, key: string, payload: any, options?: string | RequestOptions): any`
+`async IO.call(exchange: string, key: string, payload: any, options?: string | CallOptions): any`
 
 A Request to the one connection holding a Key, where a [Request](#request) goes to whichever
 Producer takes it first.
@@ -245,8 +216,15 @@ is let go when its connection closes, however it closes — once the broker has
 connection that went without a word. `back` returns once a broker holds the Key. The rest of the
 connection works throughout, and a connection that is restored claims its Keys again the same way.
 
-`call` publishes the encoded Request to the exchange under the `key` and returns the decoded Reply,
-taking the same options as [`request`](#request).
+`call` publishes the encoded Request to the exchange under the `key` and returns the decoded Reply.
+
+`options` is the encoding, or an object:
+
+| Option     | Type          | Default            |
+|------------|---------------|--------------------|
+| `encoding` | `string`      | `application/json` |
+| `timeout`  | `number`, ms  | none               |
+| `signal`   | `AbortSignal` | none               |
 
 A call ends in one of three ways:
 
@@ -272,6 +250,24 @@ same Key can therefore hold it on different shards and both answer calls, and `t
 so. A call returned by one shard is published on the next, and refused once every shard has
 returned it.
 
+### Timeout
+
+A call with a `timeout` rejects once it passes, with the `TimeoutError` of
+[`AbortSignal.timeout`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/timeout_static).
+It is published with that much
+[expiration](https://www.rabbitmq.com/docs/ttl#per-message-ttl-in-publishers), so a call its holder
+has not taken by then is dropped by the broker and never processed. A call the holder has already
+taken is processed to the end, and its Reply is discarded. A call re-sent after a lost connection
+carries the time it has left.
+
+A `signal` rejects the call with its reason once aborted, within the `timeout` where both are
+given. It ends the wait and leaves the call where it is: in its queue until the `timeout` passes,
+or, without a `timeout`, until its holder takes it. A call abandoned by its `signal` may therefore
+still be processed.
+
+A call that failed and waits for its [next attempt](#retries) loses its expiration on the way back
+to its queue, so it may be processed after its caller has stopped waiting.
+
 ### Example
 
 ```javascript
@@ -461,8 +457,9 @@ Reconnection attempts will be made indefinitely, with intervals increasing up to
 Unless the URL sets one, a 15 second heartbeat is requested, so that a connection that is gone
 without a word, such as after a machine wakes from sleep, is noticed within a minute instead of
 being left to whatever the broker suggests.
-A connection that stays silent for three heartbeats is destroyed regardless of what the broker and
-the operating system have reported, since neither is guaranteed to report anything at all.
+A connection that has received nothing for two heartbeats is closed and restored regardless of what
+the broker and the operating system have reported, since neither is guaranteed to report anything
+at all. A connection that is merely idle receives the broker's heartbeats, and is kept.
 Requesting `heartbeat=0` disables both.
 If the broker rejects the connection, for example, due to access being denied, an exception will be thrown.
 Once reconnected, the topology will be recovered, and any unanswered requests and unconfirmed events will be
@@ -484,6 +481,10 @@ connection is re-established.
 
 Incoming messages are consumed from all shards.
 
+A Reply goes back through the shard its Request arrived on, while that shard is reachable. When a
+shard is lost, the Requests sent through it that are still unanswered are re-sent through the
+others, since their Replies may be lost with it; a Request sent through another shard is not.
+
 `async connect(...shards: string[]): IO`
 
 Returns an instance of `IO` once connections to the shards are established.
@@ -661,10 +662,9 @@ The queue grows until somebody drains it, which is deliberate — the alternativ
 evidence. Nothing comq does removes it or what it holds. Alert on [`discard`](#diagnostics), and
 do not delete `comq.retry.*` or `comq.parked` on a running system.
 
-> **A parked Request is never answered.** A Consumer awaiting its Reply waits until its
-> [timeout](#timeout), or indefinitely without one, and with a limited prefetch that can deadlock
-> it. Parking keeps the Request rather than deleting
-> it — and it keeps `replyTo` and `correlationId`, so a Reply can still be produced from it by
+> **A parked Request is never answered.** A Consumer awaiting its Reply waits indefinitely — a
+> call until its [timeout](#timeout) — and with a limited prefetch that can deadlock it. Parking
+> keeps the Request rather than deleting it — and it keeps `replyTo` and `correlationId`, so a Reply can still be produced from it by
 > hand while the caller is alive — but comq itself sends no Reply and reports no error to the
 > caller.
 
@@ -800,8 +800,8 @@ Subscribe to one of the diagnostic events:
   an argument.
 - `drain`: back pressure is removed from a channel. Channel type is passed.
 - `remove`: channel is removed from the [pool](#sharded-connection), having failed to publish.
-- `lost`: a shard has lost its connection, hence the requests awaiting their replies on it are
-  re-sent. Channel type is passed.
+- `lost`: a shard has lost its connection, hence the requests sent through it that are awaiting
+  their replies are re-sent. Channel type is passed.
 - `recover`: channel's topology is recovered. Channel type is passed.
 - `discard`: message is [parked](#parked-messages), having run out of attempts. Channel type,
   raw [amqp message object](https://amqp-node.github.io/amqplib/channel_api.html#channel_consume)

package/source/channel.js

@@ -70,7 +70,9 @@ class Channel {
     this.#failfast = index !== undefined
     this.#release = release
 
-    if (this.#failfast) failsafe.disable(this.send, this.publish)
+    // a shard's publish fails rather than waits for its connection to come back: the pool
+    // fails it over to another shard, and whoever published it is told where it went
+    if (this.#failfast) failsafe.disable(this.send, this.publish, this.route)
   }
 
   async create () {

package/source/connection.js

@@ -1,12 +1,11 @@
 'use strict'
 
 const { setTimeout: delay } = require('node:timers/promises')
-const amqp = require('amqplib')
+const amqp = require('@toa.io/amqplib')
 const { Promex } = require('promex')
 const { retry } = require('reretry')
 
 const { failsafe } = require('./attributes')
-const { batch } = require('./batch')
 const presets = require('./topology')
 const channels = require('./channel')
 const emitter = require('./emitter')
@@ -36,18 +35,9 @@ class Connection {
   /** @type {boolean} */
   #closed = false
 
-  /** @type {NodeJS.Timeout | null} */
-  #heartbeatTimer = null
-
   /** @type {comq.topology.Overrides} */
   #overrides
 
-  /** @type {import('node:net').Socket | null} */
-  #heartbeatSocket = null
-
-  /** @type {(() => void) | null} */
-  #heartbeatReset = null
-
   #diagnostics = emitter.create()
 
   /**
@@ -148,9 +138,6 @@ class Connection {
     connection.on('close', (error) => this.#close(connection, error))
     this.#connection = connection
 
-    batch(connection.connection?.stream)
-
-    this.#armWatchdog(connection)
     this.#diagnostics.emit('open')
 
     try {
@@ -180,11 +167,14 @@ class Connection {
   #close = (connection, error) => {
     if (this.#connection !== connection) return
 
-    this.#disarmWatchdog()
     this.#diagnostics.emit('close', error)
     connection.removeAllListeners()
     this.#connection = undefined
 
+    // amqplib only ends the socket of a connection it has given up on, and a peer that has gone
+    // silent never ends its side, which would leave the socket to the kernel's keepalive
+    if (error !== undefined) connection.connection?.stream?.destroy()
+
     if (error !== undefined && !this.#closed) {
       this.#reopen().catch((exception) => this.#diagnostics.emit('error', exception))
     }
@@ -227,10 +217,7 @@ class Connection {
    * @param {comq.amqp.Connection} connection
    */
   #drop (connection) {
-    if (this.#connection === connection) {
-      this.#disarmWatchdog()
-      this.#connection = undefined
-    }
+    if (this.#connection === connection) this.#connection = undefined
 
     connection.removeAllListeners()
 
@@ -297,46 +284,6 @@ class Connection {
     }
   }
 
-  /**
-   * @param {comq.amqp.Connection} connection
-   * @param {number} [timeoutMs]
-   */
-  #armWatchdog (connection, timeoutMs = tolerance(connection)) {
-    this.#disarmWatchdog()
-
-    const socket = connection.connection?.stream
-
-    if (socket === undefined || timeoutMs === undefined) return
-
-    const reset = () => {
-      clearTimeout(this.#heartbeatTimer)
-      // destroying a socket without an error tells amqplib nothing: it only
-      // listens for 'error' and 'end', so a bare destroy() leaves the connection
-      // silently dead — no 'close' event, no recovery, every pending operation
-      // hanging forever
-      this.#heartbeatTimer = setTimeout(() => socket.destroy(silence()), timeoutMs)
-      this.#heartbeatTimer.unref()
-    }
-
-    this.#heartbeatSocket = socket
-    this.#heartbeatReset = reset
-
-    reset()
-    socket.on('data', reset)
-  }
-
-  #disarmWatchdog () {
-    clearTimeout(this.#heartbeatTimer)
-    this.#heartbeatTimer = null
-
-    // otherwise a byte arriving on a replaced socket rearms the watchdog of a
-    // connection that is already gone, leaving the current one unguarded
-    this.#heartbeatSocket?.off('data', this.#heartbeatReset)
-
-    this.#heartbeatSocket = null
-    this.#heartbeatReset = null
-  }
-
   #transient (exception) {
     if (this.#running) return true
     if (TRANSIENT_CODES.has(exception.code)) return true
@@ -351,6 +298,10 @@ class Connection {
  * to suggest one that leaves a connection lost for minutes before anything
  * notices, and RabbitMQ suggests 60 by default.
  *
+ * It is amqplib that tells a connection gone silent: one that has received nothing
+ * for two heartbeats is closed with an error, whatever the broker and the operating
+ * system have reported, which is what restores it.
+ *
  * @type {number}
  */
 const HEARTBEAT_S = 15
@@ -358,15 +309,6 @@ const HEARTBEAT_S = 15
 /** @type {number} */
 const KEEPALIVE_MS = 10_000
 
-/** How many heartbeats a connection may miss before it is destroyed. */
-const MISSED_HEARTBEATS = 3
-
-/** @type {number} */
-const WATCHDOG_MIN_MS = 15_000
-
-/** The watchdog interval used when the negotiated heartbeat is unknown. */
-const WATCHDOG_MS = 60_000
-
 /** @type {number} */
 const CONNECT_MS = 30_000
 
@@ -425,28 +367,6 @@ function heartbeaten (url) {
   return url + (url.includes('?') ? '&' : '?') + 'heartbeat=' + HEARTBEAT_S
 }
 
-/**
- * The watchdog measures silence, so it cannot be shorter than the interval at
- * which a healthy broker is expected to say something, which is a heartbeat
- * frame every half a heartbeat. A connection that has agreed to no heartbeats
- * says nothing at all while it is idle, leaving nothing to measure.
- *
- * @param {comq.amqp.Connection} connection
- * @return {number | undefined}
- */
-function tolerance (connection) {
-  const override = global.COMQ_TESTING_WATCHDOG_INTERVAL
-
-  if (override !== undefined) return override
-
-  const heartbeat = connection.connection?.heartbeat
-
-  if (heartbeat === undefined) return WATCHDOG_MS
-  if (heartbeat === 0) return undefined
-
-  return Math.max(heartbeat * MISSED_HEARTBEATS * 1000, WATCHDOG_MIN_MS)
-}
-
 /**
  * @return {Error}
  */