Displaying 1 to 20 from 20 results

panicparse - Crash your app in style (Golang)

  •    Go

Parses panic stack traces, densifies and deduplicates goroutines with similar stack traces. Helps debugging crashes and deadlocks in heavily parallelized process.pp streams its stdin to stdout as long as it doesn't detect any panic. panic() and Go's native deadlock detector print to stderr via the native print() function.

Ben.Demystifier - High performance understanding for stack traces (Make error logs more productive)

  •    CSharp

.NET stack traces output the compiler transformed methods; rather than the source code methods, which make them slow to mentally parse and match back to the source code. The current output was good for C# 1.0; but has become progressively worse since C# 2.0 (iterators, generics) as new features are added to the .NET languages and at C# 7.1 the stack traces are esoteric (see: Problems with current stack traces).

TraceKit - Attempts to create stack traces for unhandled JavaScript exceptions in all major browsers

  •    Javascript

In order to get stack traces, you need to wrap your code in a try/catch block like above. Otherwise the error hits window.onerror handler and will only contain the error message, line number, and column number. You also need to throw errors with throw new Error('foo') instead of throw 'foo'.

RxJava2Debug - RxJava 2.x extension to provide meaningful Stack Traces

  •    Java

A library to make StackTraces involving RxJava2 more meaningful (they will always point to your code!). If you use RxJava2, you know the pain of debugging exceptions generated somwhere across the stream, in another thread, in a nested stream, ... The StackTrace provided by RxJava2 will tell you almost nothing. Even more, if you are using systems like Crashlytics to collect reports for and Android app, most RxJava-related crashes will be reported as a single error instance (omg, no way to fix that).




errorx - A comprehensive error handling library for Go

  •    Go

Conventional approach towards errors in Go is quite limited.

AsyncFriendlyStackTrace - Async-friendly format for stack traces and exceptions

  •    CSharp

Async-friendly format for stack traces and exceptions.This produces an async-friendly format, as you can see in the examples below. There is also special handling for AggregateExceptions and ReflectionTypeLoadException (which can contain multiple inner exceptions).

babel-plugin-source-map-support - A Babel plugin which automatically makes stack traces source-map aware

  •    Javascript

In conjunction with the source-map-support module, which must be installed separately, this statement hooks into the v8 stack-trace API to translate call sites in the transpiled code back to their corresponding locations in the original code. Note: this only works in environments which support the v8 stack-trace API (e.g. Node.js and Chrome), though it's harmless in other environments.

erroz - Create abstract errors with meta-data, stack-traces and speaking error-messages.

  •    Javascript

Typical strategies of parsing errors are fragile and couple code to the error messages. By defining error objects consistently, working with errors becomes predictable and efficient. The name displayed when the error is thrown.


trace - Creates super long stack traces

  •    Javascript

See https://trace.js.org for examples. Trace only works with node.js v8.x and newer. Use npm install trace@^2 for node.js v6 and v4.

error-subclass - 💣 A base class for creating custom JavaScript error classes

  •    Javascript

A JavaScript class that makes Error subclassable. It inherits from Error (in all the right ways), so that you can safely and easily create your own Error subclasses. The provided class handles all the craziness for preserving stack traces and other things so that you don't have to worry about it. Create a class that inherits from it and you're good to go.

ghc-stack - Hacking GHC's Stack for Fun and Profit (featuring The Glorious Haskell Debugger v0

  •    C++

This document explains how to look at the stack of a GHC compiled Haskell program, and why that might be of interest even to somebody who's not a GHC hacker. Spoiler: It's a basic building block for many kinds of debugging and profiling tools. The code / explanations here are for OS X with 32bit GHC 7.6.3 and gcc 4.2.1, but I'll mention relevant differences to make this apply on a different platform / GHC / architecture as well. Just be alert about different word and pointer sizes, register names and calling conventions.

useless - Use Less. Do More. JavaScript on steroids.

  •    Javascript

In near future, it will be split into several loosely coupled, clean and maintainable NPM modules, for everyone's convenience. Stay tuned. You can override config with command line args, e.g. node example webpack.offline=false, using server/config.js trait.

stack-trace-art - The art of throwing exceptions that turn stack traces into beautiful images

  •    CSharp

Stack Trace Art is the art of throwing exceptions that create beautiful drawings on callers' stack traces. You can read more about its origin in my original blog post on Stack Trace Art. All these beautiful pieces of art are taken from the stackTraceangelo Art Gallery.

pos - Macro based print debugging. Locates debug statements in your IDE.

  •    Scala

pos, short for position, is a hyperlink based print debugging library designed to work with any IDE or text editor that supports stack trace highlighting. Using compile-time macros in Scala to extract file names and line numbers, pos makes your print statements, assertions, and log statements easier to locate. Use it to append a "smart" hyperlink to your sourcecode, avoiding the need to "grep" or use "Ctr + F" to locate print statements. Use pos instead of System.out.println or System.err.println. ^ Clicking on the compile-time generated file name and line number will cause you to jump to that line in your source code.

scala-trace-debug - Macro based print debugging. Locates log statements in your IDE.

  •    Scala

scala-trace-debug is a hyperlink based print debugging system designed to work with any IDE or text editor that supports stack trace highlighting. It had its origins in a print debugging system developed in Java for undergrads, and evolved into something production ready. Using compile-time macros in Scala and run-time switches in Java, scala-trace-debug makes your print statements and assertions easier than ever to locate. Use it to append a "smart" hyperlink to your sourcecode, avoiding the need to "grep", and turn it off by recompiling with the ENABLE_TRACE_DEBUG environment variable set to false. Write smart print statements and assertions that print out your source code. Never use System.out/err.println again. ^ Clicking on "Main.scala:12" will cause you to jump to Main.scala, line 12.

exception.vim - Vim plugin for tracing exceptions thrown by VimL scripts.

  •    Vim

Vim plugin for tracing exceptions thrown by VimL scripts. The most recent exceptions are parsed and displayed in the QuickFix window. Call exception#trace() to display the call stack for the most recent exceptions. After that, use the QuickFix commands to move through the stack.