Serverless DeepDive #06：実行環境はどこまで再利用されるのか

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

// These identify module initialization and local state, not a physical host or microVM.
const environmentId = randomUUID();
const initializedAtMs = Date.now();
const tmpPath = "/tmp/lambda-lab-node-probe.json";
let calls = 0;
let memoryValue = null;
let s3Client;
const modes = ["observe", "persist", "read", "fail", "sleep"];
console.log(
JSON.stringify({ phase: "probe-init", environmentId, 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 temporaryState() {
try {
return JSON.parse(readFileSync(tmpPath, "utf8"));
} catch (error) {
if (error.code !== "ENOENT") throw error;
return { environmentId, value: null };
}
}

function storage() {
if (!s3Client) {
const { S3Client } = require("@aws-sdk/client-s3");
s3Client = new S3Client({ maxAttempts: 1 });
}
return s3Client;
}

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 ?? "observe", "id");
const runId = identifier(event.run_id ?? "manual", "run_id");
const delayMs = event.delay_ms ?? 0;
if (!Number.isInteger(delayMs) || delayMs < 0 || delayMs > 30000)
throw new TypeError("delay_ms must be between 0 and 30000");
if (event.value !== undefined && (typeof event.value !== "string" || event.value.length > 128))
throw new TypeError("value must be a string of at most 128 characters");
const tmp = temporaryState();
const before = { memoryValue, tmpValue: tmp.value };
if (event.value !== undefined) {
memoryValue = event.value;
tmp.value = event.value;
}
writeFileSync(tmpPath, JSON.stringify(tmp));
calls += 1;
const record = {
id,
run_id: runId,
mode,
request_id: context.awsRequestId,
environment_id: environmentId,
initialized_at_ms: initializedAtMs,
count: calls,
memory_before: before.memoryValue,
memory_value: memoryValue,
tmp_environment_id: tmp.environmentId,
tmp_before: before.tmpValue,
tmp_value: tmp.value,
version: context.functionVersion,
config_mark: process.env.PROBE_CONFIG_MARK ?? "A",
node: process.version,
started_ms: Date.now(),
};
console.log(JSON.stringify({ phase: "probe-enter", ...record }));
await sleep(delayMs);
if (mode === "persist" || mode === "read") {
const bucket = process.env.LAB_EVIDENCE_BUCKET;
const prefix = process.env.LAB_EVIDENCE_PREFIX;
if (!bucket || !prefix) throw new Error("storage is not configured");
const key = `${prefix}${runId}/${id}.json`;
const { PutObjectCommand, GetObjectCommand } = require("@aws-sdk/client-s3");
record.sdk = require("@aws-sdk/client-s3/package.json").version;
if (mode === "persist") {
await storage().send(
new PutObjectCommand({ Bucket: bucket, Key: key, Body: JSON.stringify(record) }),
);
record.persisted = true;
} else {
try {
const response = await storage().send(new GetObjectCommand({ Bucket: bucket, Key: key }));
record.saved = JSON.parse(await response.Body.transformToString());
record.found = true;
} catch (error) {
if (error.name !== "NoSuchKey") throw error;
record.found = false;
}
}
}
record.finished_ms = Date.now();
console.log(JSON.stringify({ phase: "probe-result", ...record }));
if (mode === "fail") throw new Error("intentional failure after observation");
return record;
};