fix: Moved late option mutation into Init

CHANGELOG.md

@@ -15,7 +15,7 @@
   **Migration**: Update your `using` directives from `using Sentry;` to `using Sentry.Unity;`. IDEs like Rider can automatically 
   import the missing references. In some cases, you may need both `using Sentry.Unity;` (for the static API) and `using Sentry;` 
   (for types like `SentryId`). No changes are required to your actual SDK method calls (e.g., `SentrySdk.CaptureException()` 
-  remains the same). ([#2227](https://github.com/getsentry/sentry-unity/pull/2227))
+  remains the same). ([#2227](https://github.com/getsentry/sentry-unity/pull/2227), [#2239](https://github.com/getsentry/sentry-unity/pull/2239))
 
 ### Features
 

src/Sentry.Unity/Il2CppEventProcessor.cs

@@ -21,6 +21,7 @@ public UnityIl2CppEventExceptionProcessor(SentryUnityOptions options)
     {
         Options = options;
         UnityInfo = options.UnityInfo;
+        // We're throwing here but this should never happen. We're validating UnityInfo before adding the processor.
         _il2CppMethods = UnityInfo.Il2CppMethods ?? throw new ArgumentNullException(nameof(UnityInfo.Il2CppMethods),
             "Unity IL2CPP methods are not available.");
 

src/Sentry.Unity/ScriptableSentryUnityOptions.cs

@@ -115,28 +115,31 @@ public static string GetConfigPath(string? notDefaultConfigName = null)
     [field: SerializeField] public SentryLevel DiagnosticLevel { get; set; } = SentryLevel.Warning;
 
     /// <summary>
-    /// Loads the ScriptableSentryUnityOptions from `Resource`.
+    /// Loads the ScriptableSentryUnityOptions from <c>Resource</c>.
     /// </summary>
-    /// <returns>The SentryUnityOptions generated from the ScriptableSentryUnityOptions</returns>
+    /// <returns>The <c>SentryUnityOptions</c> generated from the <c>ScriptableSentryUnityOptions</c></returns>
     /// <remarks>
-    /// Used for loading the SentryUnityOptions from the ScriptableSentryUnityOptions during runtime.
+    /// This gets called from <c>SentryInitialization</c> during the game's startup.
     /// </remarks>
     public static SentryUnityOptions? LoadSentryUnityOptions()
     {
         var scriptableOptions = Resources.Load<ScriptableSentryUnityOptions>($"{ConfigRootFolder}/{ConfigName}");
         if (scriptableOptions is not null)
         {
-            return scriptableOptions.ToSentryUnityOptions(false);
+            return scriptableOptions.ToSentryUnityOptions();
         }
 
         return null;
     }
 
-    internal SentryUnityOptions ToSentryUnityOptions(bool isBuilding, ISentryUnityInfo? unityInfo = null, IApplication? application = null)
+    internal SentryUnityOptions ToSentryUnityOptions(
+        ISentryUnityInfo? unityInfo = null,
+        IApplication? application = null,
+        bool isBuilding = false)
     {
         application ??= ApplicationAdapter.Instance;
 
-        var options = new SentryUnityOptions(isBuilding, application, unityInfo)
+        var options = new SentryUnityOptions(unityInfo, application, isBuilding: isBuilding)
         {
             Enabled = Enabled,
             Dsn = Dsn,
@@ -186,6 +189,12 @@ internal SentryUnityOptions ToSentryUnityOptions(bool isBuilding, ISentryUnityIn
             PerformanceAutoInstrumentationEnabled = AutoAwakeTraces,
         };
 
+        // By default, the cacheDirectoryPath gets set on known platforms. We're overwriting this behaviour here.
+        if (!EnableOfflineCaching)
+        {
+            options.CacheDirectoryPath = null;
+        }
+
         if (!string.IsNullOrWhiteSpace(ReleaseOverride))
         {
             options.Release = ReleaseOverride;
@@ -227,23 +236,11 @@ internal SentryUnityOptions ToSentryUnityOptions(bool isBuilding, ISentryUnityIn
         // Without setting up here we might miss out on logs between option-loading (now) and Init - i.e. native configuration
         options.SetupUnityLogging();
 
-        if (options.AttachViewHierarchy)
-        {
-            options.AddEventProcessor(new ViewHierarchyEventProcessor(options));
-        }
-        if (options.AttachScreenshot)
-        {
-            options.AddEventProcessor(new ScreenshotEventProcessor(options));
-        }
-
-        if (!application.IsEditor && options.Il2CppLineNumberSupportEnabled && unityInfo?.Il2CppMethods != null)
-        {
-            options.AddIl2CppExceptionProcessor();
-        }
-
-        HandlePlatformRestrictedOptions(options, application);
+        // ExceptionFilters are added by default to the options.
         HandleExceptionFilter(options);
 
+        // The AnrDetectionIntegration is added by default. Since it is a ScriptableUnityOptions-only property we have to
+        // remove the integration when creating the options through here
         if (!AnrDetectionEnabled)
         {
             options.DisableAnrIntegration();
@@ -252,41 +249,6 @@ internal SentryUnityOptions ToSentryUnityOptions(bool isBuilding, ISentryUnityIn
         return options;
     }
 
-    internal void HandlePlatformRestrictedOptions(SentryUnityOptions options, IApplication application)
-    {
-        if (!options.UnityInfo.IsKnownPlatform())
-        {
-            options.DisableFileWrite = true;
-
-            // This is only provided on a best-effort basis for other than the explicitly supported platforms.
-            if (options.BackgroundWorker is null)
-            {
-                options.DiagnosticLogger?.LogDebug("Platform support for background thread execution is unknown: using WebBackgroundWorker.");
-                options.BackgroundWorker = new WebBackgroundWorker(options, SentryMonoBehaviour.Instance);
-            }
-
-            // Disable offline caching regardless whether it was enabled or not.
-            options.CacheDirectoryPath = null;
-            if (EnableOfflineCaching)
-            {
-                options.DiagnosticLogger?.LogDebug("Platform support for offline caching is unknown: disabling.");
-            }
-
-            // Requires file access, see https://github.com/getsentry/sentry-unity/issues/290#issuecomment-1163608988
-            if (options.AutoSessionTracking)
-            {
-                options.DiagnosticLogger?.LogDebug("Platform support for automatic session tracking is unknown: disabling.");
-                options.AutoSessionTracking = false;
-            }
-
-            return;
-        }
-
-        // Only assign the cache directory path if we're on a "known" platform. Accessing `Application.persistentDataPath`
-        // implicitly creates a directory and leads to crashes i.e. on the Switch.
-        options.CacheDirectoryPath = EnableOfflineCaching ? application.PersistentDataPath : null;
-    }
-
     private void HandleExceptionFilter(SentryUnityOptions options)
     {
         if (!options.FilterBadGatewayExceptions)

src/Sentry.Unity/SentryUnityOptions.cs

@@ -298,45 +298,48 @@ internal string? DefaultUserId
     internal ISentryUnityInfo UnityInfo { get; private set; }
     internal Action<SentryUnityOptions>? PlatformConfiguration { get; private set; }
 
-    public SentryUnityOptions() : this(false, ApplicationAdapter.Instance) { }
-
-    internal SentryUnityOptions(bool isBuilding, IApplication application, ISentryUnityInfo? unityInfo = null) :
-        this(SentryMonoBehaviour.Instance, application, isBuilding, unityInfo)
-    { }
+    public SentryUnityOptions() : this(isBuilding: false) { }
 
     // For testing
-    internal SentryUnityOptions(SentryMonoBehaviour behaviour, IApplication application, bool isBuilding, ISentryUnityInfo? unityInfo = null)
+    internal SentryUnityOptions(
+        ISentryUnityInfo? unityInfo = null,
+        IApplication? application = null,
+        SentryMonoBehaviour? behaviour = null,
+        bool isBuilding = false)
     {
         // NOTE: 'SentryPlatformServices.UnityInfo' throws when the UnityInfo has not been set. This should not happen.
         // The PlatformServices are set through the RuntimeLoad attribute in 'SentryInitialization.cs' and are required
         // to be present.
         UnityInfo = unityInfo ?? SentryPlatformServices.UnityInfo;
         PlatformConfiguration = SentryPlatformServices.PlatformConfiguration;
 
+        application ??= ApplicationAdapter.Instance;
+        behaviour ??= SentryMonoBehaviour.Instance;
+
         // IL2CPP doesn't support Process.GetCurrentProcess().StartupTime
         DetectStartupTime = StartupTimeDetectionMode.Fast;
 
-        this.AddInAppExclude("UnityEngine");
-        this.AddInAppExclude("UnityEditor");
+        AddInAppExclude("UnityEngine");
+        AddInAppExclude("UnityEditor");
         var processor = new UnityEventProcessor(this);
-        this.AddEventProcessor(processor);
-        this.AddTransactionProcessor(processor);
-        this.AddExceptionProcessor(new UnityExceptionProcessor());
-
-        this.AddIntegration(new UnityLogHandlerIntegration(this));
-        this.AddIntegration(new UnityApplicationLoggingIntegration());
-        this.AddIntegration(new StartupTracingIntegration());
-        this.AddIntegration(new AnrIntegration(behaviour));
-        this.AddIntegration(new UnityScopeIntegration(application, unityInfo));
-        this.AddIntegration(new UnityBeforeSceneLoadIntegration());
-        this.AddIntegration(new SceneManagerIntegration());
-        this.AddIntegration(new SceneManagerTracingIntegration());
-        this.AddIntegration(new SessionIntegration(behaviour));
-        this.AddIntegration(new TraceGenerationIntegration(behaviour));
-
-        this.AddExceptionFilter(new UnityBadGatewayExceptionFilter());
-        this.AddExceptionFilter(new UnityWebExceptionFilter());
-        this.AddExceptionFilter(new UnitySocketExceptionFilter());
+        AddEventProcessor(processor);
+        AddTransactionProcessor(processor);
+        AddExceptionProcessor(new UnityExceptionProcessor());
+
+        AddIntegration(new UnityLogHandlerIntegration(this));
+        AddIntegration(new UnityApplicationLoggingIntegration());
+        AddIntegration(new StartupTracingIntegration());
+        AddIntegration(new AnrIntegration(behaviour));
+        AddIntegration(new UnityScopeIntegration(application, unityInfo));
+        AddIntegration(new UnityBeforeSceneLoadIntegration());
+        AddIntegration(new SceneManagerIntegration());
+        AddIntegration(new SceneManagerTracingIntegration());
+        AddIntegration(new SessionIntegration(behaviour));
+        AddIntegration(new TraceGenerationIntegration(behaviour));
+
+        AddExceptionFilter(new UnityBadGatewayExceptionFilter());
+        AddExceptionFilter(new UnityWebExceptionFilter());
+        AddExceptionFilter(new UnitySocketExceptionFilter());
 
         IsGlobalModeEnabled = true;
 
@@ -373,6 +376,13 @@ internal SentryUnityOptions(SentryMonoBehaviour behaviour, IApplication applicat
             { LogType.Error, true},
             { LogType.Exception, true},
         };
+
+        // Only assign the cache directory path if we're on a "known" platform. Accessing `Application.persistentDataPath`
+        // implicitly creates a directory and leads to crashes i.e. on the Switch.
+        if (unityInfo?.IsKnownPlatform() ?? false)
+        {
+            CacheDirectoryPath = application.PersistentDataPath;
+        }
     }
 
     public override string ToString()

src/Sentry.Unity/SentryUnityOptionsExtensions.cs

@@ -63,11 +63,6 @@ internal static void SetupUnityLogging(this SentryUnityOptions options)
         }
     }
 
-    internal static void AddIl2CppExceptionProcessor(this SentryUnityOptions options)
-    {
-        options.AddExceptionProcessor(new UnityIl2CppEventExceptionProcessor(options));
-    }
-
     /// <summary>
     /// Disables the capture of errors through <see cref="UnityLogHandlerIntegration"/>.
     /// </summary>

src/Sentry.Unity/SentryUnitySdk.cs

@@ -11,7 +11,7 @@ internal class SentryUnitySdk
 {
     private readonly SentryUnityOptions _options;
     private IDisposable _dotnetSdk = null!;
-    private FileStream? _lockFile;
+    private FileStream? LockFile;
 
     private SentryUnitySdk(SentryUnityOptions options)
     {
@@ -30,30 +30,14 @@ private SentryUnitySdk(SentryUnityOptions options)
 
         MainThreadData.CollectData();
 
-        // On Standalone, we disable cache dir in case multiple app instances run over the same path.
-        // Note: we cannot use a named Mutex, because Unit doesn't support it. Instead, we create a file with `FileShare.None`.
-        // https://forum.unity.com/threads/unsupported-internal-call-for-il2cpp-mutex-createmutex_internal-named-mutexes-are-not-supported.387334/
-        if (ApplicationAdapter.Instance.Platform is RuntimePlatform.WindowsPlayer && options.CacheDirectoryPath is not null)
-        {
-            try
-            {
-                unitySdk._lockFile = new FileStream(Path.Combine(options.CacheDirectoryPath, "sentry-unity.lock"), FileMode.OpenOrCreate,
-                    FileAccess.ReadWrite, FileShare.None);
-            }
-            catch (Exception ex)
-            {
-                options.DiagnosticLogger?.LogWarning("An exception was thrown while trying to " +
-                                                     "acquire a lockfile on the config directory: .NET event cache will be disabled.", ex);
-                options.CacheDirectoryPath = null;
-                options.AutoSessionTracking = false;
-            }
-        }
+        // Some integrations are controlled through a flag and opt-in. Adding these integrations late so we have equal
+        // behaviour whether the options got created through the ScriptableObject or the SDK gets manually initialized
+        AddIntegrations(options);
+        SetUpWindowsPlayerCaching(unitySdk, options);
 
-        unitySdk._dotnetSdk = Sentry.SentrySdk.Init(options);
+        ConfigureUnsupportedPlatformFallbacks(options);
 
-        // We can safely call this during initialization. If the SDK self-initialized we're right on time. If the SDK
-        // was initialized manually, the RuntimeOnLoad attributes already triggered, making this call a no-op.
-        StartupTracingIntegration.StartTracing();
+        unitySdk._dotnetSdk = Sentry.SentrySdk.Init(options);
 
         // We can safely call this during initialization. If the SDK self-initialized we're right on time. If the SDK
         // was initialized manually, the RuntimeOnLoad attributes already triggered, making this call a no-op.
@@ -99,7 +83,7 @@ public void Close()
         try
         {
             // We don't really need to close, Windows would release the lock anyway, but let's be nice.
-            _lockFile?.Close();
+            LockFile?.Close();
         }
         catch (Exception ex)
         {
@@ -141,4 +125,77 @@ public void CaptureFeedback(string message, string? email, string? name, bool ad
 
         Sentry.SentrySdk.CurrentHub.CaptureFeedback(message, email, name, hint: hint);
     }
+
+    internal static void SetUpWindowsPlayerCaching(SentryUnitySdk unitySdk, SentryUnityOptions options)
+    {
+        // On Windows-Standalone, we disable cache dir in case multiple app instances run over the same path.
+        // Note: we cannot use a named Mutex, because Unity doesn't support it. Instead, we create a file with `FileShare.None`.
+        // https://forum.unity.com/threads/unsupported-internal-call-for-il2cpp-mutex-createmutex_internal-named-mutexes-are-not-supported.387334/
+        if (ApplicationAdapter.Instance.Platform is not RuntimePlatform.WindowsPlayer ||
+            options.CacheDirectoryPath is null)
+        {
+            return;
+        }
+
+        try
+        {
+            unitySdk.LockFile = new FileStream(Path.Combine(options.CacheDirectoryPath, "sentry-unity.lock"), FileMode.OpenOrCreate,
+                FileAccess.ReadWrite, FileShare.None);
+        }
+        catch (Exception ex)
+        {
+            options.DiagnosticLogger?.LogWarning("An exception was thrown while trying to " +
+                                                 "acquire a lockfile on the config directory: .NET event cache will be disabled.", ex);
+            options.CacheDirectoryPath = null;
+            options.AutoSessionTracking = false;
+        }
+    }
+
+    internal static void AddIntegrations(SentryUnityOptions options)
+    {
+        if (options.AttachViewHierarchy)
+        {
+            options.AddEventProcessor(new ViewHierarchyEventProcessor(options));
+        }
+        if (options.AttachScreenshot)
+        {
+            options.AddEventProcessor(new ScreenshotEventProcessor(options));
+        }
+
+        if (!ApplicationAdapter.Instance.IsEditor &&
+            options.UnityInfo.IL2CPP &&
+            options.Il2CppLineNumberSupportEnabled)
+        {
+            if (options.UnityInfo.Il2CppMethods is not null)
+            {
+                options.AddExceptionProcessor(new UnityIl2CppEventExceptionProcessor(options));
+            }
+            else
+            {
+                options.DiagnosticLogger?.LogWarning("Failed to find required IL2CPP methods - Skipping line number support");
+            }
+        }
+    }
+
+    internal static void ConfigureUnsupportedPlatformFallbacks(SentryUnityOptions options)
+    {
+        if (!options.UnityInfo.IsKnownPlatform())
+        {
+            options.DisableFileWrite = true;
+
+            // Requires file access, see https://github.com/getsentry/sentry-unity/issues/290#issuecomment-1163608988
+            if (options.AutoSessionTracking)
+            {
+                options.DiagnosticLogger?.LogDebug("Platform support for automatic session tracking is unknown: disabling.");
+                options.AutoSessionTracking = false;
+            }
+
+            // This is only provided on a best-effort basis for other than the explicitly supported platforms.
+            if (options.BackgroundWorker is null)
+            {
+                options.DiagnosticLogger?.LogDebug("Platform support for background thread execution is unknown: using WebBackgroundWorker.");
+                options.BackgroundWorker = new WebBackgroundWorker(options, SentryMonoBehaviour.Instance);
+            }
+        }
+    }
 }