stacktrace-js

What is stacktrace-js?

The stacktrace-js package is a JavaScript library that provides stack traces for debugging JavaScript applications. It helps developers to better understand and debug their code by providing detailed information about the call stack when an error occurs.

What are stacktrace-js's main functionalities?

Generating stack traces

This feature allows developers to generate and capture stack traces within their applications. The code sample demonstrates how to obtain a stack trace and convert it into a readable string format.

StackTrace.get().then(function(stackframes) { var stringifiedStack = stackframes.map(function(sf) { return sf.toString(); }).join('\n'); console.log(stringifiedStack); });

Instrumenting functions to automatically attach stack traces

This feature automatically attaches stack traces to errors thrown in instrumented functions. The code sample shows how to instrument a function and handle errors with attached stack traces.

function foo() { throw new Error('Bazinga!'); } foo = StackTrace.instrument(foo, function(stackframes) { var stringifiedStack = stackframes.map(function(sf) { return sf.toString(); }).join('\n'); console.log(stringifiedStack); }, function(err) { console.log(err.message); }); foo();

Other packages similar to stacktrace-js

error-stack-parser

This package parses JavaScript Error stacks. It is similar to stacktrace-js but focuses more narrowly on parsing existing error stacks rather than generating new ones or instrumenting functions.

stack-generator

Stack Generator provides a way to generate artificial backtraces to help simulate stack traces. While stacktrace-js captures real stack traces, stack-generator is useful for creating synthetic stack traces for testing or debugging purposes.

README

stacktrace.js

Framework-agnostic, micro-library for getting stack traces in all web browsers

Debug and profile your JavaScript with a stack trace of function calls leading to an error (or any condition you specify).

stacktrace.js uses browsers' Error.stack mechanism to generate stack traces, parses them, enhances them with source maps and uses Promises to return an Array of StackFrames.

Upgrading? Check the 0.x -> 1.x Migration Guide

Usage

Get a stack trace from current location

var callback = function(stackframes) {
    var stringifiedStack = stackframes.map(function(sf) { 
        return sf.toString(); 
    }).join('\n'); 
    console.log(stringifiedStack); 
};

var errback = function(err) { console.log(err.message); };

StackTrace.get().then(callback).catch(errback)
=> Promise(Array[StackFrame], Error)
=> callback([StackFrame('func1', [], 'file.js', 203, 9), StackFrame('func2', [], 'http://localhost:3000/file.min.js', 1, 3284)])

window.onerror integration

Automatically handle errors

window.onerror = function(msg, file, line, col, error) {
    // callback is called with an Array[StackFrame]
    StackTrace.fromError(error).then(callback).catch(errback);
};

Get stack trace from an Error

var error = new Error('BOOM!'); 

StackTrace.fromError(error).then(callback).catch(errback)
=> Promise(Array[StackFrame], Error)

Generate a stacktrace from walking arguments.callee

This might capture arguments information, but isn't supported in ES5 strict-mode

StackTrace.generateArtificially().then(callback).catch(errback)
=> Promise(Array[StackFrame], Error)

Trace every time a given function is invoked

// callback is called with an Array[StackFrame] every time wrapped function is called
var myFunc = function(arg) { return 'Hello ' + arg; }
var myWrappedFunc = StackTrace.instrument(myFunc, callback, errback)
=> Instrumented Function
myWrappedFunc('world');
=> 'Hello world'

// Use this if you overwrote you original function
myFunc = StackTrace.deinstrument(myFunc)
=> De-instrumented Function

Get stacktrace.js

npm install stacktrace-js
bower install stacktrace-js
component install stacktracejs/stacktrace.js
http://cdnjs.com/libraries/stacktrace.js

API

StackTrace.get(/*optional*/ options) => Promise(Array[StackFrame])

Generate a backtrace from invocation point, then parse and enhance it.

(Optional) options: Object

• filter: Function(StackFrame => Boolean) - Only include stack entries matching for which filter returns true
• sourceCache: Object (String URL => String Source) - Pre-populate source cache to avoid network requests
• offline: Boolean (default: false) - Set to true to prevent all network requests

StackTrace.fromError(error, /*optional*/ options) => Promise(Array[StackFrame])

Given an Error object, use error-stack-parser to parse it and enhance location information with stacktrace-gps.

error: Error

(Optional) options: Object

• filter: Function(StackFrame => Boolean) - Only include stack entries matching for which filter returns true
• sourceCache: Object (String URL => String Source) - Pre-populate source cache to avoid network requests
• offline: Boolean (default: false) - Set to true to prevent all network requests

StackTrace.generateArtificially(/*optional*/ options) => Promise(Array[StackFrame])

Use stack-generator to generate a backtrace by walking the arguments.callee.caller chain.

(Optional) options: Object

• filter: Function(StackFrame => Boolean) - Only include stack entries matching for which filter returns true
• sourceCache: Object (String URL => String Source) - Pre-populate source cache to avoid network requests
• offline: Boolean (default: false) - Set to true to prevent all network requests

StackTrace.instrument(fn, callback, /*optional*/ errback) => Function

• Given a function, wrap it such that invocations trigger a callback that is called with a stack trace.

• fn: Function - to wrap, call callback on invocation and call-through

• callback: Function - to call with stack trace (generated by StackTrace.get()) when fn is called

• (Optional) errback: Function - to call with Error object if there was a problem getting a stack trace. Fails silently (though fn is still called) if a stack trace couldn't be generated.

StackTrace.deinstrument(fn) => Function

Given a function that has been instrumented, revert the function to it's original (non-instrumented) state.

• fn: Function - Instrumented Function

StackTrace.report(stackframes, url) => Promise(String)

Given an Array of StackFrames, serialize and POST to given URL. Promise is resolved with response text from POST request.

Example JSON POST data:

{
  stack: [
    {functionName: 'fn', fileName: 'file.js', lineNumber: 32, columnNumber: 1},
    {functionName: 'fn2', fileName: 'file.js', lineNumber: 543, columnNumber: 32},
    {functionName: 'fn3', fileName: 'file.js', lineNumber: 8, columnNumber: 1}
  ]
}

• stackframes: Array(StackFrame) - Previously wrapped Function
• url: String - URL to POST stack JSON to

Browser Support

HEADS UP: You won't get the benefit of source maps in IE9- or other very old browsers.

Using node.js/io.js only?

I recommend the stack-trace node package specifically built for node. It has a very similar API and also supports source maps.

Contributing

This project adheres to the Open Code of Conduct. By participating, you are expected to honor this code.

Want to be listed as a Contributor? Start with the Contributing Guide!

This project is made possible due to the efforts of these fine people:

• Eric Wendelin
• Victor Homyakov
• Oliver Salzburg
• Many others

Changelog

v1.1.0

Better parsing

Updated error-stack-parser to v1.3 which parses eval stack entries in a better way and fixes a bunch of bugs.

Better resource handling

Updated stacktrace-gps. Now reuses the same instance to avoid duplicate requests for the same resource by default.

Better dev experience

JSCS and automated PR testing have been implemented to ensure consistent styles and quick feedback.

Possibly breaking changes: ErrorStackParser now provides it's own polyfill for Array.map and Array.filter. eval information is will display differently in stack traces.