@remit/sqs-client 0.0.9 → 0.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/sqs-client",
-  "version": "0.0.9",
+  "version": "0.0.10",
   "type": "module",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/poller.test.ts

@@ -81,6 +81,60 @@ describe("runQueuePoller", () => {
 		assert.deepEqual(deletedReceiptHandles, ["receipt-m1"]);
 	});
 
+	it("aborts an in-flight idle long-poll on signal instead of waiting it out", async () => {
+		let receiveCalls = 0;
+		let sawAbortSignal = false;
+
+		const sendMock = mock.method(
+			SQSClient.prototype,
+			"send",
+			// biome-ignore lint/suspicious/noExplicitAny: minimal SDK command shape
+			async function (this: SQSClient, command: any, options?: any) {
+				if (command.constructor.name === "ReceiveMessageCommand") {
+					receiveCalls++;
+					if (receiveCalls > 1) {
+						throw new Error(
+							"a second ReceiveMessage was issued — the abort did not end the poll",
+						);
+					}
+					const signal: AbortSignal | undefined = options?.abortSignal;
+					sawAbortSignal = signal instanceof AbortSignal;
+					// Model an empty long poll that only ever ends because it is
+					// aborted: request shutdown, then resolve solely on abort. A
+					// poller that waited out WaitTimeSeconds would hang this test.
+					process.emit("SIGWINCH", "SIGWINCH");
+					return await new Promise((_resolve, reject) => {
+						const fail = () =>
+							reject(
+								Object.assign(new Error("aborted"), { name: "AbortError" }),
+							);
+						if (signal?.aborted) return fail();
+						signal?.addEventListener("abort", fail, { once: true });
+					});
+				}
+				throw new Error(`unexpected command: ${command.constructor.name}`);
+			},
+		);
+
+		try {
+			await runQueuePoller({
+				targets: [
+					{ queueUrl: QUEUE_URL, handler: mock.fn(), functionName: "test-fn" },
+				],
+				log: buildLog(),
+				signals: ["SIGWINCH"],
+				// A no-op heartbeat keeps this case about the abort alone, off the
+				// real heartbeat file the default writer would touch.
+				createHeartbeat: () => async () => {},
+			});
+		} finally {
+			sendMock.mock.restore();
+		}
+
+		assert.ok(sawAbortSignal, "the receive was issued without an abort signal");
+		assert.equal(receiveCalls, 1);
+	});
+
 	it("gives every target its own heartbeat, beaten at the top of each receive attempt", async () => {
 		const beatsByQueue = new Map<string, number>();
 		let receiveCalls = 0;

package/src/poller.ts

@@ -2,6 +2,7 @@ import { inspect } from "node:util";
 import {
 	DeleteMessageCommand,
 	ReceiveMessageCommand,
+	type ReceiveMessageCommandOutput,
 } from "@aws-sdk/client-sqs";
 import type {
 	Context,
@@ -65,6 +66,7 @@ const pollTarget = async (
 	target: QueuePollerTarget,
 	log: QueuePollerLog,
 	isShuttingDown: () => boolean,
+	shutdownSignal: AbortSignal,
 	buildHeartbeat: (name: string) => Heartbeat,
 ): Promise<void> => {
 	const queueName = new URL(target.queueUrl).pathname.split("/").pop();
@@ -101,15 +103,30 @@ const pollTarget = async (
 			);
 		});
 
-		const response = await sqs.send(
-			new ReceiveMessageCommand({
-				QueueUrl: target.queueUrl,
-				MaxNumberOfMessages: maxMessages,
-				WaitTimeSeconds: LONG_POLL_WAIT_SECONDS,
-				VisibilityTimeout: visibilityTimeout,
-				MessageSystemAttributeNames: ["ApproximateReceiveCount"],
-			}),
-		);
+		let response: ReceiveMessageCommandOutput;
+		try {
+			// Abort the receive on shutdown. Without this, a container stopped
+			// while idle waits out the current 20s long poll before the loop
+			// checks the flag again, and a self-update then burns the whole
+			// stop grace on every idle worker — the bulk of the visible restart
+			// downtime. The abort ends the in-flight receive at once; an
+			// in-flight handler below is never interrupted, so a message being
+			// processed still finishes cleanly. The heartbeat above already wrote
+			// this iteration, so the abort exits without a further beat.
+			response = await sqs.send(
+				new ReceiveMessageCommand({
+					QueueUrl: target.queueUrl,
+					MaxNumberOfMessages: maxMessages,
+					WaitTimeSeconds: LONG_POLL_WAIT_SECONDS,
+					VisibilityTimeout: visibilityTimeout,
+					MessageSystemAttributeNames: ["ApproximateReceiveCount"],
+				}),
+				{ abortSignal: shutdownSignal },
+			);
+		} catch (error) {
+			if (shutdownSignal.aborted) break;
+			throw error;
+		}
 
 		if (!response.Messages || response.Messages.length === 0) {
 			continue;
@@ -190,10 +207,11 @@ const pollTarget = async (
 };
 
 /**
- * Runs every target's poll loop concurrently until a shutdown signal is
- * received (default: SIGINT, SIGTERM), then lets each loop finish its
- * current iteration and returns. Rejects (crashes the process) if any loop
- * throws — a stuck poller should exit loudly, not degrade silently.
+ * received (default: SIGINT, SIGTERM). The signal aborts each loop's in-flight
+ * long-poll receive so an idle worker returns at once instead of waiting out
+ * the current 20s poll; a loop mid-handler finishes that handler first. Rejects
+ * (crashes the process) if any loop throws — a stuck poller should exit loudly,
+ * not degrade silently.
  *
  * Every loop writes its own heartbeat file (see heartbeat.ts) at the top of its
  * receive attempt, which is how a loop that hangs instead of throwing — the
@@ -219,9 +237,13 @@ export const runQueuePoller = async (
 
 	let shuttingDown = false;
 	const isShuttingDown = () => shuttingDown;
+	// Aborted alongside the flag so a loop currently blocked in its long-poll
+	// receive returns at once, rather than after up to WaitTimeSeconds.
+	const shutdown = new AbortController();
 	const onSignal = (signal: NodeJS.Signals) => {
 		log.info({ signal }, "poller: shutdown signal received");
 		shuttingDown = true;
+		shutdown.abort();
 	};
 	for (const signal of signals) {
 		process.on(signal, onSignal);
@@ -231,7 +253,7 @@ export const runQueuePoller = async (
 
 	await Promise.all(
 		targets.map((target) =>
-			pollTarget(target, log, isShuttingDown, buildHeartbeat),
+			pollTarget(target, log, isShuttingDown, shutdown.signal, buildHeartbeat),
 		),
 	);
 };