Node.js EventEmitter - Memory Leak from Anonymous Listeners

// Pull EventEmitter from Node's built-in 'events' module — no install needed
const EventEmitter = require('events');

// Create a direct instance — acceptable for demos and simple scripts
const notificationHub = new EventEmitter();

// Register a listener for the 'userSignedUp' event.
// .on() means: every time this event fires, run this callback.
// The listener stays registered until explicitly removed with .off().
notificationHub.on('userSignedUp', (userData) => {
  // This runs synchronously when the event is emitted —
  // the emit() caller waits for this to complete before continuing.
  console.log(`[Email Service] Sending welcome email to: ${userData.email}`);
});

// Register a second listener for the SAME event.
// Both listeners run on every emit(), in registration order.
notificationHub.on('userSignedUp', (userData) => {
  console.log(`[Analytics] Recording new signup for user ID: ${userData.id}`);
});

// .once() registers a listener that fires exactly one time, then removes itself.
// Node.js handles the removal automatically — you don't need to track it.
// Perfect for one-off setup tasks, first-connection initialization, or
// any situation where reacting more than once would be incorrect.
notificationHub.once('userSignedUp', (userData) => {
  console.log(`[Promo Service] Sending first-signup discount to: ${userData.email}`);
});

console.log('--- First signup ---');
// .emit() fires the event synchronously — all listeners complete
// before the line after this one executes.
notificationHub.emit('userSignedUp', { id: 101, email: 'alex@example.com' });

console.log('\n--- Second signup ---');
// The .once() listener does NOT fire this time — it was auto-removed
// after the first emission. The two .on() listeners still fire.
notificationHub.emit('userSignedUp', { id: 102, email: 'jordan@example.com' });

// listenerCount() is useful for health monitoring — a count that grows
// over time on a long-lived emitter is a memory leak indicator.
console.log(`\nActive listeners: ${notificationHub.listenerCount('userSignedUp')}`);
console.log('// Expected: 2 — the .once() listener was auto-removed after first fire');

const EventEmitter = require('events');

// OrderProcessor extends EventEmitter — it IS an event emitter,
// not something that holds a reference to one.
// This means external code can call processor.on(), processor.once(),
// processor.off() directly, treating the processor as the event source it is.
class OrderProcessor extends EventEmitter {
  constructor() {
    super(); // Required when extending EventEmitter

    // Error listener registered in the constructor so it is always present,
    // regardless of how external code uses this class.
    this.on('error', (err) => {
      console.error(`[OrderProcessor] Internal error: ${err.message}`);
    });

    this.pendingOrders = new Map();
  }

  placeOrder(order) {
    this.pendingOrders.set(order.id, order);
    console.log(`[OrderProcessor] Processing order #${order.id}...`);

    // emit() here — the processor announces what happened.
    // It does not know or care whether Logger, Inventory, or anyone else
    // is listening. Adding a new downstream service means adding a listener
    // externally — zero changes to this class.
    this.emit('orderPlaced', order);
  }

  processPayment(order) {
    // Business rule: single transactions above $500 require manual review
    const approved = order.total < 500;

    if (approved) {
      this.pendingOrders.delete(order.id);
      // Emit enriched data — add server-side timestamp so listeners
      // don't need to generate their own.
      this.emit('paymentConfirmed', {
        ...order,
        confirmedAt: new Date().toISOString()
      });
    } else {
      this.emit('paymentFailed', {
        order,
        reason: 'Amount exceeds single-transaction limit',
        requiresManualReview: true
      });
    }
  }
}

// --- Wire up external services as listeners ---
// None of these services import or modify OrderProcessor.
// They observe it from the outside.

const processor = new OrderProcessor();

// Audit logger — listens to placement for a complete audit trail
processor.on('orderPlaced', (order) => {
  console.log(`[Logger] ORDER PLACED — ID: ${order.id}, Item: ${order.item}, Total: $${order.total}`);
});

// Inventory service — only needs to know about confirmed payments
processor.on('paymentConfirmed', (order) => {
  console.log(`[Inventory] Reserving stock for: ${order.item} (Order #${order.id})`);
});

