@remit/smtp-worker 0.0.12 → 0.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/smtp-worker",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "type": "module",
   "main": "dist/index.js",
   "exports": {

package/src/e2e-processor-shim.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { randomUUID } from "node:crypto";
 import {
 	DeleteMessageCommand,
 	ReceiveMessageCommand,
@@ -46,11 +47,16 @@ process.on("SIGTERM", () => {
 	isShuttingDown = true;
 });
 
-// Minimal Lambda Context: `withTelemetry` only reads `functionName`, for the
-// line it logs per invocation; the prod handler never touches the rest.
-const lambdaContext = {
-	functionName: `e2e-smtp-worker-${queueName}`,
-} as Context;
+// Minimal Lambda Context: `withTelemetry` reads `functionName` for the line it
+// logs per invocation and `awsRequestId` for the scope it opens around it, so
+// every line one batch produces shares a `requestId` (deploy/vps/README.md,
+// "Logs"). Minted per batch, like the production poller does — a context built
+// once would put the whole run under one id, which correlates nothing.
+const nextContext = (): Context =>
+	({
+		functionName: `e2e-smtp-worker-${queueName}`,
+		awsRequestId: randomUUID(),
+	}) as Context;
 
 const pollQueue = async (): Promise<void> => {
 	log.info("Worker started, polling...", { maxMessages });
@@ -115,7 +121,7 @@ const pollQueue = async (): Promise<void> => {
 			})),
 		};
 
-		const result = (await handler(event, lambdaContext)) as
+		const result = (await handler(event, nextContext())) as
 			| SQSBatchResponse
 			| undefined;
 

package/src/failure-kind.test.ts

@@ -0,0 +1,38 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { RefreshTokenError } from "@remit/mail-oauth-service";
+import { SmtpConnectionError } from "@remit/smtp-service";
+import { smtpFailureKind } from "./failure-kind.js";
+
+describe("smtpFailureKind", () => {
+	it("counts an SMTP authentication rejection as auth", () => {
+		assert.equal(
+			smtpFailureKind(new SmtpConnectionError("auth", "535 bad credentials")),
+			"auth",
+		);
+	});
+
+	it("counts a token refresh that cannot mint credentials as auth", () => {
+		assert.equal(
+			smtpFailureKind(
+				new RefreshTokenError({
+					kind: "reauth-required",
+					code: "invalid_grant",
+				}),
+			),
+			"auth",
+		);
+	});
+
+	it("keeps a network failure apart from an auth failure", () => {
+		assert.equal(
+			smtpFailureKind(new SmtpConnectionError("network", "ECONNREFUSED")),
+			"network",
+		);
+	});
+
+	it("classifies anything else as other", () => {
+		assert.equal(smtpFailureKind(new Error("nodemailer blew up")), "other");
+		assert.equal(smtpFailureKind("not an error"), "other");
+	});
+});

package/src/failure-kind.ts

@@ -0,0 +1,16 @@
+import type { MailFailureKind } from "@remit/logger-lambda";
+import { RefreshTokenError } from "@remit/mail-oauth-service";
+import { SmtpConnectionError } from "@remit/smtp-service";
+
+/**
+ * Which class of failure ended an SMTP send, for the exported failure counter
+ * (standalone-observability D3). `auth` is its own kind because it is the one
+ * class that never resolves itself: an expired OAuth grant or a changed
+ * password fails identically forever, and a mailbox that cannot send stays
+ * unable to send until someone re-authorises it.
+ */
+export const smtpFailureKind = (error: unknown): MailFailureKind => {
+	if (error instanceof RefreshTokenError) return "auth";
+	if (error instanceof SmtpConnectionError) return error.kind;
+	return "other";
+};

package/src/index.ts

@@ -1,12 +1,14 @@
 import { inspect } from "node:util";
 import {
 	createLogger,
-	MetricUnit,
-	metrics,
+	queueNameFromEventSource,
+	recordQueueEvent,
+	recordSmtpFailure,
 	withTelemetry,
 } from "@remit/logger-lambda";
 import type { SQSBatchResponse, SQSEvent } from "aws-lambda";
 import type { SmtpEvent } from "./events.js";
+import { smtpFailureKind } from "./failure-kind.js";
 import { processEvent } from "./processor.js";
 
 const log = createLogger();
@@ -22,14 +24,16 @@ export const handler = withTelemetry(
 				eventId: smtpEvent.eventId,
 			});
 
+			const queue = queueNameFromEventSource(record.eventSourceARN);
 			const sendStart = Date.now();
 			const failed = await processEvent(smtpEvent, log)
 				.then(() => {
-					metrics.addMetric(
-						"smtpSendLatency",
-						MetricUnit.Milliseconds,
-						Date.now() - sendStart,
-					);
+					recordQueueEvent({
+						queue,
+						eventType: smtpEvent.type,
+						outcome: "success",
+						durationMs: Date.now() - sendStart,
+					});
 					return false;
 				})
 				.catch((error) => {
@@ -37,7 +41,13 @@ export const handler = withTelemetry(
 						error: inspect(error),
 						messageId: record.messageId,
 					});
-					metrics.addMetric("smtpSendFailures", MetricUnit.Count, 1);
+					recordQueueEvent({
+						queue,
+						eventType: smtpEvent.type,
+						outcome: "failure",
+						durationMs: Date.now() - sendStart,
+					});
+					recordSmtpFailure(smtpFailureKind(error));
 					return true;
 				});
 

package/src/poller.ts

@@ -1,4 +1,4 @@
-import { createLogger } from "@remit/logger-lambda";
+import { createLogger, startMetricsServer } from "@remit/logger-lambda";
 import { runQueuePoller } from "@remit/sqs-client/poller";
 import { env } from "expect-env";
 import { handler } from "./index.js";
@@ -6,6 +6,11 @@ import { handler } from "./index.js";
 /** Production queue poller — the deployed form of `e2e-processor-shim.ts`. */
 const log = createLogger();
 
+// /metrics and nothing else, on the compose network (standalone-observability
+// D2). No health route on it: worker liveness is a heartbeat file, which keeps
+// answering when this server does not.
+startMetricsServer();
+
 await runQueuePoller({
 	log,
 	targets: [