@remit/logger-lambda 0.0.12 → 0.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/logger-lambda",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "type": "module",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/log-output.test.ts

@@ -28,7 +28,9 @@ process.stdout.write = ((
 	return (originalWrite as (...args: unknown[]) => boolean)(chunk, ...rest);
 }) as typeof process.stdout.write;
 
-const { createLogger, logger, withLogContext } = await import("./logger.js");
+const { createLogger, logger, withLogContext, withTelemetry } = await import(
+	"./logger.js"
+);
 
 const parse = (): Line[] =>
 	written
@@ -65,6 +67,23 @@ const one = (emit: () => void): Line => {
 	return lines[0];
 };
 
+// Both scopes have to be open at the same moment for a leak to be observable;
+// a gate each side waits on pins that interleaving.
+const gate = (): { reached: Promise<void>; pass: () => void } => {
+	let pass!: () => void;
+	const reached = new Promise<void>((resolve) => {
+		pass = () => resolve();
+	});
+	return { reached, pass };
+};
+
+// Sorted by message, so the comparison covers every line exactly once without
+// naming the order the scheduler happened to finish them in.
+const requestIdPerMessage = (lines: Line[]): [string, unknown][] =>
+	lines
+		.map((line): [string, unknown] => [String(line.msg), line.requestId])
+		.sort(([left], [right]) => left.localeCompare(right));
+
 describe("log output", () => {
 	it("writes one JSON object per line on stdout", () => {
 		const log = createLogger();
@@ -309,25 +328,30 @@ describe("withLogContext", () => {
 	});
 
 	it("keeps overlapping scopes apart across awaits", async () => {
-		const request = (id: string, delayMs: number) =>
-			withLogContext({ requestId: id }, async () => {
-				await new Promise((resolve) => setTimeout(resolve, delayMs));
-				logger.warn(`handled ${id}`);
-			});
+		const slowStarted = gate();
+		const fastLogged = gate();
 
 		// The slow request opens its scope first and logs last, which is exactly
 		// the interleaving a shared mutable binding gets wrong.
 		const lines = await captureAsync(async () => {
-			await Promise.all([request("slow", 10), request("fast", 1)]);
+			await Promise.all([
+				withLogContext({ requestId: "slow" }, async () => {
+					slowStarted.pass();
+					await fastLogged.reached;
+					logger.warn("handled slow");
+				}),
+				withLogContext({ requestId: "fast" }, async () => {
+					await slowStarted.reached;
+					logger.warn("handled fast");
+					fastLogged.pass();
+				}),
+			]);
 		});
 
-		assert.deepEqual(
-			lines.map((line) => [line.msg, line.requestId]),
-			[
-				["handled fast", "fast"],
-				["handled slow", "slow"],
-			],
-		);
+		assert.deepEqual(requestIdPerMessage(lines), [
+			["handled fast", "fast"],
+			["handled slow", "slow"],
+		]);
 	});
 
 	it("nests, adding to the scope it runs inside", () => {
@@ -353,3 +377,87 @@ describe("withLogContext", () => {
 		assert.equal(repeats.length, 1);
 	});
 });
+
+describe("withTelemetry", () => {
+	const context = {
+		awsRequestId: "req-1",
+		functionName: "test-function",
+	} as unknown as Parameters<Parameters<typeof withTelemetry>[0]>[1];
+
+	it("puts its own start line inside the scope", async () => {
+		const lines = await captureAsync(async () => {
+			await withTelemetry(async () => "ok")({}, context);
+		});
+		const started = lines.find(
+			(line) => line.msg === "Lambda invocation started",
+		);
+		assert.ok(started, "expected the start line");
+		assert.equal(started.requestId, "req-1");
+	});
+
+	// The line an operator correlates from is written after the handler has
+	// unwound, which is exactly what a scope opened inside the handler misses.
+	it("puts its own failure line inside the scope", async () => {
+		const lines = await captureAsync(async () => {
+			await assert.rejects(
+				withTelemetry(async () => {
+					throw new Error("boom");
+				})({}, context),
+			);
+		});
+		const failed = lines.find(
+			(line) => line.msg === "Lambda invocation failed",
+		);
+		assert.ok(failed, "expected the failure line");
+		assert.equal(failed.requestId, "req-1");
+	});
+
+	it("carries the same requestId onto the handler's own lines", async () => {
+		const lines = await captureAsync(async () => {
+			await withTelemetry(async () => {
+				logger.warn("from the handler");
+				return "ok";
+			})({}, context);
+		});
+		assert.deepEqual(
+			[...new Set(lines.map((line) => line.requestId))],
+			["req-1"],
+		);
+	});
+
+	it("keeps concurrent invocations apart", async () => {
+		const slowStarted = gate();
+		const fastLogged = gate();
+
+		const invoke = (id: string, handler: () => Promise<void>) =>
+			withTelemetry(handler)({}, {
+				awsRequestId: id,
+				functionName: "test-function",
+			} as unknown as typeof context);
+
+		const lines = await captureAsync(async () => {
+			await Promise.all([
+				invoke("slow", async () => {
+					slowStarted.pass();
+					await fastLogged.reached;
+					logger.warn("handled slow");
+				}),
+				invoke("fast", async () => {
+					await slowStarted.reached;
+					logger.warn("handled fast");
+					fastLogged.pass();
+				}),
+			]);
+		});
+
+		assert.deepEqual(
+			requestIdPerMessage(
+				lines.filter((line) => String(line.msg).startsWith("handled ")),
+			),
+			[
+				["handled fast", "fast"],
+				["handled slow", "slow"],
+			],
+		);
+	});
+});

package/src/logger.ts

@@ -159,32 +159,38 @@ export const logger: Logger = createAdapter(root, {});
 
 export const createLogger = (): Logger => createAdapter(root, {});
 
+// The scope opens around the wrapper's own two lines, not just the handler:
+// "Lambda invocation failed" is the line an operator correlates from, and it is
+// written after the handler has already unwound, so a scope opened inside the
+// handler no longer covers it. Everything the invocation writes — the wrapper's
+// lines and the handler's — carries the same `requestId`.
 export const withTelemetry = <TEvent, TResult>(
 	handler: (event: TEvent, context: Context) => Promise<TResult>,
 ): ((event: TEvent, context: Context) => Promise<TResult>) => {
-	return async (event: TEvent, context: Context): Promise<TResult> => {
-		logger.debug("Lambda invocation started", {
-			functionName: context.functionName,
-		});
-
-		const start = Date.now();
-
-		try {
-			const result = await handler(event, context);
-			recordHandlerOutcome({
-				handler: context.functionName,
-				outcome: "success",
-				durationMs: Date.now() - start,
-			});
-			return result;
-		} catch (err) {
-			recordHandlerOutcome({
-				handler: context.functionName,
-				outcome: "failure",
-				durationMs: Date.now() - start,
+	return async (event: TEvent, context: Context): Promise<TResult> =>
+		withLogContext({ requestId: context.awsRequestId }, async () => {
+			logger.debug("Lambda invocation started", {
+				functionName: context.functionName,
 			});
-			logger.error("Lambda invocation failed", { error: err });
-			throw err;
-		}
-	};
+
+			const start = Date.now();
+
+			try {
+				const result = await handler(event, context);
+				recordHandlerOutcome({
+					handler: context.functionName,
+					outcome: "success",
+					durationMs: Date.now() - start,
+				});
+				return result;
+			} catch (err) {
+				recordHandlerOutcome({
+					handler: context.functionName,
+					outcome: "failure",
+					durationMs: Date.now() - start,
+				});
+				logger.error("Lambda invocation failed", { error: err });
+				throw err;
+			}
+		});
 };

package/src/metrics.test.ts

@@ -353,7 +353,7 @@ describe("the /metrics endpoint", () => {
 			onError: (error) => reported.push(error),
 		});
 		servers.push(server);
-		await new Promise((resolve) => setTimeout(resolve, 50));
+		await new Promise<void>((resolve) => server.once("error", () => resolve()));
 		assert.equal(reported.length, 1);
 		assert.match(String(reported[0]), /EADDRINUSE/);
 		// The port that was already bound still answers: nothing died.
@@ -370,7 +370,7 @@ describe("the /metrics endpoint", () => {
 		}) as typeof process.stderr.write;
 		const server = startMetricsServer({ port: held, host: "127.0.0.1" });
 		servers.push(server);
-		await new Promise((resolve) => setTimeout(resolve, 50));
+		await new Promise<void>((resolve) => server.once("error", () => resolve()));
 		process.stderr.write = restore;
 
 		assert.equal(written.length, 1);