Advanced Node.js

// libuv's thread pool size can be tuned via an environment variable
process.env.UV_THREADPOOL_SIZE = 8; // must be set before any threadpool-using operation runs

Common follow-ups: Which specific async operations use the libuv thread pool versus the OS's native async APIps?;How would you diagnose thread pool exhaustion in a running Node.js process?

node --inspect=127.0.0.1:9229 server.js
// then open chrome://inspect in Chrome, or connect VS Code's Node debugger
// SSH tunnel from a local machine to a remote server:
// ssh -L 9229:localhost:9229 user@remote-host

Common follow-ups: Why is exposing the inspector port publicly considered a critical security vulnerability?;What's the difference between --inspect and --inspect-brk in a debugging workflow?

console.log('start');
setTimeout(() => console.log('setTimeout'), 0);
setImmediate(() => console.log('setImmediate'));
process.nextTick(() => console.log('nextTick'));
console.log('end');
// Output: start, end, nextTick, then setTimeout/setImmediate (order can vary at top level)

Common follow-ups: Why can excessive use of process.nextTick() starve the event loop of I/O callbacks?;In what specific case is setImmediate() ordering guaranteed relative to setTimeout()?

// Trigger a report on demand from within the process
const { writeReport } = require('node:process').report;
writeReport('report.json');

// Or generate one automatically on uncaught exceptions
// node --report-uncaught-exception --report-on-fatalerror app.js

Common follow-ups: What specific information does a diagnostic report include that a simple stack trace doesn't?;How do you configure a report to be generated automatically on an unhandled promise rejection?

// Bad: inconsistent shapes hurt V8's optimization
function Point(x, y) { this.x = x; if (y) this.y = y; }

// Good: consistent shape every time, same hidden class
function Point(x, y) { this.x = x; this.y = y || 0; }

Common follow-ups: How would you use the --trace-opt and --trace-deopt V8 flags to observe this behavior directly?;Does this optimization matter as much for short-lived scripts as for long-running servers?

const canContinue = writable.write(chunk);
if (!canContinue) {
  readable.pause();
  writable.once('drain', () => readable.resume());
}
// Or, preferably, let pipeline() manage this automatically:
const { pipeline } = require('node:stream/promises');
await pipeline(readable, writable);

Common follow-ups: What specifically happens if backpressure is ignored when manually consuming a readable stream with 'data' events?;How does highWaterMark affect when backpressure kicks in?

const { AsyncLocalStorage } = require('node:async_hooks');
const als = new AsyncLocalStorage();

app.use((req, res, next) => {
  als.run({ requestId: crypto.randomUUID() }, next);
});

function log(message) {
  const store = als.getStore();
  console.log(`[${store?.requestId}] ${message}`);
}

Common follow-ups: What's the performance overhead of using AsyncLocalStorage on every request in a high-throughput service?;How does AsyncLocalStorage compare to using a global variable or a WeakMap keyed by request object for this same purpose?

const { Worker } = require('node:worker_threads');
const worker = new Worker('./cpu-intensive-task.js', { workerData: { n: 40 } });
worker.on('message', (result) => console.log('Fibonacci result:', result));

// vs. child_process for running a separate program
const { spawn } = require('node:child_process');
spawn('python3', ['script.py']);

Common follow-ups: Why is memory isolation in child processes sometimes an advantage rather than a limitation?;What data types can and can't be passed directly between worker threads without serialization?

// Simplified monkey-patch example
const originalRequest = http.request;
http.request = function(...args) {
  const start = Date.now();
  const req = originalRequest.apply(this, args);
  req.on('response', () => console.log('Request took', Date.now() - start, 'ms'));
  return req;
};

Common follow-ups: How do modern instrumentation libraries use AsyncLocalStorage or diagnostics_channel instead of raw monkey-patching to reduce these conflicts?;What's a safer alternative to monkey-patching for adding cross-cutting instrumentation?

const diagnostics_channel = require('node:diagnostics_channel');
const channel = diagnostics_channel.channel('my-app:db-query');

if (channel.hasSubscribers) {
  channel.publish({ query: sql, duration: elapsedMs });
}

// Elsewhere, a monitoring tool subscribes:
diagnostics_channel.subscribe('my-app:db-query', (message) => {
  console.log('Query took', message.duration, 'ms');
});

Common follow-ups: How does the hasSubscribers check enable this near-zero overhead when unused?;What diagnostics_channel names does Node.js's own HTTP module publish by default?