Serverless DeepDive #05：Runtime APIの役割を探る

const http = require("node:http");
const { handler } = require("./index.cjs");

const authority = process.env.AWS_LAMBDA_RUNTIME_API;
if (!authority || !/^[A-Za-z0-9._-]+:\d+$/.test(authority))
throw new Error("missing Runtime API endpoint");
const base = `http://${authority}/2018-06-01/runtime`;
const log = (record) => console.log(JSON.stringify(record));
const errorBody = (error) => ({
errorType: error.name || "Error",
errorMessage: error.message || String(error),
stackTrace: [],
});

function request(method, path, body, invocationId) {
const text = body === undefined ? undefined : JSON.stringify(body);
return new Promise((resolve, reject) => {
const req = http.request(
`${base}${path}`,
{
method,
headers: {
...(text === undefined
? {}
: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(text) }),
...(invocationId ? { "Lambda-Runtime-Invocation-Id": invocationId } : {}),
},
},
(res) => {
let received = "";
res.setEncoding("utf8");
res.on("data", (chunk) => {
received += chunk;
});
res.on("error", reject);
res.on("end", () =>
resolve({ status: res.statusCode, headers: res.headers, body: received }),
);
},
);
// /next may block while Lambda freezes the process. No client timeout is set.
req.on("error", reject);
req.end(text);
});
}

async function main() {
log({ phase: "runtime-init", nodeVersion: process.version });
if (process.env.STARTUP_MODE === "init-fail") {
const result = await request("POST", "/init/error", {
errorType: "ExperimentInitError",
errorMessage: "deliberate failure before requesting an invocation",
stackTrace: [],
});
log({ phase: "init-error-post", status: result.status });
process.exit(1);
}
for (;;) {
const next = await request("GET", "/invocation/next");
if (next.status !== 200) throw new Error(`next returned ${next.status}`);
const requestId = next.headers["lambda-runtime-aws-request-id"];
const deadlineMs = Number(next.headers["lambda-runtime-deadline-ms"]);
const invocationId = next.headers["lambda-runtime-invocation-id"];
if (typeof requestId !== "string" || !Number.isFinite(deadlineMs))
throw new Error("invalid invocation headers");
const traceId = next.headers["lambda-runtime-trace-id"];
if (typeof traceId === "string") process.env._X_AMZN_TRACE_ID = traceId;
else delete process.env._X_AMZN_TRACE_ID;
const event = JSON.parse(next.body);
log({ phase: "next", label: event.label, requestId, deadlineMs, receivedAtMs: Date.now() });
const context = {
awsRequestId: requestId,
getRemainingTimeInMillis: () => Math.max(0, deadlineMs - Date.now()),
};
let path;
let payload;
try {
payload = await handler(event, context);
path = `/invocation/${requestId}/response`;
} catch (error) {
payload = errorBody(error);
path = `/invocation/${requestId}/error`;
}
if (event.operation === "omit") {
log({ phase: "response-omitted", label: event.label, requestId });
await new Promise(() => setInterval(() => {}, 1000));
}
const posted = await request("POST", path, payload, invocationId);
log({
phase: path.endsWith("/error") ? "error-post" : "response-post",
label: event.label,
requestId,
status: posted.status,
});
if (posted.status !== 202) throw new Error(`result POST returned ${posted.status}`);
}
}

main().catch((error) => {
log({ phase: "runtime-fatal", ...errorBody(error) });
process.exit(1);
});