fix: options.DisableLoggingIntegration() is no longer no-op (#2413)

Author: bitsandfoxes

CHANGELOG.md

@@ -10,6 +10,7 @@
 
 ### Fixes 
 
+- Fixed the extension methods on the options to disable unhandled exception capture and the logging integration ([#2413](https://github.com/getsentry/sentry-unity/pull/2413))
 - Fixed the breadcrumb format for lifecycle events ([#2407](https://github.com/getsentry/sentry-unity/pull/2407))
 - When targeting iOS, the `WatchdogTerminationIntegration` now defaults to `false` as to not report false positives. Users can control this through the option `IosWatchdogTerminationIntegrationEnabled` ([#2403](https://github.com/getsentry/sentry-unity/pull/2403))
 - The SDK now correctly sets the currently active scene's name on the event ([#2400](https://github.com/getsentry/sentry-unity/pull/2400))

src/Sentry.Unity/Integrations/UnityApplicationLoggingIntegration.cs

@@ -8,12 +8,11 @@ namespace Sentry.Unity.Integrations;
 
 /// <summary>
 /// Hooks into Unity's `Application.LogMessageReceived` to capture breadcrumbs for Debug log methods
-/// and optionally capture LogError events. Does not handle `Debug.LogException` since it lacks the
-/// actual exception object needed for IL2CPP processing, except on WebGL where it's treated as a log message.
+/// and optionally capture LogError events. Does not handle `Debug.LogException` - exception handling
+/// is done by UnityLogHandlerIntegration (non-WebGL) or UnityWebGLExceptionHandler (WebGL).
 /// </summary>
 internal class UnityApplicationLoggingIntegration : ISdkIntegration
 {
-    private readonly bool _captureExceptions;
     private readonly IApplication _application;
     private readonly ISystemClock _clock;
 
@@ -24,9 +23,8 @@ internal class UnityApplicationLoggingIntegration : ISdkIntegration
     private IHub _hub = null!;                                  // Set in Register
     private SentryUnityOptions _options = null!;                // Set in Register
 
-    internal UnityApplicationLoggingIntegration(bool captureExceptions = false, IApplication? application = null, ISystemClock? clock = null)
+    internal UnityApplicationLoggingIntegration(IApplication? application = null, ISystemClock? clock = null)
     {
-        _captureExceptions = captureExceptions;
         _application = application ?? ApplicationAdapter.Instance;
         _clock = clock ?? SystemClock.Clock;
     }
@@ -59,7 +57,6 @@ internal void OnLogMessageReceived(string message, string stacktrace, LogType lo
             return;
         }
 
-        ProcessException(message, stacktrace, logType);
         ProcessError(message, stacktrace, logType);
         ProcessBreadcrumbs(message, logType);
         ProcessStructuredLog(message, logType);
@@ -82,19 +79,6 @@ private bool IsGettingDebounced(LogType logType)
         };
     }
 
-    private void ProcessException(string message, string stacktrace, LogType logType)
-    {
-        // LogType.Exception is getting handled by the `UnityLogHandlerIntegration`
-        // UNLESS we're configured to process them - i.e. on WebGL
-        if (logType is LogType.Exception && _captureExceptions)
-        {
-            _options.LogDebug("Exception capture has been enabled. Capturing exception through '{0}'.", nameof(UnityApplicationLoggingIntegration));
-
-            var evt = UnityLogEventFactory.CreateExceptionEvent(message, stacktrace, false, _options);
-            _hub.CaptureEvent(evt);
-        }
-    }
-
     private void ProcessError(string message, string stacktrace, LogType logType)
     {
         if (logType is not LogType.Error || !_options.CaptureLogErrorEvents)

src/Sentry.Unity/Integrations/UnityWebGLExceptionHandler.cs

@@ -0,0 +1,65 @@
+using System;
+using Sentry.Extensibility;
+using Sentry.Integrations;
+using UnityEngine;
+
+namespace Sentry.Unity.Integrations;
+
+/// <summary>
+/// WebGL-specific exception handler that captures exceptions through Application.LogMessageReceived.
+/// Required because UnityLogHandlerIntegration (Debug.unityLogger.logHandler) doesn't work on WebGL.
+/// </summary>
+internal sealed class UnityWebGLExceptionHandler : ISdkIntegration
+{
+    private readonly IApplication _application;
+    private IHub _hub = null!;
+    private SentryUnityOptions _options = null!;
+    private ErrorTimeDebounce _errorTimeDebounce = null!;
+
+    internal UnityWebGLExceptionHandler(IApplication? application = null)
+    {
+        _application = application ?? ApplicationAdapter.Instance;
+    }
+
+    public void Register(IHub hub, SentryOptions sentryOptions)
+    {
+        _hub = hub ?? throw new ArgumentException("Hub is null.");
+        _options = sentryOptions as SentryUnityOptions
+            ?? throw new ArgumentException("Options is not of type 'SentryUnityOptions'.");
+
+        _errorTimeDebounce = new ErrorTimeDebounce(_options.DebounceTimeError);
+        _application.LogMessageReceived += OnLogMessageReceived;
+        _application.Quitting += OnQuitting;
+    }
+
+    internal void OnLogMessageReceived(string message, string stacktrace, LogType logType)
+    {
+        if (!_hub.IsEnabled)
+        {
+            return;
+        }
+
+        if (logType is not LogType.Exception)
+        {
+            return;
+        }
+
+        // We're not capturing the SDK's own logs
+        if (message.StartsWith(UnityLogger.LogTag))
+        {
+            return;
+        }
+
+        if (_options.EnableLogDebouncing && !_errorTimeDebounce.Debounced())
+        {
+            _options.LogDebug("Exception is getting debounced.");
+            return;
+        }
+
+        _options.LogDebug("Capturing exception on WebGL through LogMessageReceived.");
+        var evt = UnityLogEventFactory.CreateExceptionEvent(message, stacktrace, false, _options);
+        _hub.CaptureEvent(evt);
+    }
+
+    private void OnQuitting() => _application.LogMessageReceived -= OnLogMessageReceived;
+}

src/Sentry.Unity/SentryUnityOptions.cs

@@ -350,13 +350,21 @@ internal SentryUnityOptions(IApplication? application = null,
         AddEventProcessor(processor);
         AddTransactionProcessor(processor);
 
-        // UnityLogHandlerIntegration is not compatible with WebGL, so it's added conditionally
-        if (application.Platform != RuntimePlatform.WebGLPlayer)
+        // Exception handling differs by platform due to WebGL limitations
+        if (application.Platform == RuntimePlatform.WebGLPlayer)
         {
+            // WebGL: UnityLogHandler doesn't work, use LogMessageReceived for exceptions
+            AddIntegration(new UnityWebGLExceptionHandler());
+        }
+        else
+        {
+            // Standard platforms: Use UnityLogHandler for exceptions
             AddIntegration(new UnityLogHandlerIntegration());
-            AddIntegration(new UnityApplicationLoggingIntegration());
         }
 
+        // All platforms use ApplicationLogging for logs/warnings/errors/breadcrumbs
+        AddIntegration(new UnityApplicationLoggingIntegration());
+
         AddIntegration(new StartupTracingIntegration());
         AddIntegration(new AnrIntegration(behaviour));
         AddIntegration(new UnityScopeIntegration(application));

src/Sentry.Unity/SentryUnityOptionsExtensions.cs

@@ -80,11 +80,23 @@ internal static void SetupUnityLogging(this SentryUnityOptions options)
     }
 
     /// <summary>
-    /// Disables the capture of errors through <see cref="UnityLogHandlerIntegration"/>.
+    /// Disables the capture of logs, warnings, errors, breadcrumbs, and structured logs through
+    /// <see cref="UnityApplicationLoggingIntegration"/>.
     /// </summary>
     /// <param name="options">The SentryUnityOptions to remove the integration from.</param>
-    public static void DisableUnityApplicationLoggingIntegration(this SentryUnityOptions options) =>
+    public static void DisableUnityLoggingIntegration(this SentryUnityOptions options) =>
+        options.RemoveIntegration<UnityApplicationLoggingIntegration>();
+
+    /// <summary>
+    /// Disables the capture of unhandled exceptions. This removes both <see cref="UnityLogHandlerIntegration"/>
+    /// (non-WebGL platforms) and <see cref="UnityWebGLExceptionHandler"/> (WebGL platform).
+    /// </summary>
+    /// <param name="options">The SentryUnityOptions to remove the integration from.</param>
+    public static void DisableUnhandledExceptionCapture(this SentryUnityOptions options)
+    {
         options.RemoveIntegration<UnityLogHandlerIntegration>();
+        options.RemoveIntegration<UnityWebGLExceptionHandler>();
+    }
 
     /// <summary>
     /// Disables the application-not-responding detection.

src/Sentry.Unity/WebGL/SentryWebGL.cs

@@ -17,9 +17,6 @@ public static void Configure(SentryUnityOptions options)
     {
         options.DiagnosticLogger?.LogDebug("Updating configuration for Unity WebGL.");
 
-        // Due to special exception handling on WebGL we capture these through `LogMessageReceived` too
-        options.AddIntegration(new UnityApplicationLoggingIntegration(captureExceptions: true));
-
         // Note: we need to use a custom background worker which actually doesn't work in the background
         // because Unity doesn't support async (multithreading) yet. This may change in the future so let's watch
         // https://docs.unity3d.com/2019.4/Documentation/ScriptReference/PlayerSettings.WebGL-threadsSupport.html

test/Sentry.Unity.Tests/SentryUnityOptionsExtensionsTests.cs

@@ -1,3 +1,4 @@
+using System.Linq;
 using NUnit.Framework;
 using Sentry.Unity.Tests.Stubs;
 
@@ -129,4 +130,57 @@ public void SetupLogging_DiagnosticLoggerSet_LeavesOrRemovesDiagnosticLogger(boo
 
         Assert.AreEqual(debug, options.DiagnosticLogger is not null);
     }
+
+    [Test]
+    public void DisableUnityLoggingIntegration_RemovesUnityApplicationLoggingIntegration()
+    {
+        var options = _fixture.GetSut();
+
+        Assert.IsTrue(options.Integrations.Any(i => i is Integrations.UnityApplicationLoggingIntegration));
+
+        options.DisableUnityLoggingIntegration();
+
+        Assert.IsFalse(options.Integrations.Any(i => i is Integrations.UnityApplicationLoggingIntegration));
+    }
+
+    [Test]
+    public void DisableUnhandledExceptionCapture_RemovesUnityLogHandlerIntegration()
+    {
+        var options = _fixture.GetSut();
+
+        Assert.IsTrue(options.Integrations.Any(i => i is Integrations.UnityLogHandlerIntegration));
+
+        options.DisableUnhandledExceptionCapture();
+
+        Assert.IsFalse(options.Integrations.Any(i => i is Integrations.UnityLogHandlerIntegration));
+    }
+
+    [Test]
+    public void DisableUnhandledExceptionCapture_RemovesUnityWebGLExceptionHandler()
+    {
+        var application = new TestApplication(isEditor: false, platform: UnityEngine.RuntimePlatform.WebGLPlayer);
+        var options = new SentryUnityOptions(application: application)
+        {
+            Enabled = true,
+            Dsn = "http://test.com",
+            CaptureInEditor = true,
+            Debug = true,
+        };
+
+        Assert.IsTrue(options.Integrations.Any(i => i is Integrations.UnityWebGLExceptionHandler));
+
+        options.DisableUnhandledExceptionCapture();
+
+        Assert.IsFalse(options.Integrations.Any(i => i is Integrations.UnityWebGLExceptionHandler));
+    }
+
+    [Test]
+    public void DisableUnhandledExceptionCapture_DoesNotRemoveUnityApplicationLoggingIntegration()
+    {
+        var options = _fixture.GetSut();
+
+        options.DisableUnhandledExceptionCapture();
+
+        Assert.IsTrue(options.Integrations.Any(i => i is Integrations.UnityApplicationLoggingIntegration));
+    }
 }

test/Sentry.Unity.Tests/UnityApplicationLoggingIntegrationTests.cs

@@ -13,12 +13,10 @@ private class Fixture
             public TestHub Hub { get; set; } = null!;
             public SentryUnityOptions SentryOptions { get; set; } = null!;
 
-            public bool CaptureExceptions { get; set; } = false;
-
             public UnityApplicationLoggingIntegration GetSut()
             {
                 var application = new TestApplication();
-                var integration = new UnityApplicationLoggingIntegration(CaptureExceptions, application, clock: null);
+                var integration = new UnityApplicationLoggingIntegration(application, clock: null);
                 integration.Register(Hub, SentryOptions);
                 return integration;
             }
@@ -164,18 +162,6 @@ public void OnLogMessageReceived_AddAsBreadcrumbDisabled_NotAddedAsBreadcrumb(Lo
             Assert.IsFalse(_fixture.Hub.ConfigureScopeCalls.Count > 0);
         }
 
-        [Test]
-        public void OnLogMessageReceived_LogTypeException_CaptureExceptionsEnabled_EventCaptured()
-        {
-            _fixture.CaptureExceptions = true;
-            var sut = _fixture.GetSut();
-            var message = TestContext.CurrentContext.Test.Name;
-
-            sut.OnLogMessageReceived(message, "stacktrace", LogType.Exception);
-
-            Assert.AreEqual(1, _fixture.Hub.CapturedEvents.Count);
-        }
-
         [Test]
         [TestCase(LogType.Log)]
         [TestCase(LogType.Warning)]
@@ -305,7 +291,6 @@ public void OnLogMessageReceived_ExperimentalCaptureEnabled_CapturesStructuredLo
         {
             _fixture.SentryOptions.EnableLogs = true;
             _fixture.SentryOptions.CaptureStructuredLogsForLogType[LogType.Exception] = true;
-            _fixture.CaptureExceptions = true;
             var sut = _fixture.GetSut();
             var message = TestContext.CurrentContext.Test.Name;
 
@@ -323,7 +308,6 @@ public void OnLogMessageReceived_ExperimentalCaptureDisabled_DoesNotCaptureStruc
         {
             _fixture.SentryOptions.EnableLogs = true;
             _fixture.SentryOptions.CaptureStructuredLogsForLogType[LogType.Exception] = false;
-            _fixture.CaptureExceptions = true;
             var sut = _fixture.GetSut();
             var message = TestContext.CurrentContext.Test.Name;
 

test/Sentry.Unity.Tests/UnityWebGLExceptionHandlerTests.cs

@@ -0,0 +1,45 @@
+using NUnit.Framework;
+using Sentry.Unity.Integrations;
+using Sentry.Unity.Tests.Stubs;
+using UnityEngine;
+
+namespace Sentry.Unity.Tests;
+
+public class UnityWebGLExceptionHandlerTests
+{
+    private class Fixture
+    {
+        public TestHub Hub { get; set; } = null!;
+        public SentryUnityOptions SentryOptions { get; set; } = null!;
+
+        public UnityWebGLExceptionHandler GetSut()
+        {
+            var application = new TestApplication();
+            var integration = new UnityWebGLExceptionHandler(application);
+            integration.Register(Hub, SentryOptions);
+            return integration;
+        }
+    }
+
+    private Fixture _fixture = null!;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _fixture = new Fixture
+        {
+            Hub = new TestHub(),
+            SentryOptions = new SentryUnityOptions()
+        };
+    }
+    [Test]
+    public void OnLogMessageReceived_LogTypeException_CaptureExceptionsEnabled_EventCaptured()
+    {
+        var sut = _fixture.GetSut();
+        var message = TestContext.CurrentContext.Test.Name;
+
+        sut.OnLogMessageReceived(message, "stacktrace", LogType.Exception);
+
+        Assert.AreEqual(1, _fixture.Hub.CapturedEvents.Count);
+    }
+}