358

I am getting following warning:

(node) warning: possible EventEmitter memory leak detected. 11 listeners added. Use emitter.setMaxListeners() to increase limit.
Trace: 
    at EventEmitter.<anonymous> (events.js:139:15)
    at EventEmitter.<anonymous> (node.js:385:29)
    at Server.<anonymous> (server.js:20:17)
    at Server.emit (events.js:70:17)
    at HTTPParser.onIncoming (http.js:1514:12)
    at HTTPParser.onHeadersComplete (http.js:102:31)
    at Socket.ondata (http.js:1410:22)
    at TCP.onread (net.js:354:27)

I wrote code like this in server.js:

http.createServer(
    function (req, res) { ... }).listen(3013);

How to fix this ?

Whymarrh
  • 13,139
  • 14
  • 57
  • 108
Riz
  • 9,703
  • 8
  • 38
  • 54
  • 79
    Use `process.on('warning', e => console.warn(e.stack));` to debug the warning. Don't use `process.setMaxListeners(0);` as the warning is there for some reason. – Shwetabh Shekhar Jan 08 '18 at 09:09

22 Answers22

342

I'd like to point out here that that warning is there for a reason and there's a good chance the right fix is not increasing the limit but figuring out why you're adding so many listeners to the same event. Only increase the limit if you know why so many listeners are being added and are confident it's what you really want.

I found this page because I got this warning and in my case there was a bug in some code I was using that was turning the global object into an EventEmitter! I'd certainly advise against increasing the limit globally because you don't want these things to go unnoticed.

voltrevo
  • 9,870
  • 3
  • 28
  • 33
  • 30
    +1. Agreed. The warning indicates potential leak state and mindlessly increasing the maxListeners will not necessarily fix the problem. http://www.jongleberry.com/understanding-possible-eventemitter-leaks.html – Jeremiah Adams Jun 24 '16 at 13:45
  • 9
    FYI, the first comment's link (jongleberry.com) is offline. Here is the archived version: http://web.archive.org/web/20180315203155/http://www.jongleberry.com/understanding-possible-eventemitter-leaks.html – Jeff Ward Jul 03 '19 at 19:29
  • 3
    It may be legitimate code, for example several `async` functions run in parallel – João Pimentel Ferreira Dec 11 '21 at 21:42
  • My case was a circular dependency in the files. Hope it can help some people. – MartinJH Oct 19 '22 at 11:22
  • Archived version of article above shows nothing to me, here's the same article posted on Medium: https://jongleberry.medium.com/understanding-node-jss-possible-eventemitter-leak-error-message-bc2ee68b24ea – Alex TechNoir May 29 '23 at 14:15
120

This is explained in the node eventEmitter documentation

What version of Node is this? What other code do you have? That isn't normal behavior.

In short, its: process.setMaxListeners(0);

Also see: node.js - request - How to “emitter.setMaxListeners()”?

mikemaccana
  • 110,530
  • 99
  • 389
  • 494
ember arlynx
  • 3,129
  • 2
  • 20
  • 22
  • 5
    I am using `process.on('uncaughtException', callback);` – Riz Mar 19 '12 at 10:51
  • 42
    I wouldn't remove the max listener limit. You won't get warnings, but you will get memory leaks. –  Apr 06 '18 at 19:45
  • 5
    Using `process.setMaxListeners(0)` you might be unknowingly leaking memory. – Tanner Dolby May 14 '21 at 05:37
  • The eventEmitter URL returns a 500 error. This is the one I found for the latest version: https://nodejs.org/docs/latest/api/events.html – hernvnc Apr 18 '22 at 20:55
  • 1
    This is the worst answer: the warning is there for a reason; removing it doesn’t fix anything. – bfontaine Jul 21 '23 at 09:22
115

The accepted answer provides the semantics on how to increase the limit, but as @voltrevo pointed out that warning is there for a reason and your code probably has a bug.

Consider the following buggy code:

//Assume Logger is a module that emits errors
var Logger = require('./Logger.js');

for (var i = 0; i < 11; i++) {
    //BUG: This will cause the warning
    //As the event listener is added in a loop
    Logger.on('error', function (err) {
        console.log('error writing log: ' + err)
    });

    Logger.writeLog('Hello');
}

Now observe the correct way of adding the listener:

//Good: event listener is not in a loop
Logger.on('error', function (err) {
    console.log('error writing log: ' + err)
});

for (var i = 0; i < 11; i++) {
    Logger.writeLog('Hello');
}

Search for similar issues in your code before changing the maxListeners (which is explained in other answers)