// Email service — handles both success and failure notifications
processor.on('paymentConfirmed', (order) => {
  console.log(`[Email] Confirmation sent for Order #${order.id} — confirmed at ${order.confirmedAt}`);
});

processor.on('paymentFailed', ({ order, reason, requiresManualReview }) => {
  console.log(`[Email] Failure notice for Order #${order.id}: "${reason}"`);
  if (requiresManualReview) {
    console.log(`[Email] Flagged for manual review queue`);
  }
});

// --- Simulate order flow ---

const order1 = { id: 'ORD-001', item: 'Mechanical Keyboard', total: 120 };
processor.placeOrder(order1);
processor.processPayment(order1);

console.log('');

const order2 = { id: 'ORD-002', item: 'Ultra-Wide Monitor', total: 850 };
processor.placeOrder(order2);
processor.processPayment(order2);

const EventEmitter = require('events');

class DataPipeline extends EventEmitter {
  constructor() {
    super();

    // setMaxListeners is appropriate when your architecture genuinely needs
    // more than 10 listeners — for example, a pipeline that fan-outs to
    // many downstream consumers. Set it explicitly and comment the reason
    // so the next engineer knows this was a deliberate choice, not an oversight.
    this.setMaxListeners(20);

    // Error listener in the constructor — always present, no exceptions.
    // In production, replace console.error with your monitoring service:
    // Sentry.captureException(err), datadogLogs.error(err.message), etc.
    this.on('error', (err) => {
      console.error(`[DataPipeline] Error: ${err.message}`);
    });
  }

  fetchData(sourceUrl) {
    console.log(`[Pipeline] Fetching from: ${sourceUrl}`);

    if (!sourceUrl.startsWith('https://')) {
      // Emitting 'error' is safe here because the constructor registered
      // a handler. Without that handler, this line crashes the process.
      this.emit('error', new Error(`Insecure URL rejected: ${sourceUrl}`));
      return;
    }

    this.emit('dataReceived', { source: sourceUrl, records: 42 });
  }
}

const pipeline = new DataPipeline();

// Named function reference — the ONLY way you can remove this listener later.
// Anonymous: () => {} — registered but unremovable.
// Named:     const handler = () => {} — registered and removable.
const handleDataReceived = (payload) => {
  console.log(`[Consumer] Got ${payload.records} records from ${payload.source}`);
};

pipeline.on('dataReceived', handleDataReceived);

// --- Demonstrate error handling ---
pipeline.fetchData('http://insecure-api.example.com/data'); // triggers error
pipeline.fetchData('https://secure-api.example.com/data');  // succeeds

console.log(`\nListeners before cleanup: ${pipeline.listenerCount('dataReceived')}`);

// .off() requires the exact same function reference used in .on().
// A different function with identical body will not match — Node.js
// compares references, not source code.
pipeline.off('dataReceived', handleDataReceived);

console.log(`Listeners after cleanup: ${pipeline.listenerCount('dataReceived')}`);

// removeAllListeners() with an event name removes all listeners for that event.
// Without an argument it removes ALL listeners for ALL events — including
// the error handler, which means the next error will crash the process.
// Always pass an event name unless you are deliberately tearing down the emitter.
pipeline.removeAllListeners('dataReceived');
console.log(`dataReceived listeners after removeAll: ${pipeline.listenerCount('dataReceived')}`);
console.log(`error listeners still present: ${pipeline.listenerCount('error')}`);

const EventEmitter = require('events');

// ============================================================
// ANTI-PATTERN: New listener registered on every request call.
// This is exactly the pattern from the production incident above.
// ============================================================
function handleRequestAntiPattern(emitter, req, res) {
  // A new anonymous function is created and registered on every call.
  // It captures 'res' in its closure.
  // It can never be removed — anonymous and no .off() call.
  // After 1,000 calls: 1,000 listeners, 1,000 'res' objects in memory.
  emitter.on('responseReady', (data) => {
    res.json(data); // 'res' is retained by the closure
  });
}

