Why does my Node.js server occasionally hang when using async/await with event listeners?

I’m developing a Node.js server that listens to a stream of events from a message queue (like RabbitMQ or Kafka). I’m using async/await to handle asynchronous operations within my event listeners. However, I’ve noticed that occasionally the server seems to hang—no new events are processed, and no errors are thrown.

Here’s a simplified version of my code:

const { EventEmitter } = require('events');
const eventEmitter = new EventEmitter();

eventEmitter.on('data', async (message) => {
  try {
    await handleMessage(message);
  } catch (error) {
    console.error('Error handling message:', error);
  }
});

function startListening() {
  // Simulate receiving messages
  setInterval(() => {
    eventEmitter.emit('data', { content: 'New message' });
  }, 1000);
}

startListening();

handleMessage Function:

async function handleMessage(message) {
  // Simulate asynchronous processing
  await new Promise((resolve) => setTimeout(resolve, 2000));
  console.log('Processed message:', message.content);
}

After running for a while, the server stops processing new messages.
No error messages are logged.
CPU and memory usage remain normal.

Debugging: Added console logs before and after the await in handleMessage to see where it might be getting stuck.

Error Handling: Ensured that all promises have .catch handlers or are within try/catch blocks.

Concurrency Limits: Thought it might be due to overwhelming the event loop, so I considered implementing a concurrency limit but am unsure how to proceed.

  1. Is using async functions directly in event listeners a bad practice in Node.js?
  2. What could cause the event listener to hang without throwing errors?
  3. How can I modify my code to handle asynchronous event processing more reliably?