errors: trace unhandled promise rejection location

lib/internal/process/promises.js

@@ -99,7 +99,7 @@ class PromiseRejectionHandledWarning extends Error {
 
 /**
  * @typedef PromiseInfo
- * @property {*} reason the reason for the rejection
+ * @property {unknown} reason the reason for the rejection
  * @property {number} uid the unique id of the promise
  * @property {boolean} warned whether the rejection has been warned
  * @property {object} [domain] the domain the promise was created in
@@ -153,17 +153,18 @@ function isErrorLike(obj) {
 /**
  * @param {0|1|2|3} type
  * @param {Promise} promise
- * @param {Error} reason
+ * @param {unknown} reason
+ * @param {Error} rejectionSite
  */
-function promiseRejectHandler(type, promise, reason) {
+function promiseRejectHandler(type, promise, reason, rejectionSite) {
   if (unhandledRejectionsMode === undefined) {
     unhandledRejectionsMode = getUnhandledRejectionsMode();
   }
   // kPromiseRejectAfterResolved and kPromiseResolveAfterResolved are
   // filtered out in C++ (src/node_task_queue.cc) and never reach JS.
   switch (type) {
     case kPromiseRejectWithNoHandler: // 0
-      unhandledRejection(promise, reason);
+      unhandledRejection(promise, reason, rejectionSite);
       break;
     case kPromiseHandlerAddedAfterReject: // 1
       handledRejection(promise);
@@ -184,15 +185,17 @@ const emitUnhandledRejection = (promise, promiseInfo) => {
 
 /**
  * @param {Promise} promise
- * @param {Error} reason
+ * @param {unknown} reason
+ * @param {Error} rejectionSite
  */
-function unhandledRejection(promise, reason) {
+function unhandledRejection(promise, reason, rejectionSite) {
   pendingUnhandledRejections.set(promise, {
     reason,
     uid: ++lastPromiseId,
     warned: false,
     domain: process.domain,
     contextFrame: AsyncContextFrame.current(),
+    rejectionSite,
   });
   setHasRejectionToWarn(true);
 }
@@ -272,7 +275,7 @@ function strictUnhandledRejectionsMode(promise, promiseInfo, promiseAsyncId) {
   const err = isErrorLike(reason) ?
     reason : new UnhandledPromiseRejection(reason);
   // This destroys the async stack, don't clear it after
-  triggerUncaughtException(err, true /* fromPromise */);
+  triggerUncaughtException(err, true /* fromPromise */, promiseInfo.rejectionSite);
   if (promiseAsyncId !== undefined) {
     pushAsyncContext(
       promise[kAsyncIdSymbol],
@@ -321,7 +324,7 @@ function throwUnhandledRejectionsMode(promise, promiseInfo) {
       reason :
       new UnhandledPromiseRejection(reason);
     // This destroys the async stack, don't clear it after
-    triggerUncaughtException(err, true /* fromPromise */);
+    triggerUncaughtException(err, true /* fromPromise */, promiseInfo.rejectionSite);
     return false;
   }
   return true;

src/node_errors.cc

@@ -422,7 +422,8 @@ enum class EnhanceFatalException { kEnhance, kDontEnhance };
 static void ReportFatalException(Environment* env,
                                  Local<Value> error,
                                  Local<Message> message,
-                                 EnhanceFatalException enhance_stack) {
+                                 EnhanceFatalException enhance_stack,
+                                 bool from_promise) {
   if (!env->can_call_into_js())
     enhance_stack = EnhanceFatalException::kDontEnhance;
 
@@ -553,7 +554,11 @@ static void ReportFatalException(Environment* env,
   if (env->options()->trace_uncaught) {
     Local<StackTrace> trace = message->GetStackTrace();
     if (!trace.IsEmpty()) {
-      FPrintF(stderr, "Thrown at:\n");
+      if (from_promise) {
+        FPrintF(stderr, "Rejected at:\n");
+      } else {
+        FPrintF(stderr, "Thrown at:\n");
+      }
       PrintStackTrace(env->isolate(), trace);
     }
   }
@@ -715,7 +720,7 @@ TryCatchScope::~TryCatchScope() {
         EnhanceFatalException::kEnhance : EnhanceFatalException::kDontEnhance;
     if (message.IsEmpty())
       message = Exception::CreateMessage(env_->isolate(), exception);
-    ReportFatalException(env_, exception, message, enhance);
+    ReportFatalException(env_, exception, message, enhance, false);
     env_->Exit(ExitCode::kExceptionInFatalExceptionHandler);
   }
 }
@@ -1165,13 +1170,21 @@ static void TriggerUncaughtException(const FunctionCallbackInfo<Value>& args) {
   Isolate* isolate = args.GetIsolate();
   Environment* env = Environment::GetCurrent(isolate);
   Local<Value> exception = args[0];
-  Local<Message> message = Exception::CreateMessage(isolate, exception);
+  bool from_promise = args[1]->IsTrue();
+  Local<Value> throw_site = args[2];
+
+  Local<Message> message;
+  if (!throw_site->IsUndefined()) {
+    message = Exception::CreateMessage(isolate, throw_site);
+  } else {
+    message = Exception::CreateMessage(isolate, exception);
+  }
+
   if (env != nullptr && env->abort_on_uncaught_exception()) {
     ReportFatalException(
-        env, exception, message, EnhanceFatalException::kEnhance);
+        env, exception, message, EnhanceFatalException::kEnhance, from_promise);
     ABORT();
   }
-  bool from_promise = args[1]->IsTrue();
   errors::TriggerUncaughtException(isolate, exception, message, from_promise);
 }
 
@@ -1306,7 +1319,7 @@ void TriggerUncaughtException(Isolate* isolate,
   // the current Node.js instance.
   if (!fatal_exception_function->IsFunction()) {
     ReportFatalException(
-        env, error, message, EnhanceFatalException::kDontEnhance);
+        env, error, message, EnhanceFatalException::kDontEnhance, from_promise);
     env->Exit(ExitCode::kInvalidFatalExceptionMonkeyPatching);
     return;
   }
@@ -1367,7 +1380,8 @@ void TriggerUncaughtException(Isolate* isolate,
   }
 
   // Now we are certain that the exception is fatal.
-  ReportFatalException(env, error, message, EnhanceFatalException::kEnhance);
+  ReportFatalException(
+      env, error, message, EnhanceFatalException::kEnhance, from_promise);
   RunAtExit(env);
 
   // If the global uncaught exception handler sets process.exitCode,

src/node_errors.h

@@ -130,6 +130,7 @@ void OOMErrorHandler(const char* location, const v8::OOMDetails& details);
   V(ERR_TLS_PSK_SET_IDENTITY_HINT_FAILED, Error)                               \
   V(ERR_VM_MODULE_CACHED_DATA_REJECTED, Error)                                 \
   V(ERR_VM_MODULE_LINK_FAILURE, Error)                                         \
+  V(ERR_UNHANDLED_REJECTION, Error)                                            \
   V(ERR_WASI_NOT_STARTED, Error)                                               \
   V(ERR_ZLIB_INITIALIZATION_FAILED, Error)                                     \
   V(ERR_WORKER_INIT_FAILED, Error)                                             \
@@ -244,6 +245,10 @@ ERRORS_WITH_CODE(V)
   V(ERR_SCRIPT_EXECUTION_INTERRUPTED,                                          \
     "Script execution was interrupted by `SIGINT`")                            \
   V(ERR_TLS_PSK_SET_IDENTITY_HINT_FAILED, "Failed to set PSK identity hint")   \
+  V(ERR_UNHANDLED_REJECTION,                                                   \
+    "This error originated either by throwing inside of an async function "    \
+    "without a catch block, or by rejecting a promise which was not handled "  \
+    "with .catch().")                                                          \
   V(ERR_WASI_NOT_STARTED, "wasi.start() has not been called")                  \
   V(ERR_WORKER_INIT_FAILED, "Worker initialization failure")                   \
   V(ERR_PROTO_ACCESS,                                                          \

src/node_task_queue.cc

@@ -89,7 +89,18 @@ void PromiseRejectCallback(PromiseRejectMessage message) {
     value = Undefined(isolate);
   }
 
-  Local<Value> args[] = { type, promise, value };
+  Local<Value> rejection_site;
+  if (event == kPromiseRejectWithNoHandler) {
+    // Native error carries the throw site. Create a dummy error to capture the
+    // stack trace where the rejection actually happened, when no native error
+    // is available.
+    rejection_site =
+        value->IsNativeError() ? value : ERR_UNHANDLED_REJECTION(isolate);
+  } else {
+    rejection_site = Undefined(isolate);
+  }
+
+  Local<Value> args[] = {type, promise, value, rejection_site};
 
   double async_id = AsyncWrap::kInvalidAsyncId;
   double trigger_async_id = AsyncWrap::kInvalidAsyncId;

test/fixtures/uncaught/exception_async_tick.js

@@ -0,0 +1,3 @@
+process.nextTick(() => {
+  throw null;
+});

test/fixtures/uncaught/exception_async_tick.snapshot

@@ -0,0 +1,11 @@
+
+<project-root>/test/fixtures/uncaught/exception_async_tick.js:2
+  throw null;
+  ^
+null
+Thrown at:
+    at <project-root>/test/fixtures/uncaught/exception_async_tick.js:2:3
+    at <node-internal-frames>
+
+
+Node.js <node-version>

test/fixtures/uncaught/exception_null.js

@@ -0,0 +1 @@
+throw null;

test/fixtures/uncaught/exception_null.snapshot

@@ -0,0 +1,11 @@
+
+<project-root>/test/fixtures/uncaught/exception_null.js:1
+throw null;
+^
+null
+Thrown at:
+    at <project-root>/test/fixtures/uncaught/exception_null.js:1:1
+    at <node-internal-frames>
+
+
+Node.js <node-version>

test/fixtures/uncaught/exception_stack_malformed.js

@@ -0,0 +1,8 @@
+throw {
+  get stack() {
+    throw new Error('weird throw but ok');
+  },
+  get name() {
+    throw new Error('weird throw but ok');
+  },
+};

test/fixtures/uncaught/exception_stack_malformed.snapshot

@@ -0,0 +1,11 @@
+
+<project-root>/test/fixtures/uncaught/exception_stack_malformed.js:1
+throw {
+^
+[object Object]
+Thrown at:
+    at <project-root>/test/fixtures/uncaught/exception_stack_malformed.js:1:1
+    at <node-internal-frames>
+
+
+Node.js <node-version>

test/fixtures/uncaught/exception_symbol.js

@@ -0,0 +1 @@
+throw Symbol('foo');

test/fixtures/uncaught/exception_symbol.snapshot

@@ -0,0 +1,11 @@
+
+<project-root>/test/fixtures/uncaught/exception_symbol.js:1
+throw Symbol('foo');
+^
+
+Thrown at:
+    at <project-root>/test/fixtures/uncaught/exception_symbol.js:1:1
+    at <node-internal-frames>
+
+
+Node.js <node-version>

test/fixtures/uncaught/exception_undefined.js

@@ -0,0 +1 @@
+throw undefined;

test/fixtures/uncaught/exception_undefined.snapshot

@@ -0,0 +1,11 @@
+
+<project-root>/test/fixtures/uncaught/exception_undefined.js:1
+throw undefined;
+^
+undefined
+Thrown at:
+    at <project-root>/test/fixtures/uncaught/exception_undefined.js:1:1
+    at <node-internal-frames>
+
+
+Node.js <node-version>

test/fixtures/uncaught/rejection_async_fn_throw.js

@@ -0,0 +1,6 @@
+setImmediate(() => {
+  (async () => {
+    await 1;
+    throw null;
+  })();
+});

test/fixtures/uncaught/rejection_async_fn_throw.snapshot

@@ -0,0 +1,14 @@
+<project-root>/test/fixtures/uncaught/rejection_async_fn_throw.js:4
+    throw null;
+    ^
+
+UnhandledPromiseRejection: This error originated either by throwing inside of an async function without a catch block, or by rejecting a promise which was not handled with .catch(). The promise rejected with the reason "null".
+    at <node-internal-frames>
+    at <node-internal-frames> {
+  code: 'ERR_UNHANDLED_REJECTION'
+}
+Rejected at:
+    at <project-root>/test/fixtures/uncaught/rejection_async_fn_throw.js:4:5
+
+
+Node.js <node-version>

test/fixtures/uncaught/rejection_async_fn_throw_err.js

@@ -0,0 +1,8 @@
+const err = new Error('err with wrong stack');
+
+setImmediate(() => {
+  (async () => {
+    await 1;
+    throw err;
+  })();
+});

test/fixtures/uncaught/rejection_async_fn_throw_err.snapshot

@@ -0,0 +1,12 @@
+<project-root>/test/fixtures/uncaught/rejection_async_fn_throw_err.js:6
+    throw err;
+    ^
+
+Error: err with wrong stack
+    at Object.<anonymous> (<project-root>/test/fixtures/uncaught/rejection_async_fn_throw_err.js:1:13)
+    at <node-internal-frames>
+Rejected at:
+    at <project-root>/test/fixtures/uncaught/rejection_async_fn_throw_err.js:6:5
+
+
+Node.js <node-version>

test/fixtures/uncaught/rejection_promise_reject.js

@@ -0,0 +1,3 @@
+setImmediate(() => {
+  Promise.reject(null);
+});

test/fixtures/uncaught/rejection_promise_reject.snapshot

@@ -0,0 +1,15 @@
+<project-root>/test/fixtures/uncaught/rejection_promise_reject.js:2
+  Promise.reject(null);
+          ^
+
+UnhandledPromiseRejection: This error originated either by throwing inside of an async function without a catch block, or by rejecting a promise which was not handled with .catch(). The promise rejected with the reason "null".
+    at <node-internal-frames>
+    at <node-internal-frames> {
+  code: 'ERR_UNHANDLED_REJECTION'
+}
+Rejected at:
+    at <project-root>/test/fixtures/uncaught/rejection_promise_reject.js:2:11
+    at <node-internal-frames>
+
+
+Node.js <node-version>

test/parallel/test-node-output-trace-uncaught.mjs

@@ -0,0 +1,24 @@
+import '../common/index.mjs';
+import * as fixtures from '../common/fixtures.mjs';
+import * as snapshot from '../common/assertSnapshot.js';
+import { describe, it } from 'node:test';
+
+describe('--trace-uncaught', { concurrency: !process.env.TEST_PARALLEL }, () => {
+  const tests = [
+    { name: 'uncaught/exception_async_tick.js' },
+    { name: 'uncaught/exception_null.js' },
+    { name: 'uncaught/exception_stack_malformed.js' },
+    { name: 'uncaught/exception_symbol.js' },
+    { name: 'uncaught/exception_undefined.js' },
+    { name: 'uncaught/rejection_async_fn_throw_err.js' },
+    { name: 'uncaught/rejection_async_fn_throw.js' },
+    { name: 'uncaught/rejection_promise_reject.js' },
+  ];
+  for (const { name } of tests) {
+    it(name, async () => {
+      await snapshot.spawnAndAssert(fixtures.path(name), snapshot.defaultTransform, {
+        flags: ['--trace-uncaught'],
+      });
+    });
+  }
+});