Event Based Reporting System Coming in Version 2.0

Event Based Reporting SystemWe hinted that more details on the upcoming Exceptionless 2.0 release would get announced soon, and here we are! Lets dive in a bit further, shall we?

Many users have asked for ways to use Exceptionless to report additional types of events, rather than just errors. With version 2.0, we are moving to an event based system that will accommodate such requests.

What's an Event Based Real-Time Reporting Tool Look Like? #

  • The new system allows us to receive literally any data people want to send us instead of only allowing errors.
  • Event posts can be as simple as this:
    Post Event Exceptionless
  • You can send log messages or even entire log files.
  • Log messages can contain extended data objects just like errors can now.
  • You can post random JSON objects and the data within them will be treated as extended data.
  • You can post batches of events instead of only being able to send one at a time.
  • You can send feature usage events that let you see how often features of your application are being used. Think about how useful that will be!
  • You can send session start and end events that will enable you to know what percentage of users are affected by errors and enable you to better know what your priorities should be.
  • We will be gathering enough data to make it easy for us to begin putting together some very useful analytic reports.

We're pretty excited about the switch from error-only to send-us-any-event-you-can-think-of real-time reporting, logging, and notifications. We think it's going to be awesome, and it's almost scary how much of a playground Exceptionless is going to turn into for some of our customers. We're not pushing the limits, we're pushing for no limits!

Ideas? Concerns? Let us know. We're working hard to wrap up Exceptionless 2.0, but there's still a lot more bells and whistles we're polishing before launch! Keep an eye out for still more sneak peek material in the coming weeks!

Exceptionless 2.0 - In the Making

Exceptionless Version 2.0 Sneak PeekIt may seem quiet in Exceptionless land, but the truth is we've been writing, and re-writing, more code than you can point a cursor at. If it weren't a labor of love, our fingers would have mutinied long ago, but luckily they are in it for the long haul and are churning out some seriously sweet new features and rewrites.

Exceptionless 2.0 will include many of the feature requests that have come in since we launched, and will drastically expand on the current functionality. We know you'll love it, so continue reading for a high level view of what's coming in the near future.

Event Based System #

Many users have asked for ways to use Exceptionless to report additional types of events, rather than just errors. With 2.0, we are moving to an event based system that will accommodate this.

API Simplified #

Since going open source, we've wanted to simplify the API and make it easier to work with. We're taking the time to do it now, and it's going to be awesome. Watch out!

Pluggable System #

Plugins will allow customization and translation throughout the Exceptionless platform, including integration with third-party services and more.

Client Rewrite #

The client is being re-written be highly simplified and extensible, opening up platform support and ease of functionality additions.

Coming Soon #

Version 2.0 is coming soon. In the mean time, look for more details and sneak peeks containing examples of functionality and usage. We can't wait to show the world!

Don't forget to follow along with the development on GitHub and watch Exceptionless 2.0 while it's being built!

Web Application Errors and the 80-20 Rule

Most Frequent ErrorsYou know the 80-20 rule. The one marketers, managers, bigwigs, writers, speakers, and everyone else references to tell you what to focus on or why the widgets aren't selling like they should.

Well, as painful as it might be to hear the rule applied to yet another scenario, we're here today to let you know that 80-20 can be applied, in many cases, to your code's exceptions as well. 

20% of Errors Cause 80% of Exception Instances #

That's not so bad, is it?

All we're trying to point out is that when you start tracking and organizing the errors in your code, inevitably you'll start to realize that a small percentage of bugs are causing the majority of your total errors.

What we did about it #

We realized this ourselves, so we built the "Most Frequent Errors" report right into the Exceptionless dashboard.

When you log into your account, you immediately see which errors are causing the largest number of exceptions, how many instances of each there is, when the first occurrence was, and when the last occurrence was.

From there, you can click in, view there error's details, and hopefully find a quick resolution to the problem.

Most Frequent <> Most Important #

While it's great to chip away at the most frequent errors, it's worth pointing out that most frequent doesn't always mean most important, so be sure to focus on bottom line, customer facing, and major functionality issues first!

Have You Observed the 80-20 in the Wild? #

In your coding adventures, have you found the 80-20 rule to apply to your exceptions? Was it something you found quickly, or did you track down numerous instances of the same error before realizing it?

A Few Recent Exceptionless Case Studies

Error Stack Dashboard

We like to know how Exceptionless is helping its users, and we love it when we get feedback! Every once in a while, we like to share a story or two so we can drive home the benefits of having a real-time exception logging service tied into code projects.

Surveys are sometimes sent out to users, and we wanted to share a few recent responses.

