Crash Reporting for Electron

Electron apps fail in two languages at once. There's the JavaScript layer, where you get exceptions and stack traces that look familiar. And there's the native layer underneath, the Chromium and Node internals, where a crash dumps a minidump that has nothing to do with your .js files. A crash reporting setup that only watches one of those layers is going to miss half of what takes your app down.

BugSplat watches both. Native crashes in the main or renderer process get captured as minidumps and symbolicated into real call stacks. JavaScript errors get reported with their own stack traces. Both land in the same dashboard, grouped, versioned, and sorted by how often they're happening, so you're not switching tools to figure out which layer broke.

The two layers, and why you want both

The native side is where the scary crashes live: a segfault deep in Chromium, a bad native module, an out-of-memory kill. Electron's built-in crash reporter produces a minidump for these, and BugSplat turns that minidump into a stack trace with function names instead of a hex address salad.

The JavaScript side is where most of your day-to-day bugs actually are: an unhandled rejection, a thrown error in a handler, the thing that breaks one feature without taking down the window. You want those reported too, with the stack trace pointing at your code.

Catching only native crashes means you miss the JS errors that frustrate users without crashing the app. Catching only JS means you're blind when Chromium itself falls over. BugSplat reports both, which is the only setup that actually reflects how an Electron app fails.

Setup, briefly

You configure Electron's crash reporter to upload minidumps to your BugSplat database URL, and you add BugSplat's Node integration to catch JavaScript errors, including unhandled promise rejections, which are easy to forget and account for a surprising share of real-world failures. For symbolicated native stacks you'll upload symbols for the Electron version you're shipping against. Our docs walk through both halves, and because the Node and native pieces are documented separately, you can stand up JS error reporting in minutes and add native symbolication when you're ready.

The payoff

An Electron app is a desktop app wearing a web app's clothes, and it fails like both. The teams that get burned are the ones who treated it like a pure web app and only watched the JavaScript. When the native layer crashes on a user's machine, they had nothing. Set up both and you've got the full picture: every way your app can die, in one place, readable without a debugger.

That's the bar we hold ourselves to. Crash data you can actually act on, whichever layer it came from.

Electron setup is in the docs: docs.bugsplat.com

Want to see your own crashes, both layers? Start a free trial and send your first report.