Original post at: https://siderite.dev/blog/enhancing-net-exceptions-with-just-line-of-code/
Tracing and logging always seem simple, an afterthought, something to do when you've finished your code. Only then you realize that you would want to have it while you are testing your code or when an unexpected issue occurs in production. And all you have to work with is an exception, something that tells you something went wrong, but without any context. Here is a post that attempts to create a simple method to enhance exceptions without actually needing to switch logging level to Trace or anything like that and without great performance losses.
Note that this is a proof of concept, not production ready code.
First of all, here is an example of usage:
public string Execute4(DateTime now, string str, double dbl)
{
using var _ = TraceContext.TraceMethod(new { now, str, dbl });
throw new InvalidOperationException("Invalid operation");
}
Obviously, the exception is something that would occur in a different way in real life. The magic, though, happens in the first line. I am using (heh!) the new C# 8.0 syntax for top level using statements so that there is no extra indentation and, I might say, one of the few situations where I would want to use this syntax. In fact, this post started from me thinking of a good place to use it without confusing any reader of the code.
Also, TraceContext is a static class. That might be OK, since it is a very special class and not part of the business logic. With the new Roslyn source generators, one could insert lines like this automatically, without having to write them by hand. That's another topic altogether, though.
So, what is going on there? Since there is no metadata information about the names of the currently executing method (without huge performance issues), I am creating an anonymous object that has properties with the same names and values as the arguments of the method. This is the only thing that might differ from one place to another. Then, in TraceMethod I return an IDisposable which will be disposed at the end of the method. Thus, I am generating a context for the entire method run which will be cleared automatically at the end.
Now for the TraceContext class:
/// <summary>
/// Enhances exceptions with information about their calling context
/// </summary>
public static class TraceContext
{
static ConcurrentStack<MetaData> _stack = new();
/// <summary>
/// Bind to FirstChanceException, which occurs when an exception is thrown in managed code,
/// before the runtime searches the call stack for an exception handler in the application domain.
/// </summary>
static TraceContext()
{
AppDomain.CurrentDomain.FirstChanceException += EnhanceException;
}
/// <summary>
/// Add to the exception dictionary information about caller, arguments, source file and line number raising the exception
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private static void EnhanceException(object? sender, FirstChanceExceptionEventArgs e)
{
if (!_stack.TryPeek(out var metadata)) return;
var dict = e.Exception.Data;
if (dict.IsReadOnly) return;
dict[nameof(metadata.Arguments)] = Serialize(metadata.Arguments);
dict[nameof(metadata.MemberName)] = metadata.MemberName;
dict[nameof(metadata.SourceFilePath)] = metadata.SourceFilePath;
dict[nameof(metadata.SourceLineNumber)] = metadata.SourceLineNumber;
}
/// <summary>
/// Serialize the name and value of arguments received.
/// </summary>
/// <param name="arguments">It is assumed this is an anonymous object</param>
/// <returns></returns>
private static string? Serialize(object arguments)
{
if (arguments == null) return null;
var fields = arguments.GetType().GetProperties();
var result = new Dictionary<string, object>();
foreach (var field in fields)
{
var name = field.Name;
var value = field.GetValue(arguments);
result[name] = SafeSerialize(value);
}
return JsonSerializer.Serialize(result);
}
/// <summary>
/// This would require most effort, as one would like to serialize different types differently and skip some.
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
private static string SafeSerialize(object? value)
{
// naive implementation
try
{
return JsonSerializer.Serialize(value).Trim('\"');
}
catch (Exception ex1)
{
try
{
return value?.ToString() ?? "";
}
catch (Exception ex2)
{
return "Serialization error: " + ex1.Message + "/" + ex2.Message;
}
}
}
/// <summary>
/// Prepare to enhance any thrown exception with the calling context information
/// </summary>
/// <param name="args"></param>
/// <param name="memberName"></param>
/// <param name="sourceFilePath"></param>
/// <param name="sourceLineNumber"></param>
/// <returns></returns>
public static IDisposable TraceMethod(object args,
[CallerMemberName] string memberName = "",
[CallerFilePath] string sourceFilePath = "",
[CallerLineNumber] int sourceLineNumber = 0)
{
_stack.Push(new MetaData(args, memberName, sourceFilePath, sourceLineNumber));
return new DisposableWrapper(() =>
{
_stack.TryPop(out var _);
});
}
/// <summary>
/// Just a wrapper over a method which will be called on Dipose
/// </summary>
public class DisposableWrapper : IDisposable
{
private readonly Action _action;
public DisposableWrapper(Action action)
{
_action = action;
}
public void Dispose()
{
_action();
}
}
/// <summary>
/// Holds information about the calling context
/// </summary>
public class MetaData
{
public object Arguments { get; }
public string MemberName { get; }
public string SourceFilePath { get; }
public int SourceLineNumber { get; }
public MetaData(object args, string memberName, string sourceFilePath, int sourceLineNumber)
{
Arguments = args;
MemberName = memberName;
SourceFilePath = sourceFilePath;
SourceLineNumber = sourceLineNumber;
}
}
}
Every call to TraceMethod adds a new MetaData object to a stack and every time the method ends, the stack will pop an item. The static constructor of TraceMethod will have subscribed to the FirstChangeException event of the current application domain and, whenever an exception is thrown (caught or otherwise), its Data dictionary is getting enhanced with:
- name of the method called
- source file name
- source file line number where the exception was thrown.
- serialized arguments (remember Exceptions need to be serializable, including whatever you put in the Data dictionary, so that is why we serialize it all)
(I have written another post about how .NET uses code attributes to get the first three items of information during build time)
This way, you get information which would normally be "traced" (detailed logging which is usually detrimental to performance) in any thrown exception, but without filling some trace log or having to change production configuration and reproduce the problem again. Assuming your application does not throw exceptions all over the place, this adds very little complexity to the executed code.
Moreover, this will enhance exception with the source code file name and line number even in Release mode!
I am sure there are some issues with code that might fail and it is not caught in a try/catch and of course the serialization code is where people should put a lot of effort, since different types get to be serialized for inspection differently (think async methods and the like). And more methods should be added so that people trace whatever they like in thrown exceptions. Yet, as I said, this is a POC, so I hope it gets you inspired.
Top comments (0)