lib: capture no stack for default abort reason

The default AbortError created by AbortController.prototype.abort()
and AbortSignal.abort() captures a stack that V8 keeps unformatted.
Until it is formatted, V8 holds on to the call sites, which retain the
receivers and functions of the calling frames. A signal that outlives
the work it cancelled can then keep that work alive, including large
buffers.

Create the default reason with Error.stackTraceLimit set to 0, so no
call sites are captured. This also makes abort() without a reason
faster, as the stack is no longer collected. Callers that want a stack
can pass their own reason. Reasons passed by the caller are left
untouched.

Signed-off-by: Kuldeep Yadav <kuldeeep.yadav1@gmail.com>

Author: kuldeeepy

lib/internal/abort_controller.js

@@ -41,6 +41,7 @@ const {
     ERR_INVALID_ARG_TYPE,
     ERR_INVALID_THIS,
   },
+  isErrorStackTraceLimitWritable,
 } = require('internal/errors');
 const {
   converters,
@@ -216,6 +217,23 @@ function setWeakAbortSignalTimeout(weakRef, delay) {
   return timeout;
 }
 
+// The default reason captures no stack. A captured stack keeps the receivers
+// and functions of the aborting caller's frames alive until it is formatted,
+// so a retained signal would keep the aborted work alive, and formatting it
+// eagerly costs several microseconds per abort. Callers that want the stack
+// can pass their own reason.
+// Refs: https://github.com/nodejs/node/issues/66192
+function createDefaultAbortReason() {
+  if (!isErrorStackTraceLimitWritable()) {
+    return new DOMException('This operation was aborted', 'AbortError');
+  }
+  const limit = Error.stackTraceLimit;
+  Error.stackTraceLimit = 0;
+  const reason = new DOMException('This operation was aborted', 'AbortError');
+  Error.stackTraceLimit = limit;
+  return reason;
+}
+
 class AbortSignal extends EventTarget {
   #brand;
 
@@ -293,8 +311,7 @@ class AbortSignal extends EventTarget {
    * @param {any} [reason]
    * @returns {AbortSignal}
    */
-  static abort(
-    reason = new DOMException('This operation was aborted', 'AbortError')) {
+  static abort(reason = createDefaultAbortReason()) {
     return new AbortSignal(kDontThrowSymbol, { aborted: true, reason });
   }
 
@@ -576,7 +593,7 @@ class AbortController {
   /**
    * @param {any} [reason]
    */
-  abort(reason = new DOMException('This operation was aborted', 'AbortError')) {
+  abort(reason = createDefaultAbortReason()) {
     abortSignal(this.#signal ??= new AbortSignal(kDontThrowSymbol), reason);
   }
 

test/parallel/test-abortcontroller-default-reason-gc.mjs

@@ -0,0 +1,47 @@
+// Flags: --expose-gc
+
+import '../common/index.mjs';
+import { gcUntil } from '../common/gc.js';
+import assert from 'node:assert/strict';
+import { it } from 'node:test';
+
+// The default abort reason must not keep the objects on the caller's stack
+// alive. Refs: https://github.com/nodejs/node/issues/66192
+
+class Job {
+  controller = new AbortController();
+
+  cancel() {
+    this.controller.abort();
+    return this.controller.signal;
+  }
+
+  cancelStatic() {
+    return AbortSignal.abort();
+  }
+}
+
+for (const method of ['cancel', 'cancelStatic']) {
+  it(`does not retain the caller through the default reason (${method})`, async () => {
+    let job = new Job();
+    const jobRef = new WeakRef(job);
+    const signal = job[method]();
+    job = null;
+
+    await gcUntil('job is collected', () => jobRef.deref() === undefined);
+    assert.strictEqual(signal.aborted, true);
+    assert.strictEqual(signal.reason.name, 'AbortError');
+    assert.doesNotMatch(signal.reason.stack, /\n\s+at /);
+  });
+}
+
+it('does not throw when Error.prepareStackTrace throws', () => {
+  const { prepareStackTrace } = Error;
+  Error.prepareStackTrace = () => { throw new Error('boom'); };
+  try {
+    assert.strictEqual(new Job().cancel().reason.name, 'AbortError');
+    assert.strictEqual(new Job().cancelStatic().reason.name, 'AbortError');
+  } finally {
+    Error.prepareStackTrace = prepareStackTrace;
+  }
+});