The Process Object in Node.js

1. Process Events

• beforeExit: Emitted when the event loop is empty.
• exit: Emitted when the process is about to exit.
• disconnect: Emitted when the IPC channel is closed.
• message: Emitted when a message is received from the parent process.
• uncaughtException: Triggered by uncaught errors.
• unhandledRejection: Triggered by rejected Promises without handlers.
• warning: Emitted when Node.js issues a process warning.
• workerMessage: Emitted when a worker thread sends a message.

2. Signal Events

The Node.js process can receive POSIX signals such as SIGINT, SIGTERM, and SIGUSR1. Some signals like SIGKILL and SIGSTOP cannot be intercepted.

process.on('SIGINT', () => {
  console.log('Received SIGINT');
});

3. Process Properties

• process.arch: CPU architecture.
• process.argv: Command-line arguments.
• process.argv0: Original argv[0] value.
• process.cwd(): Current working directory.
• process.chdir(path): Change working directory.
• process.config: Compilation configuration options.
• process.debugPort: Debugger port.

4. Memory and CPU Management

• process.availableMemory(): Free memory available to the process.
• process.constrainedMemory(): Memory limits imposed by the OS.
• process.cpuUsage(): CPU usage statistics (user/system time).

5. IPC Communication

• process.channel: Reference to the IPC channel.
• process.connected: Indicates if IPC is connected.
• process.disconnect(): Closes the IPC channel.

6. Special Methods

• process.abort(): Immediately exits and generates a core dump.
• process.dlopen(): Dynamically loads native addons (C++).

Conclusion

The process object in Node.js is a central tool for managing the current runtime. Through its events, signals, and properties, developers gain full control over execution flow, system resources, and IPC. Mastering these features is essential for building robust and scalable Node.js applications.

1. Environment and Arguments

• process.env: Object containing environment variables.
• process.execArgv: Node.js-specific command-line options.
• process.execPath: Absolute path of the Node.js executable.
• process.execve(file, args, env): Replaces the current process with a new one (POSIX only).

2. Process Exit Management

• process.exit([code]): Forces immediate exit with a given code.
• process.exitCode: Sets the exit code for graceful termination.

Best practice: set process.exitCode instead of calling process.exit() directly, to avoid truncating pending I/O.

3. Build Features

• process.features.debug: Indicates a debug build.
• process.features.tls: TLS support.
• process.features.require_module: Support for loading ECMAScript modules via require().
• process.features.typescript: TypeScript support status (strip, transform, or disabled).

4. Resource Finalization

• process.finalization.register(ref, callback): Registers a callback for resource cleanup on exit.
• process.finalization.registerBeforeExit(ref, callback): Similar, but triggered on beforeExit.
• process.finalization.unregister(ref): Removes a previously registered callback.

Useful for freeing resources, but callbacks are not guaranteed to run under all circumstances.

5. Active Resources

• process.getActiveResourcesInfo(): Returns a list of active resources keeping the event loop alive.

Before: [ 'TTYWrap', 'TTYWrap' ]
After:  [ 'TTYWrap', 'TTYWrap', 'Timeout' ]

6. Built-in Modules

• process.getBuiltinModule(id): Loads a built-in Node.js module without using require().

Helps with compatibility across environments.

7. User and Group IDs (POSIX)

• process.getegid(): Effective group ID.
• process.geteuid(): Effective user ID.
• process.getgid(): Group ID of the process.
• process.getgroups(): Array of supplementary group IDs.

Available only on POSIX systems (not Windows or Android).

Conclusion

The advanced features of the process object provide developers with powerful tools to manage environment variables, exit behavior, build capabilities, and system-level resources. Mastering these APIs enables precise control over Node.js applications, ensuring stability, efficiency, and compatibility across platforms.

1. User and Group Identity

• process.getuid(): Returns the numeric user ID of the process (POSIX only).
• process.initgroups(user, extraGroup): Initializes group access list based on /etc/group. Requires root or CAP_SETGID privileges.

2. High-Resolution Timing

