[API Proposal]: Let accessing the instance of Exception (if any) on stack.

[voroninp]

Background and motivation

From time to time there's a need to not only check whether stack contains a bubbling up exception, but also to get access to the exception itself.

For example, in Open Telemetry library ExceptionProcessor uses Marshal.GetExceptionPointers to check whether exception is thrown withing the scope of activity.

However, if I don't want `OperationCancelledException' to be treated as an error, I need to have access to the instance of the exception thrown. Currently, there's no such possibility.

API Proposal

Well, I am not familiar with the intricacies of CLR, and whether such API is conceptually possible, but something like adding property to AppDomain could work:

public sealed class AppDomain
{
    public Exception? CurrentException {get;}
}

throw should set this property (overwriting previous value), catch with matching exception should set it to null.

API Usage

try
{
    throw new Exception();
}
finally
{
    // Here it is not null;
      Console.WriteLine(AppDomain.CurrentDomain.CurrentException is not null);
}

try
{
    throw new Exception();
}
catch
{
    // Here it is null;
   Console.WriteLine(AppDomain.CurrentDomain.CurrentException is null);
}
finally
{
    // Here it is null;
   Console.WriteLine(AppDomain.CurrentDomain.CurrentException is null);
}

try
{
    throw new Exception();
}
catch
{
    // Here it is null;
   Console.WriteLine(AppDomain.CurrentDomain.CurrentException is null);

   throw;
}
finally
{
    // Here it is not null;
   Console.WriteLine(AppDomain.CurrentDomain.CurrentException is not null);
}

Not sure whether value should propagate with async.

Task CheckMe() => Task.Run(() => Console.WriteLine(AppDomain.CurrentDomain.CurrentException is not null));
try
{
    throw new Exception();
}
finally
{
    // Here it is not null;
    Console.WriteLine(AppDomain.CurrentDomain.CurrentException is not null);

    // will it output true or false? 
    await CheckMe();

    // Here it is not null;
    Console.WriteLine(AppDomain.CurrentDomain.CurrentException is not null);
}

[ghost]

Tagging subscribers to this area: @dotnet/area-system-runtime
See info in area-owners.md if you want to be subscribed.

Issue Details

---

Background and motivation

From time to time there's a need to not only check whether stack contains a bubbling up exception, but also to get access to the exception itself.

For example, in Open Telemetry library ExceptionProcessor uses Marshal.GetExceptionPointers to check whether exception is thrown withing the scope of activity.

However, if I don't want `OperationCancelledException' to be treated as an error, I need to have access to the instance of the exception thrown. Currently, there's no such possibility.

API Proposal

Well, I am not familiar with the intricacies of CLR, and whether such API is conceptually possible, but something like adding property to AppDomain could work:

public sealed class AppDomain
{
    public Exception? CurrentException {get;}
}

throw should set this property (overwriting previous value), catch with matching exception should set it to null.

API Usage

try
{
    throw new Exception();
}
finally
{
    // Here it is not null;
      Console.WriteLine(AppDomain.CurrentDomain.CurrentException is not null);
}

try
{
    throw new Exception();
}
catch
{
    // Here it is null;
   Console.WriteLine(AppDomain.CurrentDomain.CurrentException is null);
}
finally
{
    // Here it is null;
   Console.WriteLine(AppDomain.CurrentDomain.CurrentException is null);
}

try
{
    throw new Exception();
}
catch
{
    // Here it is null;
   Console.WriteLine(AppDomain.CurrentDomain.CurrentException is null);

   throw;
}
finally
{
    // Here it is not null;
   Console.WriteLine(AppDomain.CurrentDomain.CurrentException is not null);
}

Not sure whether value should propagate with async.

Task CheckMe() => Task.Run(() => Console.WriteLine(AppDomain.CurrentDomain.CurrentException is not null));
try
{
    throw new Exception();
}
finally
{
    // Here it is not null;
    Console.WriteLine(AppDomain.CurrentDomain.CurrentException is not null);

    // will it output true or false? 
    await CheckMe();

    // Here it is not null;
    Console.WriteLine(AppDomain.CurrentDomain.CurrentException is not null);
}

Author:	voroninp
Assignees:	-
Labels:	api-suggestion, area-System.Runtime, untriaged
Milestone:	-

[grbell-ms]

