@fedify/amqp 2.3.0-dev.1004 → 2.3.0-dev.1013

package/deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/amqp",
-  "version": "2.3.0-dev.1004+c312f0ba",
+  "version": "2.3.0-dev.1013+4aa6a88c",
   "license": "MIT",
   "exports": {
     ".": "./src/mod.ts",

package/dist/mq.cjs

@@ -1,6 +1,15 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 let node_buffer = require("node:buffer");
 //#region src/mq.ts
+function isQueueNotFoundError(error) {
+	return typeof error === "object" && error != null && "code" in error && error.code === 404;
+}
+function isPreconditionFailedError(error) {
+	return typeof error === "object" && error != null && "code" in error && error.code === 406;
+}
+const depthProbeConcurrency = 8;
+const delayedQueueExpiryMargin = 6e4;
+const delayedQueueCleanupThreshold = 4096;
 /**
 * A message queue that uses AMQP.
 *
@@ -23,6 +32,8 @@ var AmqpMessageQueue = class {
 	#durable;
 	#senderChannel;
 	#ordering;
+	#delayedQueues = /* @__PURE__ */ new Set();
+	#delayedQueueCleanup;
 	#orderingPrepared = false;
 	nativeRetrial;
 	/**
@@ -69,6 +80,12 @@ var AmqpMessageQueue = class {
 		await this.#prepareOrdering(channel);
 		return channel;
 	}
+	async #dropSenderChannel(channel) {
+		if (this.#senderChannel === channel) this.#senderChannel = void 0;
+		try {
+			await channel.close();
+		} catch {}
+	}
 	/**
 	* Enqueues a message to be processed.
 	*
@@ -85,7 +102,7 @@ var AmqpMessageQueue = class {
 	* @param options The options for enqueueing the message.
 	*/
 	async enqueue(message, options) {
-		const channel = await this.#getSenderChannel();
+		let channel = await this.#getSenderChannel();
 		const delay = options?.delay?.total("millisecond");
 		const orderingKey = options?.orderingKey;
 		if (orderingKey != null && this.#ordering != null && (delay == null || delay <= 0)) {
@@ -110,13 +127,12 @@ var AmqpMessageQueue = class {
 				deadLetterExchange = "";
 				deadLetterRoutingKey = this.#queue;
 			}
-			await channel.assertQueue(queue, {
-				autoDelete: true,
-				durable: this.#durable,
+			channel = await this.#assertDelayedQueue(channel, queue, {
 				deadLetterExchange,
 				deadLetterRoutingKey,
-				messageTtl: delay
+				delay
 			});
+			this.#trackDelayedQueue(queue);
 		}
 		channel.sendToQueue(queue, node_buffer.Buffer.from(JSON.stringify(message), "utf-8"), {
 			persistent: this.#durable,
@@ -139,7 +155,7 @@ var AmqpMessageQueue = class {
 	* @param options The options for enqueueing the messages.
 	*/
 	async enqueueMany(messages, options) {
-		const channel = await this.#getSenderChannel();
+		let channel = await this.#getSenderChannel();
 		const delay = options?.delay?.total("millisecond");
 		const orderingKey = options?.orderingKey;
 		if (orderingKey != null && this.#ordering != null && (delay == null || delay <= 0)) {
@@ -164,19 +180,107 @@ var AmqpMessageQueue = class {
 				deadLetterExchange = "";
 				deadLetterRoutingKey = this.#queue;
 			}
-			await channel.assertQueue(queue, {
-				autoDelete: true,
-				durable: this.#durable,
+			channel = await this.#assertDelayedQueue(channel, queue, {
 				deadLetterExchange,
 				deadLetterRoutingKey,
-				messageTtl: delay
+				delay
 			});
+			this.#trackDelayedQueue(queue);
 		}
 		for (const message of messages) channel.sendToQueue(queue, node_buffer.Buffer.from(JSON.stringify(message), "utf-8"), {
 			persistent: this.#durable,
 			contentType: "application/json"
 		});
 	}
+	#trackDelayedQueue(queue) {
+		this.#delayedQueues.add(queue);
+		if (this.#delayedQueues.size > delayedQueueCleanupThreshold && this.#delayedQueueCleanup == null) this.#delayedQueueCleanup = this.#pruneMissingDelayedQueues().catch(() => void 0).finally(() => {
+			this.#delayedQueueCleanup = void 0;
+		});
+	}
+	async #assertDelayedQueue(channel, queue, options) {
+		const assertOptions = {
+			autoDelete: true,
+			durable: this.#durable,
+			deadLetterExchange: options.deadLetterExchange,
+			deadLetterRoutingKey: options.deadLetterRoutingKey,
+			messageTtl: options.delay
+		};
+		try {
+			await channel.assertQueue(queue, {
+				...assertOptions,
+				expires: options.delay + delayedQueueExpiryMargin
+			});
+			return channel;
+		} catch (error) {
+			if (!isPreconditionFailedError(error)) throw error;
+			await this.#dropSenderChannel(channel);
+		}
+		const fallbackChannel = await this.#getSenderChannel();
+		await fallbackChannel.assertQueue(queue, assertOptions);
+		return fallbackChannel;
+	}
+	async #createDepthChannel() {
+		const channel = await this.#connection.createChannel();
+		channel.on("error", () => void 0);
+		return channel;
+	}
+	async #checkQueueDepths(queueNames) {
+		const results = new Array(queueNames.length);
+		let nextIndex = 0;
+		const worker = async () => {
+			let channel;
+			const closeChannel = async () => {
+				if (channel == null) return;
+				const currentChannel = channel;
+				channel = void 0;
+				try {
+					await currentChannel.close();
+				} catch {}
+			};
+			const checkQueue = async (queue) => {
+				channel ??= await this.#createDepthChannel();
+				try {
+					return (await channel.checkQueue(queue)).messageCount;
+				} catch (error) {
+					await closeChannel();
+					if (!isQueueNotFoundError(error)) throw error;
+					return;
+				}
+			};
+			try {
+				while (nextIndex < queueNames.length) {
+					const index = nextIndex++;
+					const queue = queueNames[index];
+					results[index] = [queue, await checkQueue(queue)];
+				}
+			} finally {
+				await closeChannel();
+			}
+		};
+		const workers = Array.from({ length: Math.min(depthProbeConcurrency, queueNames.length) }, () => worker());
+		await Promise.all(workers);
+		return results;
+	}
+	async #pruneMissingDelayedQueues() {
+		const delayedQueues = [...this.#delayedQueues];
+		for (const [queue, messageCount] of await this.#checkQueueDepths(delayedQueues)) if (messageCount == null) this.#delayedQueues.delete(queue);
+	}
+	async getDepth() {
+		const readyQueues = [this.#queue];
+		if (this.#ordering != null) for (let i = 0; i < this.#ordering.partitions; i++) readyQueues.push(this.#getOrderingQueueName(i));
+		let ready = 0;
+		for (const [, messageCount] of await this.#checkQueueDepths(readyQueues)) ready += messageCount ?? 0;
+		let delayed = 0;
+		const delayedQueues = [...this.#delayedQueues];
+		for (const [queue, messageCount] of await this.#checkQueueDepths(delayedQueues)) if (messageCount == null) this.#delayedQueues.delete(queue);
+		else delayed += messageCount;
+		return {
+			queued: ready + delayed,
+			ready,
+			delayed
+		};
+	}
 	async listen(handler, options = {}) {
 		const channel = await this.#connection.createChannel();
 		await this.#prepareQueue(channel);

package/dist/mq.d.cts

@@ -1,4 +1,4 @@
-import { MessageQueue, MessageQueueEnqueueOptions, MessageQueueListenOptions } from "@fedify/fedify";
+import { MessageQueue, MessageQueueDepth, MessageQueueEnqueueOptions, MessageQueueListenOptions } from "@fedify/fedify";
 import { ChannelModel } from "amqplib";
 
 //#region src/mq.d.ts
@@ -144,6 +144,7 @@ declare class AmqpMessageQueue implements MessageQueue {
   * @param options The options for enqueueing the messages.
   */
   enqueueMany(messages: readonly any[], options?: MessageQueueEnqueueOptions): Promise<void>;
+  getDepth(): Promise<MessageQueueDepth>;
   listen(handler: (message: any) => void | Promise<void>, options?: MessageQueueListenOptions): Promise<void>;
 }
 //#endregion

package/dist/mq.d.ts

@@ -1,4 +1,4 @@
-import { MessageQueue, MessageQueueEnqueueOptions, MessageQueueListenOptions } from "@fedify/fedify";
+import { MessageQueue, MessageQueueDepth, MessageQueueEnqueueOptions, MessageQueueListenOptions } from "@fedify/fedify";
 import { ChannelModel } from "amqplib";
 
 //#region src/mq.d.ts
@@ -144,6 +144,7 @@ declare class AmqpMessageQueue implements MessageQueue {
   * @param options The options for enqueueing the messages.
   */
   enqueueMany(messages: readonly any[], options?: MessageQueueEnqueueOptions): Promise<void>;
+  getDepth(): Promise<MessageQueueDepth>;
   listen(handler: (message: any) => void | Promise<void>, options?: MessageQueueListenOptions): Promise<void>;
 }
 //#endregion

package/dist/mq.js

@@ -1,5 +1,14 @@
 import { Buffer } from "node:buffer";
 //#region src/mq.ts
+function isQueueNotFoundError(error) {
+	return typeof error === "object" && error != null && "code" in error && error.code === 404;
+}
+function isPreconditionFailedError(error) {
+	return typeof error === "object" && error != null && "code" in error && error.code === 406;
+}
+const depthProbeConcurrency = 8;
+const delayedQueueExpiryMargin = 6e4;
+const delayedQueueCleanupThreshold = 4096;
 /**
 * A message queue that uses AMQP.
 *
@@ -22,6 +31,8 @@ var AmqpMessageQueue = class {
 	#durable;
 	#senderChannel;
 	#ordering;
+	#delayedQueues = /* @__PURE__ */ new Set();
+	#delayedQueueCleanup;
 	#orderingPrepared = false;
 	nativeRetrial;
 	/**
@@ -68,6 +79,12 @@ var AmqpMessageQueue = class {
 		await this.#prepareOrdering(channel);
 		return channel;
 	}
+	async #dropSenderChannel(channel) {
+		if (this.#senderChannel === channel) this.#senderChannel = void 0;
+		try {
+			await channel.close();
+		} catch {}
+	}
 	/**
 	* Enqueues a message to be processed.
 	*
@@ -84,7 +101,7 @@ var AmqpMessageQueue = class {
 	* @param options The options for enqueueing the message.
 	*/
 	async enqueue(message, options) {
-		const channel = await this.#getSenderChannel();
+		let channel = await this.#getSenderChannel();
 		const delay = options?.delay?.total("millisecond");
 		const orderingKey = options?.orderingKey;
 		if (orderingKey != null && this.#ordering != null && (delay == null || delay <= 0)) {
@@ -109,13 +126,12 @@ var AmqpMessageQueue = class {
 				deadLetterExchange = "";
 				deadLetterRoutingKey = this.#queue;
 			}
-			await channel.assertQueue(queue, {
-				autoDelete: true,
-				durable: this.#durable,
+			channel = await this.#assertDelayedQueue(channel, queue, {
 				deadLetterExchange,
 				deadLetterRoutingKey,
-				messageTtl: delay
+				delay
 			});
+			this.#trackDelayedQueue(queue);
 		}
 		channel.sendToQueue(queue, Buffer.from(JSON.stringify(message), "utf-8"), {
 			persistent: this.#durable,
@@ -138,7 +154,7 @@ var AmqpMessageQueue = class {
 	* @param options The options for enqueueing the messages.
 	*/
 	async enqueueMany(messages, options) {
-		const channel = await this.#getSenderChannel();
+		let channel = await this.#getSenderChannel();
 		const delay = options?.delay?.total("millisecond");
 		const orderingKey = options?.orderingKey;
 		if (orderingKey != null && this.#ordering != null && (delay == null || delay <= 0)) {
@@ -163,19 +179,107 @@ var AmqpMessageQueue = class {
 				deadLetterExchange = "";
 				deadLetterRoutingKey = this.#queue;
 			}
-			await channel.assertQueue(queue, {
-				autoDelete: true,
-				durable: this.#durable,
+			channel = await this.#assertDelayedQueue(channel, queue, {
 				deadLetterExchange,
 				deadLetterRoutingKey,
-				messageTtl: delay
+				delay
 			});
+			this.#trackDelayedQueue(queue);
 		}
 		for (const message of messages) channel.sendToQueue(queue, Buffer.from(JSON.stringify(message), "utf-8"), {
 			persistent: this.#durable,
 			contentType: "application/json"
 		});
 	}
+	#trackDelayedQueue(queue) {
+		this.#delayedQueues.add(queue);
+		if (this.#delayedQueues.size > delayedQueueCleanupThreshold && this.#delayedQueueCleanup == null) this.#delayedQueueCleanup = this.#pruneMissingDelayedQueues().catch(() => void 0).finally(() => {
+			this.#delayedQueueCleanup = void 0;
+		});
+	}
+	async #assertDelayedQueue(channel, queue, options) {
+		const assertOptions = {
+			autoDelete: true,
+			durable: this.#durable,
+			deadLetterExchange: options.deadLetterExchange,
+			deadLetterRoutingKey: options.deadLetterRoutingKey,
+			messageTtl: options.delay
+		};
+		try {
+			await channel.assertQueue(queue, {
+				...assertOptions,
+				expires: options.delay + delayedQueueExpiryMargin
+			});
+			return channel;
+		} catch (error) {
+			if (!isPreconditionFailedError(error)) throw error;
+			await this.#dropSenderChannel(channel);
+		}
+		const fallbackChannel = await this.#getSenderChannel();
+		await fallbackChannel.assertQueue(queue, assertOptions);
+		return fallbackChannel;
+	}
+	async #createDepthChannel() {
+		const channel = await this.#connection.createChannel();
+		channel.on("error", () => void 0);
+		return channel;
+	}
+	async #checkQueueDepths(queueNames) {
+		const results = new Array(queueNames.length);
+		let nextIndex = 0;
+		const worker = async () => {
+			let channel;
+			const closeChannel = async () => {
+				if (channel == null) return;
+				const currentChannel = channel;
+				channel = void 0;
+				try {
+					await currentChannel.close();
+				} catch {}
+			};
+			const checkQueue = async (queue) => {
+				channel ??= await this.#createDepthChannel();
+				try {
+					return (await channel.checkQueue(queue)).messageCount;
+				} catch (error) {
+					await closeChannel();
+					if (!isQueueNotFoundError(error)) throw error;
+					return;
+				}
+			};
+			try {
+				while (nextIndex < queueNames.length) {
+					const index = nextIndex++;
+					const queue = queueNames[index];
+					results[index] = [queue, await checkQueue(queue)];
+				}
+			} finally {
+				await closeChannel();
+			}
+		};
+		const workers = Array.from({ length: Math.min(depthProbeConcurrency, queueNames.length) }, () => worker());
+		await Promise.all(workers);
+		return results;
+	}
+	async #pruneMissingDelayedQueues() {
+		const delayedQueues = [...this.#delayedQueues];
+		for (const [queue, messageCount] of await this.#checkQueueDepths(delayedQueues)) if (messageCount == null) this.#delayedQueues.delete(queue);
+	}
+	async getDepth() {
+		const readyQueues = [this.#queue];
+		if (this.#ordering != null) for (let i = 0; i < this.#ordering.partitions; i++) readyQueues.push(this.#getOrderingQueueName(i));
+		let ready = 0;
+		for (const [, messageCount] of await this.#checkQueueDepths(readyQueues)) ready += messageCount ?? 0;
+		let delayed = 0;
+		const delayedQueues = [...this.#delayedQueues];
+		for (const [queue, messageCount] of await this.#checkQueueDepths(delayedQueues)) if (messageCount == null) this.#delayedQueues.delete(queue);
+		else delayed += messageCount;
+		return {
+			queued: ready + delayed,
+			ready,
+			delayed
+		};
+	}
 	async listen(handler, options = {}) {
 		const channel = await this.#connection.createChannel();
 		await this.#prepareQueue(channel);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/amqp",
-  "version": "2.3.0-dev.1004+c312f0ba",
+  "version": "2.3.0-dev.1013+4aa6a88c",
   "description": "AMQP/RabbitMQ driver for Fedify",
   "keywords": [
     "fedify",
@@ -55,7 +55,7 @@
   },
   "peerDependencies": {
     "amqplib": "^0.10.9",
-    "@fedify/fedify": "^2.3.0-dev.1004+c312f0ba"
+    "@fedify/fedify": "^2.3.0-dev.1013+4aa6a88c"
   },
   "devDependencies": {
     "@alinea/suite": "^0.6.3",
@@ -65,7 +65,7 @@
     "@types/amqplib": "^0.10.7",
     "tsdown": "^0.21.6",
     "typescript": "^5.9.2",
-    "@fedify/testing": "^2.3.0-dev.1004+c312f0ba"
+    "@fedify/testing": "^2.3.0-dev.1013+4aa6a88c"
   },
   "scripts": {
     "build:self": "tsdown",

package/src/mq.test.ts

@@ -1,14 +1,240 @@
 import { suite } from "@alinea/suite";
 import { AmqpMessageQueue } from "@fedify/amqp/mq";
 import { getRandomKey, testMessageQueue, waitFor } from "@fedify/testing";
+import * as temporal from "@js-temporal/polyfill";
 import { assert, assertEquals, assertFalse, assertGreater } from "@std/assert";
 import { delay } from "@std/async/delay";
 // @deno-types="npm:@types/amqplib"
-import { type ChannelModel, connect } from "amqplib";
+import { type Channel, type ChannelModel, connect } from "amqplib";
 import process from "node:process";
 
+const Temporal = globalThis.Temporal ?? temporal.Temporal;
+
 const AMQP_URL = process.env.AMQP_URL;
-const test = AMQP_URL ? suite(import.meta) : suite(import.meta).skip;
+const unitTest = suite(import.meta);
+const test = AMQP_URL ? unitTest : unitTest.skip;
+
+class FakeDepthChannel {
+  #closed = false;
+
+  constructor(private readonly connection: FakeDepthConnection) {
+  }
+
+  on(): void {
+  }
+
+  assertQueue(
+    queue: string,
+    options?: { expires?: number },
+  ): Promise<void> {
+    if (this.#closed) {
+      return Promise.reject(new Error("Channel is closed"));
+    }
+    if (
+      options?.expires != null &&
+      this.connection.preconditionOnExpires.has(queue)
+    ) {
+      this.#closed = true;
+      this.connection.preconditionOnExpires.delete(queue);
+      return Promise.reject(
+        Object.assign(new Error("PRECONDITION_FAILED"), { code: 406 }),
+      );
+    }
+    this.connection.queues.add(queue);
+    if (options?.expires != null) {
+      this.connection.queueExpires.set(queue, options.expires);
+    }
+    return Promise.resolve();
+  }
+
+  sendToQueue(queue: string): boolean {
+    if (this.#closed) throw new Error("Channel is closed");
+    this.connection.messageCounts.set(
+      queue,
+      (this.connection.messageCounts.get(queue) ?? 0) + 1,
+    );
+    return true;
+  }
+
+  async checkQueue(queue: string): Promise<{ messageCount: number }> {
+    if (this.#closed) throw new Error("Channel is closed");
+    this.connection.activeChecks++;
+    this.connection.maxActiveChecks = Math.max(
+      this.connection.maxActiveChecks,
+      this.connection.activeChecks,
+    );
+    try {
+      if (this.connection.checkDelayMs > 0) {
+        await delay(this.connection.checkDelayMs);
+      }
+      return { messageCount: this.connection.messageCounts.get(queue) ?? 0 };
+    } finally {
+      this.connection.activeChecks--;
+    }
+  }
+
+  close(): Promise<void> {
+    this.#closed = true;
+    return Promise.resolve();
+  }
+}
+
+class FakeDepthConnection {
+  readonly queues = new Set<string>();
+  readonly queueExpires = new Map<string, number>();
+  readonly messageCounts = new Map<string, number>();
+  readonly preconditionOnExpires = new Set<string>();
+  activeChecks = 0;
+  channelCount = 0;
+  maxActiveChecks = 0;
+
+  constructor(readonly checkDelayMs: number = 25) {
+  }
+
+  createChannel(): Promise<Channel> {
+    this.channelCount++;
+    return Promise.resolve(new FakeDepthChannel(this) as unknown as Channel);
+  }
+}
+
+unitTest(
+  "AmqpMessageQueue.getDepth() probes delayed queues concurrently",
+  async () => {
+    const conn = new FakeDepthConnection();
+    const mq = new AmqpMessageQueue(conn as unknown as ChannelModel, {
+      queue: "ready",
+      delayedQueuePrefix: "delayed_",
+    });
+
+    await mq.enqueue("first", {
+      delay: Temporal.Duration.from({ milliseconds: 1_000 }),
+    });
+    await mq.enqueue("second", {
+      delay: Temporal.Duration.from({ milliseconds: 2_000 }),
+    });
+    await mq.enqueue("third", {
+      delay: Temporal.Duration.from({ milliseconds: 3_000 }),
+    });
+
+    assertEquals(await mq.getDepth(), {
+      queued: 3,
+      ready: 0,
+      delayed: 3,
+    });
+    assertGreater(conn.maxActiveChecks, 1);
+  },
+);
+
+unitTest("AmqpMessageQueue sets delayed queue expiry", async () => {
+  const conn = new FakeDepthConnection();
+  const mq = new AmqpMessageQueue(conn as unknown as ChannelModel, {
+    queue: "ready",
+    delayedQueuePrefix: "delayed_",
+  });
+
+  await mq.enqueue("delayed", {
+    delay: Temporal.Duration.from({ milliseconds: 1_000 }),
+  });
+
+  assertEquals(conn.queueExpires.get("delayed_1000"), 61_000);
+});
+
+unitTest(
+  "AmqpMessageQueue falls back for existing delayed queues without expiry",
+  async () => {
+    const conn = new FakeDepthConnection();
+    conn.preconditionOnExpires.add("delayed_1000");
+    const mq = new AmqpMessageQueue(conn as unknown as ChannelModel, {
+      queue: "ready",
+      delayedQueuePrefix: "delayed_",
+    });
+
+    await mq.enqueue("delayed", {
+      delay: Temporal.Duration.from({ milliseconds: 1_000 }),
+    });
+
+    assertEquals(conn.messageCounts.get("delayed_1000"), 1);
+    assertEquals(conn.queueExpires.get("delayed_1000"), undefined);
+    assertGreater(conn.channelCount, 1);
+  },
+);
+
+unitTest("AmqpMessageQueue reuses depth probe channels", async () => {
+  const conn = new FakeDepthConnection(0);
+  const mq = new AmqpMessageQueue(conn as unknown as ChannelModel, {
+    queue: "ready",
+    delayedQueuePrefix: "delayed_",
+  });
+
+  for (let milliseconds = 1; milliseconds <= 12; milliseconds++) {
+    await mq.enqueue("delayed", {
+      delay: Temporal.Duration.from({ milliseconds }),
+    });
+  }
+  conn.channelCount = 0;
+
+  assertEquals(await mq.getDepth(), {
+    queued: 12,
+    ready: 0,
+    delayed: 12,
+  });
+  assert(
+    conn.channelCount <= 9,
+    `expected at most 9 depth probe channels, got ${conn.channelCount}`,
+  );
+});
+
+unitTest(
+  "AmqpMessageQueue keeps delayed queues past cleanup threshold",
+  async () => {
+    const conn = new FakeDepthConnection(0);
+    const mq = new AmqpMessageQueue(conn as unknown as ChannelModel, {
+      queue: "ready",
+      delayedQueuePrefix: "delayed_",
+    });
+
+    for (let milliseconds = 1; milliseconds <= 4097; milliseconds++) {
+      await mq.enqueue("delayed", {
+        delay: Temporal.Duration.from({ milliseconds }),
+      });
+    }
+
+    assertEquals(await mq.getDepth(), {
+      queued: 4097,
+      ready: 0,
+      delayed: 4097,
+    });
+  },
+);
+
+unitTest(
+  "AmqpMessageQueue.getDepth() keeps delayed queues past local expiry",
+  async () => {
+    const now = Date.now;
+    const started = now();
+    Date.now = () => started;
+    try {
+      const conn = new FakeDepthConnection();
+      const mq = new AmqpMessageQueue(conn as unknown as ChannelModel, {
+        queue: "ready",
+        delayedQueuePrefix: "delayed_",
+      });
+
+      await mq.enqueue("delayed", {
+        delay: Temporal.Duration.from({ milliseconds: 1_000 }),
+      });
+      Date.now = () => started + 62_000;
+
+      assertEquals(await mq.getDepth(), {
+        queued: 1,
+        ready: 0,
+        delayed: 1,
+      });
+    } finally {
+      Date.now = now;
+    }
+  },
+);
 
 function getConnection(): Promise<ChannelModel> {
   return connect(AMQP_URL!);
@@ -37,6 +263,51 @@ test(
     ),
 );
 
+test(
+  "AmqpMessageQueue.getDepth()",
+  { sanitizeOps: false, sanitizeExit: false, sanitizeResources: false },
+  async () => {
+    const conn = await getConnection();
+    const queue = getRandomKey("depth_queue");
+    const delayedQueuePrefix = getRandomKey("depth_delayed") + "_";
+    const mq = new AmqpMessageQueue(conn, { queue, delayedQueuePrefix });
+    try {
+      assertEquals(await mq.getDepth(), {
+        queued: 0,
+        ready: 0,
+        delayed: 0,
+      });
+      await mq.enqueue("ready");
+      await mq.enqueue("delayed", {
+        delay: Temporal.Duration.from({ seconds: 60 }),
+      });
+      const started = Date.now();
+      while (Date.now() - started < 15_000) {
+        const depth = await mq.getDepth();
+        if (depth.queued === 2 && depth.ready === 1 && depth.delayed === 1) {
+          break;
+        }
+        await delay(100);
+      }
+      assertEquals(await mq.getDepth(), {
+        queued: 2,
+        ready: 1,
+        delayed: 1,
+      });
+    } finally {
+      const channel = await conn.createChannel().catch(() => undefined);
+      try {
+        await channel?.deleteQueue(queue).catch(() => {});
+        await channel?.deleteQueue(`${delayedQueuePrefix}60000`).catch(() => {
+        });
+      } finally {
+        await channel?.close().catch(() => {});
+        await conn.close().catch(() => {});
+      }
+    }
+  },
+);
+
 // Test with ordering key support (requires rabbitmq_consistent_hash_exchange plugin)
 const orderingConnections: ChannelModel[] = [];
 const orderingQueue = getRandomKey("ordering_queue");

package/src/mq.ts

@@ -1,5 +1,6 @@
 import type {
   MessageQueue,
+  MessageQueueDepth,
   MessageQueueEnqueueOptions,
   MessageQueueListenOptions,
 } from "@fedify/fedify";
@@ -7,6 +8,20 @@ import type {
 import type { Channel, ChannelModel, ConsumeMessage } from "amqplib";
 import { Buffer } from "node:buffer";
 
+function isQueueNotFoundError(error: unknown): boolean {
+  return typeof error === "object" && error != null &&
+    "code" in error && error.code === 404;
+}
+
+function isPreconditionFailedError(error: unknown): boolean {
+  return typeof error === "object" && error != null &&
+    "code" in error && error.code === 406;
+}
+
+const depthProbeConcurrency = 8;
+const delayedQueueExpiryMargin = 60_000;
+const delayedQueueCleanupThreshold = 4096;
+
 /**
  * Options for ordering key support in {@link AmqpMessageQueue}.
  *
@@ -127,6 +142,8 @@ export class AmqpMessageQueue implements MessageQueue {
     queuePrefix: string;
     partitions: number;
   };
+  #delayedQueues: Set<string> = new Set();
+  #delayedQueueCleanup?: Promise<void>;
   #orderingPrepared: boolean = false;
 
   readonly nativeRetrial: boolean;
@@ -194,6 +211,15 @@ export class AmqpMessageQueue implements MessageQueue {
     return channel;
   }
 
+  async #dropSenderChannel(channel: Channel): Promise<void> {
+    if (this.#senderChannel === channel) this.#senderChannel = undefined;
+    try {
+      await channel.close();
+    } catch {
+      // The channel may already have been closed by an AMQP exception.
+    }
+  }
+
   /**
    * Enqueues a message to be processed.
    *
@@ -214,7 +240,7 @@ export class AmqpMessageQueue implements MessageQueue {
     message: any,
     options?: MessageQueueEnqueueOptions,
   ): Promise<void> {
-    const channel = await this.#getSenderChannel();
+    let channel = await this.#getSenderChannel();
     const delay = options?.delay?.total("millisecond");
     const orderingKey = options?.orderingKey;
 
@@ -256,13 +282,12 @@ export class AmqpMessageQueue implements MessageQueue {
         deadLetterExchange = "";
         deadLetterRoutingKey = this.#queue;
       }
-      await channel.assertQueue(queue, {
-        autoDelete: true,
-        durable: this.#durable,
+      channel = await this.#assertDelayedQueue(channel, queue, {
         deadLetterExchange,
         deadLetterRoutingKey,
-        messageTtl: delay,
+        delay,
       });
+      this.#trackDelayedQueue(queue);
     }
     channel.sendToQueue(
       queue,
@@ -294,7 +319,7 @@ export class AmqpMessageQueue implements MessageQueue {
     messages: readonly any[],
     options?: MessageQueueEnqueueOptions,
   ): Promise<void> {
-    const channel = await this.#getSenderChannel();
+    let channel = await this.#getSenderChannel();
     const delay = options?.delay?.total("millisecond");
     const orderingKey = options?.orderingKey;
 
@@ -338,13 +363,12 @@ export class AmqpMessageQueue implements MessageQueue {
         deadLetterExchange = "";
         deadLetterRoutingKey = this.#queue;
       }
-      await channel.assertQueue(queue, {
-        autoDelete: true,
-        durable: this.#durable,
+      channel = await this.#assertDelayedQueue(channel, queue, {
         deadLetterExchange,
         deadLetterRoutingKey,
-        messageTtl: delay,
+        delay,
       });
+      this.#trackDelayedQueue(queue);
     }
 
     for (const message of messages) {
@@ -359,6 +383,148 @@ export class AmqpMessageQueue implements MessageQueue {
     }
   }
 
+  #trackDelayedQueue(queue: string): void {
+    this.#delayedQueues.add(queue);
+    if (
+      this.#delayedQueues.size > delayedQueueCleanupThreshold &&
+      this.#delayedQueueCleanup == null
+    ) {
+      this.#delayedQueueCleanup = this.#pruneMissingDelayedQueues()
+        .catch(() => undefined)
+        .finally(() => {
+          this.#delayedQueueCleanup = undefined;
+        });
+    }
+  }
+
+  async #assertDelayedQueue(
+    channel: Channel,
+    queue: string,
+    options: {
+      deadLetterExchange?: string;
+      deadLetterRoutingKey?: string;
+      delay: number;
+    },
+  ): Promise<Channel> {
+    const assertOptions = {
+      autoDelete: true,
+      durable: this.#durable,
+      deadLetterExchange: options.deadLetterExchange,
+      deadLetterRoutingKey: options.deadLetterRoutingKey,
+      messageTtl: options.delay,
+    };
+    try {
+      await channel.assertQueue(queue, {
+        ...assertOptions,
+        expires: options.delay + delayedQueueExpiryMargin,
+      });
+      return channel;
+    } catch (error) {
+      if (!isPreconditionFailedError(error)) throw error;
+      await this.#dropSenderChannel(channel);
+    }
+
+    const fallbackChannel = await this.#getSenderChannel();
+    await fallbackChannel.assertQueue(queue, assertOptions);
+    return fallbackChannel;
+  }
+
+  async #createDepthChannel(): Promise<Channel> {
+    const channel = await this.#connection.createChannel();
+    channel.on("error", () => undefined);
+    return channel;
+  }
+
+  async #checkQueueDepths(
+    queueNames: readonly string[],
+  ): Promise<readonly (readonly [string, number | undefined])[]> {
+    const results = new Array<readonly [string, number | undefined]>(
+      queueNames.length,
+    );
+    let nextIndex = 0;
+    const worker = async () => {
+      let channel: Channel | undefined;
+      const closeChannel = async () => {
+        if (channel == null) return;
+        const currentChannel = channel;
+        channel = undefined;
+        try {
+          await currentChannel.close();
+        } catch {
+          // The channel can already be closed by a failed passive queue check.
+        }
+      };
+      const checkQueue = async (
+        queue: string,
+      ): Promise<number | undefined> => {
+        channel ??= await this.#createDepthChannel();
+        try {
+          return (await channel.checkQueue(queue)).messageCount;
+        } catch (error) {
+          await closeChannel();
+          if (!isQueueNotFoundError(error)) throw error;
+          return undefined;
+        }
+      };
+      try {
+        while (nextIndex < queueNames.length) {
+          const index = nextIndex++;
+          const queue = queueNames[index];
+          results[index] = [queue, await checkQueue(queue)];
+        }
+      } finally {
+        await closeChannel();
+      }
+    };
+    const workers = Array.from(
+      { length: Math.min(depthProbeConcurrency, queueNames.length) },
+      () => worker(),
+    );
+    await Promise.all(workers);
+    return results;
+  }
+
+  async #pruneMissingDelayedQueues(): Promise<void> {
+    const delayedQueues = [...this.#delayedQueues];
+    for (
+      const [queue, messageCount] of await this.#checkQueueDepths(delayedQueues)
+    ) {
+      if (messageCount == null) this.#delayedQueues.delete(queue);
+    }
+  }
+
+  async getDepth(): Promise<MessageQueueDepth> {
+    const readyQueues = [this.#queue];
+    if (this.#ordering != null) {
+      for (let i = 0; i < this.#ordering.partitions; i++) {
+        readyQueues.push(this.#getOrderingQueueName(i));
+      }
+    }
+
+    let ready = 0;
+    for (const [, messageCount] of await this.#checkQueueDepths(readyQueues)) {
+      ready += messageCount ?? 0;
+    }
+
+    let delayed = 0;
+    const delayedQueues = [...this.#delayedQueues];
+    for (
+      const [queue, messageCount] of await this.#checkQueueDepths(delayedQueues)
+    ) {
+      if (messageCount == null) {
+        this.#delayedQueues.delete(queue);
+      } else {
+        delayed += messageCount;
+      }
+    }
+
+    return {
+      queued: ready + delayed,
+      ready,
+      delayed,
+    };
+  }
+
   async listen(
     // deno-lint-ignore no-explicit-any
     handler: (message: any) => void | Promise<void>,