From 4b85df6f858a341a1256b176f582f39666a9c841 Mon Sep 17 00:00:00 2001 From: bitsandfoxes Date: Wed, 29 Jul 2026 17:32:17 +0200 Subject: [PATCH 1/3] made EnableAppHangTracking control feature on all platforms --- CHANGELOG.md | 5 ++-- docs/agent-guides/platform-apple.md | 3 ++- .../Resources/Sentry/SentryOptions.asset | 2 +- src/Sentry.Unity.Android/SentryJava.cs | 2 +- .../SentryNativeAndroid.cs | 2 +- .../Android/AndroidManifestConfiguration.cs | 2 +- .../ConfigurationWindow/AdvancedTab.cs | 16 ++++--------- .../ScriptableSentryUnityOptionsEditor.cs | 2 +- src/Sentry.Unity.Native/SentryNative.cs | 2 +- src/Sentry.Unity.Native/SentryNativeBridge.cs | 4 ++-- src/Sentry.Unity.iOS/SentryNativeCocoa.cs | 16 ++++++------- .../ExperimentalSentryUnityOptions.cs | 8 +++---- .../ScriptableSentryUnityOptions.cs | 8 ++++--- src/Sentry.Unity/SentryUnityOptions.cs | 23 +++++++++++++++---- .../SentryUnityOptionsExtensions.cs | 2 +- .../IntegrationOptionsConfiguration.cs | 2 +- .../AndroidManifestConfigurationTests.cs | 4 ++-- .../SentryUnityOptionsTests.cs | 19 +++++++++++---- 18 files changed, 71 insertions(+), 51 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index d5930d00e..24b375002 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,11 +4,12 @@ ### Behavioural Changes and Deprecations -- The C# ANR watchdog and its configuration options (`AnrDetectionEnabled`, `AnrTimeout`, and `DisableAnrIntegration`) are now marked as `[Obsolete]` and `false` by default. Use `Experimental.EnableNativeAppHangTracking` instead. ([#2784](https://github.com/getsentry/sentry-unity/pull/2784)) +- The C# ANR watchdog and its configuration options (`AnrDetectionEnabled`, `AnrTimeout`, and `DisableAnrIntegration`) are now marked as `[Obsolete]` and `false` by default. Use experimental `EnableAppHangTracking` instead. ([#2784](https://github.com/getsentry/sentry-unity/pull/2784)) +- `EnableAppHangTracking` now controls native app-hang tracking on Android, iOS, Linux, macOS, and Windows and defaults to `false`. `Experimental.EnableNativeAppHangTracking` is deprecated. ### Features -- Extended experimental `options.Experimental.EnableNativeAppHangTracking` to Android. It now configures the Android NDK app-hang detector and emits Unity main-thread heartbeats. This option requires `NdkIntegrationEnabled` to be set to `true` ([#2778](https://github.com/getsentry/sentry-unity/pull/2778)) +- Extended experimental `EnableAppHangTracking` to Android. It configures the Android NDK app-hang detector and emits Unity main-thread heartbeats. This requires `NdkIntegrationEnabled` to be set to `true` ([#2778](https://github.com/getsentry/sentry-unity/pull/2778)) ### Fixes diff --git a/docs/agent-guides/platform-apple.md b/docs/agent-guides/platform-apple.md index 592460baa..cf68019e4 100644 --- a/docs/agent-guides/platform-apple.md +++ b/docs/agent-guides/platform-apple.md @@ -15,7 +15,8 @@ ## Cocoa Behavior - Cocoa configuration initializes bridge, scope/context sync, SDK name, crashed-last-run, and IL2CPP installation ID. -- iOS native app-hang tracking can disable C# ANR watchdog. +- `EnableAppHangTracking` configures Cocoa app-hang tracking on iOS and macOS when the Cocoa backend is active. +- App-hang tracking disables the C# ANR watchdog on iOS and macOS when the Cocoa backend is active. - macOS Cocoa screenshots are disabled because UIKit is unavailable. - Cocoa attachment synchronization is not implemented. diff --git a/samples/unity-of-bugs/Assets/Resources/Sentry/SentryOptions.asset b/samples/unity-of-bugs/Assets/Resources/Sentry/SentryOptions.asset index 51684bf02..2f8f980c6 100644 --- a/samples/unity-of-bugs/Assets/Resources/Sentry/SentryOptions.asset +++ b/samples/unity-of-bugs/Assets/Resources/Sentry/SentryOptions.asset @@ -85,7 +85,7 @@ MonoBehaviour: k__BackingField: 0 k__BackingField: 0 k__BackingField: 0 - k__BackingField: 0 + k__BackingField: 1 k__BackingField: {fileID: 11400000, guid: cea63afb7c75f429799422326f926abe, type: 2} k__BackingField: 1 k__BackingField: 0 diff --git a/src/Sentry.Unity.Android/SentryJava.cs b/src/Sentry.Unity.Android/SentryJava.cs index 1302a0b4f..c1db5e7dc 100644 --- a/src/Sentry.Unity.Android/SentryJava.cs +++ b/src/Sentry.Unity.Android/SentryJava.cs @@ -145,7 +145,7 @@ public void Init(SentryUnityOptions options) androidOptions.Call("setEnableScopePersistence", options.AndroidNativeAnrEnabled); androidOptions.Call("setReportHistoricalAnrs", options.AndroidReportHistoricalAnrs); androidOptions.Call("setAttachAnrThreadDump", options.AndroidAttachAnrThreadDump); - androidOptions.Call("setEnableNdkAppHangTracking", options.Experimental.EnableNativeAppHangTracking); + androidOptions.Call("setEnableNdkAppHangTracking", options.NativeAppHangTrackingEnabled); androidOptions.Call("setNdkAppHangTimeoutIntervalMillis", (long)Math.Max(0, options.AppHangTimeout.TotalMilliseconds)); androidOptions.Call("setTombstoneEnabled", options.AndroidTombstoneEnabled); diff --git a/src/Sentry.Unity.Android/SentryNativeAndroid.cs b/src/Sentry.Unity.Android/SentryNativeAndroid.cs index 37fbf674b..4a33f64f7 100644 --- a/src/Sentry.Unity.Android/SentryNativeAndroid.cs +++ b/src/Sentry.Unity.Android/SentryNativeAndroid.cs @@ -74,7 +74,7 @@ public static void Configure(SentryUnityOptions options) options.EnableScopeSync = true; options.NativeDebugImageProvider = new Native.NativeDebugImageProvider(); - if (options.Experimental.EnableNativeAppHangTracking && options.NdkIntegrationEnabled) + if (options.NativeAppHangTrackingEnabled && options.NdkIntegrationEnabled) { Logger?.LogDebug("Starting the app-hang heartbeat coroutine."); SentryMonoBehaviour.Instance.StartAppHangHeartbeat(SentryNative.AppHangHeartbeat); diff --git a/src/Sentry.Unity.Editor/Android/AndroidManifestConfiguration.cs b/src/Sentry.Unity.Editor/Android/AndroidManifestConfiguration.cs index 36daa244c..85c5052d5 100644 --- a/src/Sentry.Unity.Editor/Android/AndroidManifestConfiguration.cs +++ b/src/Sentry.Unity.Editor/Android/AndroidManifestConfiguration.cs @@ -221,7 +221,7 @@ internal void ModifyManifest(string basePath) androidManifest.SetAnr(_options.AndroidNativeAnrEnabled); androidManifest.SetPersistentScopeObserver(_options.AndroidNativeAnrEnabled); androidManifest.SetAttachAnrThreadDump(_options.AndroidAttachAnrThreadDump); - androidManifest.SetNdkAppHangTracking(_options.Experimental.EnableNativeAppHangTracking); + androidManifest.SetNdkAppHangTracking(_options.NativeAppHangTrackingEnabled); androidManifest.SetNdkAppHangTimeout((long)Math.Max(0, _options.AppHangTimeout.TotalMilliseconds)); androidManifest.SetTombstone(_options.AndroidTombstoneEnabled); androidManifest.SetTombstoneReportHistorical(_options.AndroidReportHistoricalTombstones); diff --git a/src/Sentry.Unity.Editor/ConfigurationWindow/AdvancedTab.cs b/src/Sentry.Unity.Editor/ConfigurationWindow/AdvancedTab.cs index 526e4efa3..124bb778f 100644 --- a/src/Sentry.Unity.Editor/ConfigurationWindow/AdvancedTab.cs +++ b/src/Sentry.Unity.Editor/ConfigurationWindow/AdvancedTab.cs @@ -42,7 +42,7 @@ internal static void Display(ScriptableSentryUnityOptions options, SentryCliOpti { GUILayout.Label("C# Watchdog (Deprecated)", EditorStyles.boldLabel); EditorGUILayout.HelpBox( - "The C# ANR watchdog is deprecated. Use Experimental.EnableNativeAppHangTracking instead. " + + "The C# ANR watchdog is deprecated. Use EnableAppHangTracking instead. " + "These settings will be removed in a future version.", MessageType.Warning); @@ -66,12 +66,13 @@ internal static void Display(ScriptableSentryUnityOptions options, SentryCliOpti EditorGUILayout.Space(); { - GUILayout.Label("App Hang Tracking", EditorStyles.boldLabel); + GUILayout.Label("App Hang Tracking (Experimental)", EditorStyles.boldLabel); options.EnableAppHangTracking = EditorGUILayout.Toggle( new GUIContent("Enable", - "Enables app hang detection on iOS via sentry-cocoa. App hang detection on Android, macOS, " + - "Windows, and Linux is experimental and controlled separately in the Experimental section."), + "Enables experimental app hang detection via sentry-cocoa on iOS and macOS with the Cocoa " + + "backend, and via sentry-native on Android and native desktop backends. Android requires NDK " + + "Integration; macOS requires the Native backend when using sentry-native."), options.EnableAppHangTracking); options.AppHangTimeout = EditorGUILayout.IntField( @@ -278,13 +279,6 @@ internal static void Display(ScriptableSentryUnityOptions options, SentryCliOpti options.Experimental.LinuxBackend); } - options.Experimental.EnableNativeAppHangTracking = EditorGUILayout.Toggle( - new GUIContent( - "Native App Hang Tracking", - "Enables app hang detection via sentry-native on Android, macOS, Windows, and Linux. Android " + - "requires NDK Integration; macOS requires its backend above to be set to 'Native'. Shares the " + - "App Hang Timeout configured in the App Hang Tracking section. iOS is unaffected by this option."), - options.Experimental.EnableNativeAppHangTracking); } EditorGUI.indentLevel--; EditorGUILayout.EndFoldoutHeaderGroup(); diff --git a/src/Sentry.Unity.Editor/ScriptableSentryUnityOptionsEditor.cs b/src/Sentry.Unity.Editor/ScriptableSentryUnityOptionsEditor.cs index 8be801855..486e06556 100644 --- a/src/Sentry.Unity.Editor/ScriptableSentryUnityOptionsEditor.cs +++ b/src/Sentry.Unity.Editor/ScriptableSentryUnityOptionsEditor.cs @@ -74,7 +74,7 @@ public override void OnInspectorGUI() EditorGUILayout.IntField("Watchdog Timeout [ms]", options.AnrTimeout); #pragma warning restore CS0618 // Type or member is obsolete - EditorGUILayout.LabelField("App Hang Tracking", EditorStyles.boldLabel); + EditorGUILayout.LabelField("App Hang Tracking (Experimental)", EditorStyles.boldLabel); EditorGUILayout.Toggle("Enable", options.EnableAppHangTracking); EditorGUILayout.IntField("App Hang Timeout [ms]", options.AppHangTimeout); diff --git a/src/Sentry.Unity.Native/SentryNative.cs b/src/Sentry.Unity.Native/SentryNative.cs index 74d4b0e4c..2eb1c80ed 100644 --- a/src/Sentry.Unity.Native/SentryNative.cs +++ b/src/Sentry.Unity.Native/SentryNative.cs @@ -94,7 +94,7 @@ internal static void Configure(SentryUnityOptions options, RuntimePlatform platf } options.CrashedLastRun = () => crashedLastRun; - if (options.Experimental.EnableNativeAppHangTracking) + if (options.NativeAppHangTrackingEnabled) { Logger?.LogDebug("Starting the app-hang heartbeat coroutine."); SentryMonoBehaviour.Instance.StartAppHangHeartbeat(SentryNativeBridge.AppHangHeartbeat); diff --git a/src/Sentry.Unity.Native/SentryNativeBridge.cs b/src/Sentry.Unity.Native/SentryNativeBridge.cs index ced5a9a56..3d5a44457 100644 --- a/src/Sentry.Unity.Native/SentryNativeBridge.cs +++ b/src/Sentry.Unity.Native/SentryNativeBridge.cs @@ -124,8 +124,8 @@ is RuntimePlatform.WindowsPlayer or RuntimePlatform.WindowsServer Logger?.LogInfo("Passing the native logs back to the C# layer is not supported on Mono - skipping native logger."); } - Logger?.LogDebug("Setting EnableNativeAppHangTracking: {0}", options.Experimental.EnableNativeAppHangTracking); - sentry_options_set_enable_app_hang_tracking(cOptions, options.Experimental.EnableNativeAppHangTracking ? 1 : 0); + Logger?.LogDebug("Setting EnableAppHangTracking: {0}", options.NativeAppHangTrackingEnabled); + sentry_options_set_enable_app_hang_tracking(cOptions, options.NativeAppHangTrackingEnabled ? 1 : 0); var appHangTimeoutMs = (ulong)Math.Max(0, options.AppHangTimeout.TotalMilliseconds); Logger?.LogDebug("Setting AppHangTimeout: {0}ms", appHangTimeoutMs); diff --git a/src/Sentry.Unity.iOS/SentryNativeCocoa.cs b/src/Sentry.Unity.iOS/SentryNativeCocoa.cs index 2a1e4532e..3d6293238 100644 --- a/src/Sentry.Unity.iOS/SentryNativeCocoa.cs +++ b/src/Sentry.Unity.iOS/SentryNativeCocoa.cs @@ -44,14 +44,6 @@ internal static void Configure(SentryUnityOptions options, RuntimePlatform platf options.ScopeObserver = new NativeScopeObserver("iOS", options); - if (options.EnableAppHangTracking) - { - Logger?.LogDebug("Disabling the C# ANR watchdog - sentry-cocoa handles app hang detection."); -#pragma warning disable CS0618 // Type or member is obsolete - options.DisableAnrIntegration(); -#pragma warning restore CS0618 // Type or member is obsolete - } - } else { @@ -63,6 +55,14 @@ internal static void Configure(SentryUnityOptions options, RuntimePlatform platf options.ScopeObserver = new NativeScopeObserver("macOS", options); } + if (options.EnableAppHangTracking) + { + Logger?.LogDebug("Disabling the C# ANR watchdog - sentry-cocoa handles app hang detection."); +#pragma warning disable CS0618 // Type or member is obsolete + options.DisableAnrIntegration(); +#pragma warning restore CS0618 // Type or member is obsolete + } + SentryCocoaBridgeProxy.SetSdkName(); // Since we're not building the SDK we have to overwrite the name here options.NativeContextWriter = new NativeContextWriter(); diff --git a/src/Sentry.Unity/ExperimentalSentryUnityOptions.cs b/src/Sentry.Unity/ExperimentalSentryUnityOptions.cs index 180b14c95..2fd3c683d 100644 --- a/src/Sentry.Unity/ExperimentalSentryUnityOptions.cs +++ b/src/Sentry.Unity/ExperimentalSentryUnityOptions.cs @@ -40,11 +40,9 @@ public class ExperimentalSentryUnityOptions [field: SerializeField] public LinuxBackend LinuxBackend { get; set; } = LinuxBackend.Breakpad; /// - /// Enables app hang detection via sentry-native on Android, macOS, Windows, and Linux. Defaults to - /// false. On Android, requires NdkIntegrationEnabled. On macOS, requires the backend to be - /// switched to . sentry-native monitors the main thread and - /// produces an app hang event including a stack trace. When enabled, the C# watchdog is skipped to avoid - /// duplicate reports. The timeout is taken from AppHangTimeout. + /// Legacy opt-in for native app hang detection. Use + /// instead. This property will be removed in a future version. /// + [Obsolete("Use EnableAppHangTracking instead. This property will be removed in a future version.")] [field: SerializeField] public bool EnableNativeAppHangTracking { get; set; } = false; } diff --git a/src/Sentry.Unity/ScriptableSentryUnityOptions.cs b/src/Sentry.Unity/ScriptableSentryUnityOptions.cs index 17635fa8a..7924db3b2 100644 --- a/src/Sentry.Unity/ScriptableSentryUnityOptions.cs +++ b/src/Sentry.Unity/ScriptableSentryUnityOptions.cs @@ -107,13 +107,13 @@ public static string GetConfigPath(string? notDefaultConfigName = null) [field: SerializeField] public int MaxQueueItems { get; set; } = 30; [field: SerializeField] - [Obsolete("The C# ANR watchdog is deprecated. Use Experimental.EnableNativeAppHangTracking instead. This property will be removed in a future version.")] + [Obsolete("The C# ANR watchdog is deprecated. Use EnableAppHangTracking instead. This property will be removed in a future version.")] public bool AnrDetectionEnabled { get; set; } = false; [field: SerializeField] - [Obsolete("The C# ANR watchdog is deprecated. Use Experimental.EnableNativeAppHangTracking instead. This property will be removed in a future version.")] + [Obsolete("The C# ANR watchdog is deprecated. Use EnableAppHangTracking instead. This property will be removed in a future version.")] public int AnrTimeout { get; set; } = (int)TimeSpan.FromSeconds(5).TotalMilliseconds; - [field: SerializeField] public bool EnableAppHangTracking { get; set; } = true; + [field: SerializeField] public bool EnableAppHangTracking { get; set; } = false; [field: SerializeField] public int AppHangTimeout { get; set; } = (int)TimeSpan.FromSeconds(5).TotalMilliseconds; [field: SerializeField] public bool CaptureFailedRequests { get; set; } = true; @@ -244,7 +244,9 @@ internal SentryUnityOptions ToSentryUnityOptions( options.Experimental.MacosBackend = Experimental.MacosBackend; options.Experimental.WindowsBackend = Experimental.WindowsBackend; options.Experimental.LinuxBackend = Experimental.LinuxBackend; +#pragma warning disable CS0618 // Type or member is obsolete options.Experimental.EnableNativeAppHangTracking = Experimental.EnableNativeAppHangTracking; +#pragma warning restore CS0618 // Type or member is obsolete // By default, the cacheDirectoryPath gets set on known platforms. We're overwriting this behaviour here. if (!EnableOfflineCaching) diff --git a/src/Sentry.Unity/SentryUnityOptions.cs b/src/Sentry.Unity/SentryUnityOptions.cs index 43471514a..61a744860 100644 --- a/src/Sentry.Unity/SentryUnityOptions.cs +++ b/src/Sentry.Unity/SentryUnityOptions.cs @@ -168,7 +168,7 @@ public sealed class SentryUnityOptions : SentryOptions /// /// The duration in [ms] for how long the game has to be unresponsive before an ANR event is reported. /// - [Obsolete("The C# ANR watchdog is deprecated. Use Experimental.EnableNativeAppHangTracking instead. This property will be removed in a future version.")] + [Obsolete("The C# ANR watchdog is deprecated. Use EnableAppHangTracking instead. This property will be removed in a future version.")] public TimeSpan AnrTimeout { get; set; } = TimeSpan.FromSeconds(5); /// @@ -187,11 +187,13 @@ public sealed class SentryUnityOptions : SentryOptions public bool IosWatchdogTerminationIntegrationEnabled { get; set; } = false; /// - /// Enables app hang detection on iOS through sentry-cocoa, which monitors the main thread. - /// App hang detection on Android, macOS, Windows, and Linux is experimental and controlled separately via - /// Experimental.EnableNativeAppHangTracking. + /// Enables experimental native app hang detection. This is disabled by default. + /// On iOS and macOS with the Cocoa backend, this uses sentry-cocoa. On Android and native desktop + /// backends, this uses sentry-native. Android requires and macOS + /// requires to be set to + /// when using sentry-native. /// - public bool EnableAppHangTracking { get; set; } = true; + public bool EnableAppHangTracking { get; set; } = false; /// /// The minimum duration for which the main thread must be blocked before @@ -199,6 +201,17 @@ public sealed class SentryUnityOptions : SentryOptions /// public TimeSpan AppHangTimeout { get; set; } = TimeSpan.FromSeconds(5); + internal bool NativeAppHangTrackingEnabled + { + get + { + // Preserve existing native opt-ins while callers migrate to the canonical setting. +#pragma warning disable CS0618 // Type or member is obsolete + return EnableAppHangTracking || Experimental.EnableNativeAppHangTracking; +#pragma warning restore CS0618 // Type or member is obsolete + } + } + /// /// Whether the SDK should initialize the native SDK before the game starts. This bakes the options at build-time into /// the generated Xcode project. Modifying the options at runtime will not affect the options used to initialize diff --git a/src/Sentry.Unity/SentryUnityOptionsExtensions.cs b/src/Sentry.Unity/SentryUnityOptionsExtensions.cs index 5867c4f1d..cf2dc13dc 100644 --- a/src/Sentry.Unity/SentryUnityOptionsExtensions.cs +++ b/src/Sentry.Unity/SentryUnityOptionsExtensions.cs @@ -104,7 +104,7 @@ public static void DisableUnhandledExceptionCapture(this SentryUnityOptions opti /// /// Disables the application-not-responding detection. /// - [Obsolete("The C# ANR watchdog is deprecated. Use Experimental.EnableNativeAppHangTracking instead. This method will be removed in a future version.")] + [Obsolete("The C# ANR watchdog is deprecated. Use EnableAppHangTracking instead. This method will be removed in a future version.")] public static void DisableAnrIntegration(this SentryUnityOptions options) => options.RemoveIntegration(); diff --git a/test/Scripts.Integration.Test/Scripts/IntegrationOptionsConfiguration.cs b/test/Scripts.Integration.Test/Scripts/IntegrationOptionsConfiguration.cs index 9ed7811b4..abd511677 100644 --- a/test/Scripts.Integration.Test/Scripts/IntegrationOptionsConfiguration.cs +++ b/test/Scripts.Integration.Test/Scripts/IntegrationOptionsConfiguration.cs @@ -47,7 +47,7 @@ public override void Configure(SentryUnityOptions options) #pragma warning restore CS0618 // Type or member is obsolete // App Hang tracking - options.Experimental.EnableNativeAppHangTracking = true; + options.EnableAppHangTracking = true; options.AppHangTimeout = TimeSpan.FromSeconds(2); // Runtime initialization for integration tests diff --git a/test/Sentry.Unity.Editor.Tests/Android/AndroidManifestConfigurationTests.cs b/test/Sentry.Unity.Editor.Tests/Android/AndroidManifestConfigurationTests.cs index 1f62a5bb3..0be4840a1 100644 --- a/test/Sentry.Unity.Editor.Tests/Android/AndroidManifestConfigurationTests.cs +++ b/test/Sentry.Unity.Editor.Tests/Android/AndroidManifestConfigurationTests.cs @@ -186,9 +186,9 @@ public void ModifyManifest_AndroidAttachAnrThreadDump_FlowsThroughToManifest() } [Test] - public void ModifyManifest_NativeAppHangTracking_UsesExperimentalConfiguration() + public void ModifyManifest_NativeAppHangTracking_UsesAppHangConfiguration() { - _fixture.SentryUnityOptions!.Experimental.EnableNativeAppHangTracking = true; + _fixture.SentryUnityOptions!.EnableAppHangTracking = true; _fixture.SentryUnityOptions.AppHangTimeout = TimeSpan.FromSeconds(2); var sut = _fixture.GetSut(); diff --git a/test/Sentry.Unity.Tests/SentryUnityOptionsTests.cs b/test/Sentry.Unity.Tests/SentryUnityOptionsTests.cs index cd7525628..901532e13 100644 --- a/test/Sentry.Unity.Tests/SentryUnityOptionsTests.cs +++ b/test/Sentry.Unity.Tests/SentryUnityOptionsTests.cs @@ -164,17 +164,28 @@ public void Options_Experimental_LinuxBackend_IsSettable() } [Test] - public void Options_Experimental_EnableNativeAppHangTracking_DefaultsToFalse() + public void Options_EnableAppHangTracking_DefaultsToFalse() { var options = new SentryUnityOptions(); - Assert.IsFalse(options.Experimental.EnableNativeAppHangTracking); + Assert.IsFalse(options.EnableAppHangTracking); } [Test] - public void Options_Experimental_EnableNativeAppHangTracking_IsSettable() + public void Options_EnableAppHangTracking_IsSettable() { var options = new SentryUnityOptions(); + options.EnableAppHangTracking = true; + Assert.IsTrue(options.EnableAppHangTracking); + } + + [Test] + public void Options_LegacyNativeAppHangTracking_EnablesNativeAppHangTracking() + { + var options = new SentryUnityOptions(); +#pragma warning disable CS0618 // Type or member is obsolete options.Experimental.EnableNativeAppHangTracking = true; - Assert.IsTrue(options.Experimental.EnableNativeAppHangTracking); +#pragma warning restore CS0618 // Type or member is obsolete + + Assert.IsTrue(options.NativeAppHangTrackingEnabled); } } From 58b64a05d7223a95f00d9f6e9962967e9ddee2b4 Mon Sep 17 00:00:00 2001 From: bitsandfoxes Date: Wed, 29 Jul 2026 17:38:10 +0200 Subject: [PATCH 2/3] updated changelog --- CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 24b375002..f91c47f1f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,7 +4,7 @@ ### Behavioural Changes and Deprecations -- The C# ANR watchdog and its configuration options (`AnrDetectionEnabled`, `AnrTimeout`, and `DisableAnrIntegration`) are now marked as `[Obsolete]` and `false` by default. Use experimental `EnableAppHangTracking` instead. ([#2784](https://github.com/getsentry/sentry-unity/pull/2784)) +- The C# ANR watchdog and its configuration options (`AnrDetectionEnabled`, `AnrTimeout`, and `DisableAnrIntegration`) are now marked as `[Obsolete]` and `false` by default. Use experimental `EnableAppHangTracking` instead. ([#2784](https://github.com/getsentry/sentry-unity/pull/2784), [#2787](https://github.com/getsentry/sentry-unity/pull/2787)) - `EnableAppHangTracking` now controls native app-hang tracking on Android, iOS, Linux, macOS, and Windows and defaults to `false`. `Experimental.EnableNativeAppHangTracking` is deprecated. ### Features From 06bb6e087c5a9982af1b25ab000502405631e68c Mon Sep 17 00:00:00 2001 From: bitsandfoxes Date: Thu, 30 Jul 2026 17:10:05 +0200 Subject: [PATCH 3/3] . --- src/Sentry.Unity/SentryUnityOptions.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Sentry.Unity/SentryUnityOptions.cs b/src/Sentry.Unity/SentryUnityOptions.cs index 61a744860..7e3b5ec98 100644 --- a/src/Sentry.Unity/SentryUnityOptions.cs +++ b/src/Sentry.Unity/SentryUnityOptions.cs @@ -201,11 +201,11 @@ public sealed class SentryUnityOptions : SentryOptions /// public TimeSpan AppHangTimeout { get; set; } = TimeSpan.FromSeconds(5); + // TODO: Remove with the next mayor. This is so we still support the experimental option internal bool NativeAppHangTrackingEnabled { get { - // Preserve existing native opt-ins while callers migrate to the canonical setting. #pragma warning disable CS0618 // Type or member is obsolete return EnableAppHangTracking || Experimental.EnableNativeAppHangTracking; #pragma warning restore CS0618 // Type or member is obsolete