XML Parsing Exception Caught and Fixed - Case Study

This is yet another story of an elusive bug that, without a proper error reporting service, would have gone un-noticed for a very long time.

When third-party software and services interact with your code, in any way, you have to be wary that their data may be different from yours. In this instance, our client was parsing some XML that included an unfriendly cookie name. Lets see what happened next...

.NET Exception Dashboard

Killer Cookies #

Listrak is a pretty cool company that provides, among other things, a robust email marketing, shopping cart abandonment, and welcome series suite of tools.

One of their cookies uses a "$" in it's name ($ListrakFoo or similar). When the client's XML Config packages were executed, that $ was causing an XML parsing exception.

That's not customer facing. What's the big deal? #

37,000

While not directly customer facing, it was happening on almost every page of the website and occurred something like 37,000 times in the span of it's existence.

Sluggish

Along with the sheer number of occurrences, it was also noticeably slowing the site down.

The fix #

The fix was relatively simple. The client now checks for "$" in cookie names within the affected method and just doesn't handle them.

Tracking errors like this is what we're all about. There are hundreds of thousands, probably even millions, of bugs out there right now that throw exceptions every day but manage to remain hidden in the shadows of code written by professional developers.

It's not a sign of poor programming, it simply comes with the territory. You will have bugs, big and small, in every project you work on. The difference is, with Exceptionless, you can actually be aware of, and fix, them!

Another bug bites the dust, thanks to help of Exceptionless' real-time exception reporting!

Do you have a story where our software helped you track down and squash an elusive error? Let us know! We'll publish the details and link back to your app, if you like.

Receive Error Notifications from Your App via Email

Maybe you've got this awesome new web app that you're ready to go live with, or maybe you're working on a project that is already customer facing but you've got major new features rolling out and want to make sure all goes well.

We both know there's going to be something that isn't completely right after launch. It might be a big bug stopping certain users from placing orders on your site, or it might be something that won't even affect your customers. It might be highly visible, or completely hidden from your view. Either way, you want to know when that error occurs and what the details are. That's where Exceptionless comes in.

Real-Time Error Notifications via Email #

ASP.NET Error Notifications

The Exceptionless platform provides a great real-time dashboard view of your errors, but our email notifications allow you to be absolutely in touch with any errors that may be occurring within your application.

Notification options #

There are several email notification options for your app's exceptions.

To receive notifications, you need to turn them on under the "My Account" section, in the "Profile Information" tab. This option should be on by default. Then, you can view the below options under the individual project settings by clicking on the cog/gear icon next to the project name at the top of your dashboard.

Email Notification Settings

Lets take a look at the different options:
  1. Daily Project Summary
    This is simply a summary of your project, including error counts, etc, that you can receive each day.
  2. Critical Errors
    You can mark an individual error as critical, and then check this box to receive email notifications each time that error occurs.
  3. Error Regressions
    If you have marked an error as fixed, you can check this to get an email notification if it ever rears it's ugly head again.
  4. Error Occurrence Notification Frequency
    These are fairly self-explanatory. How often would you like to receive emails?

    1. All Occurrences
    2. New Only
    3. Never

_Note: _You can also turn notifications off for individual errors by going to Options>>Disable Notifications while inside a specific error.

Sit back and relax #

... until an error notification comes in, that is. Then you should probably fix it.

Catching a Server-Side Browser Cookie Support Error - Case Study

Internet Explorer CookiesAs with every new release of software, things change. And, like we all expected, there wasn't an exception to that rule when Microsoft introduced Internet Explorer 10 into the mix.

Everyone coding for the web had the normal things to worry about, of course, like design formatting, speed, and support, but one of our clients experienced something that would have taken a long time to catch if they hadn't been using Exceptionless' real-time error reporting.

Who Adopts New Versions of IE Right Away, Anyway? #

Like many, the client's web team doesn't necessarily adopt the latest version of IE right away, much less use it as their main browser. Unfortunately, that leads to little immediate exposure to potential bugs.

Lets explore how this came back to bite them, and how Exceptionless helped them treat the wound quickly.

A nasty customer-facing error #

Users of the client's eCommerce platform that were already using IE10 were able to view and use the website fine, until they logged in. At that point, everything broke. They couldn't checkout, browse, or submit contact forms.