Exceptionless Case Study Questions #

  • What is the number one customer-facing bug that Exceptionless has helped you track down? Can you give us a brief description of the bug and how you solved it?

  • User 1: "Missing DLLs in the client environment, due to required 3rd party apps not being installed (eg: Crystal Reports runtime). [Exceptionless] enabled me to create a list of missing DLLs and computers for relay to the client."

  • User 2: They were previously handling their own exception logging well and don't have any serious customer-facing errors coming in.

  • When you first started using Exceptionless, were you surprised by the number of errors that were being reported? Approximately how many were you seeing per day?

  • User 1: "Not really, but just because I had written a similar tool that logged these before, they just were not as accessible (database table on web service)." The user reported that the above bug was appearing 10-15 times each day.

  • User 2: They were already handling their error logging and already had errors down to a minimum, around 50 per month. "The primary reasons that we switched to Exceptionless from our own code is that Exceptionless captures additional detail (including code line numbers), Exceptionless has a better interface and design for reviewing and managing errors and bugs (including summary views that we didn’t previously have), and we no longer need to maintain our own error-logging code."

  • What is the number one internal bug that Exceptionless has helped you track down? Can you give us a brief description of the bug and how you solved it?

  • User 1: N/A

  • User 2: "...a small number of situations where our code doesn’t correctly handle empty record sets (that is, where, based on the specific query string parameters in the URL, no corresponding records are found in the database and the page is expecting that there will always be records to display)."

  • What is the number one feature request or change that you would like to see the Exceptionless Team tackle?

  • User 1: "More options to filter dashboard by tags/versions/environment variables. Custom reporting, exporting to CSV file etc or other way to import them into TFS or similar."

  • User 2: "...my number one request is probably for additional information in daily summary emails and for a combined daily summary. Notification defaults and moving notification settings out of the project setup is probably a close second; or perhaps the ability to add comments when marking an issue as fixed would be my second highest feature request."

  • If you have any other other examples of Exceptionless helping you squash bugs, please share them below - we would love to hear them!

  • User 1: N/A

  • User 2: "...in our small team, the additional information from Exceptionless (as well as the process of converting to Exceptionless) has prompted us to review and solve a few ongoing bugs that we were aware of..."

What has Exceptionless Done for You? #

If you use Exceptionless to log, report, organize, and squash errors in your code, we want to hear how it helps, what kind of crazy errors you are eliminating, and your general thoughts on the project! Don't be shy, we won't bite.

Thanks to Philip with the Beth Israel Deaconess Medical Center and Michael with Customer Logic for their case study contributions. We appreciate it guys!

Exception Handling & Logging Tool for ASP.NET, Web API, WebForms, WPF, Console, MVC, and more

Visual .NET Exception GraphHaving a handle on your code's errors is important. Thousands, if not millions, of exceptions are thrown every day in production code without anyone knowing. These errors might be affecting the bottom line, or they could be negligible - either way, it's important to know that they exist, how often they are occurring, and what parts of the app are affected.

Are you looking for a comprehensive tool that handles logging, reporting, grouping, and notifications for exceptions in your ASP.NET, Web API, WebForms, WPF, Console, MVC, or NancyFX app? Exceptionless does all that, and more. Lets take a look.

Who is Exceptionless for? #

Exceptionless is for developers and dev teams that want to have enhanced visibility of errors, track down bugs faster, tighten up code, and produce a better overall product for the end user.

Currently, the platform is .NET based and has client support for ASP.NET, Web API, WebForms, WPF, Console, MFC, and NancyFX. Soon, we will support clients for JavaScript, PHP, Ruby on Rails, Java, Python, and more. Developers are welcome to work on supporting other technologies, as well. Contributors receive free hosting credits!

Take the Tour #

Grouping Error DashboardIn a nutshell, Exceptionless provides a dashboard, detailed error reports, custom object handling, intelligent error grouping, email notifications, and a fluent API for sending manual error reports.

Take a look at the tour page for more details on each feature, and follow the the links at the end of each section to read even more about each. Specifically, make sure to check out the in-depth look at the Exceptionless project portal blog post. It has screenshots and explanations for each feature.

Feel free to contact us with any questions, or sign up and take it for a test drive - implementation takes minutes!

Open Source - Host it Yourself or with Us #

Back in February, we went open source, allowing developers that have the resources and infrastructure to host Exceptionless for free. Since then, we've had several contributors to the project and more than 50 forks. Pretty exciting stuff!

We offer extremely reasonable hosting services for those that would prefer we handle that side of things. The single user, single project hosting account is free, then the small team account starts at $15 per month. Pricing scales from there. Check out the Pricing Plans page for full pricing details and frequently asked questions.

Intelligent App Error Grouping Helps Organize Your Exceptions