• process.hrtime([time]): Legacy method returning [seconds, nanoseconds] tuple.
• process.hrtime.bigint(): Modern method returning nanoseconds as a bigint.

const start = process.hrtime.bigint();
setTimeout(() => {
  const end = process.hrtime.bigint();
  console.log(`Benchmark took ${end - start} nanoseconds`);
}, 1000);

3. Signal Handling

• process.kill(pid[, signal]): Sends a signal to a process. Default signal: SIGTERM.

Despite its name, process.kill() is a signal sender and may not necessarily terminate the target process.

4. Environment Loading

• process.loadEnvFile(path): Loads environment variables from a .env file into process.env.

5. Main Module

• process.mainModule: Deprecated property, previously used as an alternative to require.main.

6. Memory Usage

• process.memoryUsage(): Returns detailed memory usage (rss, heapTotal, heapUsed, external, arrayBuffers).
• process.memoryUsage.rss(): Faster method returning Resident Set Size (RSS).

console.log(process.memoryUsage());
// { rss: 4935680, heapTotal: 1826816, heapUsed: 650472, ... }

7. Event Loop Scheduling

• process.nextTick(callback): Adds a callback to the "next tick queue," executed before the event loop continues.

This method ensures asynchronous consistency but should be used carefully to avoid infinite loops. Modern alternative: queueMicrotask().

Conclusion

The advanced methods of the process object provide developers with fine-grained control over timing, memory, signals, and environment management. Mastering these APIs enables precise diagnostics, efficient resource handling, and stable application design in Node.js.

1. queueMicrotask() vs process.nextTick()

• process.nextTick(): Adds callbacks to the "next tick queue," executed before the microtask queue in CommonJS modules.
• queueMicrotask(): Uses the microtask queue, the same queue used for Promise handlers (then, catch, finally).
• In ESM modules, since they are processed as part of the microtask queue, queueMicrotask() callbacks run before process.nextTick().

Promise.resolve().then(() => console.log('resolve'));
queueMicrotask(() => console.log('microtask'));
process.nextTick(() => console.log('nextTick'));
// Output:
// nextTick
// resolve
// microtask

2. Advantages and Differences

• Portability: queueMicrotask() works across all JavaScript environments.
• Flexibility: process.nextTick() allows passing arguments directly to the callback.
• Error Handling: Errors in microtasks should be handled inside the callback; otherwise, they propagate to uncaughtException.

3. Related Process Properties

• process.pid: Current process ID.
• process.ppid: Parent process ID.
• process.platform: Operating system platform (linux, win32, darwin, etc.).
• process.permission.has(scope[, reference]): Checks runtime permissions when the Permission Model is enabled.

4. Diagnostic Reporting

• process.report.getReport(): Generates a diagnostic report as a JavaScript object.
• process.report.writeReport(): Writes a diagnostic report to a file or stdout/stderr.
• Options include reportOnFatalError, reportOnUncaughtException, and reportOnSignal.

5. Resource Usage

• process.resourceUsage(): Returns detailed resource usage metrics (CPU time, RSS, page faults, context switches).

{
  userCPUTime: 82872,
  systemCPUTime: 4143,
  maxRSS: 33164,
  minorPageFault: 2469,
  fsWrite: 8,
  voluntaryContextSwitches: 79
}

6. User and Group Management (POSIX)

• process.setuid(id): Sets the user ID.
• process.setgid(id): Sets the group ID.
• process.seteuid(id) / process.setegid(id): Sets effective user/group IDs.
• process.setgroups(groups): Sets supplementary group IDs.

7. Process I/O

• process.stdin: Stream connected to standard input (fd 0).
• process.stdout: Stream connected to standard output (fd 1).
• process.stderr: Stream connected to standard error (fd 2).

Behavior may be synchronous or asynchronous depending on the destination (file, TTY, pipe).

Conclusion

Choosing between queueMicrotask() and process.nextTick() depends on the use case. For portability and consistency across environments, queueMicrotask() is generally preferred. However, when argument passing or tighter control of the event loop is required, process.nextTick() can be useful. Alongside these, the process object provides powerful tools for diagnostics, resource management, and system-level control in Node.js.