// ============================================================
// CORRECT PATTERN: One listener, registered once at startup.
// Per-request state lives in a Map, not in a closure.
// ============================================================
class RequestDispatcher extends EventEmitter {
  constructor() {
    super();
    this.setMaxListeners(5); // Only a few listeners — intentionally bounded
    this.pendingRequests = new Map();
    this.requestCounter = 0;

    // This single listener is registered ONCE in the constructor.
    // It handles dispatch for ALL requests by reading from the Map.
    // Listener count stays at 1 regardless of traffic volume.
    this.on('responseReady', (payload) => {
      const { requestId, data } = payload;
      const res = this.pendingRequests.get(requestId);

      if (!res) {
        // Request timed out or was already handled — discard cleanly
        console.warn(`[Dispatcher] No pending request for ID ${requestId} — discarding`);
        return;
      }

      res.json(data);
      // Remove from Map immediately — allows GC to collect the response object
      this.pendingRequests.delete(requestId);
    });

    // Error listener always present
    this.on('error', (err) => {
      console.error(`[Dispatcher] Error: ${err.message}`);
    });
  }

  handleRequest(req, res) {
    const requestId = ++this.requestCounter;

    // Store the response object in the Map — not in a listener closure
    this.pendingRequests.set(requestId, res);

    // Simulate async work with a timer — in production this would be
    // a database call, an external API request, or a queue message
    setTimeout(() => {
      this.emit('responseReady', {
        requestId,
        data: { status: 'ok', requestId, processed: Date.now() }
      });
    }, 10);

    // Timeout guard: remove from Map after 5 seconds to prevent
    // Map growth from requests that never complete
    setTimeout(() => {
      if (this.pendingRequests.has(requestId)) {
        this.pendingRequests.delete(requestId);
        console.warn(`[Dispatcher] Request ${requestId} timed out — cleaned up`);
      }
    }, 5000);
  }
}

const dispatcher = new RequestDispatcher();

console.log(`Listeners at startup: ${dispatcher.listenerCount('responseReady')}`);

// Simulate 1,000 concurrent requests.
// Listener count must remain constant — if it grows, the pattern is broken.
for (let i = 0; i < 1000; i++) {
  dispatcher.handleRequest({}, { json: (data) => {} });
}

// Allow the async work to complete
setTimeout(() => {
  console.log(`Listeners after 1,000 requests: ${dispatcher.listenerCount('responseReady')}`);
  console.log(`Pending Map entries: ${dispatcher.pendingRequests.size}`);
  console.log('// Expected: 1 listener, 0 pending (all completed within timeout)');
}, 500);

const EventEmitter = require('events');
const { on } = require('events');

// ============================================================
// Pattern 1: Async iteration with events.on()
// Consumes events as a for-await-of loop with natural backpressure.
// The loop body completes before the next event is yielded.
// ============================================================
class MetricsCollector extends EventEmitter {
  constructor() {
    super();
    this.setMaxListeners(20);
    this.on('error', (err) => console.error('[MetricsCollector]', err.message));
  }

  record(name, value) {
    this.emit('metric', { name, value, timestamp: Date.now() });
  }
}

async function processMetricsInBatches(emitter, batchSize = 10, totalLimit = 30) {
  let count = 0;
  let batch = [];

  // events.on() returns an async iterable.
  // Each yield delivers the event arguments as an array.
  // The loop pauses between iterations — producer can emit freely,
  // but consumption is controlled by how fast the loop body runs.
  for await (const [metric] of on(emitter, 'metric')) {
    batch.push(metric);
    count++;

    if (batch.length >= batchSize) {
      // Simulate a batched write — this could be a database insert,
      // a Kafka produce call, or a metrics API flush
      console.log(`[Batch Write] Flushing ${batch.length} metrics to storage (total so far: ${count})`);
      batch = [];
    }

    if (count >= totalLimit) break; // Exit condition — loop terminates cleanly
  }

  if (batch.length > 0) {
    console.log(`[Batch Write] Final flush: ${batch.length} remaining metrics`);
  }

  console.log(`[Done] Consumed ${count} metrics total`);
}

