Node.js will use all the memory available, and that's OK! - Matteo Collina - dotJS 2025

Summary

This presentation dives into the concept of memory leaks in Node.js applications, explaining how memory consumption behaves in the V8 garbage collector and what happens when the system reaches memory limits. The speaker emphasizes that Node.js can allocate more memory than it seems to be using, which often leads to confusion about memory leaks. Practical advice on memory tuning and the impact of server-side rendering in React is provided, along with live demos showcasing how adjusting memory settings can improve performance. The session wraps up with a discussion on optimizing Node.js apps in production and introduces a new book on enterprise-level Node.js management.

Takeaways

• 😀 Node.js memory leaks are often mistaken for real crashes, but in reality, the application may just be killed by the operating system once memory consumption reaches a certain threshold.
• 😀 A memory leak occurs when memory that is no longer needed is not released, typically because it's not accessible or properly cleaned up.
• 😀 In Node.js, memory management is handled by V8's garbage collector, which uses two types of collectors: Scavenge (for new objects) and Mark-and-Sweep (for old objects).
• 😀 V8's garbage collector organizes memory into 'new space' for fresh objects and 'old space' for long-lived objects, with old objects getting cleaned up more slowly.
• 😀 Memory is not immediately released to the operating system even after objects are garbage collected, which can cause memory usage to appear high even though it's not actively used.
• 😀 The resident set size (RSS) in Node.js can grow substantially without being indicative of a memory leak, as memory is reserved for potential future allocations.
• 😀 In a typical web application, synchronous processing and object allocations can quickly increase memory consumption, and managing this through garbage collection is crucial.
• 😀 Configuring memory size in Node.js, including adjusting parameters like 'max-old-space-size' and 'max-semi-space-size,' can optimize memory handling and performance.
• 😀 React server-side rendering can consume significant memory due to the high number of objects allocated per request, so it's important to monitor and adjust memory allocation.
• 😀 By configuring the memory space sizes correctly, Node.js applications can reduce latency and increase throughput, as demonstrated in the live performance tests presented.
• 😀 Increasing the young generation size for memory allocation can significantly improve the health of the garbage collection cycle, reducing latency and improving performance.

Q & A

What common misconception do developers have when they see high memory usage in Node.js applications?

Many developers assume their application has a memory leak when memory usage grows, but often it is just Node.js retaining memory for future use, not an actual leak.

What is the formal definition of a memory leak?

A memory leak occurs when memory that is no longer needed is not released, typically because it’s still referenced somewhere even though it’s inaccessible to the program.

Why do Node.js applications sometimes appear to keep increasing their memory usage?

Node.js (through the V8 engine) doesn’t always release memory back to the operating system immediately; it keeps it allocated in anticipation of future allocations to improve performance.

How does the V8 garbage collector manage memory in JavaScript?

V8 divides memory into a 'new space' for young objects and an 'old space' for older ones. It uses 'scavenge' collection for new space and a slower 'mark and sweep' process for old space.

What does the saying 'all objects die young' mean in the context of garbage collection?

It means most objects in typical applications are created and discarded quickly, so the garbage collector can efficiently clean them up without moving them to old space.

What is the impact of objects being moved from new space to old space in V8?

Objects that survive multiple garbage collection cycles are moved to old space, where cleanup is less frequent and more resource-intensive, which can increase memory usage over time.

Why should developers not terminate Node.js processes when they reach 80% of memory usage?

High memory usage is normal because Node.js reserves memory for performance reasons. Killing the process prematurely disrupts normal operation without fixing any actual issue.

How can adjusting V8 memory configuration improve Node.js performance?

By tuning parameters like max old space size and max semi-space size, developers can balance memory usage and garbage collection frequency, reducing latency and improving throughput.

What change occurred between Node.js versions 20 and 22 regarding memory allocation?

V8 started computing the maximum semi-space size based on available system memory, which can lead to too-small allocations in low-memory environments unless manually tuned.

How does increasing the young generation size affect application performance?

Increasing young generation size allows more temporary objects to be collected efficiently, reducing promotions to old space and improving latency and throughput.

What is the tool 'VAT' introduced in the talk, and what does it do?

VAT is a multi-threaded Node.js application server that can run multiple Node.js apps in one process and includes monitoring features to track metrics like memory, CPU, and latency.

What is the main takeaway regarding monitoring Node.js memory usage?

Developers should monitor the heap used-to-total ratio and RSS rather than absolute memory values, focusing on how memory is utilized and not just how much is allocated.

What practical performance improvement was demonstrated in the speaker’s benchmark?

By increasing the young generation memory size, the application achieved around a 10% reduction in latency and a 10% increase in throughput, highlighting the benefits of tuning GC settings.

What does the speaker recommend as a good trade-off for Node.js performance optimization?

He suggests trading some additional memory usage for reduced compute load and latency, which generally yields a healthier and faster application.