@remit/logger-lambda 0.0.9 → 0.0.11

package/src/logger.test.ts

@@ -2,78 +2,19 @@ import assert from "node:assert/strict";
 import { beforeEach, describe, it, mock } from "node:test";
 import type { Context } from "aws-lambda";
 
-const addMetric = mock.fn();
-const publishStoredMetrics = mock.fn();
-const captureColdStartMetric = mock.fn();
-const addContext = mock.fn();
-const logTrace = mock.fn();
-const logDebug = mock.fn();
-const logInfo = mock.fn();
-const logWarn = mock.fn();
-const logError = mock.fn();
-const logCritical = mock.fn();
-const appendPersistentKeys = mock.fn();
+// The logging half of this package is covered by log-output.test.ts against its
+// real stdout output; this file is the telemetry wrapper, so the logger is
+// silenced and only what reaches the metric registry is observed.
+process.env.LOG_LEVEL = "silent";
 
-class MockLogger {
-	addContext = addContext;
-	trace = logTrace;
-	debug = logDebug;
-	info = logInfo;
-	warn = logWarn;
-	error = logError;
-	critical = logCritical;
-	appendPersistentKeys = appendPersistentKeys;
-	createChild = () => createChild();
-}
-
-const createChild = mock.fn(() => new MockLogger());
-
-class MockMetrics {
-	addMetric = addMetric;
-	publishStoredMetrics = publishStoredMetrics;
-	captureColdStartMetric = captureColdStartMetric;
-}
-
-mock.module("@aws-lambda-powertools/logger", {
-	namedExports: { Logger: MockLogger },
-});
-
-mock.module("@aws-lambda-powertools/metrics", {
-	namedExports: {
-		Metrics: MockMetrics,
-		MetricUnit: { Count: "Count", Milliseconds: "Milliseconds" },
-	},
-});
-
-const { createLogger, metrics, withTelemetry } = await import("./logger.js");
-const { Metrics } = await import("@aws-lambda-powertools/metrics");
+const { withTelemetry } = await import("./logger.js");
+const { registry, resetMetrics } = await import("./metrics.js");
 
 type Recorded = { mock: { calls: { arguments: unknown[] }[] } };
 
 const calls = (fn: Recorded): unknown[][] =>
 	fn.mock.calls.map((call) => call.arguments);
 
-const lastCall = (fn: Recorded): unknown[] => {
-	const recorded = calls(fn);
-	assert.ok(recorded.length > 0, "expected the mock to have been called");
-	return recorded[recorded.length - 1];
-};
-
-const recorded = [
-	addMetric,
-	publishStoredMetrics,
-	captureColdStartMetric,
-	addContext,
-	logTrace,
-	logDebug,
-	logInfo,
-	logWarn,
-	logError,
-	logCritical,
-	appendPersistentKeys,
-	createChild,
-];
-
 const makeContext = (): Context =>
 	({
 		awsRequestId: "test-request-id",
@@ -90,68 +31,34 @@ const makeContext = (): Context =>
 		succeed: () => {},
 	}) as unknown as Context;
 
