.NET Framework Logging Your Way

Loupe is much more than just another logging system

Loupe integrates with your application as a TraceListener. This means that Loupe captures all calls made to the .NET Trace and Debug classes (ex., Trace.Write, Trace.WriteLine, Debug.WriteLineIf, etc). In addition, Loupe listens for and captures a great deal of additional useful information that is ignored by most .NET logging systems:

• Console.WriteLine messages are ignored by the TraceListener infrastructure, but Loupe captures these messages and tags them so that they can be easily highlighted or filtered.
• Unhandled exceptions are automatically logged by Loupe including the full stack trace and details of the exception. In addition, with Loupe it very easy to log errors and exceptions in your code. For example, if you pass an Exception object to Trace.WriteLine, the exception details and stack trace are nicely formatted when viewed in Loupe Desktop.
• .NET system events such as AssemblyLoad, NetworkAddressChanged, NetworkAvailabilityChanged, PowerModeChanged, DisplaySettingsChanged, SessionSwitch, and TimeChanged are automatically recorded by Loupe. This can be extremely helpful when troubleshooting. For example, knowing screen resolution just changed might be crucial to understanding a display update error.
• .NET performance counters (perf counters) are automatically recorded so you have running profiles of memory, processor, network and disk performance
• Detailed configuration data for the session is automatically recorded to support usage analytics and problem troubleshooting. For example, version numbers for the O/S, application and each loaded assembly are captured because version mismatches are a common root cause of user-reported problems. Likewise, knowing time zone and culture often explains logic errors in applications used internationally.
• Custom metrics can easily be defined with Loupe to capture whatever metrics provide value to your team. Typical usages include tracking feature utilization and monitoring throughput, performance, and reliability at a system or module level.

Loupe delivers the loose coupling afforded by the Observer pattern in .NET’s design of the TraceListener class then goes well beyond TraceListener capabilities to capture all the other error, usage and configuration data you need to effectively support your applications or implement a customer experience improvement program.

Safe and efficient

Loupe is designed to be used in released production systems as well as during testing. To support this, the Loupe Agent was carefully crafted to be safe and efficient:

• All API calls are thread-safe and execute on low-priority background threads to ensure that logging has imperceptible impact on application responsiveness.
• In-memory buffers are bounded with graceful handling of overflow conditions.
• Persisted data is highly compressed to keep log files small.
• Disk storage for log files is automatically and intelligently managed to ensure that Loupe will never fill up your disk. Simple configuration settings let you specify the maximum age and size for logged data as well as ensuring that no data is logged at all unless the amount of available space on the disk exceeds a threshold.
• The logging agent is designed to always fail-safe. We recognize that it’s crucial for a logging system to never be the cause of a system failure.

Loupe works with Trace, Log4Net or any .NET log framework

If you prefer, Loupe can be easily integrated with your logging framework of choice. For example, Loupe can capture messages written to Microsoft.Extensions.Logging and log4net. If Loupe isn’t integrated with the logging system you use already it’s easy to do - Loupe includes an API designed for fast and efficient integration in the box!

Loupe also includes its own rich logging API supporting both simple and advanced logging usages.