Rayee Roded
  • 2,440
  • 1
  • 20
  • 21
94

By default, a maximum of 10 listeners can be registered for any single event.

If it's your code, you can specify maxListeners via:

const emitter = new EventEmitter()
emitter.setMaxListeners(100)
// or 0 to turn off the limit
emitter.setMaxListeners(0)

But if it's not your code you can use the trick to increase the default limit globally:

require('events').EventEmitter.prototype._maxListeners = 100;

Of course you can turn off the limits but be careful:

// turn off limits by default (BE CAREFUL)
require('events').EventEmitter.prototype._maxListeners = 0;

BTW. The code should be at the very beginning of the app.

ADD: Since node 0.11 this code also works to change the default limit:

require('events').EventEmitter.defaultMaxListeners = 0
zag2art
  • 4,869
  • 1
  • 29
  • 39
46

Replace .on() with once(). Using once() removes event listeners when the event is handled by the same function.

If this doesn't fix it, then reinstall restler with this in your package.json "restler": "git://github.com/danwrong/restler.git#9d455ff14c57ddbe263dbbcd0289d76413bfe07d"

This has to do with restler 0.10 misbehaving with node. you can see the issue closed on git here: https://github.com/danwrong/restler/issues/112 However, npm has yet to update this, so that is why you have to refer to the git head.

mati
  • 5,218
  • 3
  • 32
  • 49
Davis Dulin
  • 629
  • 5
  • 9
10

Node Version : v11.10.1

Warning message from stack trace :

process.on('warning', e => console.warn(e.stack));
(node:17905) MaxListenersExceededWarning: Possible EventEmitter memory leak detected. 11 wakeup listeners added. Use emitter.setMaxListeners() to increase limit
MaxListenersExceededWarning: Possible EventEmitter memory leak detected. 11 wakeup listeners added. Use emitter.setMaxListeners() to increase limit
    at _addListener (events.js:255:17)
    at Connection.addListener (events.js:271:10)
    at Connection.Readable.on (_stream_readable.js:826:35)
    at Connection.once (events.js:300:8)
    at Connection._send (/var/www/html/fleet-node-api/node_modules/http2/lib/protocol/connection.js:355:10)
    at processImmediate (timers.js:637:19)
    at process.topLevelDomainCallback (domain.js:126:23)

After searching for github issues, documentation and creating similar event emitter memory leaks, this issue was observed due to node-apn module used for iOS push notification.

This resolved it :

You should only create one Provider per-process for each certificate/key pair you have. You do not need to create a new Provider for each notification. If you are only sending notifications to one app then there is no need for more than one Provider.

If you are constantly creating Provider instances in your app, make sure to call Provider.shutdown() when you are done with each provider to release its resources and memory.

I was creating provider object each time the notification was sent and expected the gc to clear it.

Sandeep PC
  • 797
  • 8
  • 12
4

I am getting this warning too when install aglio on my mac osx.

I use cmd fix it.

sudo npm install -g npm@next

https://github.com/npm/npm/issues/13806

Legolas Bloom
  • 1,725
  • 1
  • 19
  • 17
3

I prefer to hunt down and fix problems instead of suppressing logs whenever possible. After a couple days of observing this issue in my app, I realized I was setting listeners on the req.socket in an Express middleware to catch socket io errors that kept popping up. At some point, I learned that that was not necessary, but I kept the listeners around anyway. I just removed them and the error you are experiencing went away. I verified it was the cause by running requests to my server with and without the following middleware:

socketEventsHandler(req, res, next) {
        req.socket.on("error", function(err) {
            console.error('------REQ ERROR')
            console.error(err.stack)
        });
        res.socket.on("error", function(err) {
            console.error('------RES ERROR')
            console.error(err.stack)
        });
        next();
    }

Removing that middleware stopped the warning you are seeing. I would look around your code and try to find anywhere you may be setting up listeners that you don't need.

Mouneer
  • 12,827
  • 2
  • 35
  • 45
lwdthe1
  • 1,001
  • 1
  • 16
  • 16
3

As pointed out by others, increasing the limit is not the best answer. I was facing the same issue, but in my code I was nowhere using any event listener. When I closely looked into the code, I was creating a lot of promises at times. Each promise had some code of scraping the provided URL (using some third-party library). If you are doing something like that, then it may be the cause.

Refer this thread on how to prevent that: What is the best way to limit concurrency when using ES6's Promise.all()?

brc-dd
  • 10,788
  • 3
  • 47
  • 67
2

