Bug line

Raygun, Stack Hunter, Sentry, Takipi and Airbrake: Modern developer tools to help you crush bugs before bugs crush your app

With the Java ecosystem going forward, web applications serving growing numbers of requests and users’ demand for high performance – comes a new breed of modern development tools. A fast paced environment with rapid new deployments requires tracking errors and gaining insight to an application’s behavior on a level traditional methods can’t sustain. In this post we’ve decided to gather 5 of those tools, see how they integrate with Java and find out what kind of tricks they have up their sleeves. It’s time to smash some bugs.

Raygun

Mindscape’s Raygun is a web based error management system that keeps track of exceptions coming from your apps. It supports various desktop, mobile and web programming languages, including Java, Scala, .NET, Python, PHP, and JavaScript. Besides that, sending errors to Raygun is possible through a REST API and a few more Providers (that’s how they call language and framework integrations) came to life thanks to developer community involvement.

Raygun screenshots

Key Features:

  • Error grouping – Every occurrence of a bug is presented within one group with access to single instances of it, including its stack trace.
  • Full text search – Error groups and all collected data is searchable.
  • View app activity – Every action on an error group is displayed for all your team to see: status updates, comments and more.
  • Affected users – Counts of affected users appear by each error.
  • External integrations – Github, Bitbucket, Asana, JIRA, HipChat and many more.

The Java angle: To use Raygun with Java, you’ll need to add some dependencies to your pom.xml file if you’re using Maven or add the jars manually. The second step would be to add an UncaughtExceptionHandler that would create an instance of RaygunClient and send your exceptions to it. In addition, you can also add custom data fields to your exceptions and send them together to Raygun. The full walkthrough is available here.

Behind the curtain: Meet Robie Robot, the certified operator of Raygun. As in, the actual ray gun.

Check it out on: https://raygun.io

Find the Crap in Your Java App

Show me how >>

Fred

Sentry

Started as a side-project, Sentry is an open-source web based solution that serves as a real time event logging and aggregation platform. It monitors errors and displays when, where and to whom they happen, promising to do so without relying solely on user feedback. Supported languages and frameworks include Ruby, Python, JS, Java, Django, iOS, .NET and more.

Sentry screenshot

Key Features:

  • See the impact of new deployments in real time
  • Provide support to specific users interrupted by an error
  • Detect and thwart fraud as its attempted – notifications of unusual amounts of failures on purchases, authentication, and other sensitive areas
  • External Integrations – GitHub, HipChat, Heroku, and many more

The Java angle: Sentry’s Java client is called Raven and supports major existing logging frameworks like java.util.logging, Log4j, Log4j2 and Logback with Slf4j. An independent method to send events directly to Sentry is also available. To set up Sentry for Java with Logback for example, you’ll need to add the dependencies manually or through Maven, then add a new Sentry appender configuration and you’re good to do. Instructions are available here.

Behind the curtain: Sentry was an internal project at Disqus back in 2010 to solve exception logging on a Django application by Chris Jennings and David Cramer

Check it out on: https://www.getsentry.com/

Takipi

Unlike most of the other tools, Takipi is far more than a stack trace prettifier. It was built with a simple objective in mind: Telling developers exactly when and why production code breaks. Whenever a new exception is thrown or a log error occurs – Takipi captures it and shows you the variable state which caused it, across methods and machines. Takipi will overlay this over the actual code which executed at the moment of error – so you can analyze the exception as if you were there when it happened.

Takipi screenshot

Key features:

  • Detect – Caught/uncaught exceptions, Http and logged errors.
  • Prioritize – How often errors happen across your cluster, if they involve new or modified code, and whether that rate is increasing.
  • Analyze – See the actual code and variable state, even across different machines and applications.
  • Easy to install – No code or configuration changes needed.
  • Less than 2% overhead.

The Java angle: Takipi was built for production environments in Java and Scala. The installation takes less than 1min, and includes attaching a Java agent to your JVM.

Behind the curtain: Each exception type and error has a unique monster that represents it. You can find these monster here.

Check it out on: http://www.takipi.com/

Airbrake

Another tool that has put exception tracking on its eyesights is Rackspace’s Airbrake, taking on the mission of “No More Searching Log Files”. It provides users with a web based interface that includes a dashboard with error details and an application specific view. Supported languages include Ruby, PHP, Java, .NET, Python and even… Swift.

Airbrake screenshots

Key Features:

  • Detailed stack traces, grouping by error type, users and environment variables
  • Team productivity – Filter importance errors from the noise
  • Team collaboration – See who’s causing bugs and whose fixing them
  • External Integrations – HipChat, GitHub, JIRA, Pivotal and over 30 more

The Java angle: Airbrake officially supports only Log4j, although a Logback library is also available. Log4j2 support is currently lacking. The installation procedure is similar to Sentry, adding a few dependencies manually or through Maven, adding an appender, and you’re ready to start. Similarly, a direct way to send messages to Airbrake is also available with AirbrakeNotice and AirbrakeNotifier. More details are available here.

