project. It was started by the primary contributors to node.js but in the first few months attracted more active developers than the node.js project has had in its entire history.
Scoped and safe extensions myIterable[Symbol.iterator]; // Native promises (more on those later) getFoo(arg).then(function(val){ // no error param //throw Error("Promises are throw safe"); return val + 1; // can also return a promise });
operation has not yet completed. - fulfilled (value) - operation completed successfully. - rejected (error) - an error condition occurred Once a promise changes state it can’t change state again - If a promise is fulfilled with 1 it will forever stay that way.
15); // return promise or value }).then(function(bar){ return getBaz(bar, 10); // can throw here, throw safe }).catch(function(err){ // like a sync try/catch // handle error across the chain in one place - no (err, res) });
(in any method) JSON.parse(j); // still throws - invalid JSON x.y.z(j); // what if no y property? // ... actual processing }).then(function(val){ // this never executes - I don't know why - no notification });
(in any method) JSON.parse(j); // still throws - invalid JSON x.y.z(j); // what if no y property? // ... actual processing }).done(); // throw on rejection - not in ES2015 promises
2013 I flew to Finland to a month. There, I met a fellow user and chat friend Petka. Petka was very upset about the performance and debuggability of promises at the time.
using any type of promises: // I need this to find out about unhandled rejections process.on("unhandledRejection", function(reason, p){ … }); // I need this to find out about false positives process.on("rejectionHandled", function(p){ … });
promise libraries such as bluebird and when as well as some native promise implementations offer potentially unhandled rejection tracking. This means that the following: Promise.reject(new Error("err")); // never attach a `catch` Does not get silently suppressed being an error but instead gets logged to the console or otherwise treated by the promise library. A common request is a way to handle rejection application wide. NodeJS code often includes several copies of the same promise library or different promise libraries and it is currently difficult to install a global hook on potentially unhandled rejections. For example code using Bluebird for concurrency, akamai for their API, bookshelf as an ORM and request- promise for web requests uses 4 promise libraries already - 3 Bluebirds and a WhenJS. If someone wants to log errors for
Bluebirds and a WhenJS. If someone wants to log errors for all tracked unhandled rejections they'd have to add at least four handlers - if they miss any their code won't do what they expect. This document attempts to offer a standard way for promise libraries and potentially native promises in Node to communicate they have detected an unhandled rejection. The hook In order to handle rejections the following new events will be fired on process: Event 'unhandledRejection': Emitted whenever a possibly unhandled rejection is detected. This event is emitted with the following arguments: • reason the rejection reason of the promise susprected in having an unhandled rejection • p the promise suspected in having an unhandled rejection itself. process.on('unhandledRejection', function(reason, p){ console.log("Possibly Unhandled Rejection at: Promise ", p, " reason: ", reason);
reason); // application specific logging here }); Event 'rejectionHandled': Emitted whenever a possibly unhandled rejection was mistakenly identified and was eventually handled. For example if the promise library made a mistake considering p in the following case unhandled: let p = Promise.reject(new Error("err")); setTimeout(() => p.catch(function(){}), 86400); This event is emitted with the following arguments: • p the promise who was believed to be an unhandled rejection. This event is useful in order to recover from detection mistakes. While in my experience this rarely happens in practice this additional hook helps in such cases.
one is currently firing events by these names in NodeJS code in GitHub. In other languages Promises as an abstraction are indeed not unique to JavaScript - let's explore what other languages do. • in C# 4.0 and .NET in general - such a hook exists for Task with an unterminated error handler will crash your application unless you add a TaskScheduler.UnobservedTaskException event handler. In 4.5 you can handle errors yourself (like .catch). • In Scala it used to silent fail (lots of surprised answers in SO - e.g.http://stackoverflow.com/questions/24453080/) but that upset peoplehttps://groups.google.com/forum/#!searchin/scala- user/The$20silence$20of$20failed$20futures/scala-user/1X2QISf3604/2dw0XhMh0RUJ , they now intend to support that case. • Dart futures already do this forwarding rejections to the global error handler.
unhandled rejection hander. Note that JavaScript is pretty special in that it is the only case I know of where a lot of different implementations of this abstract concept exist. Statistics These are usage statistics about events current libraries already fire. These usage examples were collected from public GitHub projects using bluebird promises offering (non-global) hooks. First a summary of bluebird's onPossiblyUnhandledRejection from GitHub. Large (>1000 stars) libraries typically don't change onPossiblyUnhandledRejection, the largest ORMS: Sequelize, Waterline and Bookshelf do not hook on it however users of those libraries sometimes do. It also very common for people to override it in test code. Here are libraries and projects using onPossiblyUnhandledRejection in their code: • https://github.com/FelisCatus/SwitchyOmega (843 stars, proxy switch, custom logger) • https://github.com/AppGyver/steroids (237 stars, PhoneGap extension, throw and crash) • https://github.com/att/rcloud (153 stars, AT&T R script cloud thing, defaults to custom logging) • https://github.com/simplyianm/githubfollowers/ (101 stars, defaults to log and adds a console log, rather pointless call)
https://github.com/martin-liu/m- sails/blob/f02f33a60c424517168b365c0c61da4ad85b8ba6/api/coffee/services/Promise.coffee(0 stars, personal project) • https://github.com/danprince/cyvasse (Game, 0 stars, undefined passed to get Q like behavior, lots (100) like this using bundler.js) Future work Add a similar solution for promise libraries in browsers, possibly the WhatWG proposal. Related work: • Promise Inspection Protocol • Bluebird's onPossiblyUnhandledRejection • WhatWG browser proposal
iojs/io.js (now nodejs/io.js) repositories. NodeJS: Consider exposing unhandled rejection hook Jan 8th Anyone? Jan 22th Would you at least backport this from io.js? Feb 8th
iojs/io.js (now nodejs/io.js) repositories. io.js: Consider exposing unhandled rejection hook Jan 8th I like this idea, what about… Jan 8th Sounds good, what should the behavior be on X? Jan 8th
iojs/io.js (now nodejs/io.js) repositories. io.js: Here are some clarifications Jan 8th Nice idea, I made an attempt at a PR Jan 8th Some clarification Jan 8th
iojs/io.js (now nodejs/io.js) repositories. io.js: Here are some clarifications Jan 8th Nice idea, I made an attempt at a PR Jan 8th Some clarification Jan 8th
for promises as specified in https://gist.github. com/benjamingr/0237932cee84712951a2 Fixes #256 commit a81693e964fbe3441ce34ac66fbf19cfb78620871 parent e80f803 petkaantonov authored on Feb 8
yuuuuuuu168
takahashim
terapyon
koukihosaka
teamlab
mhrtech
makocchi
satomasahiro2005
y0hgi
willnet
pfn
rfdnxbro
marcoroth
davidcarrasco
szymonslowik
iamctodd
reverentgeek
philnash
smashingmag
hatefulcrawdad
ammeep
sabderemane
destraynor
madoxten
![Promises Promises are easy to aggregate: Promise.all([getFoo(), getBar()]).then(function(results){ // both](https://files.speakerdeck.com/presentations/da15a279e9b0478292e4d3a3d0131412/slide_46.jpg){kind=link}
