How to detect memory leaks on NodeJS in a production environment
What a memory leak is?
A memory leak in Node.js occurs when a program retains references to objects in memory, preventing the garbage collector from reclaiming that memory even though it is no longer needed. If memory leaks are not addressed, they can lead to increased memory consumption and potentially cause the application to slow down or crash.
Possible reasons
Circular References
Circular dependencies among objects may hinder the garbage collector's ability to identify and collect them. When two objects refer to each other and lack external references, there is a risk that they may remain uncollected.
Global variables
Global variables in Node.js are the variables referenced by the root node. Global variables are never garbage-collected throughout the execution time of an app. They occupy memory as long as the app is running.
Here’s an example:
// Example of a potential memory leak with global variables
const globalData = [];
function addDataToGlobal() {
// Adding data to the global array without clearing or managing it.
globalData.push(new Array(1000000).fill('data'));
}Closures
Closures retain information about their context. If a closure holds a reference to a large object in the heap, it will keep the object in memory for as long as the closure is active. This can cause a memory leak if the closure is not used properly.
Here’s an example:
// Example of a potential memory leak with closures
function createClosure() {
const data = 'Sensitive data';
return function() {
console.log(data);
};
}
const closure = createClosure();
// The 'data' variable is retained in the closure, preventing it from being garbage collected.How to identify memory leaks in a production environment?
It is important to have a tool to monitor the health of our application, especially as access to the production environment is often restricted. New relic is a powerful tool that allows us to monitor various features of our application. For instance, the chart below represents memory usage over time.
How to address memory leaks?
To begin, it is important to replicate the production environment as closely as possible. Docker containers are a useful tool for achieving this as they allow for the specification of the operating system, version, and other necessary details.
To set up the Node.js app in debug mode, follow these steps:
To update the start process in our Dockerfile: to monitor memory usage, we need to add the --inspect flag.
...
EXPOSE 9229 ## <--debug port
...
CMD ["node", "--inspect-brk=0.0.0.0:9229", "./src/main.js"]Open Chorem DecTools: we can use the dedicated DevTools for Node from Chrome for memory diagnostics. Copy an paste the next link on Google Chrome: chrome://inspect/#devices and then follow the link
Start Docker container: When the Docker container is started, the DevTools should connect to our application automatically.
Compare snapshots
If you can reproduce the leak while your application is running locally, it's easier to get access to useful runtime information and it will be easier to trace the error. Since we can use the heap snapshot utility to compare multiple states of our application.
Select Heap Snapshot and press the Take Snapshot button.
Looking at the captured snapshot, you can see every data structure allocated in your node process, but it's a bit overwhelming. To make it easier to see what's leaking, take a few more snapshots so you can compare them. However, you will only be able to observe the leak if there is traffic being sent to the server.
After performing an important traffic to the server, take another heap snapshot.
Then select the last snapshot and switch from the “Summary” view to the “Comparison” view in the drop-down.
This will greatly reduce the number of objects you see. A good rule of thumb is to ignore the items in brackets first, as these are built-in structures. The next item in the list in this case is the Object. If you look at some of the retained objects, you can see some examples of the data that has been leaked, which you can use to track down the leak in your application.
