How to monitor the memory usage of Node.js?

Question

How can I monitor the memory usage of Node.js?

Solution 1

node-memwatch : detect and find memory leaks in Node.JS code. Check this tutorial Tracking Down Memory Leaks in Node.js

Solution 2

The built-in process module has a method memoryUsage that offers insight in the memory usage of the current Node.js process. Here is an example from in Node v0.12.2 on a 64-bit system:

$ node --expose-gc
> process.memoryUsage();  // Initial usage
{ rss: 19853312, heapTotal: 9751808, heapUsed: 4535648 }
> gc();                   // Force a GC for the baseline.
undefined
> process.memoryUsage();  // Baseline memory usage.
{ rss: 22269952, heapTotal: 11803648, heapUsed: 4530208 }
> var a = new Array(1e7); // Allocate memory for 10m items in an array
undefined
> process.memoryUsage();  // Memory after allocating so many items
{ rss: 102535168, heapTotal: 91823104, heapUsed: 85246576 }
> a = null;               // Allow the array to be garbage-collected
null
> gc();                   // Force GC (requires node --expose-gc)
undefined
> process.memoryUsage();  // Memory usage after GC
{ rss: 23293952, heapTotal: 11803648, heapUsed: 4528072 }
> process.memoryUsage();  // Memory usage after idling
{ rss: 23293952, heapTotal: 11803648, heapUsed: 4753376 }

In this simple example, you can see that allocating an array of 10M elements consumers approximately 80MB (take a look at heapUsed).
If you look at V8's source code (Array::New, Heap::AllocateRawFixedArray, FixedArray::SizeFor), then you'll see that the memory used by an array is a fixed value plus the length multiplied by the size of a pointer. The latter is 8 bytes on a 64-bit system, which confirms that observed memory difference of 8 x 10 = 80MB makes sense.

Solution 3

Also, if you'd like to know global memory rather than node process':

var os = require('os');

os.freemem();
os.totalmem();

See documentation

Solution 4

The original memwatch is essentially dead. Try memwatch-next instead, which seems to be working well on modern versions of Node.

Solution 5

You can use node.js memoryUsage

const formatMemoryUsage = (data) => `${Math.round(data / 1024 / 1024 * 100) / 100} MB`

const memoryData = process.memoryUsage()

const memoryUsage = {
                rss: `${formatMemoryUsage(memoryData.rss)} -> Resident Set Size - total memory allocated for the process execution`,
                heapTotal: `${formatMemoryUsage(memoryData.heapTotal)} -> total size of the allocated heap`,
                heapUsed: `${formatMemoryUsage(memoryData.heapUsed)} -> actual memory used during the execution`,
                external: `${formatMemoryUsage(memoryData.external)} -> V8 external memory`,
}

console.log(memoryUsage)
/*
{
    "rss": "177.54 MB -> Resident Set Size - total memory allocated for the process execution",
    "heapTotal": "102.3 MB -> total size of the allocated heap",
    "heapUsed": "94.3 MB -> actual memory used during the execution",
    "external": "3.03 MB -> V8 external memory"
}
*/

View more solutions

Comments

[Wottensprels]

A little more details could be helpful

[Ingwie Phoenix]

@majidarif Go to Applications > Utilities and you will find an Activity Monitor app. That one is the equivalent of Task Manager. OS X also has the top command as well.

[Golo Roden]

node-memwatch does not seem to be alive any more (last updated in March 2013). Are there any alternatives?

[fre2ak]

@GoloRoden npm install memwatch-next works fine. Here is the repo: github.com/marcominetti/node-memwatch

[saintedlama]

A more up to date resource for hunting down memory leaks apmblog.dynatrace.com/2015/11/04/…

[Mike]

memwatch isn't maintained anymore and won't work on an recent version of node so don't even bother.

[Damodaran]

Understanding Garbage Collection and hunting Memory Leaks in Node.js

[Damodaran]

Did you know you can inspect your node application’s memory without instrumenting your code ? It’s possible using a tool called mdb_v8

[Rob W]

@MestreSan Which version of Node doesn't need --expose-gc for the gc function?

[Rob W]

@MestreSan I never said that you need --expose-gc for process.memoryUsage(). gc() (requiring --expose-gc) was used in the answer to deterministically trigger garbage collection to make it easier to see what the process.memoryUsage reports.

[Alex]

However, freemem() is not the same as available memory on the server. Any way to find available memory rather than free?

[Ryan Shillington]

use htop instead of top on Linux. It's much better.

[Frank Meulenaar]

The king is dead; long live the king: npmjs.com/package/node-memwatch

[suther]

That's an awesome answer to measure JS-Stuff in the right way. Thank you for that answer.

[Andrew]

You did the lords work with this one. I just realized all the methods exposed by calling process which will help me create a more efficient application. Thanks.

[ΔO 'delta zero']

I believe this should be the accepted answer.

[Raghav Garg]

node-memwatch at least works with node version 10. Thanks, @FrankMeulenaar :+1:

[Silvio Guedes]

the both libraries (memwatch-next and node-memwatch) are deprecated or not working.

[Gaëtan Boyals]

If you have a new question, please ask it by clicking the Ask Question button. Include a link to this question if it helps provide context. - From Review

[spechter]

@SarathKumar I think you are asking about "node-memwatch-new", so you just want to go here, and follow the instructions: npmjs.com/package/node-memwatch-new

[SarathKumar]

Ok Thankyou @spechter