The beauty of open-source solutions is that you are often given the option to self-host or pay for an easy hosted solution by the company or people who created the project. This is true of many projects. Ghost is a popular example of this from the blogging world. Some analytics serves, including Matomo, allow users to choose between a hosted and a self-hosted solution. In that same vein, Exceptionless provides a self-hosted option for those who would like to host their own error monitoring.
Today, we're going to walk through setting up a self-hosted Exceptionless instance. Let's get started!
Exceptionless provides a simple Docker image to help get started with self-hosting. We're going to make use of that, so the first step is to download Docker for desktop if you don't already have it. Once you're able to download that and start it, you should then be able to execute docker commands from the command line. Test it out by running docker stats in the command line.
Pretty cool, right? Just by downloading and running the desktop application, you also have access to the Docker CLI. That CLI is what we'll need to run our self-hosted instance of Docker.
Let's make sure we can get Exceptionless running locally. Ready for how easy this is? Are you?
Ok, start up Docker Desktop, then in your command line, run:
docker run --rm -it -p 5200:8080 exceptionless/exceptionless:latest
This will check to see if you've already downloaded the latest Exceptionless release, and if not, it will install all of the necessary dependencies. This is important because Exceptionless is split into a client-side front-end and a server-side back-end. Docker lets all of this be combined.
When the process in your command line finishes up, open your browser and navigate to http://localhost:5200. If all went well, you should see the Exceptionless login page.
Go ahead and sign up for an account. Keep in mind, this is not a good production solution, but it's a great way to get started with a self-hosted error monitoring solution.
Along with the front-end that we're looking at now, you also have a full Exceptionless server running. To prove it, let's run a simple cURL command.
Make sure to use the email and password you just signed up with. You should get a token back. This shows you that the API is running successfully and you can now do everything you would with a hosted Exceptionless instance, but locally. Go ahead and try it out. Here are the full API docs for Exceptionless.
The problem here is the data you save in this run of your self-hosted Exceptionless instance will not be saved between runs. As soon as you shut down Docker and exit the application, your data will be deleted and you'll be starting from scratch. That's no fun. Let's fix it.
Go ahead and shut down Exceptionless either by exiting in the command line or by going into your Docker Desktop Dashboard and clicking the stop button your Exceptionless instance. Once it's stopped, open up your command line again and run:
Now, when you sign up at http://localhost:5200, your data will be persisted. You can start tracking errors locally and that data will be shown in your Exceptionless dashboard even after you shut down Docker/Exceptionless and restart it.
Your homework: Try running this locally with SSL and SMTP enabled. It's just as simple as everything else we've done so far because Exceptionless has really taken the time to make sure the developer experience is top-notch. Check out the instructions here.
Error monitoring is incredibly important to both your customer's experience and your own sanity. To give yourself true control over error monitoring, you can choose a solution like Exceptionless, and as you've seen here, self-host it pretty easily. Of course, if you'd rather let Exceptionless take care of hosting, that's covered too.
Now, you can go and experiment with your newly installed, self-hosted, error monitoring service. Will you let it run on your machine? Will you tinker and get it production-ready? Will you deploy it to a remote server somewhere? (That last one might be the subject of a future post 😉)
For anyone who has built an application, you've probably built it on some library or framework that changes over time. To keep up, you have to upgrade your application. However, there are varying schools of thought around when you should upgrade. At Exceptionless, we like to be on the bleeding edge. As an open-source company, we feel a responsibility to the community to know and understand the open-source tools we use. As such, we have already upgraded Exceptionless to use .NET 5.0.
To give you a little background, .NET 5.0 was introduced in May of 2019. The announcement was a big one as Microsoft chose to drop the .NET Core distinction. Going forward, we will just see cross-platform support in the form of ".NET X.X". The first release candidate for .NET 5.0 was announced September 13, 2020. We chose to upgrade and begin using .NET 5.0 immediately. That decision was driven by Microsoft's commitment to supporting production usage of the rc1 release. And as it turned out, the upgrade process was not too painful at all.
All in, the upgrade took about one hour and was a very small commit. You can actually see the commit here. This is really a testament to the foundation we've built here combined with the long-running foundation Microsoft has built with the .NET framework. Exceptionless is no small application and yet we were able to upgrade to an early release candidate in order to capitalize on new capabilities. To highlight the scale of Exceptionless and the relatively minor impact the upgrade process had, let's take a look at some of our numbers.
1.4 TB Elasticsearch Cluster
173M Elasticsearch Documents
384M Redis Operations/Day
122M HTTP Requests/Day
2,476 GitHub Stars
568 GitHub Forks
There are always multiple schools of thought around running pre-release code on production applications, but for us, the decision was a no-brainer. The top motivators were performance improvements, availability of new C# features, and Docker improvements for our self-hosted solution.
We are a developer tool, and as such, performance is important. .NET 5.0 allows us to leverage the performance boosts associated with the upgrade and pass that along to our customers and the community around us. We compared our memory and performance from .NET Core 3.1 to the .NET 5.0 rc-1 release and saw enough gains to help support our decision to move forward with rolling this out to production.
The .NET team's focus on pushing the boundaries of garbage collection was an important factor for us. GC is such a critical component to performance, and it impacts almost everything within the framework. We were excited to see the focus Microsoft put on continuing to improve performance in this area and felt the gains were enough to really tilt us towards our production release of Exceptionless using .NET 5.0.
As a quick, visual example, of other improvements, here's a table Ben Adams tweeted that gives us glimpse into the performance gains of .NET 5.0 over .NET 3.1
With the release of C# 9, we, once again, get significant improvements. Anytime a programming language releases new features, it's important to ask yourself whether those features are necessary for your application. In the case of C# 9, there are multiple features we believe will help improve the code legibility, overall codebase size, and ultimately performance. It always comes back to performance!
Pattern matching in C# 9 is a feature we are particularly excited about. If you're interested in a deep dive into the improvements here, Anthony Giretti has a great post highlighting the new functionality. For Exceptionless, pattern matching represents a better way for us to execute logical operations we already support. In doing so, we can reduce code complexity, improve performance, and deliver a better experience.
Records are an exciting new feature in C# 9 as well. Data immutability is important, once again, for—you guessed it—performance. The way Dave Brock puts it on his blog is apt:
Immutable types reduce risk, are safer, and help to prevent a lot of nasty bugs that occur when you update your object.
Data records give us immutability in the form of a dedicated struct. Rather than extending the functionality of C#'s existing structs, records give us the ability to reach for a data-specific type that offers built-in immutability.
We are proud of our open-source roots. We want to make self-hosting Exceptionless as easy as possible, and Docker has made this a reality. Our Docker image is the fastest and easiest way to get started with self-hosting and .NET 5.0 only improves the Docker experience.
.NET 5.0 enables better resource compaction which, in turn, reduces the cost associated with Docker images. This is important to the bottom line, but .NET 5.0's improvements go beyond dollar-savings with Docker. The new features also improve memory constraints which—say it with me now—improve performance.
One additional benefit of the .NET 5.0 rc-1 release candidate is how our Docker image now works better with Kubernetes resource constraints. We're pretty big fans of Docker and Kubernetes, so anything to improve the experience around both is a win in our eyes.
We took an early release candidate from a massive framework and rolled it out to production almost immediately after it was announced. Are we crazy? We don't think so, but you decide.
In development, we tend to think of errors as things that are thrown when our code does not execute properly. Errors can be caught and handled or they can be missed and result in uncaught exceptions. But how do we classify errors that are not directly caused by the code we write? How do we identify and address errors that are caused by the design decisions we made (or didn't make)?
You may already be using an error monitoring service, and if you are, you could continue using that and reach for yet another tool to help you with your user experience woes. Or, rather than adding another product to your endless list of tools that keep your application running, you can use the error monitoring service to both monitor for traditional errors and user experience problems.
Let's take a look at how we can do this. There are plenty of logging services out there, and most of them do the same thing. However, we're going to take a look at Exceptionless. Exceptionless is an especially attractive choice for three reasons:
The API allows us to do exactly what I'm proposing in this article.
While self-hosting may be an attractive option (and one that I will surely write about ina future post), we're going to sign up for a free account using Exceptionless's hosted platform. To do so, go to https://exceptionless.com and click the Sign Up button in the top-right:
Once you sign up, you'll be prompted to name your team and project. You'll also need to choose the language in which your project is written. I'm choosing NodeJS, but you can choose whatever language applies to you because I'll be referencing cURL commands to keep our solution as general-purpose and adaptable as possible. Once you've created a project, you will be provided an API Key. Hold on to that, we'll need to use it as a bearer token later.
*Pro-tip: To convert a cURL command to the language of your choice, use Postman and import the raw command. You can then choose the code option and see how to run the API call in the language you prefer.
You'll want to follow the documentation to set up your codebase to send errors appropriately to Exceptionless, but we will also need to think about how we are going to handle these UX errors.
To do this, let's first think about some of the problems a user may face on a site and how we can handle them. A simple example that I can think of is what I'm going to call "Happy Path Slippage." We build applications with a happy path in mind. It's how we test, naturally. We have to force ourselves to test outside of the happy path, so it's also important to monitor how often our users deviate from the happy path.
Let's say we have a simple e-commerce application. The happy path, in this case, would be:
User signs up
User searches for a product
User adds product to shopping cart
User checks out
That is the ideal flow, but we know users won't always follow that flow. However, what we don't know is how often users will deviate and if they do deviate. To track this with Exceptionless, we are going to use simple GET requests with a query parameter to build a funnel analysis. We will want to track product searches, shopping cart adds, and checkouts.
Let's start with the setup for product searches. Remember, we're going to use a GET request. You can read more of the Exceptionless documentation here, but the request is pretty simple. We will want to pass in an indicator that the event is a productSearch and what the product is. We can do that like this:
curl --location --request GET 'https://api.exceptionless.io/api/v2/events/submit/usage?source=productSearch&message=YOUR_PRODUCT'\ --header 'Authorization: Bearer YOUR_API_KEY'
Feel free to add whatever product name you'd like in the query. Just replace YOUR_PRODUCT with the name of the product you'd like to track. You can run the cURL command from the command line or you can use it to build a real request you would use in your app. If we run that then take a look at our dashboard in Exceptionless, we can start to make use of the data.
The Exceptionless dashboard takes you to a handy chart of most frequent exceptions/errors. However, we're tracking User Experience issues tied to features in our application, so those events won't appear on the Exceptions dashboard. Instead, if you click the Features Usage link on the left navigation, then click Events, you should see your new productSearch event.
Pretty cool! This alone starts to become useful. We can cut out a separate analytics tracking tool by using our error monitoring service (Exceptionless in this case) to track events outside the normal error reporting. But we can take it a step further.
Remember, we want to track the funnel from search to checkout. So, let's send through another event representing a cartAdd when a user adds a product to their shopping cart. Here we are adding an extra parameter to also track how many of the product is added to the cart.
curl --location --request GET 'https://api.exceptionless.io/api/v2/events/submit/usage?source=cartAdd&value=QUANTITY_ADDED&message=YOUR_PRODUCT'\ --header 'Authorization: Bearer YOUR_API_KEY'
Exceptionless has real-time monitoring, so if you flip back to your dashboard after running the above command, you should already see the event in the list:
I think you're already seeing how easy this is, but let's round this out by adding a checkout event to track.
curl --location --request GET 'https://api.exceptionless.io/api/v2/events/submit/usage?source=checkout&message=YOUR_PRODUCT'\ --header 'Authorization: Bearer YOUR_API_KEY'
Again, your Exceptionless dashboard should update in real-time. This is starting to shape up! Now, let's dive into the events because right now we have the start of a nice funnel analysis, but we don't know yet what products were searched for, added to the cart, and checked out. The cool thing here is we can click into an event like productSearch for example and get detailed info.
Go ahead and try it. Click on the event and you'll be taken to a dedicated Event Occurrence page.
This is useful information. Combined with our user experience funnel analysis, we can start to make product decisions. Just for fun, I want to show you what this could look like when leveraging the Most Frequent view.
Again, we should click on the Features Usage link on the side navigation. This time, we'll choose the Most Frequent option. I've created a bunch of events so that we can see how useful the Most Frequent view can be.
Now we have the makings of a useful way of tracking the user experience right from within our error reporting tool. The benefit here is that we can use a single tool to help us with monitoring, bugs, event tracking, and user experience. Exceptionless makes this incredibly easy, is self-hostable, is open source, and if you choose the hosted option is very affordable.
Go forth and track errors AND user experience all in one place.
Exceptionless 5.0 is here and we wanted to make a quick blog post highlighting the new features, bug fixes, and of course upgrading.
In this release, we focused primarily on migrating the application to ASP.NET Core, localization, along with ongoing performance enhancements and bug fixes.
Exceptionless now runs on ASP.NET Core! This brings in many performance advantages as well as cross platform support.
Docker/Kubernetes based hosting is now the default hosting model. This will bring seamless and quick upgrades while reducing the amount of environmental related errors.
Added Chinese localization support. Thanks @Varorbc, @edwardmeng for that contribution!
Added support for using various different cloud hosted services (e.g., Aliyun, Minio, S3) and metric providers (e.g., InfluxDB). Thanks @edwardmeng for that contribution!
When viewing 404 event types, you will now see a grid column for IP addresses. This will allow you to quickly identify any bots or security scans that might be happening to your applications.
In addition to client side plugins that will remove sensitive user data, we've added server side code as well to remove any missed sensitive user data.
Added the ability to delete your account on the manage account page.
If you are using our hosted service, you do not need to upgrade anything on your end. If you are self hosting Exceptionless and upgrading from version 4 or 5, a little work is needed to get up and running using the new docker images and configuration. See our upgrade guide for more information.
Whether you’re developing a quick module, application, or full blown, go-to-market product, you’re going to need some form of event logging throughout the development process. It can be done without, but you’ll be making your job multiple magnitudes more difficult and losing valuable man hours that could be put towards making your product better instead of just not breaking.
Event logging provides a detailed record of events, bugs, and custom triggers that occur in your application, environment, or product. The information collected gives you a wealth of data to both forensically troubleshoot a bug after it’s occurred as well as proactively to prevent future errors.
This now service is now an invaluable resource to increase your development team’s efficiency and productivity as well as increasing visibility of what goes on behind the scenes in your development environment. On top of that, it also helps maximize application uptime and operation by minimizing the long-term effects of bugs and unwanted events.
Individual raw event logs are too dense and unwieldy to be reviewed. If you were to rely on the raw data, you’d need to specifically hire someone to dig through all that info to pass on the important info to your developers. Event tracking software will parse the data and catalog the important information in an intuitive manner to make everyone’s lives easier. In a nutshell, it will shine a light on the needle in your proverbial haystack.
The great thing about event tracking is that it’s running around the clock. When you and your team aren’t in the office, it’s keeping a watchful eye on your project and collecting data 24/7. It collects data from all sources across your development environment and all of this data is funneled to your dashboard for real-time reporting and criteria based sorting. This allows you to both find the event you’re looking for and quickly dive into its potential causes.
Exceptionless groups common events into stacks based on where the event occurred and the type of error. This cleans up and consolidates the data on your dashboard and in your reports to keep it from being cluttered as well as keeping that information in a single place for your analysis. Even though the event’s footprint is smaller, you’ll still be able to identify larger iterations of the same event to prioritize your work.
It can be incredibly difficult to replicate an event that a user encountered. There’s a slew of information you need to accurately track the cause and the user simply may not, or cannot, provide it. You could spends hours or days just trying to isolate what triggered an event. Hours that could have been put towards building a new feature or getting your product to market.
Event tracking software makes it so a bug that once took a week to find can be found, patched, and pushed live in a matter of minutes or hours instead of days or weeks. Spend less time on maintenance and more time innovating.
Your developers’ time is valuable, and expensive. Even though it’s important, having them blindly diving down rabbit holes to chase bugs and other events can be incredibly costly and not productive. Not every project has a big budget and you may have to work faster and more efficiently to wrap it up without going over budget. While an event logging software may sound like an additional expense, the amount of time you save troubleshooting and fixing bugs will easily cover the cost. And the great thing is, the more you use it, the more you save.
All the information in the world won’t help you if it’s impossible to dig through. We specifically built our dashboard to give a clear high level view of your application while still being clear the further you drill down into individual events and bugs. You can quickly view the health of your application, track data from actually users, and intelligently drill down into recent errors. It seamlessly unites metrics and productivity while you analyze and explore data to rapidly troubleshoot your application.
Bugs, exceptions, issues, faults, errors, incidents, whatever you want to call them, they’re unavoidable. No matter how elegantly you think you wrote your code, no matter how many user cases you think you’ve covered, your application is going to have bugs and part of our jobs is to find those bugs and fix them. You can track these bugs using an Excel or Google sheet (if you’re a glutton for punishment), but the best way is to use a bug tracking platform that tracks, records, reports, and manages these exceptions for you.
In its simplest form, bug tracking is when a developer is alerted to an event when their code does not operate as intended. They catalog the issue, collect as much information as they can that led to said event, and attempt to recreate it so they can fix the problem.
As you can imagine, doing all of this manually becomes quite unwieldy the larger an application gets. On top of that, with larger applications comes additional layers of complexity that a user simply can’t account for or give you the proper information to set you on the path for resolving their bug. This is why it’s so important to have an automated event tracker.
A bug tracking software of any kind is a must have for any sort of application at any stage of development, even months or years after it goes live. The larger your product, the more important it is to have some form of bug tracking implemented. (This is also a tell tale sign of whether or not a development team is worth their salt.)
You can spend hours, days, weeks, and even months trying to track down a bug if you don’t have the right information. Having a software platform in place for tracking bugs helps your development team work smarter and faster when troubleshooting these issues. The software will record, document, and organize these bugs automatically with critical information about the user, event, and the application at the time it occurred. No more chasing down info. It’s already done for you!
C# is one of, if not the most used programming language of the last 15 years. It’s an elegant object oriented language that allows developers to build .NET applications. While it can be daunting at first if you aren’t familiar with it, it’s actually quite simple to use and relatively easy to learn. However, the applications can get quite complicated because of its structure. A misplaced bracket, variable, or object can cause cascading issues that aren’t easy to detect or remedy.
Due to the potentially complicated landscape that is a C# application, detecting, diagnosing, and fixing a bug can be a near-Herculean task, especially if you aren’t the developer that originally created said application. It may have been coded in a non-optimal way or due to time constraints, it had to be done in a hacky way that’s just waiting to implode. This is where a bug tracking solution for your C# application is an invaluable addition to your infrastructure.
You can’t be everywhere at once and see everything, especially in the larger C# applications. Having C# bug tracking software guarantees that you can be with it collecting data in the background. Regardless of when a bug occurs, our platform will have a full report with everything you need to set your development team in the right direction.
Exceptionless’ automated bug tracking already tracks an enormous amount of contextual information automatically, but you can track even more information by creating a custom object. If you want to grab info on what was in a customer’s before it threw a bug, custom object. Once created, you can set these objects as top level tabs to improve their visibility.
Every bug is intelligently tracked on our dashboard and consolidated into stacked groups based on where it occurred and the type of bug. Not only does this keep things nice and tidy, but it also lets you triage whether or not a bug needs to be fixed as soon as possible. These reports also persist after the bug has been fixed so you have historical data just in case the bug resurfaces later.
Our bug reports extensively tracks a robust set of information to help you quickly track down and fix the error. The default information covers type of error, stack trace, date, request information, and environment information, but that can easily be expanded upon and tailored to your application with custom objects.
We have extensively documented our platform and API to make it easy and painless to use. You can use our fluent API to easily add custom objects, tags, and other information as well as marking certain errors as vitally important.
RECAP
Troubleshooting and fixing bugs is part of our jobs as developers and, as the saying goes, we need to work smarter, not harder so we can spend more time creating new features to our applications rather than patching errors. Exceptionless’ C# bug tracking software will intuitively, and automatically, organize any bugs that do occur to help you pinpoint the cause so your application can get back on track.
Bug tracking. Two words that you’ll never be able to escape as a developer. Our goal as developers is to always create a high quality product with pristine code, but let’s face it, nobody’s perfect and accidents happen. Bugs are going to pop up no matter how hard we work or how much we plan ahead. They’re an inevitable part of the job and the more complex your project becomes, the more likely unexpected bugs are to start popping up.
You can try and track these little annoyances manually, like some kind of an animal, or use a bug tracking software to significantly speed up the process and provide a log of what happened and where to prevent future iterations of the same issue.
At its core, bug tracking is when a developer tracks, logs, and resolves a bug or issue that caused their software to not perform as intended. This could be as simple as a missing semicolon or trailing slash or as complicated as a vulnerability in your back end.
In the old days of yesteryear, there weren’t any (good) bug tracking software platforms so developer had to exhaustively QA test their code before publishing and even then, they couldn’t catch everything. Bugs sometimes went to production undetected and they relied on users to report issues so they could investigate them manually later. As you can imagine, this was an incredibly time consuming and tedious process that ate up far too much time and resources that could have been spent developing the next great feature to propel sales.
At the risk of sounding pretentious, Kurt Vonnegut said that "Everyone wants to build and nobody wants to do maintenance." Whether we like it or not, we can’t always build the next big feature or streamline the functionality of our platform. Sometimes we have to hunt down elusive bugs and do maintenance to keep our code clean and keep a solid foundation so we can keep building.
Ignoring or intentionally leaving bugs to multiply in the code can damage your company’s reputation (and revenue) if one of these errors affects your customers’ ability to do their job or compromises their information. It will save everyone involved a ton of time, money, and headache if you simply implement a bug tracking software from the get go. Your code will stay clean and you’ll stop losing users, leads, and customers. It’s a win / win for everyone.
ASP.NET is a coding model used to build enterprise class applications with minimal coding. This not only cuts down on the amount of man hours necessary to complete your project, but also simplifies running and maintaining said application due to its (relative) simplicity. If you’re new to the ASP.NET platform, do not be surprised if it’s not the easiest thing to pick up, but once you do, you’ll understand why it’s one of the most popular development platforms out there. (There are a ton of tutorials & learning environments if you’re looking to learn the platform.)
Just because ASP.NET is a simplified coding platform doesn’t mean that you won’t have bugs. If anything, it can make them a bit tougher to find, but that’s where having an integrated bug tracking suite comes into play.
Our bug tracking software suite helps development teams find, record, and categorize bugs and errors in real time for your ASP.NET websites, applications, and services. It organizes information in an intuitive and easy to digest dashboard to help your platform become exceptionless.
Bugs can happen anywhere at anytime and if you aren’t watching, they can go unnoticed for months, sometimes years. Our bug tracking software runs in the background of your ASP.net platform 24/7/365 so if something happens, we have a full report with the data you need to craft surgical solution with ease
Once a bug has been discovered and tracked, there’s no need to attempt to replicate the issue. A detailed report is automatically created that intelligently organizes important information to help resolve the bug.
Curious about what else is captured in our reports? Check out the full write up on our detailed error reports.
For ease of browsing, our platforms groups errors together based on a variety of criteria, i.e. date, type, platform, browser, etc. to help you drill down and pinpoint the cause of bugs in your application. It also keeps a full history of the exception even after it’s been resolved in case it resurfaces in the future.
You no longer have to worry about your customers letting you know about bugs or checking a dashboard every morning. Simply update your notification settings and get instant emails when an error happens, only when new errors happen, or not at all. You can even flag resolved errors to send emails in the event that regress to their previously broken state.
Bugs are an inescapable part of any ASP.NET application, but they don’t have to be an unmanageable nuisance. Implementing an error tracking solution will help you organize bugs as they occur while providing vital information that will help you pinpoint the cause and quickly resolve them. Keep your development teams updating your application with new features with an ASP.NET bug tracking software.
We've added .NET Standard 2.0 support, which allows you to easily integrate with UWP applications now.
Microsoft.Extensions.Logging support has also been added via the Exceptionless.Extensions.Logging client. Thank you @moogle001 for contributing to this feature!
Thanks to @jamierushton, we now allow null and default values to be serialized, which translates to greater insight into contextual data.
We're now using GitLink to debug packages more easily.
If you are using our hosted service, you do not need to upgrade anything on your end. If you are self hosting Exceptionless and upgrading from version 2 or 3, you should just have to update your NuGet packages. See our upgrade guide for more information.
Since we first introduced Slack integration with the goal of further improving notifications in Exceptionless, we've come back around with updates, a few bug fixes, and wanted to give everyone a quick all-in-one overview of the feature!
Thanks to everyone that has provided feedback, bug reports, and suggestions. If you have any, don't hesitate to submit an issue over on GitHub. We're always looking to improve and would love your input!
Along the way, we have run into incoming webhook issues, some usability/setup workflow updates that needed to be made to make the process more usable, and, among other things, incorrectly created action URLs that weren't being handled correctly with rate limiting.
Then, click on "Add Slack Notifications" and log in to your slack team.
Once logged in, you will need to select the channel you want Exceptionless Notifications to post to and click Authorize.
Once authorized, you can then configure the different notification settings by going back to the Exceptionless app and into the project's integrations tab again.
Once integrated and configured, notifications will look something like the below screenshot, with the message, type of event, stack trace, links to actions, etc.
We're excited to keep improving notifications, and would love for you guys to continue testing and providing feedback! What else would you like to see happening with notifications? What are we doing right, and wrong?
Integrations with other chat & productivity tools like HipChat and Microsoft Teams are on our list, as well, so if you use these please ping us and let us know so we can gauge interest!
Recently, we released Exceptionless.JavaScript 1.5. The major update for the release was the addition of universal JavaScript (React Universal) support! More details below. The key is that we can now run in server side node apps, or in the browser, with a single script and do the right thing!
TL;DR: Isomorphism is the functional aspect of seamlessly switching between client- and server-side rendering without losing state. Universal is a term used to emphasize the fact that a particular piece of JavaScript code is able to run in multiple environments. - Gert Hengeveld, Isomorphism vs Universal JavaScript
We have gotten lots of requests for Universal JavaScript support. What this means is that you can use a library in the browser or server without any changes from the end user. This is great because you can just consume the library and just know it will work using the same API service no matter where you want to use it. The main con of using a universal client is the increased payload size as you know have to send node support to the browser as well.
We implemented universal JavaScript support by bundling both the browser and node scripts together. But it wasn't as easy as concatenating the files together. We had to refactor the node and browser entry points so that they would automatically run, while ensuring that the initialization of environment specific code (storage, network, etc.) only ran when specific environment conditions were met. This is pretty easy to do with an IIFE function and a quick if check as shown here. Next, we needed to provide a new entry point that imported both of the entry points which ensures that browser and node entry points run.
This update adds support for universal apps, and a React Universal sample that shows the exact changes that were required to get everything working and setup can be found here. The pull request for universal support can be found here.
To target it, you just need to reference the universal script (exceptionless.universal.js), this will happen automatically if you install via browserfiy or webpack.
/