.NET 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
- Unhandled exceptions are automatically logged by Loupe including the
full stack trace and details of the exception. In addition, Loupe makes 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.
- .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
- .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
- 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 includes the "glue code" to work with log4net
as a log4net Appender.
In a similar way, the glue code for other logging systems can be easily developed.
Drop us a line if you have integrated Loupe with another logging systems
and would be willing to share your adapter with the community.
Loupe also includes its own rich logging API supporting both
simple and advanced logging usages.