// ============================================================
// Pattern 2: Instrumenting an emitter for observability
// Wraps emit() to add metrics and tracing without modifying
// the emitter class or any of its listeners.
// ============================================================
function instrumentEmitter(emitter, emitterName) {
  const originalEmit = emitter.emit.bind(emitter);

  emitter.emit = function instrumentedEmit(eventName, ...args) {
    // Skip 'newListener' and 'removeListener' to avoid infinite recursion
    if (eventName !== 'newListener' && eventName !== 'removeListener') {
      const listenerCount = emitter.listenerCount(eventName);
      console.log(
        `[Telemetry] ${emitterName} emitting '${eventName}' ` +
        `to ${listenerCount} listener(s) at ${new Date().toISOString()}`
      );
      // In production: increment a Datadog metric, add an OpenTelemetry span, etc.
    }
    return originalEmit(eventName, ...args);
  };

  return emitter;
}

// --- Demonstrate async iteration ---
const collector = new MetricsCollector();

// Start the async consumer before emitting
processMetricsInBatches(collector, 10, 30).catch(console.error);

// Emit 30 metrics — the async loop consumes them in batches
for (let i = 0; i < 30; i++) {
  collector.record('api.latency', Math.round(Math.random() * 200));
}

// --- Demonstrate instrumentation ---
console.log('\n--- Instrumented emitter ---');
const instrumentedCollector = instrumentEmitter(new MetricsCollector(), 'MetricsCollector');
instrumentedCollector.on('metric', (m) => console.log(`[Consumer] Received: ${m.name} = ${m.value}`));
instrumentedCollector.record('http.requests', 1542);

// io.thecodeforge — javascript tutorial

const EventEmitter = require('events');

// Production: always enable captureRejections at the emitter level
const emitter = new EventEmitter({ captureRejections: true });

// Trap: this logs every time a listener is added
emitter.on('newListener', (event, listener) => {
  console.log(`Registered listener for: ${event}`);
});

// Safe registration
emitter.on('data', (msg) => console.log(msg));
emitter.emit('data', 'hello');

// Output:
// Registered listener for: data
// hello

// io.thecodeforge — javascript tutorial

const EventEmitter = require('events');
const bus = new EventEmitter();

const handler = (msg) => {
  console.log(`Handler saw: ${msg}`);
  // Dangerous: removing other listeners mid-emission
  bus.removeListener('data', someOtherHandler);
};

const someOtherHandler = (msg) => {
  console.log(`Other handler: ${msg}`);
};

bus.on('data', handler);
bus.on('data', someOtherHandler);

bus.emit('data', 'first');
bus.emit('data', 'second');

// Output:
// Handler saw: first
// Other handler: first       <-- both fire for 'first'
// Handler saw: second       <-- other handler removed? no, only for NEXT emission
// (no 'Other handler' for 'second' because removal took effect after first emission)

// io.thecodeforge — javascript tutorial

const EventEmitter = require('events');

class Monitor extends EventEmitter {
  constructor() {
    super();
    this.listenerCounts = new Map();

    this.on('newListener', (event, listener) => {
      const count = (this.listenerCounts.get(event) || 0) + 1;
      this.listenerCounts.set(event, count);
      console.log(`[MONITOR] +1 ${event} (total: ${count})`);

      // Stale listener leak detection
      if (count > 10) {
        console.warn(`[WARN] ${event} has ${count} listeners — possible leak`);
      }
    });

    this.on('removeListener', (event) => {
      const count = (this.listenerCounts.get(event) || 1) - 1;
      this.listenerCounts.set(event, count);
      console.log(`[MONITOR] -1 ${event} (total: ${count})`);
    });
  }
}

const monitor = new Monitor();
monitor.on('update', () => {});
monitor.on('update', () => {});
monitor.removeAllListeners('update');

