@remit/logger-lambda 0.0.12 → 0.0.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/logger-lambda",
-  "version": "0.0.12",
+  "version": "0.0.13",
   "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
@@ -353,3 +355,76 @@ 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 invoke = (id: string, delayMs: number) =>
+			withTelemetry(async () => {
+				await new Promise((resolve) => setTimeout(resolve, delayMs));
+				logger.warn(`handled ${id}`);
+			})({}, {
+				awsRequestId: id,
+				functionName: "test-function",
+			} as unknown as typeof context);
+
+		const lines = await captureAsync(async () => {
+			await Promise.all([invoke("slow", 10), invoke("fast", 1)]);
+		});
+
+		assert.deepEqual(
+			lines
+				.filter((line) => String(line.msg).startsWith("handled "))
+				.map((line) => [line.msg, line.requestId]),
+			[
+				["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;
+			}
+		});
 };