feat: Add integration to TaskScheduler.UnobservedTaskException (#481)

Author: lucas-zimerman

src/Sentry/Integrations/TaskUnobservedTaskExceptionIntegration.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Diagnostics;
+using Sentry.Internal;
+using System.Runtime.ExceptionServices;
+using System.Security;
+using Sentry.Protocol;
+using System.Threading.Tasks;
+
+namespace Sentry.Integrations
+{
+    internal class TaskUnobservedTaskExceptionIntegration : IInternalSdkIntegration
+    {
+        private readonly IAppDomain _appDomain;
+        private IHub _hub;
+
+        internal TaskUnobservedTaskExceptionIntegration(IAppDomain appDomain = null)
+            => _appDomain = appDomain ?? AppDomainAdapter.Instance;
+
+        public void Register(IHub hub, SentryOptions _)
+        {
+            Debug.Assert(hub != null);
+            _hub = hub;
+            _appDomain.UnobservedTaskException += Handle;
+        }
+
+        public void Unregister(IHub hub)
+        {
+            _appDomain.UnobservedTaskException -= Handle;
+            _hub = null;
+        }
+
+        // Internal for testability
+        [HandleProcessCorruptedStateExceptions, SecurityCritical]
+        internal void Handle(object sender, UnobservedTaskExceptionEventArgs e)
+        {
+            if (e.Exception != null)
+            {
+                e.Exception.Data[Mechanism.MechanismKey] = "UnobservedTaskException";
+                _ = _hub?.CaptureException(e.Exception);
+                (_hub as IDisposable)?.Dispose();
+            }
+        }
+    }
+}

src/Sentry/Internal/AppDomainAdapter.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Runtime.ExceptionServices;
 using System.Security;
+using System.Threading.Tasks;
 
 namespace Sentry.Internal
 {
@@ -9,6 +10,8 @@ internal interface IAppDomain
         event UnhandledExceptionEventHandler UnhandledException;
 
         event EventHandler ProcessExit;
+
+        event EventHandler<UnobservedTaskExceptionEventArgs> UnobservedTaskException;
     }
 
     internal sealed class AppDomainAdapter : IAppDomain
@@ -19,15 +22,21 @@ private AppDomainAdapter()
         {
             AppDomain.CurrentDomain.UnhandledException += OnUnhandledException;
             AppDomain.CurrentDomain.ProcessExit += OnProcessExit;
+            TaskScheduler.UnobservedTaskException += OnUnobservedTaskException;
         }
 
         public event UnhandledExceptionEventHandler UnhandledException;
 
         public event EventHandler ProcessExit;
 
+        public event EventHandler<UnobservedTaskExceptionEventArgs> UnobservedTaskException;
+
         private void OnProcessExit(object sender, EventArgs e) => ProcessExit?.Invoke(sender, e);
 
         [HandleProcessCorruptedStateExceptions, SecurityCritical]
         private void OnUnhandledException(object sender, UnhandledExceptionEventArgs e) => UnhandledException?.Invoke(this, e);
+
+        [HandleProcessCorruptedStateExceptions, SecurityCritical]
+        private void OnUnobservedTaskException(object sender, UnobservedTaskExceptionEventArgs e) => UnobservedTaskException?.Invoke(this, e);
     }
 }

test/Sentry.Tests/TaskUnobservedTaskExceptionIntegrationTests.cs

@@ -0,0 +1,100 @@
+using System;
+using NSubstitute;
+using Sentry.Integrations;
+using Sentry.Internal;
+using Xunit;
+using System.Linq;
+using System.Threading.Tasks;
+using Sentry.Extensibility;
+using Sentry.Protocol;
+using System.Threading;
+using Microsoft.Extensions.Logging;
+
+namespace Sentry.Tests
+{
+    public class TaskUnobservedTaskExceptionIntegrationTests
+    {
+        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 TaskUnobservedTaskExceptionIntegration GetSut()
+                => new TaskUnobservedTaskExceptionIntegration(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.Handle(this, new UnobservedTaskExceptionEventArgs(new AggregateException()));
+
+            _ = _fixture.Hub.Received(1).CaptureEvent(Arg.Any<SentryEvent>());
+        }
+
+// Only triggers in release mode.
+#if RELEASE
+        [Fact] // Integration test.
+        public void Handle_UnobservedTaskException_CaptureEvent()
+        {
+            _fixture.AppDomain = AppDomainAdapter.Instance;
+            var evt = new ManualResetEvent(false);
+            _fixture.Hub.When(x => x.CaptureEvent(Arg.Any<SentryEvent>()))
+                .Do(_ => evt.Set());
+
+            var sut = _fixture.GetSut();
+            sut.Register(_fixture.Hub, SentryOptions);
+            try
+            {
+                Task.Factory.StartNew(() => { throw new Exception("Unhandled on Task"); });
+                Thread.Sleep(2000);
+                GC.Collect();
+                GC.WaitForPendingFinalizers();
+
+                Assert.True(evt.WaitOne(TimeSpan.FromMilliseconds(1)));
+            }
+            finally
+            {
+                sut.Unregister(_fixture.Hub);
+            }
+        }
+#endif
+
+        [Fact]
+        public void Handle_NoException_NoCaptureEvent()
+        {
+            var sut = _fixture.GetSut();
+            sut.Register(_fixture.Hub, SentryOptions);
+
+            sut.Handle(this, new UnobservedTaskExceptionEventArgs(null));
+
+            _ = _fixture.Hub.DidNotReceive().CaptureEvent(Arg.Any<SentryEvent>());
+        }
+
+        [Fact]
+        public void Register_UnhandledException_Subscribes()
+        {
+            var sut = _fixture.GetSut();
+            sut.Register(_fixture.Hub, SentryOptions);
+
+            _fixture.AppDomain.Received().UnobservedTaskException += sut.Handle;
+        }
+
+        [Fact]
+        public void Unregister_UnhandledException_Unsubscribes()
+        {
+            var sut = _fixture.GetSut();
+            sut.Register(_fixture.Hub, SentryOptions);
+            sut.Unregister(_fixture.Hub);
+
+            _fixture.AppDomain.Received(1).UnobservedTaskException -= sut.Handle;
+        }
+    }
+}