A small tool to see node.js errors with less clutter:
... which is more readable compared to node's unformatted errors:
Install with npm:
$ npm install pretty-error
Usage and Examples
To see an error rendered with colors, you can do this:
var PrettyError = ;var pe = ;var renderedError = pe;console;
Of course, you can render caught exceptions too:
But if you want pretty-error to render all errors, there is a shortcut for it:
... which is essentially equal to:
var PrettyError = ;// instantiate PrettyError, which can then be used to render error objectsvar pe = ;pestart;
You can also preload pretty-error into your code using node's
$ node --require pretty-error/start your-module.js
How it Works
PrettyError turns error objects into something similar to an html document, and then uses RenderKid to render the document using simple html/css-like commands. This allows PrettyError to be themed using simple css-like declarations.
PrettyError's default theme is a bunch of simple css-like rules. Here is the source of the default theme.
Since the default theme is all css, you can customize it to fit your taste. Let's do a minimal one:
// the start() shortcut returns an instance of PrettyError ...pe = start;// ... which we can then use to customize like this:pe;
This is how our minimal theme will look like:
Read RenderKid's docs to learn about all the css rules that are supported.
There are a few methods to help you customize the contents of your error logs.
Let's instantiate first:
PrettyError = ;pe = ;// or:pe = start;
You might want to substitute long paths with shorter, more readable aliases:
You might want to skip trace lines that belong to specific packages (chai, when, socket.io):
Skipping node files
// this will skip node.js, path.js, event.js, etc.pe;
Skipping by callback
You can customize which trace lines get logged and which won't:
Modifying each trace line's contents
pe; // Errors will be rendered without coloring
Integrating with frameworks
PrettyError is very simple to set up, so it should be easy to use within other frameworks.
Most frameworks such as express, catch errors automatically and provide a mechanism to handle those errors. Here is an example of how you can use PrettyError to log unhandled errors in express:
// this is app.jsvar express = ;var PrettyError = ;var app = ;app;var server = app;// we can now instantiaite Prettyerror:pe = ;// and use it for our app's error handler:app;// we can optionally configure prettyError to simplify the stack trace:pe; // this will skip events.js and http.js and similar core node filespe; // this will skip all the trace lines about express` core and sub-modules
PrettyError.start() modifies the stack traces of all errors thrown anywhere in your code, so it could potentially break packages that rely on node's original stack traces. I've only encountered this problem once, and it was with BlueBird when
Promise.longStackTraces() was on.
In order to avoid this problem, it's better to not use
PrettyError.start() and instead, manually catch errors and render them with PrettyError:
var PrettyError = ;var pe = ;// To render exceptions thrown in non-promies code:process;// To render unhandled rejections created in BlueBird:process;// While PrettyError.start() works out of the box with when.js` unhandled rejections,// now that wer'e manually rendering errors, we have to instead use npmjs.org/packages/pretty-monitor// to handle when.js rejections.
The only drawback with this approach is that exceptions thrown in the first tick are not prettified. To fix that, you can delay your application's startup for one tick:
// (continued form above)throw ; // not prettifiedprocess;