How to integrate pretty-error with Express.js?

Use it as middleware in the error handler; the README shows code to log errors with pe.render(err) after skipping node files and express packages for cleaner output.

Can pretty-error handle unhandled promise rejections?

Yes, but with caveats; for BlueBird, avoid start() and handle manually with process.on('unhandledRejection'), or use pretty-monitor for when.js, as noted in Troubleshooting.

What's the performance impact of using pretty-error?

It adds minimal overhead by formatting errors in real-time, but for high-throughput apps, consider disabling colors with withoutColors() or using it selectively to avoid slowdowns.

How to customize colors in pretty-error themes?

Use appendStyle() with CSS-like rules; specify colors like 'bright-white' and backgrounds, and adjust padding, as detailed in the theming section with examples.

pretty-error vs chalk for error formatting?

pretty-error focuses on structured stack trace formatting with themes, while chalk is for general terminal styling; choose pretty-error for readable error output and chalk for simple colorized text.

Does pretty-error work with TypeScript?

Likely yes, as it's a standard Node.js library, but the README doesn't mention TypeScript specifics, so check compatibility or use type definitions if available via DefinitelyTyped.

How to skip node_modules in pretty-error output?

Use skipPackage() for specific packages or skipPath() for directories; for example, pe.skipNodeFiles() skips core Node.js files, and you can filter further with callbacks.

Open-Awesome

pretty-error

MITCoffeeScript

A Node.js library that formats error stack traces into clean, readable, and customizable colored output.

GitHub

1.5k stars51 forks0 contributors

What is pretty-error?

pretty-error is a Node.js library that formats error stack traces into clean, colored, and readable output. It solves the problem of cluttered and hard-to-read error messages by applying syntax highlighting and structured layouts, making debugging faster and more intuitive.

Target Audience

Node.js developers who frequently debug applications and want clearer, more organized error output, especially those working in CLI tools or server-side frameworks.

Value Proposition

Developers choose pretty-error because it dramatically improves error readability with minimal setup, offers extensive customization through CSS-like theming, and integrates seamlessly into existing Node.js projects without disrupting core functionality.

Overview

See node.js errors with less clutter

Use Cases

Best For

Debugging Node.js applications with verbose stack traces
Creating cleaner error logs for CLI tools
Integrating formatted error reporting into Express.js apps
Customizing error output colors and layouts for team standards
Filtering out irrelevant packages from stack traces
Improving error visibility in development environments

Not Ideal For

Applications using BlueBird with Promise.longStackTraces() enabled, due to potential conflicts with global error modification
Production environments requiring raw, machine-parsable error logs for automated monitoring tools
Projects needing immediate, zero-configuration error formatting without manual integration steps

Pros & Cons

Pros

Clean Error Formatting

Transforms noisy stack traces into color-coded, structured output, as shown in the screenshot comparison, making debugging faster and more intuitive.

Extensive Customization

Allows CSS-like theming to style error elements, including colors, backgrounds, and padding, with examples in the README for creating minimal or brand-matching themes.

Flexible Integration

Supports global use via start() or per-error rendering, and integrates easily with frameworks like Express for centralized error logging, as demonstrated in the code snippets.

Advanced Trace Filtering

Provides methods to skip or modify trace lines by package, path, or callback, helping developers focus on relevant code without clutter.

Cons

Potential Library Conflicts

The start() method modifies all error stack traces globally, which can break packages like BlueBird, requiring manual workarounds as admitted in the Troubleshooting section.

Limited Async Support

Errors thrown in the first tick are not prettified unless startup is delayed with process.nextTick(), adding complexity for asynchronous code handling.

Customization Overhead

Creating custom themes requires understanding CSS-like rules and RenderKid, which might be non-trivial for developers unfamiliar with this approach.

Frequently Asked Questions

Related Projects

Tiny millisecond conversion utility

Stars5,531

Forks321

Last commit19 days ago

pretty-bytes

Convert bytes to a human readable string: 1337 → 1.34 kB

Stars1,299

Forks88

Last commit8 months ago

pretty-ms

Convert milliseconds to a human readable string: `1337000000` → `15d 11h 23m 20s`

Stars1,208

Forks66

Last commit7 months ago

read-art

Scrape/Crawl article from any site automatically. Make any web page readable, no matter Chinese or English.

Stars346

Forks36

Last commit7 years ago

Community-curated · Updated weekly · 100% open source

Found a gem we're missing?

Open-Awesome is built by the community, for the community. Submit a project, suggest an awesome list, or help improve the catalog on GitHub.

Submit a project Star on GitHub