events: add max listener warning for EventTarget

Signed-off-by: James M Snell <[email protected]> PR-URL: #36001Fixes: #35990 Reviewed-By: Benjamin Gruenbaum <[email protected]> Reviewed-By: Rich Trott <[email protected]>

Author: jasnell

doc/api/events.md

@@ -383,6 +383,29 @@ Installing a listener using this symbol does not change the behavior once an
 `'error'` event is emitted, therefore the process will still crash if no
 regular `'error'` listener is installed.
 
+### `EventEmitter.setMaxListeners(n[, ...eventTargets])`
+<!-- YAML
+added: REPLACEME
+-->
+
+*`n`{number} A non-negative number. The maximum number of listeners per
+`EventTarget` event.
+*`...eventsTargets`{EventTarget[]|EventEmitter[]} Zero or more{EventTarget}
+ or{EventEmitter} instances. If none are specified, `n` is set as the default
+ max for all newly created{EventTarget} and{EventEmitter} objects.
+
+```js
+const{
+setMaxListeners,
+EventEmitter
+} =require('events');
+
+consttarget=newEventTarget();
+constemitter=newEventEmitter();
+
+setMaxListeners(5, target, emitter);
+```
+
 ### `emitter.addListener(eventName, listener)`
 <!-- YAML
 added: v0.1.26

lib/events.js

