Q:

What happens with Node.js events?

I have an Express app that uses an event emitter when resolving requests to a specific route. When a request is received, emit is called, which runs code in the handler. This code takes around 5 seconds to complete. What will happen when the Express endpoint receives 10 or more requests per second at one time? 
Will the events be put into the call stack and complete in the order they are put into the call stack? 
Thank you
status.emit('newCompletion')

A:

EventEmitter events are synchronous.  They execute when you .emit() them.  You can pretty much think of them like function calls where calling .emit() just immediately calls the functions of any matching listeners.

Will the events be put into the call stack and complete in the order they are put into the call stack?

They are executed synchronously.  The wording you used here makes me think you think there's some sort of queue for eventEmitter events.  There is not.  You call .emit() and any listeners for that event name are immediately called (before .emit() even returns).

I have an Express app that uses an event emitter when resolving requests to a specific route. When a request is received, emit is called, which runs code in the handler.  This code takes around 5 seconds to complete. What will happen when the Express endpoint receives 10 or more requests per second at one time?

If the 5 seconds to complete is synchronous code, then nothing else will happen during those 5 seconds.  No other incoming requests will be processed (they will likely be sitting in some incoming TCP queue in the OS or in an event queue).  So, one will run its 5 seconds of code, return control back to nodejs (by finishing its execution) and then nodejs will get the next event form the event queue and process the next request.
If the 5 seconds to complete contains some asynchronous operations so it's 5 seconds of clock time, but not 5 seconds of CPU time, then things are more complicated.  As soon as the first request fires off an asynchronous operation with a registered callback and then returns control back to node.js, it will then grab the next event from the event queue and start running that request handler.  That will run until it returns control back to the system.  Any .emit() calls in either of these requests will be synchronous and will not cause anything other than a function call to occur to execute the handlers for that event.
You can see that .emit() is synchronous here in that it comes before other tasks and microtasks:

let em = new EventEmitter();
em.on("hello", function() {
    console.log("hello");
});


// schedule "immediate" task
setTimeout(function() {
    console.log("timer");
}, 0)

// schedule "immediate" micro-task
Promise.resolve().then(function() {
    console.log("promise");
});

em.emit("hello");
console.log("ready");
<script src="https://cdnjs.cloudflare.com/ajax/libs/EventEmitter/5.2.2/EventEmitter.js"></script>