Because the team wasn't using IE10 regularly yet for testing actual logged-in user transactions, they were clueless!

Luckily, Exceptionless reported the customers' errors and the team was able to take notice of the recurring bug within days, rather than weeks or months.

Turns out... the problem was server-side! #

After the error was reported in the Exceptionless Dashboard, the team was able to use the attached details to trace the root of the issue back to the server's definitions of which browsers support modern cookie encryption.

All the server needed was a routine update that had not been performed! Bam - fixed.

Another bug bites the dust #

We love to hear stories like this. Something so simple, yet so easy to overlook and cause serious customer-facing problems!

Errors like this happen every day to hundreds, if not thousands, of small, medium, and large software teams across the world. We just want to help squash as many of them as we can!

An In-Depth Look at the Exceptionless Project Portal

We cover the basic features of the Exceptionless platform on our feature tour page, but we wanted to give everyone a deeper look into all the information available via the web-based, real-time .NET error reporting admin area.

Continue reading to learn more.

The Dashboard #

Visual .NET Exception Graph

The Exceptionless Dashboard features a quick overview of the exceptions for the currently selected project. It also updates in real-time, so you can watch exceptions roll in.

This is a great place to glimpse your exceptions by total, unique, new, or per hour. The most frequent and most recent exceptions are also displayed here, along with a graph representing your total and unique exceptions. You can go directly to an error's details by clicking on it.

At the top of the page, throughout the admin, you can:

  • Change the project you are currently viewing
  • Go to that projects settings
  • Adjust the date range
  • Show/Hide hidden errors
  • Show/Hide fixed errors
  • Show/Hide "Not Found" errors

Exceptionless Date Range Selector

Show/Hide Errors & Select Date Range

View Most Recent, Most Frequent, and New Exceptions #

On the left side of the dashboard, you can select to view your Most Recent, Most Frequent, or New (first time) .NET exceptions.

New .NET Exceptions

New Errors

Most Recent #

The most recent report lists your errors individually with the one that occurred last at the top. It also tells you exactly how long ago the error occurred. You can click into the exception to view details.

Most Frequent and New Exceptions #

Each of these reports lists the respective error type with a summary, the count, when the error first happened, and the last occurrence. Most frequent is ordered by count, and new is ordered by most recent.

Lets Take a Look at Exception Details #

Error Stack Page #

Error Stack Options

If you click into any error, Exceptionless will show you the error stack, which includes the number of occurrences, when it first happened, and the latest re-occurrence. You can adjust the date range on this page, like the rest, and you also get a nice graph of that error's occurrences over time. Each individual time the error triggered is listed below the graph, and you can click into each instance separately.

Before we do that, though, I'd like to point out another major feature of the error stack page..

Above and to the right of the graph are two buttons: "Mark Fixed" and "Options". Mark fixed is exactly what it sounds like, and if you click on the "Options" button it drops down with the following choices:

  • Hide from reports
  • Promote to external
  • Add reference link
  • Disable notifications
  • Future occurrences are critical
  • Reset stats

Individual Error Details #

After you click into an individual error instance, you will see the following tabs.

.NET Exception Environment Details

Error Overview

This page shows you a quick overview of the error, including the stack trace. It includes the date and time, type, message, platform, URL, and referrer. You can also go to the previous or next occurrence.

Exception

This tab displays a few overview details, then gives you a list of loaded modules related to the error.

Request

The request view gives you the request details, including date and time, http method, url, referrer, client IP, user agent, browser, browser OS, device, and whether or not it's a known bot. You also get Post Data.

Environment

Because you needed all the data, the environment tab displays time and date, machine name, ip address, processor count, total, available, and process memory, OS name, OS version, architecture, runtime version, process ID, process name, and command line details. It also has client information, such as install date, version, platform, submission method, application starts, and errors submitted.

What Else Can I Do from the Admin? #

Naturally, you can manager your projects, organizations, and account, but we also have pretty handy feedback and support tools so you can let us know how we're doing! Your feedback and comments are important and provide direction to the code.

Exceptionless Support

In short, the tool offers extremely helpful insights into the world of your web application's bugs. Whether internal or customer-facing, knowing when, where, and how many exceptions are being generated makes it easier for you to track them down and squash them. And when you've fixed it, regression notifications are there to let you know if it rears its ugly head again.