Exception Grouping TotalsHaving a tool like Exceptionless to report and log your software's errors is great, but many of our clients experience thousands of instances of each error over various lengths of time, which can become overwhelming quickly.

We couldn't just leave them with a huge list of individual error occurrences to drudge through, so we went through several different potential options until we devised the best way to group them.

Grouping Errors Intelligently #

What's there to group by? #

  1. The details we provide on each error give us countless ways to group them. While some wouldn't make sense, we considered everything.
  • Date
  • Type
  • Message
  • Platform
  • Location
  • Browser information
  • User information
  • Environment information
  • Request details
  • and more...

Drill down fast #

Since we use Exceptionless to report and track down our own bugs, it was easy to put ourselves in our own shoes and think about what would allow us to drill down and fix errors quickly.

With that mindset, we decided that there were two important error details that should be used for grouping.

  1. Where the error occurred
    We felt that, first and foremost, we wanted to know where the error was occurring. Even though there is a possibility it might be occurring in multiple locations, we felt that each location represented its own importance in our grouping scheme.
  2. Type of error
    The type of error is also very important, and we felt that when you combine type with location, you get a set of errors that holds enough significant explicit data to be recognized as a group.

What Grouping Allows Us to Do #

When we group app errors by location and type, it allows us to report error instance counts, first occurrences, frequency of occurrence, and most recent occurrence on the dashboard.

Error Group Details

Error Group Details

This seemingly basic grouping forms the basis for the different Exceptionless dashboard tabs and pages, thus becoming a major cornerstone for the platform. Click into a group, and you see the title, exception type, and location, along with a graph of occurrences and the most recent occurrences.

From there, you can drill down into each occurrence and scrutinize all of the error's details.

That's how we do it! Any questions? Let us know.

Exceptionless Now Hosted on Azure

Microsoft AzureAs usual, we've been working on ways to improve the Exceptionless service.

Due to growing demand for our hosted error reporting plans, we decided to move everything to the Microsoft Azure Cloud platform.

We completed the move last week and, except for a few small hiccups that were quickly resolved, everything is already running faster across the board!

Benefits of Azure #

Bring on the errors! #

As our user base continues to expand, the first priority is to continue providing the best service possible. Azure allows us to guarantee scalability, and has already proven to be much faster and more responsive. We're ready for whatever you can throw at us.

Focus #

Developing infrastructure takes time, and we would rather be developing the code behind Exceptionless. The move to Azure allows us to do just that, taking a lot off our plate in terms of hosting. It's pretty awesome.

Future Azure partner #

In the future, we would like to become an Azure partner and be listed as one of the approved store add-ons. We're not there yet, because we've got to go through the application process, etc, etc, but it's in the works!

"Azure is an open and flexible cloud platform that enables you to quickly build, deploy and manage applications across a global network of Microsoft-managed datacenters. You can build applications using any language, tool or framework. And you can integrate your public cloud applications with your existing IT environment." - Microsoft Azure

We are happy with the move and think it means great things for the future of Exceptionless. We hope our users appreciate the speed and responsiveness, and can see the improvements in service.

Detailed Error Reports - What's Included?

When an error occurs in your app, you need to know the critical details, fast, so you can drill down and fix it. We get it - we're developers too - that's why we built Exceptionless.

The trick was organizing the data so it didn't overwhelm our users, while still providing all the important stuff so developers wouldn't have to spend extra time tracking down versions, requesting stack traces, or pulling teeth to get environment information.

Lets take a look at the default information included with every error. We say default because you can easily add your own information with custom objects.

Each Error Occurrence #

Every single error occurrence has the following tabs:

  • Overview
  • Exception
  • Request
  • Environment

On each of these, you can go to the previous or next occurrence for easy comparison.

Lets take a closer look at each tab.

Error Overview #

Exception Reporting Overview

The overview tab holds general information for that occurrence, including the variables below. Sometimes this is all you'll need to track down the bug. Sometimes you'll need to dig deeper.

  • Occurred On
  • Error Type
  • Message
  • Platform
  • URL
  • Referrer
  • Browser
  • Browser OS
  • User Name
  • Stack Trace

Exception Tab #

Exceptionless Exception Details

On the exception tab, we reference the timestamp, error type, message, and stack trace, while also providing you with all of the loaded modules, including versions.

Request Tab

Exceptionless Request Details

Here we have tons of important request info:

  • Occurred On
  • HTTP Method
  • URL
  • Referrer
  • Client IP
  • User Agent
  • Browser
  • Browser OS
  • Device
  • Is Known Bot
  • Cookie Values

Environment Tab

Exceptionless Environment Details

