Stack traces are available by default in most modern browsers
Most modern browsers provide stack traces without having to do any extra work. Errorception makes the most of this, and gives you stack traces when possible.
error.stack (or some similar property depending on the browser) can be accessed to get at the stack trace.
This means that when you send errors to Errorception using
_errs.push, since you are handing over an
Error object to Errorception, you will have access to the stack trace in most cases.
Browser support: All browsers except older versions of IE provide a stack trace if you have an error object. In IE <10, it is simply impossible to get stack traces in Internet Explorer, using any method at all.
This doesn't stop Errorception from trying to get stack traces, of course. :) Errorception tries its best even in older IEs, to build a stack trace. Read more about call stacks in IE.
window.onerror as its primary mechanism of catching errors. However, traditionally,
window.onerror hasn't received an
Error object. As a result,
window.onerror hasn't had access to stack traces, and has suffered a bad rap as a result.
However, there was recently a change made to the HTML spec to pass a valid
Error object to
window.onerror. Errorception fully supports this, and uses the error object to extract stack traces.
Browser support: Chrome and Firefox rolled this out in their public builds around November 2013. That's ages ago in browser years! IE doesn't support this yet, but I've been keeping an eye on them, and I'm confident that the next release of IE will provide error objects. Webkit is still to catch up here, and stack traces aren't currently available with
window.onerror in Webkit.
When you copy/paste Errorception's snippet to your site, Errorception uses the
window.onerror approach by default. In addition to this, you could also send errors to Errorception using
_errs.push, which will also give you stack traces in your errors. However, it's admittedly some extra work. Is it worth it?
I recommend that you start with the vanilla
window.onerror approach — the one that Errorception provides by default when you copy/paste the script snippet. If you come across an error that absolutely needs a stack trace to debug, but doesn't already have one, you could consider using
_errs.push for just that part of your code.
That way, neither do you need to make any code changes preemptively, nor does Errorception need to wrap all browser/library native methods to get error objects. It's worth considering that Errorception deduplicates errors rather intelligently. So, if any one error occurrence has a stack trace, you already have what you want. When all of this fails, and the error isn't in IE <10, is when I'd consider using