Finding the Context for .NET Errors with Loupe

An error log on its own can be helpful for troubleshooting your application. But sometimes, you will need more than a single log to understand a problem. Context is key when troubleshooting, sometimes beyond what’s available in a simple text log file. A basic text log file may be hard to navigate with larger projects or lack supplemental data needed for proper context.

Here let’s go over the various ways Loupe 5 can help you navigate the whole context for any error in your .NET applications. Using different searches and tools with Loupe View and Resolve can help uncover what happened before an error occurred and how often it happened.

Contextual Information Held in the Session Data

With Loupe View, each session has a details page, which is a good start for learning about the context of an error. Here’s an example details page within Loupe 5:

Example Loupe Details page, showing supplemental data such as the operating system, app version, app promotion, hardware specs, and more

The details page includes the following data on the application session:

  • Application Version, Environment, and Promotion
  • Hardware Specs of the machine that ran the software, such as memory and CPU data
  • Start time, end time, and duration of the session
  • Information on the Operating System and version of .NET running the software.

These details help prioritize error resolution. For example, an error resulting from a performance issue may not matter if the machine specs for the session do not match your minimum requirements. Or maybe a particular error is only seen on a specific operating system rarely used by your customers. These are the kind of problems that would require the appropriate supplemental data to prioritize accurately.

If you want to view session details for local apps exclusively, you can check out our Loupe Desktop Client, which is entirely free and offers the session details view. Both clients use the same agents, meaning they will collect this data automatically for you without manually including it in each log (you can learn more about the advantages of logging supplemental data here).

The Loupe Resolve Event List

Loupe Resolve is our defect tracking module, which makes it very easy to track the occurrences of a specific error. Central to the Loupe Resolve module are Events. Events are items dedicated to a specific error or warning and track the following data on them:

  • Number of occurrences
  • Number of affected Sessions
  • Number of affected Computers
  • Date/time of the first and last occurrence

Here’s an example of the details tab for an Event, containing that information:

Details tab for a new event in Loupe Resolve

Events are categorized into three lists for easy review:

  • Most Recent: The most recent errors from your applications.
  • Most Widespread: Errors that happen across most individual machines/users.
  • Most Frequent: Errors that take place the most often, regardless of machine/user.

With each Event you can take the following actions:

Events options within the Loupe Resolve module

  • Create New Issue: If this is an application defect you want to resolve, create an Issue to track its resolution and to notify you if it ever appears again.
  • Add to Existing Issue: If you have an issue related to the Event, you can simply merge the Event into it.
  • Ignore Event: Delay the decision. This will remove the Event from the list until it happens again.
  • Suppress Event: Ignore the Event forever. It will not appear in the list, but you can still view the error in your logs.

Events overall help you organize errors in your application for prioritizing their resolution. It’s hard to know what’s important when all the errors are collected in the same log session, maybe appearing thousands of times each. Collating them into Events helps you see the error for what it actually is, understand its context within your log data collection, and make better decisions.

Clock View For Individual Events

Within Loupe Resolve, each Event has a “clock view.” The Clock View allows you to view logs before an event occurred without manually finding the entry in your session data. Below is an example workflow, showing a user clicks an event, reads the event log, and checks the Clock View for context:

Clock View example gif, showing flow from clicking event to seeing log context

The more you log, the more you will get out of this specific view. While it’s tempting to only send warning, error, and critical logs to your Loupe Repo and save storage, having information logs adds important context to this screen. Our recommendation usually is to log as much as you can, and this view is one reason to do so.

Understanding Your Users’ History with an Error

Many teams first learn of errors through communication with their users. Even though Loupe provides notification settings designed to prevent the need for these conversations, the truth is that errors will sometimes occur outside the bounds of your notification rules (or the notification may go ignored).

When these conversations do happen, Loupe makes it easy to learn more about our user’s experience by using the global search. You can search for a user’s name, and Loupe will show you a page including contact information, a list of applications they use, and a list of their recent sessions. You can comb through the session and see how their experience played out through your log data.

If you have Loupe Resolve enabled, this page will also include a list of recent Issues they have experienced (defects actively tracked for resolution) and recent events (uncategorized errors and warnings waiting for triage). These lists are the quickest way to see what problems users have experienced and the frequency of those problems.

Let Loupe Help You Find the Context

Loupe ensures you have the data you need to troubleshoot errors in your application. If you would like to give Loupe a try, you can learn more about our 30-day free trial in the link below.

See The Trial

Rock solid centralized logging

Unlimited applications, unlimited errors, scalable from solo startup to enterprise.