Behind the curtain: Airbrake was acquired by Exceptional, which then got acquired by Rackspace.

Check it out on: https://airbrake.io/

StackHunter

Currently in beta, Stack Hunter provides a self hosted tool to track your Java exceptions. A change of scenery from the past hosted tools. Other than that, it aims to provide a similar feature set to inform developers of their exceptions and help solve them faster.

StackHunter screenshot

Key Features:

  • A single self hosted web interface to view all exceptions
  • Collections of stack trace data and context including key metrics such as total exceptions, unique exceptions, users affected, & sessions affected
  • Instant email alerts when exceptions occur
  • Exceptions grouping by root cause

The Java angle: Built specifically for Java, StackHunter runs on any servlet container running Java 6 or above. Installation includes running StackHunter on a local servlet, configuring an outgoing mail server for alerts, and configuring the application you’re wishing to log. Full instructions are available here.

Behind the curtain: StackHunter is developed by Dele Taylor, who also works on Data Pipeline – a tool for transforming and migrating data in Java.

Check it out on: http://stackhunter.com/

Bonus: ABRT

Another approach to error tracking worth mentioning is used by ABRT, an automatic bug detection and reporting tool from the Fedora ecosystem, which is a Red Hat sponsored community project. Unlike the 5 tools we covered here, this one is intended to be used not only by app developers – but their users as well. Reporting bugs back to Red Hat with richer context that otherwise would have been harder to understand and debug.

ABRT

The Java angle: Support for Java exceptions is still in its proof of concept stage. A Java connector developed by Jakub Filák is available here.

Behind the curtain: ABRT is an open-source project developed by Red Hat.

Check it out on: https://github.com/abrt/abrt


Did we miss any other tools? How do you keep track of your exceptions? Please let me know in the comments section below

Further reading: 

7 New Tools Java Developers Should Know – Read more

Yoda

Join over 30,254 Java developers

Get new posts about Java, Scala and everything in between

Watch a live demo
Yoda
Some kind of monster @ OverOps, GDG Haifa lead.
  • http://blog.stackhunter.com/ Dele Taylor

    Thanks for the StackHunter mention Alex. You guys rock.

    • http://www.takipi.com/ Alex Zhitnitsky

      Thanks Dele! 🙂

  • Preet Shukla

    Appdynamics 🙂 It’s a brilliant performance management tool. Works with Java, .net, php, phython and even node.js . you need to attach an agent to your jvm.

    • http://www.takipi.com/ Alex Zhitnitsky

      Hi Preet, right, they’re more focused on performance. Check out this new post we published about them and New Relic:
      http://www.takipiblog.com/appdynamics-vs-new-relic-which-tool-is-right-for-you-the-complete-guide/

      • Preet Shukla

        Brilliant comparison Alex 🙂 Indeed a very details one. Great effort..Thanks 🙂

        BTW Appdynamics is moving toward HTML 5 so the drawback for Flash should soon be vanished.

        • http://www.takipi.com/ Alex Zhitnitsky

          Thanks Preet, good to hear about the HTML5 plans, where was it published?

  • Joshua Wold

    Thanks for the read. Wondering if you have had experience with Bugsnag as well and if so, what was your take?

  • Andreas Sewe

    Another error tracking tool Java developers may be interested in is Ctrlflow Automated Error Reporting.

    (Full disclosure: I’m the CTO of Codetrails, the company behind Ctrlflow.)

    Key Features:

    – Automatic deduplication: Similar error reports are presented within one group (called problem) with access both to a condensed stack trace summarizing all error reports in the group as well as access to the complete stack traces of individual reports.
    – Bug tracker integration: There’s no need to duplicate effort. You can first start triaging a problem in Ctrlflow Automated Error Reporting, later open a bug for it in your bug tracker, and then have any changes synchronized automatically between the two systems. (At the moment, Bugzilla, JIRA, and Github are supported.)
    – User comments: Users can send comments along with their error reports. They can also revisit their reports at a later time to add more details.
    – Talkback options: Whenever users report an error, they not only receive information about the current status of the underlying problem (perhaps it has been fixed in the meantime), but can also be asked for additional steps to reproduce.

    The Java angle: Ctrlflow Automated Error Reporting is optimized for Java (but works for any JVM language). A Logback appender is available, so you can silently send error reports from any Java application using SLF4J + Logback. But where Ctrlflow Automated Error Reporting really shines is complex desktop applications developed, e.g., using the Eclipse Rich Client Platform. Instead of using a fire-and-forget approach to error reporting, you can notify your users about problems, ask them for comments, and inform them when they encounter a problem that has been fixed already in your latest version.

    Behind the curtain: The Eclipse Automated Error Reporting Initiative relies on Ctrlflow Automated Error Reporting. Since Eclipse Mars (released in June 2015), more than 3 million reports by 350,000 Eclipse users have helped fix 8,000 problems in the Eclipse IDE.

    Check it out on: https://www.ctrlflow.com/automated-error-reporting/