Still not convinced? Give it a try - sign up today, for free.

Find Leaking Exceptions by Eliminating Empty Catch Blocks - Case Study

How a client eliminated 50+ exceptions/hour #

Recently, a client contacted us and gave us a pretty incredible case study. He found a huge number of "leaking" exceptions by eliminating all of the empty catch statements in his ASP.NET code and sending an exception to Exceptionless instead. By doing so, he was able to track down about 12 individual bugs and get rid of over 50 exceptions per hour by fixing them. That's 1200+ exceptions per day - gone!

"This gave us a picture of just how many poorly written methods were leaking exceptions. The answer was, A LOT. So, even though these weren't customer facing, they were expensive and a good indicator of code quality. In just a couple of days, we were able to eliminate the majority of them completely." - Eric Burcham

After speaking with Mr. Burcham further, he explained that while there were only about 12 individual bugs, the number of times that those bugs were occurring in different areas throughout the code (an ASP.NET eCommerce solution) was numerous. Luckily, he was able to use several multi-line find and replace actions to make all the changes relatively quickly and get things back on track.

A brief code example #

Empty .NET catch blocks #

Before using Exceptionless to generated exceptions, the catch blocks were empty.

try
{
// Do Something
}
catch { }

Using Exceptionless to generate an exception in the catch block #

By submitting an exception in the catch block, instead, their eyes were opened to thousands of daily exceptions.

try
{
// Do Something
}
catch(Exception ex)
{
ex.ToExceptionless().Submit();
}

But I can already throw an exception in my catch block... #

While you can throw an exception in a catch block normally with .NET, Eric was able to utilize Exceptionless' intelligent error grouping, notifications, and detailed reporting to pinpoint the problems and deal with them accordingly. Then, he was able to monitor the decline of occurrences and make sure that there were no regressions. That's pretty powerful, we think.

.NET Exception Reporting and Why You Need It

We have all worked on projects, large and small, where tiny, one-off bugs went unnoticed for a while before they were finally reported by a user or discovered by a developer. In some instances, these bugs probably affected the end-user's ability to use the service, purchase an item, etc, meaning that there was a direct impact on the bottom line.

What if you didn't have to worry about .NET exceptions going unnoticed anymore?

Enter real-time .NET exception reporting #

Exceptionless ASP.NET Error Reporting

What .NET developers needed was a tool that focused on error reporting by logging, grouping, and sending notifications. They needed flexibility through custom objects and a fluent API. They needed every error detail presented in a organized, readable manner. The even needed charts that clearly showed their progress in squashing the tens, hundreds, or thousands of daily exceptions that they didn't know they were occurring.

We needed all that, too, so we built a tool that does it all for us!

What a .NET exception reporting tool has up its sleeves #

When we set out to build Exceptionless, we went through hundreds of possible features, and even toyed with building a larger product that including other functionality, but in the end we decided we wanted it to do the following things really well.

  • Send error notifications
  • Group exceptions intelligently into stacks
  • Show top errors and allow them to be prioritized
  • Provide detailed error reports, including stacktrace
  • Have a dashboard with an immediate view of error statistics and trends
  • Allow custom objects to be added to reports
  • Allow unlimited users per organization
  • Give developers a way to **mark exceptions critical, fixed, or **monitor for regressions
  • Provide real-time updates, as exceptions happen
  • Support offline usability in scenarios where the developer is traveling, etc
  • Be able to be installed in less than 5 minutes

Why Exceptionless is a must-try for .NET developers #

You should give it a shot if:

  • Finding that bug 2 weeks sooner could have saved you or your company a lot of money
  • Customers were lost because of a bug on production that you couldn't see locally or in the development environment
  • You fixed a bug in one spot, only to find out that it was happening in several other places as well
  • There might be errors here or there, but they probably aren't affecting very many users (hint: they probably are).
  • You or your team are making a lot of changes in the next sprint, and you really want to make sure you know when a bug gets introduced
  • and the list goes on...
And of course, we're here to help!

If you have any issues or questions, just let us know! You can contact us here on the website, or via the support button on your Exceptionless dashboard.

Find Customer Facing Bugs with Exceptionless - Case Study

The Power of .NET Error Reporting #

