@remit/sqs-client 0.0.10 → 0.0.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/sqs-client",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "type": "module",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -9,6 +9,10 @@
       "types": "./src/index.ts",
       "default": "./src/index.ts"
     },
+    "./heartbeat": {
+      "types": "./src/heartbeat.ts",
+      "default": "./src/heartbeat.ts"
+    },
     "./poller": {
       "types": "./src/poller.ts",
       "default": "./src/poller.ts"

package/src/poller.test.ts

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import { describe, it, mock } from "node:test";
 import { SQSClient } from "@aws-sdk/client-sqs";
-import type { SQSBatchResponse, SQSEvent } from "aws-lambda";
+import type { Context, SQSBatchResponse, SQSEvent } from "aws-lambda";
 import { runQueuePoller } from "./poller.js";
 
 const QUEUE_URL = "http://localhost:9324/000000000000/remit-test";
@@ -231,6 +231,67 @@ describe("runQueuePoller", () => {
 		assert.match(String(failures[0]?.arguments[0]?.error), /ENOSPC/);
 	});
 
+	// The `requestId` every line of one invocation is grouped by
+	// (deploy/vps/README.md, "Logs") is minted here, and it has to reach both the
+	// handler and the poller's own bracketing lines — otherwise grouping on it
+	// stops right before the line saying what happened to the message.
+	it("gives each batch its own requestId, on the handler context and on its own lines", async () => {
+		let receiveCalls = 0;
+		const sendMock = mock.method(
+			SQSClient.prototype,
+			"send",
+			// biome-ignore lint/suspicious/noExplicitAny: minimal SDK command shape, not worth typing per-command here
+			async function (this: SQSClient, command: any) {
+				if (command.constructor.name === "ReceiveMessageCommand") {
+					receiveCalls++;
+					if (receiveCalls >= 2) process.emit("SIGWINCH", "SIGWINCH");
+					return { Messages: [buildMessage(`m${receiveCalls}`)] };
+				}
+				if (command.constructor.name === "DeleteMessageCommand") return {};
+				throw new Error(`unexpected command: ${command.constructor.name}`);
+			},
+		);
+
+		const handler = mock.fn(
+			async (
+				_event: SQSEvent,
+				_context: Context,
+			): Promise<SQSBatchResponse> => ({ batchItemFailures: [] }),
+		);
+		const log = buildLog();
+
+		try {
+			await runQueuePoller({
+				targets: [{ queueUrl: QUEUE_URL, handler, functionName: "test-fn" }],
+				log,
+				signals: ["SIGWINCH"],
+				createHeartbeat: () => async () => {},
+			});
+		} finally {
+			sendMock.mock.restore();
+		}
+
+		const requestIds = handler.mock.calls.map(
+			(call) => call.arguments[1].awsRequestId,
+		);
+		assert.equal(requestIds.length, 2);
+		for (const requestId of requestIds)
+			assert.match(requestId, /^[0-9a-f-]{36}$/);
+		assert.notEqual(requestIds[0], requestIds[1]);
+
+		const bracketing = ["poller: invoking handler", "poller: batch processed"];
+		for (const message of bracketing) {
+			const lines = log.info.mock.calls.filter(
+				(call) => call.arguments[1] === message,
+			);
+			assert.equal(lines.length, 2, `expected two ${message} lines`);
+			assert.deepEqual(
+				lines.map((call) => call.arguments[0].requestId),
+				requestIds,
+			);
+		}
+	});
+
 	it("throws when constructed with no targets", async () => {
 		await assert.rejects(
 			() => runQueuePoller({ targets: [], log: buildLog() }),

package/src/poller.ts

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 import { inspect } from "node:util";
 import {
 	DeleteMessageCommand,
@@ -75,8 +76,6 @@ const pollTarget = async (
 	const maxMessages = target.maxMessages ?? DEFAULT_MAX_MESSAGES;
 	const visibilityTimeout =
 		target.visibilityTimeoutSeconds ?? DEFAULT_VISIBILITY_TIMEOUT_SECONDS;
-	const lambdaContext = { functionName: target.functionName } as Context;
-
 	log.info({ queue: queueName, maxMessages }, "poller: started");
 
 	// Always long-poll (SQS max WaitTimeSeconds). An empty long poll is free
@@ -146,8 +145,26 @@ const pollTarget = async (
 		);
 		if (messages.length === 0) continue;
 
+		// One batch is one handler invocation, so the id is minted per batch: it is
+		// the `requestId` every line of that invocation is grouped by (see
+		// deploy/vps/README.md, "Logs"). A context built once per target would put
+		// the whole queue's lifetime under one id, which correlates nothing.
+		//
+		// Minted before the poller's own bracketing lines rather than next to the
+		// handler call: grouping on the id has to reach the line saying whether the
+		// message was deleted or left for redelivery, which is what someone looks
+		// for after a failure.
+		const lambdaContext = {
+			functionName: target.functionName,
+			awsRequestId: randomUUID(),
+		} as Context;
+
 		log.info(
-			{ queue: queueName, count: messages.length },
+			{
+				queue: queueName,
+				count: messages.length,
+				requestId: lambdaContext.awsRequestId,
+			},
 			"poller: invoking handler",
 		);
 
@@ -198,6 +215,7 @@ const pollTarget = async (
 				queue: queueName,
 				deleted: succeeded.length,
 				leftForRedelivery: failedIds.size,
+				requestId: lambdaContext.awsRequestId,
 			},
 			"poller: batch processed",
 		);