Merge signal abort code before user based BeforeSend

src/Sentry/Platforms/Cocoa/SentrySdk.cs

@@ -93,6 +93,39 @@ private static void InitSentryCocoaSdk(SentryOptions options)
         {
             nativeOptions.BeforeSend = evt =>
             {
+                // When we have an unhandled managed exception, we send that to Sentry twice - once managed and once native.
+                // The managed exception is what a .NET developer would expect, and it is sent by the Sentry.NET SDK
+                // But we also get a native SIGABRT since it crashed the application, which is sent by the Sentry Cocoa SDK.
+
+                // There should only be one exception on the event in this case
+                if (evt.Exceptions?.Length == 1)
+                {
+                    // It will match the following characteristics
+                    var ex = evt.Exceptions[0];
+
+                    // Thankfully, sometimes we can see Xamarin's unhandled exception handler on the stack trace, so we can filter
+                    // them out. Here is the function that calls abort(), which we will use as a filter:
+                    // https://github.com/xamarin/xamarin-macios/blob/c55fbdfef95028ba03d0f7a35aebca03bd76f852/runtime/runtime.m#L1114-L1122
+                    if (ex.Type == "SIGABRT" && ex.Value == "Signal 6, Code 0" &&
+                        ex.Stacktrace?.Frames.Any(f => f.Function == "xamarin_unhandled_exception_handler") is true)
+                    {
+                        // Don't send it
+                        options.LogDebug("Discarded {0} error ({1}). Captured as  managed exception instead.", ex.Type, ex.Value);
+                        return null!;
+                    }
+
+                    // Similar workaround for NullReferenceExceptions. We don't have any easy way to know whether the
+                    // exception is managed code (compiled to native) or original native code though.
+                    // See: https://github.com/getsentry/sentry-dotnet/issues/3776
+                    if (ex.Type == "EXC_BAD_ACCESS")
+                    {
+                        // Don't send it
+                        options.LogDebug("Discarded {0} error ({1}). Captured as  managed exception instead.", ex.Type, ex.Value);
+                        return null!;
+                    }
+                }
+
+                // we run our SIGABRT checks first before handing over to user events
                 // because we delegate to user code, we need to protect anything that could happen in this event
                 try
                 {
@@ -115,6 +148,7 @@ private static void InitSentryCocoaSdk(SentryOptions options)
         {
             nativeOptions.OnCrashedLastRun = evt =>
             {
+
                 // because we delegate to user code, we need to protect anything that could happen in this event
                 try
                 {
@@ -163,43 +197,6 @@ private static void InitSentryCocoaSdk(SentryOptions options)
         // nativeOptions.DefaultIntegrations
         // nativeOptions.EnableProfiling  (deprecated)
 
-        // When we have an unhandled managed exception, we send that to Sentry twice - once managed and once native.
-        // The managed exception is what a .NET developer would expect, and it is sent by the Sentry.NET SDK
-        // But we also get a native SIGABRT since it crashed the application, which is sent by the Sentry Cocoa SDK.
-        nativeOptions.BeforeSend = evt =>
-        {
-            // There should only be one exception on the event in this case
-            if (evt.Exceptions?.Length == 1)
-            {
-                // It will match the following characteristics
-                var ex = evt.Exceptions[0];
-
-                // Thankfully, sometimes we can see Xamarin's unhandled exception handler on the stack trace, so we can filter
-                // them out. Here is the function that calls abort(), which we will use as a filter:
-                // https://github.com/xamarin/xamarin-macios/blob/c55fbdfef95028ba03d0f7a35aebca03bd76f852/runtime/runtime.m#L1114-L1122
-                if (ex.Type == "SIGABRT" && ex.Value == "Signal 6, Code 0" &&
-                    ex.Stacktrace?.Frames.Any(f => f.Function == "xamarin_unhandled_exception_handler") is true)
-                {
-                    // Don't send it
-                    options.LogDebug("Discarded {0} error ({1}). Captured as  managed exception instead.", ex.Type, ex.Value);
-                    return null!;
-                }
-
-                // Similar workaround for NullReferenceExceptions. We don't have any easy way to know whether the
-                // exception is managed code (compiled to native) or original native code though.
-                // See: https://github.com/getsentry/sentry-dotnet/issues/3776
-                if (ex.Type == "EXC_BAD_ACCESS")
-                {
-                    // Don't send it
-                    options.LogDebug("Discarded {0} error ({1}). Captured as  managed exception instead.", ex.Type, ex.Value);
-                    return null!;
-                }
-            }
-
-            // Other event, send as normal
-            return evt;
-        };
-
         // Set hybrid SDK name
         SentryCocoaHybridSdk.SetSdkName("sentry.cocoa.dotnet");