When capturing events with exception, link to current trace

Regarding: https://github.com/getsentry/sentry-dotnet/pull/848#discussion_r582439193

If the current Span is already mapped to a different exception (via BindException/span.Finish(ex)), what should happen?

Also, if the current span on scope is the root transaction, but the exception is bound to some nested Span (or maybe even Span that’s not part of the bound Transaction), what should happen?

There are probably other similar edge cases.

@bruno-garcia

[Tyrrrz]

@bruno-garcia thanks, I think it’s clear now.

The second use case is already supported I believe. I will implement the first use case.

[bruno-garcia]

Maciej helped me remember the original issue. I think it’s about being able to do this:

var span = hub.GetSpan()?.StartTransaction(...);

try
{
    // ...
}
catch (Exception ex)
{
    Sentry.CaptureException(ex);
}

// Not providing exception here
// It's automatically bound to the last captured exception
span?.Finish();

@bruno-garcia is this right?

That exception was captured within the scope of the open span, which is available on the Scope. So capturing the exception can copy the scope.context.trace information into the error event. That span is not connected to error that way, we don’t need to add anything from the error into the span.

This is one use case. There’s a second:

try {
Work();
catch (e) {
CaptureException(e);
}

Work() {
var child = span.startChild();
try {
throw null;
child.finish(); // assumes finishes with OK.
} catch(e){
child.finish(error);
throw;
}
}

With the snippet above, the transaction will be finished and flushed by the time the exception is rethrown. This means we’ll never know “within which span” let alone the trace that exception happened. The idea is to:

Work() {
var transaction = span.startTransaction();
try {
throw null;
transaction.finish(); // assumes finishes with OK.
} catch(e){
transaction.finish(e); // now the span has a reference to the Exception
throw;
}
}

The idea is to hold that Exception instance in a WeakRefMap so when we CaptureException(e) we can look up that exception by reference to get the Span instance.