feat: SentryUnityInfo for build-time variables at runtime (#531)

bitsandfoxes · web-flow · commit f347e90347e8 · 2022-01-28T04:45:31.000-05:00
diff --git a/package-dev/Runtime/SentryInitialization.cs b/package-dev/Runtime/SentryInitialization.cs
@@ -27,17 +27,12 @@ public static void Init()
             var options = ScriptableSentryUnityOptions.LoadSentryUnityOptions();
             if (options.ShouldInitializeSdk())
             {
+                var sentryUnityInfo = new SentryUnityInfo();
 
 #if SENTRY_NATIVE_IOS
                 SentryNativeIos.Configure(options);
 #elif SENTRY_NATIVE_ANDROID
-                var il2cpp =
-#if ENABLE_IL2CPP
-                true;
-#else
-                false;
-#endif
-                SentryNativeAndroid.Configure(options, il2cpp);
+                SentryNativeAndroid.Configure(options, sentryUnityInfo);
 #endif
 
                 SentryUnity.Init(options);
diff --git a/package-dev/Runtime/SentryUnityInfo.cs b/package-dev/Runtime/SentryUnityInfo.cs
@@ -0,0 +1,14 @@
+﻿using Sentry.Unity;
+
+public class SentryUnityInfo : ISentryUnityInfo
+{
+    public bool IL2CPP
+    {
+        get =>
+#if ENABLE_IL2CPP
+            true;
+#else
+            false;
+#endif
+    }
+}
diff --git a/samples/unity-of-bugs/Assets/Scripts/SmokeTester.cs b/samples/unity-of-bugs/Assets/Scripts/SmokeTester.cs
@@ -74,18 +74,14 @@ void Verify(HttpRequestMessage message)
             options.DiagnosticLogger = new ConsoleDiagnosticLogger(SentryLevel.Debug);
             options.CreateHttpClientHandler = () => new TestHandler(Verify);
 
+            var sentryUnityInfo = new SentryUnityInfo();
+
 #if SENTRY_NATIVE_IOS
             Debug.Log("SMOKE TEST: Configure Native iOS.");
             SentryNativeIos.Configure(options);
 #elif SENTRY_NATIVE_ANDROID
             Debug.Log("SMOKE TEST: Configure Native Android.");
-            var il2cpp =
-#if ENABLE_IL2CPP
-            true;
-#else
-            false;
-#endif
-            SentryNativeAndroid.Configure(options, il2cpp);
+            SentryNativeAndroid.Configure(options, sentryUnityInfo);
 #endif
 
             Debug.Log("SMOKE TEST: SentryUnity Init.");
diff --git a/src/Sentry.Unity.Android/SentryNativeAndroid.cs b/src/Sentry.Unity.Android/SentryNativeAndroid.cs
@@ -12,7 +12,7 @@ public static class SentryNativeAndroid
         /// Configures the native Android support.
         /// </summary>
         /// <param name="options">The Sentry Unity options to use.</param>
-        public static void Configure(SentryUnityOptions options, bool il2cpp)
+        public static void Configure(SentryUnityOptions options, ISentryUnityInfo sentryUnityInfo)
         {
             if (options.AndroidNativeSupportEnabled)
             {
@@ -39,7 +39,7 @@ public static void Configure(SentryUnityOptions options, bool il2cpp)
 
                 // When running on Mono, we shouldn't take over the signal handler because its used to propagate exceptions into the VM.
                 // If we take over, a C# null reference ends up crashing the app.
-                if (il2cpp)
+                if (sentryUnityInfo.IL2CPP)
                 {
                     // At this point Unity has taken the signal handler and will not invoke the original handler (Sentry)
                     // So we register our backend once more to make sure user-defined data is available in the crash report.
diff --git a/src/Sentry.Unity/ISentryUnityInfo.cs b/src/Sentry.Unity/ISentryUnityInfo.cs
@@ -0,0 +1,7 @@
+namespace Sentry.Unity
+{
+    public interface ISentryUnityInfo
+    {
+        public bool IL2CPP { get; }
+    }
+}
diff --git a/test/Scripts.Tests/package-release.zip.snapshot b/test/Scripts.Tests/package-release.zip.snapshot
@@ -301,6 +301,8 @@ Runtime/Sentry.xml
 Runtime/Sentry.xml.meta
 Runtime/SentryInitialization.cs
 Runtime/SentryInitialization.cs.meta
+Runtime/SentryUnityInfo.cs
+Runtime/SentryUnityInfo.cs.meta
 Samples~/unity-of-bugs/Scenes.meta
 Samples~/unity-of-bugs/Scripts.meta
 Samples~/unity-of-bugs/Scenes/1_Bugfarm.unity
diff --git a/test/Sentry.Unity.Android.Tests/SentryNativeAndroidTests.cs b/test/Sentry.Unity.Android.Tests/SentryNativeAndroidTests.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Threading;
 using NUnit.Framework;
+using Sentry.Unity;
 
 namespace Sentry.Unity.Android.Tests
 {
@@ -9,7 +10,7 @@ public class SentryNativeAndroidTests
         private bool _reinstallCalled;
         private Action? _originalReinstallSentryNativeBackendStrategy;
         private Action _fakeReinstallSentryNativeBackendStrategy;
-        private bool _il2cpp;
+        private TestSentryUnityInfo _sentryUnityInfo = null!;
 
         public SentryNativeAndroidTests()
             => _fakeReinstallSentryNativeBackendStrategy = () => _reinstallCalled = true;
@@ -21,7 +22,7 @@ public void SetUp()
                 Interlocked.Exchange(ref SentryNative.ReinstallSentryNativeBackendStrategy,
                     _fakeReinstallSentryNativeBackendStrategy);
             _reinstallCalled = false;
-            _il2cpp = false;
+            _sentryUnityInfo = new TestSentryUnityInfo { IL2CPP = false };
         }
 
         [TearDown]
@@ -34,39 +35,39 @@ public void TearDown() =>
         public void Configure_DefaultConfiguration_SetsScopeObserver()
         {
             var options = new SentryUnityOptions();
-            SentryNativeAndroid.Configure(options, _il2cpp);
+            SentryNativeAndroid.Configure(options, _sentryUnityInfo);
             Assert.IsAssignableFrom<AndroidJavaScopeObserver>(options.ScopeObserver);
         }
 
         [Test]
         public void Configure_DefaultConfiguration_SetsCrashedLastRun()
         {
             var options = new SentryUnityOptions();
-            SentryNativeAndroid.Configure(options, _il2cpp);
+            SentryNativeAndroid.Configure(options, _sentryUnityInfo);
             Assert.IsNotNull(options.CrashedLastRun);
         }
 
         [Test]
         public void Configure_NativeAndroidSupportDisabled_ObserverIsNull()
         {
             var options = new SentryUnityOptions { AndroidNativeSupportEnabled = false };
-            SentryNativeAndroid.Configure(options, _il2cpp);
+            SentryNativeAndroid.Configure(options, _sentryUnityInfo);
             Assert.Null(options.ScopeObserver);
         }
 
         [Test]
         public void Configure_DefaultConfiguration_EnablesScopeSync()
         {
             var options = new SentryUnityOptions();
-            SentryNativeAndroid.Configure(options, _il2cpp);
+            SentryNativeAndroid.Configure(options, _sentryUnityInfo);
             Assert.True(options.EnableScopeSync);
         }
 
         [Test]
         public void Configure_NativeAndroidSupportDisabled_DisabledScopeSync()
         {
             var options = new SentryUnityOptions { AndroidNativeSupportEnabled = false };
-            SentryNativeAndroid.Configure(options, _il2cpp);
+            SentryNativeAndroid.Configure(options, _sentryUnityInfo);
             Assert.False(options.EnableScopeSync);
         }
 
@@ -75,10 +76,10 @@ public void Configure_NativeAndroidSupportDisabled_DisabledScopeSync()
         [TestCase(false, false)]
         public void Configure_IL2CPP_ReInitializesNativeBackendOnlyOnIL2CPP(bool il2cpp, bool expectedReinstall)
         {
-            _il2cpp = il2cpp;
+            _sentryUnityInfo.IL2CPP = il2cpp;
             Assert.False(_reinstallCalled); // Sanity check
 
-            SentryNativeAndroid.Configure(new(), _il2cpp);
+            SentryNativeAndroid.Configure(new(), _sentryUnityInfo);
 
             Assert.AreEqual(expectedReinstall, _reinstallCalled);
         }
@@ -87,8 +88,13 @@ public void Configure_IL2CPP_ReInitializesNativeBackendOnlyOnIL2CPP(bool il2cpp,
         public void Configure_NativeAndroidSupportDisabled_DoesNotReInitializeNativeBackend()
         {
             var options = new SentryUnityOptions { AndroidNativeSupportEnabled = false };
-            SentryNativeAndroid.Configure(options, _il2cpp);
+            SentryNativeAndroid.Configure(options, _sentryUnityInfo);
             Assert.False(_reinstallCalled);
         }
     }
+
+    public class TestSentryUnityInfo : ISentryUnityInfo
+    {
+        public bool IL2CPP { get; set; }
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ public static class SentryNativeAndroid`
`12`	`12`	`/// Configures the native Android support.`
`13`	`13`	`/// </summary>`
`14`	`14`	`/// <param name="options">The Sentry Unity options to use.</param>`
`15`		`- public static void Configure(SentryUnityOptions options, bool il2cpp)`
	`15`	`+ public static void Configure(SentryUnityOptions options, ISentryUnityInfo sentryUnityInfo)`
`16`	`16`	`{`
`17`	`17`	`if (options.AndroidNativeSupportEnabled)`
`18`	`18`	`{`
`@@ -39,7 +39,7 @@ public static void Configure(SentryUnityOptions options, bool il2cpp)`
`39`	`39`
`40`	`40`	`// When running on Mono, we shouldn't take over the signal handler because its used to propagate exceptions into the VM.`
`41`	`41`	`// If we take over, a C# null reference ends up crashing the app.`
`42`		`- if (il2cpp)`
	`42`	`+ if (sentryUnityInfo.IL2CPP)`
`43`	`43`	`{`
`44`	`44`	`// At this point Unity has taken the signal handler and will not invoke the original handler (Sentry)`
`45`	`45`	`// So we register our backend once more to make sure user-defined data is available in the crash report.`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Threading;`
`3`	`3`	`using NUnit.Framework;`
	`4`	`+using Sentry.Unity;`
`4`	`5`
`5`	`6`	`namespace Sentry.Unity.Android.Tests`
`6`	`7`	`{`
`@@ -9,7 +10,7 @@ public class SentryNativeAndroidTests`
`9`	`10`	`private bool _reinstallCalled;`
`10`	`11`	`private Action? _originalReinstallSentryNativeBackendStrategy;`
`11`	`12`	`private Action _fakeReinstallSentryNativeBackendStrategy;`
`12`		`- private bool _il2cpp;`
	`13`	`+ private TestSentryUnityInfo _sentryUnityInfo = null!;`
`13`	`14`
`14`	`15`	`public SentryNativeAndroidTests()`
`15`	`16`	`=> _fakeReinstallSentryNativeBackendStrategy = () => _reinstallCalled = true;`
`@@ -21,7 +22,7 @@ public void SetUp()`
`21`	`22`	`Interlocked.Exchange(ref SentryNative.ReinstallSentryNativeBackendStrategy,`
`22`	`23`	`_fakeReinstallSentryNativeBackendStrategy);`
`23`	`24`	`_reinstallCalled = false;`
`24`		`- _il2cpp = false;`
	`25`	`+ _sentryUnityInfo = new TestSentryUnityInfo { IL2CPP = false };`
`25`	`26`	`}`
`26`	`27`
`27`	`28`	`[TearDown]`
`@@ -34,39 +35,39 @@ public void TearDown() =>`
`34`	`35`	`public void Configure_DefaultConfiguration_SetsScopeObserver()`
`35`	`36`	`{`
`36`	`37`	`var options = new SentryUnityOptions();`
`37`		`- SentryNativeAndroid.Configure(options, _il2cpp);`
	`38`	`+ SentryNativeAndroid.Configure(options, _sentryUnityInfo);`
`38`	`39`	`Assert.IsAssignableFrom<AndroidJavaScopeObserver>(options.ScopeObserver);`
`39`	`40`	`}`
`40`	`41`
`41`	`42`	`[Test]`
`42`	`43`	`public void Configure_DefaultConfiguration_SetsCrashedLastRun()`
`43`	`44`	`{`
`44`	`45`	`var options = new SentryUnityOptions();`
`45`		`- SentryNativeAndroid.Configure(options, _il2cpp);`
	`46`	`+ SentryNativeAndroid.Configure(options, _sentryUnityInfo);`
`46`	`47`	`Assert.IsNotNull(options.CrashedLastRun);`
`47`	`48`	`}`
`48`	`49`
`49`	`50`	`[Test]`
`50`	`51`	`public void Configure_NativeAndroidSupportDisabled_ObserverIsNull()`
`51`	`52`	`{`
`52`	`53`	`var options = new SentryUnityOptions { AndroidNativeSupportEnabled = false };`
`53`		`- SentryNativeAndroid.Configure(options, _il2cpp);`
	`54`	`+ SentryNativeAndroid.Configure(options, _sentryUnityInfo);`
`54`	`55`	`Assert.Null(options.ScopeObserver);`
`55`	`56`	`}`
`56`	`57`
`57`	`58`	`[Test]`
`58`	`59`	`public void Configure_DefaultConfiguration_EnablesScopeSync()`
`59`	`60`	`{`
`60`	`61`	`var options = new SentryUnityOptions();`
`61`		`- SentryNativeAndroid.Configure(options, _il2cpp);`
	`62`	`+ SentryNativeAndroid.Configure(options, _sentryUnityInfo);`
`62`	`63`	`Assert.True(options.EnableScopeSync);`
`63`	`64`	`}`
`64`	`65`
`65`	`66`	`[Test]`
`66`	`67`	`public void Configure_NativeAndroidSupportDisabled_DisabledScopeSync()`
`67`	`68`	`{`
`68`	`69`	`var options = new SentryUnityOptions { AndroidNativeSupportEnabled = false };`
`69`		`- SentryNativeAndroid.Configure(options, _il2cpp);`
	`70`	`+ SentryNativeAndroid.Configure(options, _sentryUnityInfo);`
`70`	`71`	`Assert.False(options.EnableScopeSync);`
`71`	`72`	`}`
`72`	`73`
`@@ -75,10 +76,10 @@ public void Configure_NativeAndroidSupportDisabled_DisabledScopeSync()`
`75`	`76`	`[TestCase(false, false)]`
`76`	`77`	`public void Configure_IL2CPP_ReInitializesNativeBackendOnlyOnIL2CPP(bool il2cpp, bool expectedReinstall)`
`77`	`78`	`{`
`78`		`- _il2cpp = il2cpp;`
	`79`	`+ _sentryUnityInfo.IL2CPP = il2cpp;`
`79`	`80`	`Assert.False(_reinstallCalled); // Sanity check`
`80`	`81`
`81`		`- SentryNativeAndroid.Configure(new(), _il2cpp);`
	`82`	`+ SentryNativeAndroid.Configure(new(), _sentryUnityInfo);`
`82`	`83`
`83`	`84`	`Assert.AreEqual(expectedReinstall, _reinstallCalled);`
`84`	`85`	`}`
`@@ -87,8 +88,13 @@ public void Configure_IL2CPP_ReInitializesNativeBackendOnlyOnIL2CPP(bool il2cpp,`
`87`	`88`	`public void Configure_NativeAndroidSupportDisabled_DoesNotReInitializeNativeBackend()`
`88`	`89`	`{`
`89`	`90`	`var options = new SentryUnityOptions { AndroidNativeSupportEnabled = false };`
`90`		`- SentryNativeAndroid.Configure(options, _il2cpp);`
	`91`	`+ SentryNativeAndroid.Configure(options, _sentryUnityInfo);`
`91`	`92`	`Assert.False(_reinstallCalled);`
`92`	`93`	`}`
`93`	`94`	`}`
	`95`	`+`
	`96`	`+ public class TestSentryUnityInfo : ISentryUnityInfo`
	`97`	`+ {`
	`98`	`+ public bool IL2CPP { get; set; }`
	`99`	`+ }`
`94`	`100`	`}`