Environment isn't something that we always think about, but in some cases it can tell us a lot about the exception. We've got you covered!

  • Occurred On
  • Machine Name
  • IP Address
  • Processor Count
  • Total Memory
  • Available Memory
  • Process Memory
  • OS Name
  • OS Version
  • Architecture
  • Runtime Version
  • Process ID
  • Process Name
  • Command Line
  • Client Information
    • Install Date
    • Version
    • Platform
    • Submission Method
    • Application Starts
    • Errors Submitted

How Did We Do? #

We have done our best to include all the important information in an organized, easy to read, intuitive interface. Think we're missing something? Think we can organize it differently? Let us know! We love feedback.

Exceptionless 1.4 Released

Exceptionless Version 1.4Exceptionless 1.4 brings with it both server and client changes, a new client integration, some minor updates, and lots of bug fixes. Check out the changelog items below, and let us know if you have any questions.

We want to extend our thanks again to the developers that have worked on the project since we went open source a few weeks ago. See their contributions below, along with links to their GitHub profiles.

Server #

  • The app will now be displayed in full screen mode on iOS devices (via Add to Home Screen).
  • Added the ability to view the status page while in maintenance mode.
  • Added the ability disable error processing on the error controller.
  • Various usability improvements dealing with chart date-range selection.
  • Added documentation link on the sidebar.
  • Added checks to limit the number of max results returned from various API methods.
  • Add new indexes to help performance and fix some inefficient queries.
  • Changed the way we are filtering fixed and hidden errors to be more efficient.
  • Updated all indexes to be created in the background if they don't already exist.
  • Switched the JavaScriptEngineSwitcher to use JurassicJsEngine. Jurassic has no external dependencies on IE or Windows specific libraries.
  • Fixed a race condition that would throw an exception when updating stats.
  • Fixed a bug where the EnforceRetentionLimitsAction was returning all the query results and then paging them.
  • The upgrade script now upgrades the database in a background thread.
  • Fixed a bug where an error with no stack trace wouldn't be processed.
  • Fixed a bug where the list loading indicators could spin non-stop.
  • Fixed a bug where errors could be stored with the incorrect DateTimeOffset. This caused inconsistencies between charts and list data.
  • Fixed a bug where the error stack's tags were not being synced with the error instances.
  • Fixed a bug where the terms and privacy links could point to the wrong domain.
  • Fixed a bug where a UriFormatException could be thrown when viewing an error occurrence. This could be caused by third party obfuscators that create a new pdb file.
  • Updated the UpgradableJsonMediaTypeFormatter to handle errors gracefully.
  • Fixed a bug where the EncodingDelegatingHandler could throw an exception when there was no request content.
  • Fixed a bug that could prevent an error from being processed.

Client #

  • Added support for Nancy (Contrib: luisrudge).
  • Better support for low trust environments (Contrib: obsbne).
  • Fixed a bug where the MVC integration could interfere with custom error pages.
  • Fixed a bug where a batch of errors wouldn't be sent if an error occurred while sending a previous error in the same batch.
  • The client will now attempt to delete an already sent error when ProcessQueue is called.
  • Fixed a bug where an exception would occur while deleting the manifest file that was saved by a different or elevated user.

Achievement Unlocked - 1000 Accounts and Over 8,000,000 Errors Reported!

8 million errors reportedJust over six months ago, we launched Exceptionless with a mission to impact the coding community in a positive way. The goal was, and still is, to help developers find, track, and squash errors, ultimately creating better code for users.

A few days ago we officially hit 1000 accounts, and as of today Exceptionless has reported 8,562,499 errors! We couldn't be more excited!

Sure, we're busier than ever now, answering emails, conversing with open source contributors on new features, and working on new features ourselves, but seeing something grow this quickly, that we've put so much work into, leaves us with little room to complain. The only real thing we can do is say thank you.

Thanks #

We'd like to thank all of our users for using the service, providing feedback, asking the hard questions that make us realize we need to make tweaks here and there, and providing us with direction.

Also, we would specifically like to thank our beta testers that were with us from the beginning. You know who you are, and without you Exceptionless simply would not be the tool it is today.

And, of course, we have to thank everyone that has contributed to and forked the project since we went open source a few weeks ago. 39 forks, 124 GitHub stars, and a NancyFX client so far - not bad!

But Wait, There's More! #

They say there's no sleep for the wicked, so we're feverishly working on a few major things that will have big long-term benefits for the app.

  • Moving to Azure for faster, more robust, scaleable hosting
  • Simplifying the API to make it easier for new clients to be implemented and improve metric reporting
  • JavaScript client

That's just the tip of the iceberg, of course. The to-do list is ever-growing, but we've got to start somewhere.

Let us know what you think #

If you are just now joining the Exceptionless community, let us know what you think. Love it or hate it, we want to know why and how to improve.

Happy bug hunting!