feat: appdomain exit flush

src/Sentry/Integrations/AppDomainProcessExitIntegration.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Diagnostics;
+using Sentry.Internal;
+
+namespace Sentry.Integrations
+{
+    internal class AppDomainProcessExitIntegration : IInternalSdkIntegration
+    {
+        private readonly IAppDomain _appDomain;
+        private IHub _hub;
+
+        public AppDomainProcessExitIntegration(IAppDomain appDomain = null)
+        {
+            _appDomain = appDomain ?? AppDomainAdapter.Instance;
+        }
+
+        public void Register(IHub hub, SentryOptions options)
+        {
+            Debug.Assert(hub != null);
+            _hub = hub;
+            _appDomain.ProcessExit += HandleProcessExit;
+        }
+
+        public void Unregister(IHub hub)
+        {
+            _appDomain.ProcessExit -= HandleProcessExit;
+            _hub = null;
+        }
+
+        internal void HandleProcessExit(object sender, EventArgs e)
+        {
+            (_hub as IDisposable)?.Dispose();
+        }
+    }
+}

src/Sentry/Integrations/AppDomainUnhandledExceptionIntegration.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Diagnostics;
+using System.Threading.Tasks;
 using Sentry.Internal;
 
 namespace Sentry.Integrations

src/Sentry/Internal/AppDomainAdapter.cs

@@ -5,16 +5,26 @@ namespace Sentry.Internal
     internal interface IAppDomain
     {
         event UnhandledExceptionEventHandler UnhandledException;
+
+        event EventHandler ProcessExit;
     }
 
     internal sealed class AppDomainAdapter : IAppDomain
     {
         public static AppDomainAdapter Instance { get; } = new AppDomainAdapter();
 
-        private AppDomainAdapter() => AppDomain.CurrentDomain.UnhandledException += OnUnhandledException;
-
+        private AppDomainAdapter()
+        {
+            AppDomain.CurrentDomain.UnhandledException += OnUnhandledException;
+            AppDomain.CurrentDomain.ProcessExit += OnProcessExit;
+        }
+
         public event UnhandledExceptionEventHandler UnhandledException;
 
+        public event EventHandler ProcessExit;
+
+        private void OnProcessExit(object sender, EventArgs e) => ProcessExit?.Invoke(sender, e);
+
         private void OnUnhandledException(object sender, UnhandledExceptionEventArgs e)
             => UnhandledException?.Invoke(this, e);
     }

src/Sentry/PublicAPI.Unshipped.txt

@@ -1 +1 @@
-
+static Sentry.SentryOptionsExtensions.DisableAppDomainProcessExitFlush(this Sentry.SentryOptions options) -> void

src/Sentry/SentryOptions.cs

@@ -378,7 +378,8 @@ public SentryOptions()
 
             Integrations
                 = ImmutableList.Create<ISdkIntegration>(
-                    new AppDomainUnhandledExceptionIntegration());
+                    new AppDomainUnhandledExceptionIntegration(),
+                    new AppDomainProcessExitIntegration());
 
             InAppExclude
                 = ImmutableList.Create(

src/Sentry/SentryOptionsExtensions.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.ComponentModel;
 using System.Linq;
 using Sentry.Extensibility;
@@ -29,9 +30,14 @@ public static void DisableDuplicateEventDetection(this SentryOptions options)
         /// Disables the capture of errors through <see cref="AppDomain.UnhandledException"/>
         /// </summary>
         /// <param name="options">The SentryOptions to remove the integration from.</param>
-        public static void DisableAppDomainUnhandledExceptionCapture(this SentryOptions options)
-            => options.Integrations = options.Integrations.RemoveAll(p => p.GetType() == typeof(AppDomainUnhandledExceptionIntegration));
+        public static void DisableAppDomainUnhandledExceptionCapture(this SentryOptions options) => options.RemoveIntegration<AppDomainUnhandledExceptionIntegration>();
 
+        /// <summary>
+        /// Disables the capture of errors through <see cref="AppDomain.ProcessExit"/>
+        /// </summary>
+        /// <param name="options">The SentryOptions to remove the integration from.</param>
+        public static void DisableAppDomainProcessExitFlush(this SentryOptions options) => options.RemoveIntegration<AppDomainProcessExitIntegration>();
+
         /// <summary>
         /// Add an integration
         /// </summary>
@@ -40,6 +46,15 @@ public static void DisableAppDomainUnhandledExceptionCapture(this SentryOptions
         public static void AddIntegration(this SentryOptions options, ISdkIntegration integration)
             => options.Integrations = options.Integrations.Add(integration);
 
+        /// <summary>
+        /// Removes all integrations of type <typeparamref name="TIntegration"/>.
+        /// </summary>
+        /// <typeparam name="TIntegration">The type of the integration(s) to remove.</typeparam>
+        /// <param name="options">The SentryOptions to remove the integration(s) from.</param>
+        /// <returns></returns>
+        internal static void RemoveIntegration<TIntegration>(this SentryOptions options) where TIntegration : ISdkIntegration
+            => options.Integrations = options.Integrations.RemoveAll(p => p.GetType() == typeof(TIntegration));
+
         /// <summary>
         /// Add prefix to exclude from 'InApp' stack trace list
         /// </summary>
@@ -159,5 +174,6 @@ internal static void SetupLogging(this SentryOptions options)
                 options.DiagnosticLogger = null;
             }
         }
+
     }
 }

test/Sentry.Tests/AppDomainProcessExitIntegrationTests.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Threading.Tasks;
+using NSubstitute;
+using Sentry.Integrations;
+using Sentry.Internal;
+using Xunit;
+
+namespace Sentry.Tests
+{
+    public class AppDomainProcessExitIntegrationTests
+    {
+        private class Fixture
+        {
+            public IHub Hub { get; set; } = Substitute.For<IHub, IDisposable>();
+
+            public IAppDomain AppDomain { get; set; } = Substitute.For<IAppDomain>();
+
+            public Fixture() => Hub.IsEnabled.Returns(true);
+
+            public AppDomainProcessExitIntegration GetSut() => new AppDomainProcessExitIntegration(AppDomain);
+        }
+
+        private readonly Fixture _fixture = new Fixture();
+
+        public SentryOptions SentryOptions { get; set; } = new SentryOptions();
+
+        [Fact]
+        public void Handle_WithException_CaptureEvent()
+        {
+            var sut = _fixture.GetSut();
+            sut.Register(_fixture.Hub, SentryOptions);
+
+            sut.HandleProcessExit(this, EventArgs.Empty);
+
+            (_fixture.Hub as IDisposable).Received(1).Dispose();
+        }
+
+        [Fact]
+        public void Register_ProcessExit_Subscribes()
+        {
+            var sut = _fixture.GetSut();
+            sut.Register(_fixture.Hub, SentryOptions);
+
+            _fixture.AppDomain.Received().ProcessExit += sut.HandleProcessExit;
+        }
+
+        [Fact]
+        public void Unregister_ProcessExit_Unsubscribes()
+        {
+            var sut = _fixture.GetSut();
+
+            sut.Register(_fixture.Hub, SentryOptions);
+            sut.Unregister(_fixture.Hub);
+
+            _fixture.AppDomain.Received(1).ProcessExit -= sut.HandleProcessExit;
+        }
+    }
+}