-describe("remit-logger-lambda", () => {
-	beforeEach(() => {
-		for (const fn of recorded) fn.mock.resetCalls();
-	});
-
-	it("exports metrics as a Metrics instance", () => {
-		assert.ok(metrics instanceof Metrics);
-	});
-
-	it("object-first call maps to Powertools message + attributes", () => {
-		const log = createLogger(makeContext());
-		log.error({ error: "boom", messageId: "m1" }, "Failed to parse message");
-		assert.deepEqual(lastCall(logError), [
-			"Failed to parse message",
-			{ error: "boom", messageId: "m1" },
-		]);
-	});
-
-	it("object-first call without message uses empty string", () => {
-		const log = createLogger();
-		log.info({ count: 3 });
-		assert.deepEqual(lastCall(logInfo), ["", { count: 3 }]);
-	});
-
-	it("string-first call passes message then attributes", () => {
-		const log = createLogger();
-		log.warn("watch out", { reason: "slow" });
-		assert.deepEqual(lastCall(logWarn), ["watch out", { reason: "slow" }]);
-	});
-
-	it("string-first call without attributes passes only the message", () => {
-		const log = createLogger();
-		log.debug("hello");
-		assert.deepEqual(lastCall(logDebug), ["hello"]);
-	});
-
-	it("fatal maps to Powertools critical", () => {
-		const log = createLogger();
-		log.fatal({ fatal: true }, "the end");
-		assert.deepEqual(lastCall(logCritical), ["the end", { fatal: true }]);
-	});
-
-	it("trace maps to Powertools trace", () => {
-		const log = createLogger();
-		log.trace("trace me");
-		assert.deepEqual(lastCall(logTrace), ["trace me"]);
-	});
+type HistogramValue = {
+	metricName?: string;
+	labels: Record<string, string | number>;
+	value: number;
+};
 
-	it("child creates a Powertools child and appends bindings", () => {
-		const log = createLogger();
-		const child = log.child({ queue: "imap" });
-		assert.equal(calls(createChild).length, 1);
-		assert.deepEqual(lastCall(appendPersistentKeys), [{ queue: "imap" }]);
-		child.info({ done: true }, "child log");
-		assert.deepEqual(lastCall(logInfo), ["child log", { done: true }]);
-	});
+const handlerAggregate = async (
+	suffix: string,
+	labels: Record<string, string>,
+): Promise<number> => {
+	const metric = registry.getSingleMetric("remit_handler_duration_seconds");
+	assert.ok(metric, "expected the handler duration histogram to be registered");
+	const { values } = (await metric.get()) as { values: HistogramValue[] };
+	const match = values.find(
+		(value) =>
+			value.metricName === `remit_handler_duration_seconds_${suffix}` &&
+			value.labels.handler === labels.handler &&
+			value.labels.outcome === labels.outcome,
+	);
+	assert.ok(
+		match,
+		`expected a _${suffix} sample for ${JSON.stringify(labels)}`,
+	);
+	return match.value;
+};
 
-	it("setBindings appends persistent keys", () => {
-		const log = createLogger();
-		log.setBindings({ requestId: "r1" });
-		assert.deepEqual(lastCall(appendPersistentKeys), [{ requestId: "r1" }]);
-	});
+describe("remit-logger-lambda", () => {
+	beforeEach(() => resetMetrics());
 
 	it("withTelemetry calls the handler and returns its result", async () => {
 		const handler = mock.fn(async () => "hello");
@@ -169,34 +76,20 @@ describe("remit-logger-lambda", () => {
 		await assert.rejects(wrapped({}, makeContext()), /boom/);
 	});
 
-	it("withTelemetry publishes metrics in finally even on error", async () => {
+	it("withTelemetry records a failed invocation against the registry", async () => {
 		const handler = mock.fn(async () => {
 			throw new Error("fail");
 		});
-		const wrapped = withTelemetry(handler);
-		await assert.rejects(wrapped({}, makeContext()));
-		assert.ok(calls(publishStoredMetrics).length > 0);
+		await assert.rejects(withTelemetry(handler)({}, makeContext()));
+		const labels = { handler: "test-function", outcome: "failure" };
+		assert.equal(await handlerAggregate("count", labels), 1);
 	});
 
-	it("withTelemetry emits errorCount on handler failure", async () => {
-		const handler = mock.fn(async () => {
-			throw new Error("fail");
-		});
-		const wrapped = withTelemetry(handler);
-		await assert.rejects(wrapped({}, makeContext()));
-		assert.deepEqual(calls(addMetric), [["errorCount", "Count", 1]]);
-	});
-
-	it("withTelemetry emits invocationCount and invocationLatency on success", async () => {
+	it("withTelemetry records a successful invocation and its duration", async () => {
 		const handler = mock.fn(async () => 42);
-		const wrapped = withTelemetry(handler);
-		await wrapped({}, makeContext());
-		const [countCall, latencyCall] = calls(addMetric);
-		assert.deepEqual(countCall, ["invocationCount", "Count", 1]);
-		assert.deepEqual(latencyCall.slice(0, 2), [
-			"invocationLatency",
-			"Milliseconds",
-		]);
-		assert.equal(typeof latencyCall[2], "number");
+		await withTelemetry(handler)({}, makeContext());
+		const labels = { handler: "test-function", outcome: "success" };
+		assert.equal(await handlerAggregate("count", labels), 1);
+		assert.equal(typeof (await handlerAggregate("sum", labels)), "number");
 	});
 });

package/src/logger.ts

@@ -1,40 +1,90 @@
-import { Logger as PowertoolsLogger } from "@aws-lambda-powertools/logger";
-import { Metrics, MetricUnit } from "@aws-lambda-powertools/metrics";
+import { AsyncLocalStorage } from "node:async_hooks";
 import type { Context } from "aws-lambda";
+import { pino, stdSerializers } from "pino";
+import { recordHandlerOutcome } from "./metrics.js";
 
 type LogBindings = Record<string, unknown>;
 
-type PowertoolsLevel =
-	| "trace"
-	| "debug"
-	| "info"
-	| "warn"
-	| "error"
-	| "critical";
+type EmitLevel = "trace" | "debug" | "info" | "warn" | "error" | "fatal";
+
+const LEVELS = [
+	"trace",
+	"debug",
+	"info",
+	"warn",
+	"error",
+	"fatal",
+	"silent",
+] as const;
+
+const DEFAULT_LEVEL = "info";
+
+const isLevel = (value: string): boolean =>
+	(LEVELS as readonly string[]).includes(value);
+
+const requestedLevel = process.env.LOG_LEVEL?.trim().toLowerCase();
+
+const level =
+	requestedLevel && isLevel(requestedLevel) ? requestedLevel : DEFAULT_LEVEL;
 
 const isBindings = (value: unknown): value is LogBindings =>
 	typeof value === "object" && value !== null;
 
-const emit = (
-	target: PowertoolsLogger,
-	level: PowertoolsLevel,
+// Written by the writer itself, so a binding of the same name would be a second
+// occurrence of the key on the line and every JSON parser takes the last one —
+// a call-site field named `level` would silently retag the line. Dropped rather
+// than renamed: a field the operator cannot rely on is worse than an absent one.
+const RESERVED = ["level", "time", "service", "msg"] as const;
+
+const withoutReserved = (fields: LogBindings): LogBindings => {
+	let kept: LogBindings | undefined;
+	for (const key of RESERVED) {
+		if (!(key in fields)) continue;
+		kept ??= { ...fields };
+		delete kept[key];
+	}
+	return kept ?? fields;
+};
+
+// One JSON object per line on stdout: `level` as a lowercase name, `time` as
+// RFC 3339, `service` naming the image, `msg` always present, and every binding
+// at the top level. The field contract is documented in deploy/vps/README.md
+// under "Logs" — log-shipping rules are written against these names.
+//
+// `error` carries an Error at most call sites in this repo, so it is serialised
+// the way pino serialises `err`: a bare Error spreads to nothing, which is how a
+// stack trace disappears from a worker failure line.
+const root = pino({
+	level,
+	base: { service: process.env.REMIT_SERVICE_NAME ?? "remit" },
+	timestamp: pino.stdTimeFunctions.isoTime,
+	formatters: { level: (label: string) => ({ level: label }) },
+	serializers: { error: stdSerializers.err },
+});
+
+type PinoLogger = typeof root;
+
+// A level nobody can spell is worth one line rather than a crashed container:
+// the operator asked for something and did not get it, and every other line
+// still arrives.
+if (requestedLevel && requestedLevel !== level) {
+	root.warn(
+		{ configured: requestedLevel, expected: LEVELS.join(", ") },
+		`LOG_LEVEL is not a level name; logging at ${level}`,
+	);
+}
+
+// The interface accepts (bindings, message) and (message, bindings); pino reads
+// (bindings, message) only, and treats an object after a string message as a
+// format argument. Normalising here is what keeps both call shapes working.
+const normalize = (
 	first: LogBindings | string,
 	second?: LogBindings | string,
-): void => {
-	if (typeof first !== "string") {
-		const message = typeof second === "string" ? second : "";
-		target[level](message, first);
-		return;
+): [LogBindings, string] => {
+	if (typeof first === "string") {
+		return [isBindings(second) ? second : {}, first];
 	}
-	if (second === undefined) {
-		target[level](first);
-		return;
-	}
-	if (typeof second === "string") {
-		target[level](first, second);
-		return;
-	}
-	target[level](first, second);
+	return [first, typeof second === "string" ? second : ""];
 };
 
 export interface Logger {
@@ -54,72 +104,87 @@ export interface Logger {
 	setBindings(bindings: LogBindings): void;
 }
 
-const createAdapter = (target: PowertoolsLogger): Logger => ({
-	trace: (first: LogBindings | string, second?: LogBindings | string): void =>
-		emit(target, "trace", first, second),
-	debug: (first: LogBindings | string, second?: LogBindings | string): void =>
-		emit(target, "debug", first, second),
-	info: (first: LogBindings | string, second?: LogBindings | string): void =>
-		emit(target, "info", first, second),
-	warn: (first: LogBindings | string, second?: LogBindings | string): void =>
-		emit(target, "warn", first, second),
-	error: (first: LogBindings | string, second?: LogBindings | string): void =>
-		emit(target, "error", first, second),
-	fatal: (first: LogBindings | string, second?: LogBindings | string): void =>
-		emit(target, "critical", first, second),
-	child: (bindings: LogBindings): Logger => {
-		const childLogger = target.createChild();
-		if (isBindings(bindings)) {
-			childLogger.appendPersistentKeys(bindings);
-		}
-		return createAdapter(childLogger);
-	},
-	setBindings: (bindings: LogBindings): void => {
-		target.appendPersistentKeys(bindings);
-	},
-});
-
-const powertoolsLogger = new PowertoolsLogger({
-	serviceName: process.env.POWERTOOLS_SERVICE_NAME ?? "remit",
-});
+// Bindings from a scope opened by withLogContext. A server handling requests
+// concurrently cannot carry per-request fields on a shared logger instance:
+// whichever request wrote last owns them until the next one overwrites them.
+const scope = new AsyncLocalStorage<LogBindings>();
+
+/**
+ * Runs `fn` with `bindings` on every line any logger writes inside it,
+ * including asynchronous continuations. Scopes nest: an inner call adds to the
+ * bindings of the one it runs inside.
+ */
+export const withLogContext = <T>(bindings: LogBindings, fn: () => T): T =>
+	scope.run({ ...scope.getStore(), ...bindings }, fn);
+
+// Every binding is merged into one object here rather than handed to pino:
+// pino's own child/setBindings append to a cached string it writes verbatim, so
+// a shadowing key would appear twice on one line, and a per-request setBindings
+// on a long-lived logger would grow that string without bound.
+const createAdapter = (target: PinoLogger, persistent: LogBindings): Logger => {
+	const emit = (
+		level: EmitLevel,
+		first: LogBindings | string,
+		second?: LogBindings | string,
+	): void => {
+		const [fields, message] = normalize(first, second);
+		target[level](
+			withoutReserved({ ...persistent, ...scope.getStore(), ...fields }),
+			message,
+		);
+	};
 
-export const logger: Logger = createAdapter(powertoolsLogger);
+	return {
+		trace: (first: LogBindings | string, second?: LogBindings | string): void =>
+			emit("trace", first, second),
+		debug: (first: LogBindings | string, second?: LogBindings | string): void =>
+			emit("debug", first, second),
+		info: (first: LogBindings | string, second?: LogBindings | string): void =>
+			emit("info", first, second),
+		warn: (first: LogBindings | string, second?: LogBindings | string): void =>
+			emit("warn", first, second),
+		error: (first: LogBindings | string, second?: LogBindings | string): void =>
+			emit("error", first, second),
+		fatal: (first: LogBindings | string, second?: LogBindings | string): void =>
+			emit("fatal", first, second),
+		child: (bindings: LogBindings): Logger =>
+			createAdapter(target, { ...persistent, ...bindings }),
+		setBindings: (bindings: LogBindings): void => {
+			Object.assign(persistent, bindings);
+		},
+	};
+};
 
-export const metrics = new Metrics({
-	namespace: process.env.POWERTOOLS_METRICS_NAMESPACE ?? "Remit",
-	serviceName: process.env.POWERTOOLS_SERVICE_NAME ?? "remit",
-});
+export const logger: Logger = createAdapter(root, {});
 
-export const createLogger = (_context?: Context): Logger =>
-	createAdapter(powertoolsLogger);
+export const createLogger = (): Logger => createAdapter(root, {});
 
 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> => {
-		powertoolsLogger.addContext(context);
 		logger.debug("Lambda invocation started", {
 			functionName: context.functionName,
 		});
 
-		metrics.captureColdStartMetric();
-
 		const start = Date.now();
 
 		try {
 			const result = await handler(event, context);
-			const duration = Date.now() - start;
-
-			metrics.addMetric("invocationCount", MetricUnit.Count, 1);
-			metrics.addMetric("invocationLatency", MetricUnit.Milliseconds, duration);
-
+			recordHandlerOutcome({
+				handler: context.functionName,
+				outcome: "success",
+				durationMs: Date.now() - start,
+			});
 			return result;
 		} catch (err) {
-			metrics.addMetric("errorCount", MetricUnit.Count, 1);
-			logger.error("Lambda invocation failed", { error: String(err) });
+			recordHandlerOutcome({
+				handler: context.functionName,
+				outcome: "failure",
+				durationMs: Date.now() - start,
+			});
+			logger.error("Lambda invocation failed", { error: err });
 			throw err;
-		} finally {
-			metrics.publishStoredMetrics();
 		}
 	};
 };