node:process

The node:process module in Azion Runtime: the process object, examples of environment variables, nextTick, and process information, and the supported APIs.

Last updated

View as Markdown Agent setup

The node:process module provides process, the Node.js object that holds information about the current process and controls its execution. In a function, its frequent uses are reading environment variables through process.env and scheduling work with process.nextTick(). Deployed, process.env holds the environment variables of your account, which you can also read with Azion.env.get().

In Azion Runtime, process is also a global, but the global and the default export of node:process are different objects. In the examples below, the global process.env.NODE_ENV returns production, and the same property of the imported object returns no value.

Under azion dev, the nextTick callbacks of the deferred execution example run before End, and the response lists both of them. Without a .env file in the project, process.env holds the whole shell environment of the machine that runs azion dev.

Examples

Each example is a complete function that imports from node:process. The response below each example is the one a deployed function returns.

Environment variables and nextTick

This function logs the global process.env.NODE_ENV, schedules a callback with nextTick, and returns the value in the response:

JavaScript
01/**
02 * An example of using the Node.js Process API in an Azion Function.
03 * Support:
04 * - Extended by library `process`
05 * Portions of this file Copyright Roman Shtylman, licensed under the MIT license.
06 * @module runtime-apis/nodejs/process/main
07 * @example
08 * // Build and run with the Azion CLI:
09 * azion build
10 * azion dev
11 */
12import { env, nextTick } from "node:process";
13
14/**
15 * Example of using the process api
16 * @param {*} event
17 */
18const main = async (event) => {
19 console.log(process.env.NODE_ENV);
20
21 nextTick(() => {
22 console.log("Hello, Next Tick!");
23 // Deployed, this line was not logged before the response was sent
24 });
25
26 return new Response(`NODE_ENV: ${process.env.NODE_ENV}`, { status: 200 });
27};
28
29export default main;

The function logs production and responds with this body:

NODE_ENV: production

Configuration from environment variables

This function reads four configuration values from process.env, falls back to a default for each one, and reports whether an API key is set without exposing its value:

JavaScript
01import process from "node:process";
02
03const main = async (event) => {
04 // Read environment variables
05 const nodeEnv = process.env.NODE_ENV || "development";
06 const apiKey = process.env.API_KEY;
07 const debug = process.env.DEBUG === "true";
08 const maxRetries = parseInt(process.env.MAX_RETRIES || "3", 10);
09
10 console.log("Environment:", nodeEnv);
11 console.log("Debug mode:", debug);
12 console.log("Max retries:", maxRetries);
13
14 // Check if required variables are set
15 if (!apiKey) {
16 console.warn("API_KEY not configured");
17 }
18
19 // Build configuration object
20 // Security: Never expose sensitive env vars in responses
21 // Use boolean flags instead of actual values
22 const config = {
23 environment: nodeEnv,
24 debug,
25 maxRetries,
26 hasApiKey: !!apiKey // Boolean only, not the actual key
27 };
28
29 return new Response(JSON.stringify(config), {
30 headers: { "Content-Type": "application/json" }
31 });
32};
33
34export default main;

With none of the four variables set, the function logs the warning API_KEY not configured and responds with the defaults:

{"environment":"development","debug":false,"maxRetries":3,"hasApiKey":false}

Deferred execution with nextTick

This function records the order in which its code runs around two nextTick calls, waits 10 ms, and returns the order:

JavaScript
01import { nextTick } from "node:process";
02import { setTimeout } from "node:timers/promises";
03
04const main = async (event) => {
05 const executionOrder = [];
06
07 executionOrder.push("Start");
08
09 // Schedule with nextTick - runs after the current code
10 // Deployed, the callbacks have not run when the response is built
11 nextTick(() => {
12 executionOrder.push("NextTick callback");
13 console.log("Deferred execution completed");
14 });
15
16 executionOrder.push("After nextTick call");
17
18 // Schedule a second callback
19 nextTick(() => {
20 executionOrder.push("Second nextTick");
21 });
22
23 // Wait 10 ms before building the response
24 await setTimeout(10);
25
26 executionOrder.push("End");
27
28 console.log("Execution order:", executionOrder.join(" -> "));
29
30 return new Response(JSON.stringify({ executionOrder }), {
31 headers: { "Content-Type": "application/json" }
32 });
33};
34
35export default main;