Could Open Telemetry achieve the same result using a first-chance exception handler?
Whenever an exception is thrown, it could be stored in a thread/task -local field. The ExceptionProcessor could then access the most recent exception using the field and determine whether that exception is bubbling up using fnGetExceptionPointers.

[voroninp]

@grbell-ms

If I am not missing something particularly important, it should work.

async Task Main()
{
    using var activity1 = new Activity();
    try
    {
        using var activity2 = new Activity();
	await ThrowAsync();
    }
    catch
    {		
    }
}

public Task ThrowAsync() => Task.Run(() => throw new OperationCanceledException());

public sealed class Activity : IDisposable
{
    [ThreadStatic]
    private static GCHandle _currentExceptionHandle;
	
    static Activity()
    {
        AppDomain.CurrentDomain.FirstChanceException += (s,e) =>
	{
 	    if (_currentExceptionHandle.IsAllocated)
	    {
	        _currentExceptionHandle.Free();
            }
	    _currentExceptionHandle = GCHandle.Alloc(e.Exception, GCHandleType.Weak);
	};
    }
	
    private readonly IntPtr _exceptionAddress;

    public Activity()
    {
        _exceptionAddress = Marshal.GetExceptionPointers();
    }

    public void Dispose()
    {
        var curentExceptionAddr = Marshal.GetExceptionPointers();
	var isExceptionBubblingUp = _exceptionAddress != curentExceptionAddr && curentExceptionAddr != IntPtr.Zero;
	if (isExceptionBubblingUp && _currentExceptionHandle.Target is Exception currentException)
	{
	    Console.WriteLine($"Thrown exception {currentException}");
	}
	else if (_currentExceptionHandle.IsAllocated)
	{
	    _currentExceptionHandle.Free();
	}
    }
}

[grbell-ms]

@voroninp I would change GCHandle to WeakReference<Exception> for simplicity, but that's about what I was imagining. ☺️

But I'm no expert, so no promises this works without extensive testing. 😅

[voroninp]

I started with Weak reference, but decided, GCHandle will prevent memory allocations.

[adrianotr]

I ended up with the implementation below. Do you see any possible issues with it?

public sealed class DetailedExceptionProcessor : BaseProcessor<Activity>
{
    private const string EnabledKey = "DetailedExceptionProcessor.Enabled";
    private const string ExceptionKey = "DetailedExceptionProcessor.Exception";

    static DetailedExceptionProcessor()
    {
        AppDomain.CurrentDomain.FirstChanceException += (_, args) =>
        {
            if (Activity.Current is { } activity
                && activity.GetCustomProperty(EnabledKey) is true)
            {
                activity.SetCustomProperty(ExceptionKey, args.Exception);
            }
        };
    }

    public override void OnStart(Activity activity)
    {
        activity.SetCustomProperty(EnabledKey, true);
    }

    public override void OnEnd(Activity activity)
    {
        if (activity.GetCustomProperty(ExceptionKey) is Exception exception 
            && Marshal.GetExceptionPointers() != IntPtr.Zero)
        {
            activity.SetStatus(Status.Error);
            activity.RecordException(exception);
            activity.SetStatus(ActivityStatusCode.Error);
        }
        
        activity.SetCustomProperty(EnabledKey, null);
        activity.SetCustomProperty(ExceptionKey, null);
    }
}

[voroninp]

Yep came up to similar one https://gist.github.com/voroninp/704c1cb556bd03697ef0c80524de1b24

[jkotas]

Yep came up to similar one https://gist.github.com/voroninp/704c1cb556bd03697ef0c80524de1b24

This will leak the GCHandles over time as threads come and go. There is nothing that would take care of cleaning up of the GCHandles - GCHandles are low-level "unmanaged" resources that must be freed manually.

[voroninp]

@jkotas , despite it allocation with weak type?!

[jkotas]

I ended up with the implementation below. Do you see any possible issues with it?

This will capture the last thrown exception. It won't be the exception that the activity crashed with if there are exceptions thrown and handled during cleanup (finally blocks, using statements in C#, etc.). There is no good way to this 100% right today. It is what this new API proposal is about - introduce an API that allow you to do it properly.

[jkotas]

@jkotas , despite it allocation with weak type?!

Yes, the weak type for GCHandle means that the target is referenced weekly. It does change that the GCHandle itself must be explicitly freed.

You want to use WeakReference<T> here. WeakReference is a GCHandle with finalizer that cleans it up when no longer used.

[voroninp]

@jkotas , thanks, I'll fix it.