Giving back to the development community is important to us over here at Exceptionless. We love open source!
As such, the Exceptionless NuGet assembly library, with 31 assemblies and over 176,000 package downloads, is ever growing and expanding right along with our GitHub repos.
We thought we would give everyone a quick tour, and at the same time perhaps provide a good resource and reference page.
Exceptionless, our primary open source application, provides real-time error, feature, and log reporting for ASP.NET, Web API, WebForms, WPF, Console, and MVC apps (and more, soon!).
Below you will find the NuGet assemblies for all the platforms we currently support.
Exceptionless.Portable
Exceptionless client for portable (PCL) applications. This is the base library all the other implementations build on top of. It contains all the basic functionality that powers the Exceptionless clients! This library can be used on many different platforms. It’s worth noting that this is a very basic client and as such you won’t get all the bells and whistles as described here in the PCL configuration section. For those bells and whistles, see the Exceptionless package, below.
Frameworks: .NET 4, .NET 4.5, Silverlight 5, Windows 8, Windows Phone 8.1, Windows Phone Silverlight 8
Exceptionless Exceptionless client for non visual (ie. Console and Services) applications.** **We recommend using this package if you are not using any other platform specific packages (E.G., Exceptionless.Mvc), as it provides all the bells and whistles that are missing in the portable package.
Frameworks: .NET 4.0, .NET 4.5
Exceptionless.Mvc Exceptionless client for ASP.NET MVC 3+ applications.
Frameworks: .NET 4.0, .NET 4.5
Exceptionless.WebApi Exceptionless client for ASP.NET Web API applications.
Frameworks: .NET 4.0, .NET 4.5
Exceptionless.Web Exceptionless client for ASP.NET WebForms applications.
Frameworks: .NET 4.0, .NET 4.5
Foundatio (Requires .NET 4.5) is an open source library for building distributed applications that we built, use, and think you will find helpful. Foundatio provides in memory, redis, and azure implementations. This allows you to do development or testing using in-memory versions and switch them out for redis or azure implementations in production. This saves you time (setup and maintaining) and money (not paying for cloud resources) during development and testing! Foundatio source code can be found at https://github.com/FoundatioFx/Foundatio.
Exceptionless was built using Foundatio and utilizes implementations for caching, queues, locks, messaging, jobs, file storage, and metrics.
Foundatio
Foundatio consists of pluggable foundation blocks for building distributed apps, including caching, queues, locks, messaging, jobs, file storage, and metrics.
Foundatio Redis Implementations
Contains the redis implementations of caching, queues, locks, messaging, jobs, file storage.
Foundatio Azure ServiceBus Implementations
Contains the redis implementations of queues and messaging. The azure packages are split into different packages so you don't have to take extra azure dependencies on things you don't need.
Foundatio Azure Storage Implementations
Contains the redis implementations of file storage. The azure packages are split into different packages so you don't have to take extra azure dependencies on things you don't need.
Exceptionless RandomData
RandomData is a utility class for easily generating random data, making the creation of good unit test data a breeze.
Frameworks: .NET 4.0, .NET 4.5 View Source
Exceptionless DateTimeExtensions
This package includes DateTimeRange, Business Day, and various DateTime, DateTimeOffset, and TimeSpan extension methods.
Frameworks: .NET 4.0, .NET 4.5, Windows 8, Windows Phone 8.1 View Source
We don't plan on stopping anytime soon, and will continue writing assemblies to make life easier for developers everywhere. Naturally, we could always use your help, so fork us on GitHub if you feel like chipping in. We always appreciate our contributors!
Otherwise, let us know what you think of Exceptionless, Foundatio, and all our other projects. Feedback is always welcomed and appreciated.
A plugin is a client-side addin that is run every time you submit an event.
Plugins can be used to add or remove data from an event, or even allow you to cancel an event submission.
Each client-specific implementation registers a plugin to provide client-specific information like request info, environmental info, etc. These abilities make plugins very powerful.
Let's take a more in-depth look at Exceptionless Plugins and how they are used.
First, we are assuming that you have already created an account and installed and configured the latest version of the Exceptionless client (plugins require client v3 - released 4/6/2015). If you are still using the 1.x client, you will need to upgrade to use plugins. Please contact support via an in-app support message or our contact page if you have any questions or need assistance in this area.
Before we create our first plugin, it’s important to keep in mind that each plugin will run every time an event is submitted. As such, you should ensure your plugins are fast and not super resource-intensive so your app remains as quick as possible.
To create a plugin, you have to specify a System.Action, or create a class that derives from IEventPlugin.
Every plugin is passed an EventPluginContext, which contains all the valuable contextual information that your plugin may need via the following properties:
**Client
** The ExceptionlessClient that created the event.
**Event
** The target event.
**ContextData
** Allows plugins to access additional contextual data to allow them to add additional data to events.
**Log
** An ExceptionlessLog implementation that lets you write to the internal logger. This internal logger is used only when debugging the client.
****Resolver
**** The ExceptionlessClient`s dependency resolver. This is useful for resolving other dependencies at runtime that were not requested via constructor injection.
Exceptionless Plugin Example - Add System Uptime to Feature Usages #
The following system uptime plugin derives from IEventPlugin and places the system uptime into every feature usage event as extended data when the plugin’s Run(context) method is called.
// Get the system uptime using(var pc =newPerformanceCounter("System","System Up Time")){ pc.NextValue();
var uptime = TimeSpan.FromSeconds(pc.NextValue());
// Store the system uptime as an extended property. context.Event.SetProperty("System Uptime", String.Format("{0} Days {1} Hours {2} Minutes {3} Seconds", uptime.Days, uptime.Hours, uptime.Minutes, uptime.Seconds)); } } } }
Output in Exceptionless:
Note: We kept the formatting of the uptime simple for the sake of this example, but we recommend using our open source DateTimeExtensions library if you wish to format it in a really pretty manner.
Plugin Priority
You might have noticed that there is a priority attribute with a value of 100. The priority of a plugin determines the order that the plugin will run in (runs in order of lowest to highest, and then by order added). All plugins that ship as part of the client start with a priority of 10 and increment by multiples of 10. If you want your addin to run first, give it a low priority (e.g., 0, 1, 2, 3, 4, 5). If you want it to run last, give it a high priority (>100). By default, if you don’t specify a priority, 0 will be used.
To make sure your plugin runs first (if required), you can inspect the configuration's plugin property in Visual Studio while debugging.
foreach(var plugin in Exceptionless.ExceptionlessClient.Default.Configuration.Plugins) Console.WriteLine(plugin);
Now that we've created the plugin, we’ll add it when our application starts up by calling one of the Exceptionless.ExceptionlessClient.Default.Configuration.AddPlugin() overloads.
In most cases, we use the following overload to register plugins:
When you add a plugin by specifying the type, we inspect the type and try to find a PriorityAttribute. If we can’t find one, the default value of 0 will be used.
You can also add a plugin by passing a System.Action to AddPlugin. Please note that we are specifying a key when adding the action plugin so we can remove it later. If you are not going to be removing your plugin, then you can omit the first argument.
We pass AddPlugin three arguments:
A unique plugin key (which can be used to remove the plugin later)
Priority
An action that contains all of our logic to add the system uptime (or whatever your plugin does).
// Get the system uptime using(var pc =newPerformanceCounter("System","System Up Time")){ pc.NextValue(); var uptime = TimeSpan.FromSeconds(pc.NextValue());
// Store the system uptime as an extended property. context.Event.SetProperty("<wbr />System Uptime", String.Format("{0} Days {1} Hours {2} Minutes {3} Seconds", uptime.Days, uptime.Hours, uptime.Minutes, uptime.Seconds));
Can you think of ways that plugins can help your app? Are you already building some? Let us know what they are and how they help! Eventually, we plan on building a library of useful and common plugins that other developers can easily implement. The more help we've got, the faster that library will grow!
We're all about exceptions, but sometimes, as developers, we run into bugs that don't throw them but still cause major havoc in the system. There are also times we just need to record an event with a custom message to help track down bottlenecks, etc.
That's where Exceptionless meets log messages.
In Exceptionless 2.0, you can now send custom log messages to a Log Messages dashboard where they can be tracked and view just like exceptions and other events.
For this example, we are assuming that you have already created an account and installed and configured the Exceptionless 2.0 client. If you are still using the 1.x client, you will need to upgrade to send us log messages. Please contact support via an in-app support message or our contact page if you have any questions or need assistance in this area.
Getting fancier, you can also specify the log source and log level.
In the below example, "typeof(MainWindow)__.FullName" specifies the log source, and "Info" specifies the log level. If no log source is specified, the log messages will be stacked under a global log stack.
We recommend specifying one of the following log levels, all of which add a visual indicator to each log message (see below screenshot).
There are a number of additional pieces of data you can use for your event. The below bullets include the current EventBuilder list, but we are always adding more that can be found on GitHub. Also, view more examples here on our Sending Events page.
You can also submit a log message with an HTTP post to our events endpoint.
My log message
My second log message.
By default, any content that is submitted to the API post is a log message. The above example will be broken into two log messages because it automatically splits text content by the new line.
We also have integrations with major logging frameworks. The benefits of using a logging framework is finer, more granular control over what is logged.
For example, you can log only warnings or errors project-wide, but then enable trace level messages for a specific class. We do this to keep our system from getting filled up with noise that doesn't add any value unless there is an issue.
This also allows you to quickly change what you want to log to. Maybe you want to turn off logging to Exceptionless, or log to Exceptionless and to disk.
NLog or Log4net Usage
To use the NLog or Log4net clients, you’ll just need to bring down the NuGet package and follow the detailed readme.
Note on performance: Use in-memory event storage for high volumes
There are some performance considerations you should be aware of when you are logging very high numbers of log events and using our client. We've spent a lot of time to ensure Exceptionless doesn't degrade your applications performance. However, if you are logging thousands of messages a minute, you should use the in-memory event storage.
This tells the client not to serialize the log events to disk before sending and thus is much faster (the client doesn't need to serialize the event to disk and read it from disk before sending). This comes at the expense that if the application dies, you will lose any unsent events that were in memory. When you use the NLog or Log4net targets and specify the API key as part of the target configuration, we will automatically create a second client instance that uses in-memory storage only for log messages. This way, any logged exceptions or feature usages still use disk storage, while log messages use in-memory storage, allowing maximum performance.
The Log Messages Dashboard makes it easy to see log occurrences. You can keep track of how active a component is, or how long code takes to execute using existing metrics.
For metrics, we have created an open source metrics library called Foundatio. We use it for Exceptionless, and think you will find it extremely helpful as well. Check it out! We'll be posting an article on Foundatio soon, so check back.
We think we've added some pretty cool features to Exceptionless 2.0, including logging, but you are the ultimate judge. What's good? What's bad? What's missing? Let us know via a comment on the blog, social media, in-app, or however else you want to get in touch!
If you're new to Exceptionless 2.0, make sure to check out the launch article for more details on the new features and enhancements.
If you want to know when a button is being clicked, or what users are doing certain tasks, feature usage logging will help you track and visualize each occurrence.
What you learn from logging these types of feature usages might surprise you, and at the very least you'll know more about how users interact with your system.
For this example, we are assuming that you have already created an account and installed and configured the Exceptionless 2.0 client. If you are still using the 1.x client, you will need to upgrade to send us feature usage events. Please contact support via an in-app support message or our contact page if you have any questions or need assistance in this area.
Example 1 - Signup
In the example below, we are going to submit a feature usage when any user signs up.
To submit the feature occurrence, you just need to call our api as follows:
SubmitFeatureUsage creates a simple feature usage and submits it. To include more information, please use CreateFeatureUsage (example below).
More detailed examples
You can also submit additional information with a feature usage using our fluent api. This is nice when you want to add contextual information, contact information, or a tag.
Example 2 - Signup with tags
If, for instance, you wanted to indicate how a user signs up, you can add a tag to the feature usage occurrence. In the below example, we are tagging a feature usage that uses GitHub to sign up.
There are a number of additional pieces of data you can use for your event. The below bullets include the current EventBuilder list, but we are always adding more that can be found on GitHub. Also, view more examples here on our Sending Events page.
You can also submit a feature usage by posting JSON to our API. See details in our API Documentation. If you need an API key for simply posting events, you can find it in your project settings. Otherwise, please refer to the auth login documentation to get a user scoped api key.
Feature usage logging makes it very easy to see how often a feature, such as logging into an account, is used over time. If usage of one type of login, for instances, is never used, there might be an issue or you could consider removing it (less code debt). Or, if one is used the majority of the time, maybe it should be first in the list. There are almost unlimited ways you can use feature usage data to improve user experience.
If we click on the stack for the signup feature, it shows the tag list of the providers that have been used to signup (GitHub and Google, in this instance).
You can even go further and filter by a tag to see exactly how people are logging into your system using the search filter. Example: "tag:GitHub"
Regarding the SetUserIdentity example above, we can see that user information being appended to a feature usage occurrence if we visit the "Search" feature and view an occurrence.
We think so, and we hope you do too. Either way, we're always looking for feedback, so let us know what you think via the comments below, an in app support message, or via the contact page.
Users will notice a completely new interface and experience numerous new features and improvements, highlighted below. Existing users that update their clients (not required) will experience improved client efficiency, the ability to send us logs, and more. We believe 2.0 will usher in a new era in event reporting and logging, becoming a true asset to developers everywhere.
Shipping 2.0 out to our amazing customers has us overwhelmed with excitement, and we can't wait to see all the new ways in which Exceptionless will be used to squash bugs and improve apps everywhere. Read on for more details on updating existing clients and all the new features and changes. We know you'll love it.
Follow these quick and easy steps below to update your Exceptionless client to 2.0.
Open the NuGet Package Manager dialog.
Click on the Updates tab.
Select the Exceptionless NuGet packages and click the Update button.
**You should be good to go!
** If you need more info, view our updating documentation or contact us via in-app support. We're always here to help if you have any questions!
Check out these awesome new and improved features#
Exceptionless 2.0 is faster, sleeker, mobile-friendly, more functional, includes all the below major improvements, and has countless smaller tweaks and changes we poured our heart and soul into. It's a whole new system - check it out!
Searching / Filtering
We’ve implemented Elasticsearch and you can search/filter ALL the things! Read more here and watch a quick demo video here.
Cross Organization Views
You now have the ability to view all events across all organizations, a single organization, or a project.
Fully Documented API
For all your API needs, check out the API Documentation
**Bulk Actions
** Select multiple events or instances of events and do with them as you please! Watch the preview demo.
**Faster than Ever!
** Exceptionless 2.0 is a single page app (SPA) and is lightning fast. We’re using AngularJS and we’re stoked to give our users a super quick experience!
**And more… **Check out more new features, including source links, in our Exceptionless 2.0 Overview article. Includes details on: Event Based Reporting System, Simplified API, The Pluggable System, Client Rewrite, New Message Bus & Queuing, and Job System Enhancement.
Our live preview went great! Thank you EVERYONE that sent feedback and comments.
We received some awesome feedback from many of our customers, made some UI/usability tweaks and improvements, and fixed a few minor bugs. We also added the ability to search custom fields, which is a pretty big deal for some.
Naturally, we used Exceptionless 2.0 to log, report on, and gather data for the preview - and it worked amazingly! (shameless, but true, promotion)
On average, we traced 200,000+ anonymous log messages within the app each day from preview activity. That data allowed us to learn a lot more about the behavior of Exceptionless 2.0 in areas such as jobs and gave us additional insight into what was going on. We were able to use a combination of errors, logs, and feature usage metrics to track down and fix an issue with external logins, as well. Awesome!
The system also helped us track down and identify a performance issue that we were able to fix and improve.
Overall, we had no major surprises and were able to tweak and improve several pieces of the app that we think will make it even more awesome.
No software application is ever "done," so make sure to keep the feedback coming. We've made a huge leap from Exceptionless 1.x, but we want to keep improving the system in all areas. We love hearing from our users, and respond to each email, in-app message, website form submission, etc. So, please, let us know what you think!
Oh boy! We're ready for you guys to beat on Exceptionless 2.0 in a sandbox environment!
We've made you wait, and everyone has done so quite patiently, but now it's officially time to check out V2.0 for yourself.
We're super excited, but we also need your help! At this point, we are asking for any and all feedbackto help us tweak and refine and get things launched. Check out the details and instructions below, and make sure to send us thoughts, critiques, praise, and (of course) bug reports via GitHub Issues.
Log in with your existing Exceptionless account Some very recent accounts may not allow you to log in. If this is the case, please create new account for testing purposes.
View your current data in the new system - play around with it!
(Optional, but Encouraged) Upgrade your client and start sending events to Exceptionless 2.0! Notice:All new data sent to this sandbox preview will be lost when the final version of Exceptionless 2.0 goes live. You will have a gap in historical data. Also, existing clients (1.x) will still work against the 2.0 API when we go live.
Open the NuGet Package Manager dialog.
Click on the Updates tab.
Select "Include Prerelease" from the dropdown.
Select the Exceptionless NuGet packages and click the Update button.
**You should be good to go!
** If you need more info, view our upgrading documentation or contact us via in-app support.
Provide feedback via GitHub Issues. (good, bad, or ugly - we want it all)
All events submitted to the 2.0 system may be reset at any time and will be reset before we go live (sandboxed). New events that are submitted, and any changes that happen in the 2.0 preview, will not be available in the 1.x system and will be lost once 2.0 goes live. Existing clients (1.x) will still work against the 2.0 API when we go live.
We have covered many of these new features in previous update posts, but there are a few new additions and tweaks we've thrown in since then, along with links to previous discussions.
Searching / Filtering
We've implemented Elasticsearch and you can search/filter ALL the things! Read more here and watch a quick demo video here.
Cross Organization Views
You now have the ability to view all events across all organizations, a single organization, or a project.
Fully Documented API
For all your API needs, check out the API Documentation
**Bulk Actions
** Select multiple events or instances of events and do with them as you please! Watch the preview demo.
**Faster than Ever!
** Exceptionless 2.0 is a single page app (SPA) and is lightning fast. We're using AngularJS and we're stoked to give our users a super quick experience!
**And more...
** Check out more new features, including source links, in our Exceptionless 2.0 Overview article. Includes details on: Event Based Reporting System, Simplified API, The Pluggable System, Client Rewrite, New Message Bus & Queuing, and Job System Enhancement.
We've asked a few times already in this post, but we have to ask, once again, for your feedback on the V2.0 platform. Our users define Exceptionless, and to make it the absolute best we can, we rely on you to let us know what's good, what's bad, and what we shouldn't have even wasted the bytes on. So please, give it a go and use GitHub Issues to give us your thoughts. We appreciate it more than you know. Thanks!
We know, we know... It's been a while since our last update. As so often is the case, the holidays took their toll on work and waists here at Exceptionless over the past few months. However, we're not slacking too bad. In fact, we've got a small update on Exceptionless 2.0 that proves it's hasn't been all turkey and naps!
In general, the primary features and functionality of the new version are complete and we are in the testing, bug fix, and tweaking phase before we officially launch a production environment and begin orchestrating the process of data migration and rolling users over into the new system.
One of the main things we've been working hard to get right is the new filtering system. Since we put together our filter demo video, we've added in the following searchable items:
Another major feature we want to make sure is ready to go when we launch is the documentation. We aren't quite finished with the user documentation, but the API documentation has been updated and is current. Of course, we'll keep updating everything as development continues and will field any support related questions you may have.
We've been bragging about how fast Exceptionless 2.0 will be, and we're not joking. We've been putting a lot of time recently into optimizing the queue processor so that it's not just fast, but really fast. You'll see!
Another little feature we've added is the ability to specify custom user agent strings to treat as bots. We're sure a few of you guys will find that handy.
As mentioned above, we're still working out some bugs and preparing to enter the production and migration phase. We'll be sure to keep everyone updated via the blog, social media, email, and in-app as we get closer to launch.
Until next time, we hope everyone had a great holiday season and is enjoying a happy new year!
You know you want it! Bulk edit actions, that is. The ability to select multiple exceptions or occurrences of a single exception and do with them as you please, all at once. Well, they're coming, and today we've got a sneak peak!
We're not changing the world here, but we're making yours a little more efficient. Maybe you want to remove sensitive instances of an error that contains certain data, or maybe you you've got some test errors that you don't want included in the total count, either way the new feature should help. Check it out and let us know what you think!
Welcome to another sneak peak video for the upcoming Exceptionless 2.0. Today we'll be looking at the new bulk edit feature, one of many highly requested features we wanted to make sure we got into version 2.
If we log in to our Exceptionless 2.0 dashboard, which you've hopefully checked out the overview of in a previous blog post and video, we can see that there are now check boxes next to each exception, and if you click in to an individual exception, there is also a check box next to each occurrence of that exception.
Going back to the dashboard, you can select one, multiple, or all visible exceptions. Then, after you've made your selections, you can mark all of them fixed or hidden, or you can delete them.
Now, if we go into a specific exception, we can make all of the same selections, and then we can delete those specific occurrences of that exception.
And that's a quick look at the new bulk edit feature of the soon-to-be Exceptionless 2.0. Please leave a comment on this video or blog post and let us know what you think or any questions you may have. Thanks for watching.
If you've used Exceptionless, chances are a search or filter system would have helped you out more than once. We know, and we agree! That's why we've made it a priority with Exceptionless 2.0, which is coming very soon.
To expand on our previous "Exceptionless 2.0 User Interface FIRST LOOK" article, we want to give everyone a little bit more of a look at the filtering system. This demo isn't anything super fancy, but it gives you a good idea of how easy and fast it will be to filter and search through your event data.
As always, we are looking for feedback on the platform as we continue to draw nearer to launch, so feel free to leave us a comment or contact us and let us know what you think. We hope you like it!
Hi there. Today we want to quickly demonstrate the use of the new filtering system in Exceptionless 2.0.
Let's check out a quick example.
With our new tagging system, you can add any tag you like to an exception - so maybe you want to tag various exceptions to be related to a specific feature or issue - you can do that now.
As you can see in our dummy data here, we've introduced Tag 1 through Tag 5 on various exceptions.
If we go back out to the main dashboard and click up here on our filter/search icon, we can give it a quick test.
Lets say I want to see all exceptions tagged "tag4". OK Great. How about tag5? And tag 3? Cool.
Now, we can also do that within a group of exceptions... Let's look at this one. Again, all we do is filter by the different tags to see their frequency, look at individual instances, and more. Let me run through the different tags real quick.
And that's a quick look at the Exceptionless 2.0 Filtering system, which gives you even more control over sorting and finding the information you need.
Looking forward to filtering your Exceptionless events? #
Great! That's what we like to hear. We think it's going to be super easy, super fast, and even fun for some of you data junkies. Again, if you have any questions or comments, please let us know.
We can prove it! Exceptionless 2.0 is real, and we've got evidence!
We've been wanting to give everyone a sneak peak for a long time, and today we are excited to finally be able to. Watch the video above to see a high level overview of the new UI and features.
There are still quite a few small things to take care of before we release it, but we are happy to say that we are around the 85% mark as far as being finished. Once we get closer, we will be putting up a live demo/preview site for everyone to play with and give feedback on.
Please don't hesitate to give us any feedback you may have after watching the video or reading the transcript below. We want to hear it!
On the left navigation bar, we have the 4 default event types, exceptions, log messages, broken links, and feature usages. Each has a dashboard, most recent, most frequent, and new view, which generates a page very similar to what you're used to seeing.
As promised with version 2.0, we also have an all events section, which you can send literally any event to. We'll go into more detail on that in future posts and videos.
If we move to the top navigation bar, we see that you can now view data across all projects or by individual projects - a highly requested feature. We then have a quick time period selector, and finally the new filtering system, which allows you to quickly filter your exceptions. We'll show off that feature in it's own video soon.
Moving down into the data portion of the view, one feature that actually isn't new is that you can click and drag to select a period of time on the graph. Just a quick pointer there. Something that is new is the ability to select multiple exceptions or instances of an exception and perform bulk actions on it, such as Mark Fixed, Mark Hidden, or Delete. Again, more on that soon.
One last quick feature that we thought we would highlight today is that all times are now translated to the user's timezone, so your team members can always be working in their specific time no matter where they are.
That's about it for today, but keep an eye out for more updates as we close in on a release date for Exceptionless 2.0. We know some of these features and enhancements have been on your request list, and we're really excited to be this close to shipping them for you guys.
Giving back to the development community is important to us over here at Exceptionless. We love open source!
A plugin is a client-side addin that is run every time you submit an event.
We're all about exceptions, but sometimes, as developers, we run into bugs that don't throw them but still cause major havoc in the system. There are also times we just need to record an event with a custom message to help track down bottlenecks, etc.
The ability to log feature usages is one of the many 
Today, after much development and 
Oh boy! We're ready for you guys to beat on Exceptionless 2.0 in a sandbox environment!
We know, we know... It's been a while since our last update. As so often is the case, the holidays took their toll on work and waists here at Exceptionless over the past few months. However, we're not slacking too bad. In fact, we've got a small update on Exceptionless 2.0 that proves it's hasn't been all turkey and naps!
You know you want it! Bulk edit actions, that is. The ability to select multiple exceptions or occurrences of a single exception and do with them as you please, all at once. Well, they're coming, and today we've got a sneak peak!
If you've used Exceptionless, chances are a search or filter system would have helped you out more than once. We know, and we agree! That's why we've made it a priority with Exceptionless 2.0, which is coming very soon.
Lets take a quick look around, shall we?