In a deployed function, the nextTick callbacks have not run when the function builds its response, so the order ends at End and lists neither callback:

{"executionOrder":["Start","After nextTick call","End"]}

Process information

This function reads the platform, architecture, versions, and process IDs, and returns them as formatted JSON:

JavaScript
01import process from "node:process";
02
03const main = async (event) => {
04 // In Azion Runtime, these process properties return fixed values:
05 // - process.platform and process.arch are empty strings
06 // - process.pid is 200 and process.ppid is 100
07 // - process.versions holds only the node field
08
09 // Platform information
10 const platform = process.platform;
11 const arch = process.arch;
12 const versions = process.versions;
13
14 // Process identification
15 const pid = process.pid;
16 const ppid = process.ppid;
17
18 // Runtime information
19 const nodeVersion = process.version;
20 const v8Version = versions.v8;
21
22 console.log("Platform:", platform);
23 console.log("Architecture:", arch);
24 console.log("Node version:", nodeVersion);
25 console.log("V8 version:", v8Version);
26 console.log("Process ID:", pid);
27
28 // Build info object with fallbacks for potentially undefined values
29 const processInfo = {
30 platform,
31 arch,
32 pid,
33 ppid,
34 nodeVersion,
35 v8Version,
36 versions: {
37 node: versions.node || "unknown",
38 v8: versions.v8 || "unknown",
39 openssl: versions.openssl || "unknown"
40 }
41 };
42
43 return new Response(JSON.stringify(processInfo, null, 2), {
44 headers: { "Content-Type": "application/json" }
45 });
46};
47
48export default main;

The function responds with the fixed values. v8Version is undefined, so JSON.stringify leaves it out of the body:

JSON
01{
02 "platform": "",
03 "arch": "",
04 "pid": 200,
05 "ppid": 100,
06 "nodeVersion": "v22.14.0",
07 "versions": {
08 "node": "22.14.0",
09 "v8": "unknown",
10 "openssl": "unknown"
11 }
12}

Memory usage

This function reads process.memoryUsage() before and after it builds an array, and returns both readings and the difference:

JavaScript
01import process from "node:process";
02
03const main = async (event) => {
04 // Get initial memory usage
05 const initialMemory = process.memoryUsage();
06
07 // Simulate some work
08 const data = [];
09 for (let i = 0; i < 1000; i++) {
10 data.push({ id: i, data: "x".repeat(100) });
11 }
12
13 // Get memory usage after work
14 const finalMemory = process.memoryUsage();
15
16 // Calculate memory delta
17 const memoryDelta = {
18 rss: finalMemory.rss - initialMemory.rss,
19 heapTotal: finalMemory.heapTotal - initialMemory.heapTotal,
20 heapUsed: finalMemory.heapUsed - initialMemory.heapUsed,
21 external: finalMemory.external - initialMemory.external
22 };
23
24 console.log("Initial heap used:", initialMemory.heapUsed, "bytes");
25 console.log("Final heap used:", finalMemory.heapUsed, "bytes");
26 console.log("Memory delta:", memoryDelta.heapUsed, "bytes");
27
28 return new Response(JSON.stringify({
29 initial: {
30 rss: initialMemory.rss,
31 heapTotal: initialMemory.heapTotal,
32 heapUsed: initialMemory.heapUsed
33 },
34 final: {
35 rss: finalMemory.rss,
36 heapTotal: finalMemory.heapTotal,
37 heapUsed: finalMemory.heapUsed
38 },
39 delta: memoryDelta
40 }), {
41 headers: { "Content-Type": "application/json" }
42 });
43};
44
45export default main;

Every field of process.memoryUsage() returns 0, so both readings and the difference are 0:

{"initial":{"rss":0,"heapTotal":0,"heapUsed":0},"final":{"rss":0,"heapTotal":0,"heapUsed":0},"delta":{"rss":0,"heapTotal":0,"heapUsed":0,"external":0}}

