Function createOnGlobalUncaughtException

lib/internal/process/execution.js:166–226

()

// or this function should take extra care of the async hooks before it
// schedules a setImmediate.
function createOnGlobalUncaughtException() {
  // The C++ land node::errors::TriggerUncaughtException() will
  // exit the process if it returns false, and continue execution if it
  // returns true (which indicates that the exception is handled by the user).
  return (er, fromPromise) => {
    // It's possible that defaultTriggerAsyncId was set for a constructor
    // call that threw and was never cleared. So clear it now.
    clearDefaultTriggerAsyncId();

    const type = fromPromise ? 'unhandledRejection' : 'uncaughtException';
    process.emit('uncaughtExceptionMonitor', er, type);
    // Primary callback (e.g., domain) has priority and always handles the exception
    if (exceptionHandlerState.captureFn !== null) {
      exceptionHandlerState.captureFn(er);
    } else {
      // If no primary callback, try auxiliary callbacks (e.g., REPL)
      // They must return true to indicate handling
      let handled = false;
      for (let i = exceptionHandlerState.auxiliaryCallbacks.length - 1; i >= 0; i--) {
        if (exceptionHandlerState.auxiliaryCallbacks[i](er) === true) {
          handled = true;
          break;
        }
      }
      if (!handled && !process.emit('uncaughtException', er, type)) {
        // If someone handled it, then great. Otherwise, die in C++ land
        // since that means that we'll exit the process, emit the 'exit' event.
        try {
          if (!process._exiting) {
            process._exiting = true;
            process.exitCode = kGenericUserError;
            process.emit('exit', kGenericUserError);
          }
        } catch {
          // Nothing to be done about it at this point.
        }
        return false;
      }
    }

    // If we handled an error, then make sure any ticks get processed
    // by ensuring that the next Immediate cycle isn't empty.
    require('timers').setImmediate(noop);

    // Emit the after() hooks now that the exception has been handled.
    if (afterHooksExist()) {
      do {
        const asyncId = executionAsyncId();
        if (asyncId === 0)
          popAsyncContext(0);
        else
          emitAfter(asyncId);
      } while (hasAsyncIdStack());
    }
    // And completely empty the id stack, including anything that may be
    // cached on the native side.
    clearAsyncIdStack();