Serverless DeepDive #09：失敗後の実行環境に何が残るのか

const { randomUUID } = require("node:crypto");
const { readFileSync, writeFileSync } = require("node:fs");
const { setTimeout: sleep } = require("node:timers/promises");

// A module initialization ID is not a physical host or microVM identifier.
const initId = randomUUID();
const initializedAtMs = Date.now();
const tmpPath = "/tmp/lambda-lab-reset-state.json";
let calls = 0;
let memoryValue = null;
let memoryStage = null;
const modes = ["observe", "commit", "throw", "exit", "timeout"];
console.log(
JSON.stringify({
phase: "reset-init",
init_id: initId,
initialized_at_ms: initializedAtMs,
node: process.version,
}),
);

function identifier(value, field) {
if (typeof value !== "string" || !/^[a-z0-9-]{1,64}$/.test(value))
throw new TypeError(`${field} must match [a-z0-9-]{1,64}`);
return value;
}

function readTemporaryState() {
try {
const saved = JSON.parse(readFileSync(tmpPath, "utf8"));
if (
!saved ||
typeof saved !== "object" ||
Array.isArray(saved) ||
typeof saved.init_id !== "string" ||
typeof saved.request_id !== "string" ||
typeof saved.run_id !== "string" ||
typeof saved.id !== "string" ||
typeof saved.value !== "string" ||
!["pending", "complete"].includes(saved.stage)
)
throw new TypeError("invalid temporary state");
return saved;
} catch (error) {
if (error.code !== "ENOENT") throw error;
return null;
}
}

exports.handler = async (event, context) => {
if (!event || typeof event !== "object" || Array.isArray(event))
throw new TypeError("event must be a JSON object");
const mode = event.mode ?? "observe";
if (!modes.includes(mode)) throw new TypeError("unknown mode");
const id = identifier(event.id ?? "work", "id");
const runId = identifier(event.run_id ?? "manual", "run_id");
const value = event.value ?? "pending-09";
if (typeof value !== "string" || value.length > 128)
throw new TypeError("value must be a string of at most 128 characters");
const delayMs = event.delay_ms ?? 2500;
if (!Number.isInteger(delayMs) || delayMs < 0 || delayMs > 30000)
throw new TypeError("delay_ms must be between 0 and 30000");

const previous = readTemporaryState();
const memoryBefore = memoryValue;
const memoryStageBefore = memoryStage;
calls += 1;
let saved = previous;
if (mode !== "observe") {
memoryValue = value;
memoryStage = "pending";
saved = {
init_id: initId,
request_id: context.awsRequestId,
run_id: runId,
id,
value,
stage: "pending",
};
writeFileSync(tmpPath, JSON.stringify(saved));
if (mode === "commit") {
memoryStage = "complete";
saved.stage = "complete";
writeFileSync(tmpPath, JSON.stringify(saved));
}
}

const record = {
phase: "reset-observe",
run_id: runId,
id,
mode,
request_id: context.awsRequestId,
init_id: initId,
initialized_at_ms: initializedAtMs,
count: calls,
memory_before: memoryBefore,
memory_value: memoryValue,
memory_stage_before: memoryStageBefore,
memory_stage: memoryStage,
tmp_before: previous?.value ?? null,
tmp_before_stage: previous?.stage ?? null,
tmp_value: saved?.value ?? null,
tmp_stage: saved?.stage ?? null,
tmp_init_id: saved?.init_id ?? null,
tmp_request_id: saved?.request_id ?? null,
tmp_same_job: saved?.run_id === runId && saved?.id === id,
tmp_complete: saved?.run_id === runId && saved?.id === id && saved?.stage === "complete",
node: process.version,
version: context.functionVersion,
started_ms: Date.now(),
};
// Flush this pre-fault observation before the intentional process exit.
await new Promise((resolve, reject) =>
process.stdout.write(`${JSON.stringify(record)}\n`, (error) =>
error ? reject(error) : resolve(),
),
);
if (mode === "throw") throw new Error("intentional handler exception after temporary write");
if (mode === "exit") process.exit(1);
if (mode === "timeout") await sleep(delayMs);
return { ...record, finished_ms: Date.now() };
};