In my case, it was child.stderr.pipe(process.stderr) which was being called when I was initiating 10 (or so) instances of the child. So anything, that leads to attach an event handler to the same EventEmitter Object in a LOOP, causes nodejs to throw this error.

Vikas Gautam
  • 1,793
  • 22
  • 21
2

Sometimes these warnings occur when it isn't something we've done, but something we've forgotten to do!

I encountered this warning when I installed the dotenv package with npm, but was interrupted before I got around to adding the require('dotenv').load() statement at the beginning of my app. When I returned to the project, I started getting the "Possible EventEmitter memory leak detected" warnings.

I assumed the problem was from something I had done, not something I had not done!

Once I discovered my oversight and added the require statement, the memory leak warning cleared.

Motate
  • 207
  • 3
  • 4
2

Thanks to RLaaa for giving me an idea how to solve the real problem/root cause of the warning. Well in my case it was MySQL buggy code.

Providing you wrote a Promise with code inside like this:

pool.getConnection((err, conn) => {

  if(err) reject(err)

  const q = 'SELECT * from `a_table`'

  conn.query(q, [], (err, rows) => {

    conn.release()

    if(err) reject(err)

    // do something
  })

  conn.on('error', (err) => {

     reject(err)
  })
})

Notice there is a conn.on('error') listener in the code. That code literally adding listener over and over again depends on how many times you call the query. Meanwhile if(err) reject(err) does the same thing.

So I removed the conn.on('error') listener and voila... solved! Hope this helps you.

Adrian
  • 524
  • 7
  • 18
2

In my case it was due to not closing the Sequelize connections to database while creating them inside of the async function called with setInterval.

1

I was having this till today when I start grunt watch. Finally solved by

watch: {
  options: {
    maxListeners: 99,
    livereload: true
  },
}

The annoying message is gone.

Eliran Malka
  • 15,821
  • 6
  • 77
  • 100
Ariful Haque
  • 3,662
  • 5
  • 37
  • 59
1

i was having the same problem. and the problem was caused because i was listening to port 8080, on 2 listeners.

setMaxListeners() works fine, but i would not recommend it.

the correct way is to, check your code for extra listeners, remove the listener or change the port number on which you are listening, this fixed my problem.

Noman Abid
  • 63
  • 1
  • 1
  • 10
1

You need to clear all listeners before creating new ones using:

Client / Server

socket.removeAllListeners(); 

Assuming socket is your client socket / or created server socket.

You can also subscribe from specific event listeners like for example removing the connect listener like this:

this.socket.removeAllListeners("connect");
ProllyGeek
  • 15,517
  • 9
  • 53
  • 72
1

I was facing the same issue, but i have successfully handled with async await.
Please check if it helps.

let dataLength = 25;
Before:
  for (let i = 0; i < dataLength; i++) {
      sftp.get(remotePath, fs.createWriteStream(xyzProject/${data[i].name}));
  }

After:
  for (let i = 0; i < dataLength; i++) {
      await sftp.get(remotePath, fs.createWriteStream(xyzProject/${data[i].name}));
  }

Vivek Mehta
  • 734
  • 8
  • 10
0

You said you are using process.on('uncaughtException', callback);
Where are you executing this statement? Is it within the callback passed to http.createServer?
If yes, different copy of the same callback will get attached to the uncaughtException event upon each new request, because the function (req, res) { ... } gets executed everytime a new request comes in and so will the statement process.on('uncaughtException', callback);
Note that the process object is global to all your requests and adding listeners to its event everytime a new request comes in will not make any sense. You might not want such kind of behaviour.
In case you want to attach a new listener for each new request, you should remove all previous listeners attached to the event as they no longer would be required using:
process.removeAllListeners('uncaughtException');

0

Our team's fix for this was removing a registry path from our .npmrc. We had two path aliases in the rc file, and one was pointing to an Artifactory instance that had been deprecated.

The error had nothing to do with our App's actual code but everything to do with our development environment.

RossO
  • 101
  • 2
0

In my case, this error was caused by having an instance of the library multiparty being instantiated inside my Next.js API endpoint outside the handler function.

Moving this: const form = new multiparty.Form(); inside the handler function solved the issue for me. Maybe this helps somebody.

-4

Adding EventEmitter.defaultMaxListeners = <MaxNumberOfClients> to node_modules\loopback-datasource-juggler\lib\datasource.js fixed may problem :)

-5

Put this in the first line of your server.js (or whatever contains your main Node.js app):

require('events').EventEmitter.prototype._maxListeners = 0;

and the error goes away :)

Sebastian
  • 8,952
  • 3
  • 32
  • 30