The Backtrace team has engaged with software development teams across various industries during the past year. One of the trends we noticed was that C# was being used adjacent to many of the products that we were already supporting. Here are 3 common ways we saw C# being used:
- As a cross-platform Desktop or Mobile UI using Xamarin or UWP.
- As a scripting engine for Games that run on the Unity engine.
- Hybrid, where C++ libraries are used from a C# application.
As a result, we spent some engineering time to create the Backtrace C# crash and exception reporter, which we recently announced.
Many developers use HockeyApp, Crashlytics, or their own internal solution to do crash and exception reporting. However, these solutions often lack key features that can give you the analysis you need to quickly identify, analyze, and remediate error-causing bugs.
Here are five ways that the Backtrace error monitoring platform can improve your C# exception reporting:
1. Automated symbolication
The impact of symbol management on the debug process is overlooked. Too often, symbol generation is treated like another administrative set-up task when the build pipeline is first set up, and not updated to ensure it’s used appropriately with your debug analysis tools.
Backtrace has solved the pain of configuring your debug environments by generating human readable callstacks with automatic symbolication. Your development teams integrate your build system with Backtrace so symbols are collected automatically from wherever the team currently stores the information. Backtrace also provides support for Symbol Servers, which allows the system to automatically retrieve symbols from wherever they might be stored, without needing to know details about product names or release versions.
2. Effective error grouping and deduplication
Simplistic callstack grouping algorithms are often too coarse-grained or fine-grained to accurately group and deduplicate bugs. Backtrace uses four different algorithms in our heuristic matching which are constantly learning as we get feedback for commonly used libraries. The Backtrace system deduplicates crashes based on rules that have been extrapolated from hundreds of millions of crashes across complex real-world applications.
3. Attach files such as log files or minidumps to provide greater context
Log files aren’t useful to you if they’re sitting on your user’s desktop. Other solutions don’t give you the ability to attach files, so you have to rely on your users to send the log files to you. Backtrace customers are able to associate file attachments with crashes being managed in Backtrace, providing ancillary information such as log files of user activity right alongside the crash record.
4. Query and group by system and custom attributes
Backtrace attributes give deep insights into your crashes by providing information such as process age (how long app has been running) and operating system details. This is important due to the cross-platform nature of C# applications (Mac and Windows and Linux; Android and iOS). Backtrace metadata provides OS data so you know exactly which platforms are affected.
The Backtrace Query Builder also allows you to prioritize crashes based on system and custom attributes that are most important to you, such as user, OS, version, graphic drivers, screen resolutions, process age, and more. You can discover patterns in your crashes that might not otherwise be obvious like contains, not-contains, or regular expressions, on callstacks or other metadata provided in the crash report.
In addition to providing a simple string value, Backtrace provides version comparisons and a rich set of data types and formats for sophisticated comparisons, operators and visualizations. These include data types for commits, versions, environments, hostnames, memory addresses, file size types, timestamps, IP addresses and more.
5. Understanding errors across languages
Applications are rarely written in one language these days. Many applications use a C# based front end for GUI programming while relying on native components written in C++ to provide more granular access to system internals. Can you cross the chasm to report on errors from all the languages that are used to build modern applications? With Backtrace, you have a comprehensive platform that can analyze both C++ and C# crashes, providing you with full visibility into what caused your crash.
Beyond the advantages that the Backtrace platform provides, we have two bonus capabilities that are specific to the Backtrace C# capture library. These are quickly becoming invaluable as we see the library used in more types of environments.
Bonus #1. Offline support On mobile or laptop, if your application crashes and your user isn’t connected to the network they can’t send valuable crash reports to you. Backtrace stores crash reports locally and sends them to you when the user is back up and running.
Bonus #2. Support across .NET environments There are plenty of .net environments in the wild: .net 3.5, Xamarin, .NET core, and more. We test and certify on all of them. No matter where your C# is running, Backtrace has a breadth of platform support for C#.
With these powers at your fingertips, Backtrace can help your team improve the quality and stability of your C# and related applications, no matter what platform or runtime you use.