domain: fix recursive error handler call in emit

When an EventEmitter emits 'error' and the domain's error handler
throws, the exception should propagate to the parent domain, not
recursively call the same domain's error handler.

The bug was that currentDomain/currentStack were not updated when
temporarily switching to the parent domain context during error
emission. Since domainExceptionHandler checks currentDomain first,
exceptions would incorrectly route back to the same domain.

Fixes by updating currentDomain/currentStack alongside the ALS store.

Author: mcollina

lib/domain.js

@@ -642,10 +642,15 @@ EventEmitter.prototype.emit = function emit(...args) {
 
     // Change the current active domain
     const newActiveDomain = newStack.length > 0 ? newStack[newStack.length - 1] : null;
+    const prevCurrentDomain = currentDomain;
+    const prevCurrentStack = currentStack;
+
     if (store) {
       setDomainStore({ domain: newActiveDomain, stack: newStack });
     }
     exports.active = newActiveDomain;
+    currentDomain = newActiveDomain;
+    currentStack = newStack;
 
     updateExceptionCapture();
 
@@ -657,6 +662,8 @@ EventEmitter.prototype.emit = function emit(...args) {
       setDomainStore({ domain: origActiveDomain, stack: origDomainsStack });
     }
     exports.active = origActiveDomain;
+    currentDomain = prevCurrentDomain;
+    currentStack = prevCurrentStack;
     updateExceptionCapture();
 
     return false;

test/parallel/test-domain-error-handler-throw-no-recursion.js

@@ -0,0 +1,45 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const domain = require('domain');
+
+// Test that when a domain's error handler throws, the exception does NOT
+// recursively call the same domain's error handler. Instead, it should
+// propagate to the parent domain or crash the process.
+
+let d1ErrorCount = 0;
+let d2ErrorCount = 0;
+
+const d1 = domain.create();
+const d2 = domain.create();
+
+d1.on('error', common.mustCall((err) => {
+  d1ErrorCount++;
+  assert.strictEqual(err.message, 'from d2 error handler');
+  // d1 should only be called once - when d2's error handler throws
+  assert.strictEqual(d1ErrorCount, 1);
+}));
+
+d2.on('error', common.mustCall((err) => {
+  d2ErrorCount++;
+  // d2's error handler should only be called once for the original error
+  assert.strictEqual(d2ErrorCount, 1);
+  assert.strictEqual(err.message, 'original error');
+  // Throwing here should go to d1, NOT back to d2
+  throw new Error('from d2 error handler');
+}));
+
+d1.run(() => {
+  d2.run(() => {
+    // Emit an error on an EventEmitter bound to d2
+    const EventEmitter = require('events');
+    const ee = new EventEmitter();
+    d2.add(ee);
+
+    // This should:
+    // 1. Call d2's error handler with 'original error'
+    // 2. d2's error handler throws 'from d2 error handler'
+    // 3. That exception should go to d1's error handler, NOT d2 again
+    ee.emit('error', new Error('original error'));
+  });
+});