ApexCCTV Logo One of our long time customers, ApexCCTV, recently described how Exceptionless' .NET error reporting allowed them to find and squash a bug that was causing their website to be completely unusable by some customers.

Because of the e-commerce development environment being used, this issue would not have been brought to their attention without the implementation of Exceptionless, making this a prime example of how powerful the tool is and what it can mean for all types of .NET web applications.

What customers were experiencing #

"After a site upgrade, every page of the site was crashing if the customer had been previously logged in." - ApexCCTV

So, if a user had selected the "keep me logged in" box the last time they logged in, prior to the update, nothing was working for them.

The cause #

When a customer logs in, a secure cookie for that user is created behind the scenes. The code update had changed the format of the cookie, but not the name, so when a user visited the site with the old cookie, the authentication was breaking. This was throwing errors and crashing the site for the customer, but because the development team clears cookies regularly, and no one had reported any issues, the exceptions were flying under the radar.

The fix #

Exceptionless logged and reported the error, and the fix was easy - simply change the cookie name so that users were forced to get a fresh cookie the next time they visited the site. Bam, done! Users could then happly log in and buy security cameras without any issues.

There could be, and a lot of the times are, errors like this in any .NET project, and using a real-time exception reporting tool like Exceptionless can really be an asset, saving time, money, and customers.

Exceptionless 1.2.0 Released

Server Features #

  • Added ability to copy extended data to the clipboard.
  • Added ability to copy stack traces to the clipboard. This is very useful when you have an obfuscated stack trace and wish to decode it.
  • Added ability to purchase yearly billing plans.
  • Added the ability to consume the rest api with an apikey query string parameter.
  • We now show friendly error messages when an error occurs while downgrading or upgrading billing plans.
  • Numerous improvements to the project configuration page.
  • Numerous bug fixes and performance enhancements.

Client Features #

Update your NuGet packages to take advantage of these improvements!

  • Added support for MVC5 and Web API 2.0.
  • Improved the detection and ignoring of duplicate errors to prevent them from being reported.
  • The client now excludes dynamic assemblies from the modules error report section.
  • AddObject now serializes objects to a depth of 5 by default.
  • Fixed a couple bugs that may occur when multiple client instances are running on the same machine concurrently.
  • Fixed a bug with the ExceptionlessWcfHandleErrorAttribute where it wouldn't catch errors when aspNetCompatibilityEnabled was set to false.
  • The client now submits errors to collector.exceptionless.com/api/v1/error.
  • Fixed a bug that would prevent the Windows Form client from showing the Crash Report dialog.
  • Fixed a bug where multiple HttpModule sections could be added by the NuGet installer.

Introducing Exceptionless

Exceptionless is a new error reporting service that helps you answer important questions about the software that you build.

  • Do you know when and how your app is failing?
  • Are my users running into issues and walking away?
  • What are the top issues that I should be fixing?
  • What issues are affecting the most people and would give me the highest ROI when fixed?
  • Is my app getting more or less stable with each release over time?

The definition of the word exceptionless is: to be without exception. Our product provides real-time error reporting for your apps. It organizes the gathered information into simple actionable data that will help your app become exceptionless!

Exceptionless Dashboard

You can integrate Exceptionless into your application in a matter of seconds and start getting the answer to all these questions right now! It’s simply a matter of adding our library and setting your sAPI key.

Exceptionless gives you a look at your application health and allows you to take a closer look at how oftern errors occur. You can dive into a specific error stack to get detailed information about an error. You can also mark an error as fixed or hide an error completely.

Exceptionless Error Stack

We believe that all app developers should strive to be Exceptionless and that’s why we are offering a FREE plan! It’s easy to get started, so what are you waiting for??

Exceptionless 1.1.0 Released

Features #

  • Added ability to visually select a custom date range, giving you the ability to investigate spikes.
  • Added ability to add reference links to error stacks.
  • Added web hook and Zapier support.
  • Added daily summary notification.
  • Added ability to filter out hidden and 404 errors.
  • Added ability to promote stacks to external services.
  • Added ability to add reference links to stacks.
  • Added ExceptionlessWcfHandleErrorAttribute to Exceptionless.Web package.
  • Minor visual improvements and fixes for mobile and desktop layouts.
  • Numerous bug fixes and other enhancements.