// Output:
// [MONITOR] +1 update (total: 1)
// [MONITOR] +1 update (total: 2)
// [MONITOR] -1 update (total: 1)
// [MONITOR] -1 update (total: 0)

// io.thecodeforge — javascript tutorial
const EventEmitter = require('events');
const myEmitter = new EventEmitter();
myEmitter.on('data', (msg) => console.log(msg));
myEmitter.emit('data', 'Hello from EventEmitter!');

// io.thecodeforge — javascript tutorial
const EventEmitter = require('events');
const test = new EventEmitter();
test.on('ready', () => console.log('Prerequisites met'));
test.emit('ready');

const EventEmitter = require('events');

class TicketManager extends EventEmitter {
  constructor(capacity) {
    super();
    this.capacity = capacity;
    this.bookings = 0;
  }

  book() {
    if (this.bookings >= this.capacity) {
      this.emit('error', new Error('Capacity full'));
      return;
    }
    this.bookings++;
    this.emit('booking', { id: Date.now(), remaining: this.capacity - this.bookings });
    if (this.bookings === this.capacity) {
      this.emit('capacity', 'Full');
    }
  }

  cancel() {
    if (this.bookings === 0) {
      this.emit('error', new Error('No bookings to cancel'));
      return;
    }
    this.bookings--;
    this.emit('cancellation', { remaining: this.capacity - this.bookings });
  }
}

// Usage with listener tracking
const manager = new TicketManager(3);
const listeners = [];

const onBooking = (data) => console.log('Booking:', data);
const onError = (err) => console.error('Error:', err.message);

manager.on('booking', onBooking);
manager.on('error', onError);
listeners.push({ event: 'booking', handler: onBooking });
listeners.push({ event: 'error', handler: onError });

manager.book();
manager.book();
manager.book();
manager.book(); // triggers error

// Cleanup
listeners.forEach(({ event, handler }) => manager.removeListener(event, handler));
console.log('Listeners after cleanup:', manager.listenerCount('booking')); // 0

const { EventEmitter, captureRejectionSymbol } = require('events');

const emitter = new EventEmitter({ captureRejections: true });

emitter.on('async-event', async () => {
  throw new Error('Async error');
});

emitter.on('error', (err) => {
  console.error('Caught:', err.message);
});

emitter.emit('async-event');
// Output: Caught: Async error

// Without captureRejections, the above would be an unhandled rejection.

const { once, EventEmitter } = require('events');

async function waitForFirstEvent(emitter) {
  try {
    const [data] = await once(emitter, 'ready');
    console.log('Ready with:', data);
  } catch (err) {
    console.error('Failed:', err.message);
  }
}

const emitter = new EventEmitter();
waitForFirstEvent(emitter);

setTimeout(() => emitter.emit('ready', { status: 'ok' }), 100);

// With AbortController
const ac = new AbortController();
const promise = once(emitter, 'data', { signal: ac.signal });
ac.abort(); // rejects promise with AbortError

const { EventEmitterAsyncResource } = require('events');
const { executionAsyncId } = require('async_hooks');

class TracedEmitter extends EventEmitterAsyncResource {
  constructor() {
    super({ name: 'TracedEmitter' });
  }

  emit(event, ...args) {
    console.log(`Emit in async context ${executionAsyncId()}`);
    return super.emit(event, ...args);
  }
}

const emitter = new TracedEmitter();
emitter.on('event', () => {
  console.log(`Listener in async context ${executionAsyncId()}`);
});

emitter.emit('event');
// Output shows same async ID for emit and listener

const EventEmitter2 = require('eventemitter2');

const emitter = new EventEmitter2({
  wildcard: true,
  delimiter: ':',
  newListener: false,
  maxListeners: 20
});

emitter.on('user:*', (data) => {
  console.log('User event:', data);
});

emitter.emit('user:login', { id: 1 });
emitter.emit('user:logout', { id: 1 });
// Both trigger the same listener

// Namespace example
const ns = emitter.getNamespace('user');
ns.on('login', (data) => console.log('Login:', data));

// Cleanup: remove all listeners matching pattern
emitter.off('user:*');