@@ -30,6 +30,7 @@ const{
  NumberIsNaN,
  ObjectCreate,
  ObjectDefineProperty,
+ ObjectDefineProperties,
  ObjectGetPrototypeOf,
  ObjectSetPrototypeOf,
  Promise,
@@ -67,6 +68,9 @@ const{
 
 constkCapture=Symbol('kCapture');
 constkErrorMonitor=Symbol('events.errorMonitor');
+constkMaxEventTargetListeners=Symbol('events.maxEventTargetListeners');
+constkMaxEventTargetListenersWarned=
+Symbol('events.maxEventTargetListenersWarned');
 
 letDOMException;
 constlazyDOMException=hideStackFrames((message,name)=>{
@@ -120,6 +124,7 @@ EventEmitter.prototype._maxListeners = undefined;
 // By default EventEmitters will print a warning if more than 10 listeners are
 // added to it. This is a useful default which helps finding memory leaks.
 letdefaultMaxListeners=10;
+letisEventTarget;
 
 functioncheckListener(listener){
 if(typeoflistener!=='function'){
@@ -142,6 +147,48 @@ ObjectDefineProperty(EventEmitter, 'defaultMaxListeners',{
 }
 });
 
+ObjectDefineProperties(EventEmitter,{
+kMaxEventTargetListeners: {
+value: kMaxEventTargetListeners,
+enumerable: false,
+configurable: false,
+writable: false,
+},
+kMaxEventTargetListenersWarned: {
+value: kMaxEventTargetListenersWarned,
+enumerable: false,
+configurable: false,
+writable: false,
+}
+});
+
+EventEmitter.setMaxListeners=
+function(n=defaultMaxListeners, ...eventTargets){
+if(typeofn!=='number'||n<0||NumberIsNaN(n))
+thrownewERR_OUT_OF_RANGE('n','a non-negative number',n);
+if(eventTargets.length===0){
+defaultMaxListeners=n;
+}else{
+if(isEventTarget===undefined)
+isEventTarget=require('internal/event_target').isEventTarget;
+
+// Performance for forEach is now comparable with regular for-loop
+eventTargets.forEach((target)=>{
+if(isEventTarget(target)){
+target[kMaxEventTargetListeners]=n;
+target[kMaxEventTargetListenersWarned]=false;
+}elseif(typeoftarget.setMaxListeners==='function'){
+target.setMaxListeners(n);
+}else{
+thrownewERR_INVALID_ARG_TYPE(
+'eventTargets',
+['EventEmitter','EventTarget'],
+target);
+}
+});
+}
+};
+
 EventEmitter.init=function(opts){
 
 if(this._events===undefined||

lib/internal/event_target.js

@@ -26,13 +26,19 @@ const{
 ERR_INVALID_THIS,
 }
 }=require('internal/errors');
-const{validateInteger,validateObject }=require('internal/validators');
+const{ validateObject }=require('internal/validators');
 
 const{ customInspectSymbol }=require('internal/util');
 const{ inspect }=require('util');
 
 constkIsEventTarget=SymbolFor('nodejs.event_target');
 
+constEventEmitter=require('events');
+const{
+ kMaxEventTargetListeners,
+ kMaxEventTargetListenersWarned,
+}=EventEmitter;
+
 constkEvents=Symbol('kEvents');
 constkStop=Symbol('kStop');
 constkTarget=Symbol('kTarget');
@@ -43,8 +49,6 @@ const kCreateEvent = Symbol('kCreateEvent');
 constkNewListener=Symbol('kNewListener');
 constkRemoveListener=Symbol('kRemoveListener');
 constkIsNodeStyleListener=Symbol('kIsNodeStyleListener');
-constkMaxListeners=Symbol('kMaxListeners');
-constkMaxListenersWarned=Symbol('kMaxListenersWarned');
 constkTrustEvent=Symbol('kTrustEvent');
 
 // Lazy load perf_hooks to avoid the additional overhead on startup
@@ -221,6 +225,8 @@ class Listener{
 
 functioninitEventTarget(self){
 self[kEvents]=newSafeMap();
+self[kMaxEventTargetListeners]=EventEmitter.defaultMaxListeners;
+self[kMaxEventTargetListenersWarned]=false;
 }
 
 classEventTarget{
@@ -233,7 +239,24 @@ class EventTarget{
 initEventTarget(this);
 }
 
-[kNewListener](size,type,listener,once,capture,passive){}
+[kNewListener](size,type,listener,once,capture,passive){
+if(this[kMaxEventTargetListeners]>0&&
+size>this[kMaxEventTargetListeners]&&
+!this[kMaxEventTargetListenersWarned]){
+this[kMaxEventTargetListenersWarned]=true;
+// No error code for this since it is a Warning
+// eslint-disable-next-line no-restricted-syntax
+constw=newError('Possible EventTarget memory leak detected. '+
+`${size}${type} listeners `+
+`added to ${inspect(this,{depth: -1})}. Use `+
+'events.setMaxListeners() to increase limit');
+w.name='MaxListenersExceededWarning';
+w.target=this;
+w.type=type;
+w.count=size;
+process.emitWarning(w);
+}
+}
 [kRemoveListener](size,type,listener,capture){}
 
 addEventListener(type,listener,options={}){
@@ -417,9 +440,6 @@ ObjectDefineProperty(EventTarget.prototype, SymbolToStringTag,{
 
 functioninitNodeEventTarget(self){
 initEventTarget(self);
-// eslint-disable-next-line no-use-before-define
-self[kMaxListeners]=NodeEventTarget.defaultMaxListeners;
-self[kMaxListenersWarned]=false;
 }
 
 classNodeEventTargetextendsEventTarget{
@@ -430,33 +450,12 @@ class NodeEventTarget extends EventTarget{
 initNodeEventTarget(this);
 }
 
-[kNewListener](size,type,listener,once,capture,passive){
-if(this[kMaxListeners]>0&&
-size>this[kMaxListeners]&&
-!this[kMaxListenersWarned]){
-this[kMaxListenersWarned]=true;
-// No error code for this since it is a Warning
-// eslint-disable-next-line no-restricted-syntax
-constw=newError('Possible EventTarget memory leak detected. '+
-`${size}${type} listeners `+
-`added to ${inspect(this,{depth: -1})}. Use `+
-'setMaxListeners() to increase limit');
-w.name='MaxListenersExceededWarning';
-w.target=this;
-w.type=type;
-w.count=size;
-process.emitWarning(w);
-}
-}
-
 setMaxListeners(n){
-validateInteger(n,'n',0);
-this[kMaxListeners]=n;
-returnthis;
+EventEmitter.setMaxListeners(n,this);
 }
 
 getMaxListeners(){
-returnthis[kMaxListeners];
+returnthis[kMaxEventTargetListeners];
 }
 
 eventNames(){

test/parallel/test-eventtarget-memoryleakwarning.js

@@ -0,0 +1,79 @@
+// Flags: --no-warnings
+'use strict';
+constcommon=require('../common');
+const{
+ setMaxListeners,
+ EventEmitter
+}=require('events');
+constassert=require('assert');
+
+common.expectWarning({
+MaxListenersExceededWarning: [
+['Possible EventTarget memory leak detected. 3 foo listeners added to '+
+'EventTarget. Use events.setMaxListeners() '+
+'to increase limit'],
+['Possible EventTarget memory leak detected. 3 foo listeners added to '+
+'[MessagePort [EventTarget]]. '+
+'Use events.setMaxListeners() to increase '+
+'limit'],
+['Possible EventTarget memory leak detected. 3 foo listeners added to '+
+'[MessagePort [EventTarget]]. '+
+'Use events.setMaxListeners() to increase '+
+'limit'],
+['Possible EventTarget memory leak detected. 3 foo listeners added to '+
+'[AbortSignal [EventTarget]]. '+
+'Use events.setMaxListeners() to increase '+
+'limit'],
+],
+ExperimentalWarning: [[
+'AbortController is an experimental feature. This feature could change '+
+'at any time'
+]]
+});
+
+
+{
+constet=newEventTarget();
+setMaxListeners(2,et);
+et.addEventListener('foo',()=>{});
+et.addEventListener('foo',()=>{});
+et.addEventListener('foo',()=>{});
+}
+
+{
+// No warning emitted because prior limit was only for that
+// one EventTarget.
+constet=newEventTarget();
+et.addEventListener('foo',()=>{});
+et.addEventListener('foo',()=>{});
+et.addEventListener('foo',()=>{});
+}
+
+{
+constmc=newMessageChannel();
+setMaxListeners(2,mc.port1);
+mc.port1.addEventListener('foo',()=>{});
+mc.port1.addEventListener('foo',()=>{});
+mc.port1.addEventListener('foo',()=>{});
+}
+
+{
+// Set the default for newly created EventTargets
+setMaxListeners(2);
+constmc=newMessageChannel();
+mc.port1.addEventListener('foo',()=>{});
+mc.port1.addEventListener('foo',()=>{});
+mc.port1.addEventListener('foo',()=>{});
+
+constac=newAbortController();
+ac.signal.addEventListener('foo',()=>{});
+ac.signal.addEventListener('foo',()=>{});
+ac.signal.addEventListener('foo',()=>{});
+}
+
+{
+// It works for EventEmitters also
+constee=newEventEmitter();
+setMaxListeners(2,ee);
+assert.strictEqual(ee.getMaxListeners(),2);
+}