unhandledrejection is not working for anonymous async function promises. Some code works in nodejs

[Lesiuk]

Deno (1.18.3)

import {delay} from "std/async/delay.ts";

globalThis.addEventListener("unhandledrejection", (error) => {
    console.error('unhandledRejection', error);
    e.preventDefault();
});

(async () => {
    throw 'failed';
})();


await delay(5_000);
console.log('success');

Node (19.1.0)

process.on('unhandledRejection', (error) => {
    console.error('unhandledRejection', error);
});

(async () => {
    throw 'failed';
})();

await new Promise((resolve) => setTimeout(resolve, 5_000));
console.log('success');

Result:
error: Uncaught "failed"

Expected:
success

[bartlomieju]

This works perfectly fine for me on Deno 1.28.3:

import {delay} from "https://deno.land/[email protected]/async/delay.ts";

globalThis.addEventListener("unhandledrejection", (e) => {
    console.error('unhandledRejection', e);
    e.preventDefault();
});

(async () => {
    throw 'failed';
})();


await delay(5_000);
console.log('success');

Handling of unhandledrejection was added in Deno v1.24, so earlier versions are not able to handle it properly.

[Lesiuk]

@bartlomieju 1.18.3 was a typo, I mean 1.28.3

I checked it and you are right. It works when running from empty directory. But it does not with my deno.lock file.

I created a repository which reproduces it.

[email protected]:Lesiuk/deno-unhandledrejection-reproduction.git

[Lesiuk]

@bartlomieju

[Lesiuk]

Even if I refresh the lock file, it still doesn't work.

[bartlomieju]

Interesting, I can indeed reproduce it with a lock file.

[bartlomieju]

After some debugging and discussion with @dsherret I pinpointed that this is caused by npm: imports, which suggests that it's related to Node compatibility layer. I will debug it further, as it's possibly related to #16628

[bartlomieju]

Digged a bit more and this is indeed coming from the Node compatibility layer, see:

  globalThis.addEventListener("unhandledrejection", (event) => {
      if (process.listenerCount("unhandledRejection") === 0) {
        // The Node.js default behavior is to raise an uncaught exception if
        // an unhandled rejection occurs and there are no unhandledRejection
        // listeners.
        if (process.listenerCount("uncaughtException") === 0) {
          throw event.reason;
        }

        event.preventDefault();
        uncaughtExceptionHandler(event.reason, "unhandledRejection");
        return;
      }

      event.preventDefault();
      process.emit("unhandledRejection", event.reason, event.promise);
    });

We're hitting the:

        if (process.listenerCount("uncaughtException") === 0) {
          throw event.reason;
        }

branch which causes the exception to be raised. I'm not sure what would be the best course of action here, @dsherret @cjihrig thoughts?

[bartlomieju]

Related #16943

[Lesiuk]

@bartlomieju Do you have any idea how we could fix this?

[bartlomieju]

We've discussed this and still debating how to do it without having to introduce a special API for Node compat layer, however we don't have any good ideas, so we might have to add a special API. This is still on my radar, but I had to switch to work on the release. I'll try to get it fixed before end of the year.

[kt3k]

How about adding a special API to get listener count of EventTarget?

const listenerCount = Symbol("listenerCount"); // only available to Deno internals
class EventTarget {
  ...
  /** Gets the count of listeners */
  [listenerCount](type: string)]: number {...}
}

And use it like:

if (process.listenerCount("uncaughtException") === 0 && globalThis[listenerCount]("unhandledrejection") === 0) {
  throw event.reason;
}

[piscisaureus]

Here's an idea (JK!):

import { delay } from "https://deno.land/[email protected]/async/delay.ts";

globalThis.addEventListener("unhandledrejection", (e) => {
  console.error("unhandledRejection");
  e.preventDefault();
});

window.addEventListener("error", (ev) => {
  console.error("snatched error:", ev.error);
  ev.preventDefault();
});

(async () => {
  throw "failed";
})();

await delay(2_000);
console.log("success");

output:

🦕 deno run -A unhandled.ts
snatched error: failed
success

[bartlomieju]

@piscisaureus both these event listeners are already installed by std/node so that's not really a viable solution. @kt3k's solution should work, but I'm worried about edge cases (that I admin I haven't come up with) that might not be sufficient - ideally we want to do "Node-style" handling at the very end, to let all user code event listeners handle it first.

[kt3k]

@bartlomieju

ideally we want to do "Node-style" handling at the very end, to let all user code event listeners handle it first.

That might also work. Do you suggest special event registration API like .addLastEventListener(type: string)? Or maybe define a special event which will be triggered after unhandledrejection, like afterunhandledrejection (accessible only from the internals)?

[bartlomieju]

@bartlomieju

ideally we want to do "Node-style" handling at the very end, to let all user code event listeners handle it first.

That might also work. Do you suggest special event registration API like .addLastEventListener(type: string)? Or maybe define a special event which will be triggered after unhandledrejection, like afterunhandledrejection (accessible only from the internals)?

I was suggesting a private API like: Deno[Deno.internal].node.unhandledRejectionHandler

[bartlomieju]

Note to self: error, beforeunload and unload events most likely suffer from the same problem.

[bartlomieju]

This should be much more approachable now with #17724 landed