Uptime and timing

This function reads process.uptime() and process.hrtime(), then measures a 100 ms wait with process.hrtime.bigint():

JavaScript
01import process from "node:process";
02import { setTimeout } from "node:timers/promises";
03
04const main = async (event) => {
05 // Get process uptime in seconds
06 const uptime = process.uptime();
07
08 // Get high-resolution time
09 const hrtime = process.hrtime();
10 const hrtimeBigint = process.hrtime.bigint();
11
12 console.log("Process uptime:", uptime, "seconds");
13 console.log("High-res time:", hrtime);
14 console.log("High-res time (bigint):", hrtimeBigint.toString(), "nanoseconds");
15
16 // Measure an operation; deployed, the measured time is 0
17 const start = process.hrtime.bigint();
18
19 // Simulate work
20 await setTimeout(100);
21
22 const end = process.hrtime.bigint();
23 const elapsedNs = Number(end - start);
24 const elapsedMs = elapsedNs / 1_000_000;
25
26 console.log("Operation took:", elapsedMs.toFixed(2), "ms");
27
28 return new Response(JSON.stringify({
29 uptime: {
30 seconds: uptime,
31 formatted: formatUptime(uptime)
32 },
33 hrtime: {
34 seconds: hrtime[0],
35 nanoseconds: hrtime[1]
36 },
37 operationTime: {
38 nanoseconds: elapsedNs,
39 milliseconds: elapsedMs
40 }
41 }), {
42 headers: { "Content-Type": "application/json" }
43 });
44};
45
46// Helper function defined before export
47function formatUptime(seconds) {
48 const hours = Math.floor(seconds / 3600);
49 const minutes = Math.floor((seconds % 3600) / 60);
50 const secs = Math.floor(seconds % 60);
51 return `${hours}h ${minutes}m ${secs}s`;
52}
53
54export default main;

Deployed, process.uptime() returns 0, process.hrtime() returns whole seconds with 0 nanoseconds, and the time measured across the 100 ms wait is 0:

{"uptime":{"seconds":0,"formatted":"0h 0m 0s"},"hrtime":{"seconds":1767268800,"nanoseconds":0},"operationTime":{"nanoseconds":0,"milliseconds":0}}

Supported APIs

The table lists the status of each node:process API in Azion Runtime:

APIStatus
process.env🟢 Supported
process.nextTick()🟢 Supported
process.platform🟡 Partially supported (empty string)
process.arch🟡 Partially supported (empty string)
process.version🟢 Supported
process.versions🟡 Partially supported (node only)
process.pid🟡 Partially supported (fixed value)
process.ppid🟡 Partially supported (fixed value)
process.uptime()🟡 Partially supported (returns 0)
process.hrtime()🟡 Partially supported
process.hrtime.bigint()🟡 Partially supported
process.memoryUsage()🟡 Partially supported (returns 0)
process.cwd()🟡 Partially supported
process.exit()🟡 Partially supported
process.on()🟡 Partially supported
process.argv🟡 Partially supported
process.title🟡 Partially supported
process.binding()🔴 Not supported

APIs marked 🟡 Partially supported have limited functionality compared to the full Node.js implementation. Their values are fixed and do not describe the machine that runs your code. process.platform, process.arch, and process.title are empty strings, process.pid is 200, and process.ppid is 100. process.version is v22.14.0, and process.versions holds only node. process.cwd() returns /, and process.argv is an empty array. Deployed, process.hrtime() and process.hrtime.bigint() return whole seconds with 0 nanoseconds.

process.exit() does not terminate the runtime process, and process.on() has limited event support. process.binding() throws Error: [unenv] process.binding is not implemented yet!. For environment configuration, use process.env, which is fully supported.

Node.js APIs

The status of every Node.js module in Azion Runtime, process included.

Environment variables API

How a function reads the environment variables of your account with Azion.env.get().

node:os

The os module, whose functions also return fixed values inside a function.

Node.js process documentation

The full Node.js reference for every node:process API in the table.