feat(switch2): Nintendo Switch 2 support, and stop the offline transport raising system dialogs

CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## Unreleased
 
+### Features
+
+- Added Nintendo Switch 2 support. The SDK now recognises the platform, links the Switch 2 build of the native library from `Assets/Plugins/Sentry/Switch2/`, and uploads its debug symbols. Switch 2 shares the existing `SwitchNativeSupportEnabled` option ([#2831](https://github.com/getsentry/sentry-unity/pull/2831))
+
+### Fixes
+
+- The `UnityWebRequestTransport` no longer opens a connection while the platform reports no network, and backs off exponentially (1s up to 60s) after a connection error instead of retrying on every envelope. On Nintendo Switch each send attempt made while offline raises the system's "connect to the internet" dialog, so a game with logs or metrics enabled produced a prompt every few seconds ([#2831](https://github.com/getsentry/sentry-unity/pull/2831))
+- The `UnityLogger` no longer throws while logging an exception whose stack trace cannot be stringified. On Nintendo Switch this escaped from inside the handler that had already dealt with the original error, aborting SDK initialization and leaving the Unity integrations unregistered ([#2831](https://github.com/getsentry/sentry-unity/pull/2831))
+- On Nintendo Switch the SDK now asks the native SDK whether the network is usable before sending, instead of relying on `Application.internetReachability`, which reports the console as reachable while it is offline. Every send attempted in that state raised the system's "connect to the internet" dialog. Requires a sentry-switch build exposing `sentry_switch_utils_is_network_available()` ([#2831](https://github.com/getsentry/sentry-unity/pull/2831))
+
 ### Dependencies
 
 - Bump .NET SDK from v6.8.0 to v6.9.0 ([#2815](https://github.com/getsentry/sentry-unity/pull/2815))

package-dev/Plugins/Switch/sentry_native_stubs.c

@@ -408,6 +408,13 @@ const char* sentry_switch_utils_get_default_user_id(void)
     return "";
 }
 
+int sentry_switch_utils_is_network_available(void)
+{
+    /* Return 1 - with no native SDK to ask, assume the network is usable and let the
+       transport fall back on its connection-error backoff */
+    return 1;
+}
+
 /*
  * =============================================================================
  * Utility Functions

package-dev/Runtime/SentryInitialization.cs

@@ -20,6 +20,10 @@
 #define SENTRY_NATIVE_SWITCH
 #endif
 
+#if UNITY_SWITCH2
+#define SENTRY_NATIVE_SWITCH2
+#endif
+
 #if UNITY_WEBGL
 #define SENTRY_WEBGL
 #endif
@@ -45,7 +49,7 @@
 using Sentry.Unity.iOS;
 #elif SENTRY_NATIVE_ANDROID
 using Sentry.Unity.Android;
-#elif SENTRY_NATIVE || SENTRY_NATIVE_SWITCH
+#elif SENTRY_NATIVE || SENTRY_NATIVE_SWITCH || SENTRY_NATIVE_SWITCH2
 using Sentry.Unity.Native;
 #elif SENTRY_WEBGL
 using Sentry.Unity.WebGL;
@@ -108,7 +112,7 @@ private static void SetUpPlatformServices()
             SentryPlatformServices.PlatformConfiguration = SentryNativeCocoa.Configure;
 #elif SENTRY_NATIVE_ANDROID
             SentryPlatformServices.PlatformConfiguration = SentryNativeAndroid.Configure;
-#elif SENTRY_NATIVE_SWITCH
+#elif SENTRY_NATIVE_SWITCH || SENTRY_NATIVE_SWITCH2
             SentryPlatformServices.PlatformConfiguration = SentryNativeSwitch.Configure;
 #elif SENTRY_NATIVE
             SentryPlatformServices.PlatformConfiguration = SentryNative.Configure;

package-dev/Runtime/io.sentry.unity.dev.runtime.asmdef

@@ -9,6 +9,7 @@
         "LinuxStandalone64",
         "macOSStandalone",
         "Switch",
+        "Switch2",
         "PS5",
         "WSA",
         "WebGL",

package/Runtime/io.sentry.unity.runtime.asmdef

@@ -12,6 +12,7 @@
         "macOSStandalone",
         "PS5",
         "Switch",
+        "Switch2",
         "WSA",
         "WebGL",
         "WindowsStandalone32",

src/Sentry.Unity.Editor/ConfigurationWindow/AdvancedTab.cs

@@ -176,7 +176,7 @@ internal static void Display(ScriptableSentryUnityOptions options, SentryCliOpti
                 options.PlayStationNativeSupportEnabled);
 
             options.SwitchNativeSupportEnabled = EditorGUILayout.Toggle(
-                new GUIContent("Nintendo Switch", "Whether to enable native scope sync support on Nintendo Switch."),
+                new GUIContent("Nintendo Switch", "Whether to enable native scope sync support on Nintendo Switch and Switch 2."),
                 options.SwitchNativeSupportEnabled);
         }
 

src/Sentry.Unity.Editor/Native/SwitchNativePluginBuildPreProcess.cs

@@ -1,3 +1,4 @@
+using System;
 using System.IO;
 using System.Linq;
 using Sentry.Extensibility;
@@ -21,32 +22,57 @@ namespace Sentry.Unity.Editor.Native;
 /// </remarks>
 internal class SwitchNativePluginBuildPreProcess : IPreprocessBuildWithReport
 {
-    private static readonly string[] RequiredFiles =
+    /// <summary>
+    /// <c>BuildTarget.Switch2</c> only exists in Unity 6000.3 and newer, and this assembly is
+    /// compiled against a single Unity version, so the target is matched by name. The build report
+    /// hands us the value itself, so the enum member never has to be referenced.
+    /// </summary>
+    internal const string Switch2BuildTargetName = "Switch2";
+
+    private static bool IsSwitchFamily(BuildTarget target) =>
+        target == BuildTarget.Switch || IsSwitch2(target);
+
+    private static bool IsSwitch2(BuildTarget target) =>
+        string.Equals(target.ToString(), Switch2BuildTargetName, StringComparison.Ordinal);
+
+    /// <summary>
+    /// Both platforms share one stub, so the required libraries are what differ between them.
+    /// </summary>
+    private static string[] RequiredFilesFor(BuildTarget target)
     {
-        "Assets/Plugins/Sentry/Switch/libsentry.a",
-        "Assets/Plugins/Sentry/Switch/libzstd.a",
-    };
+        var directory = IsSwitch2(target) ? Switch2BuildTargetName : nameof(BuildTarget.Switch);
+        return new[]
+        {
+            $"Assets/Plugins/Sentry/{directory}/libsentry.a",
+            $"Assets/Plugins/Sentry/{directory}/libzstd.a",
+        };
+    }
 
     public int callbackOrder => -100;
 
     public void OnPreprocessBuild(BuildReport report)
     {
-        if (report.summary.platform != BuildTarget.Switch)
+        if (!IsSwitchFamily(report.summary.platform))
         {
             return;
         }
 
         var options = SentryScriptableObject.LoadOptions(isBuilding: true);
         var logger = options?.DiagnosticLogger ?? new UnityLogger(new SentryUnityOptions());
 
-        ConfigureStub(logger, options?.SwitchNativeSupportEnabled ?? false);
+        // Switch 2 reuses the Switch implementation and therefore its option.
+        ConfigureStub(logger, options?.SwitchNativeSupportEnabled ?? false, report.summary.platform);
     }
 
-    internal static void ConfigureStub(IDiagnosticLogger logger, bool nativeSupportEnabled)
+    internal static void ConfigureStub(IDiagnosticLogger logger, bool nativeSupportEnabled, BuildTarget target)
     {
-        logger.LogDebug("Switch native support: checking for required files:\n{0}",
-            string.Join("\n", RequiredFiles.Select(f => $"  - {f}")));
+        var requiredFiles = RequiredFilesFor(target);
+
+        logger.LogDebug("{0} native support: checking for required files:\n{1}",
+            target, string.Join("\n", requiredFiles.Select(f => $"  - {f}")));
 
+        // One stub serves both platforms; the importer tracks compatibility per build target, so
+        // enabling it for one does not affect the other.
         var stubPath = Path.Combine("Packages", SentryPackageInfo.GetName(), "Plugins", "Switch", "sentry_native_stubs.c");
 
         var importer = AssetImporter.GetAtPath(stubPath) as PluginImporter;
@@ -56,14 +82,16 @@ internal static void ConfigureStub(IDiagnosticLogger logger, bool nativeSupportE
             return;
         }
 
-        var existingFiles = RequiredFiles.Where(File.Exists).ToList();
-        var missingFiles = RequiredFiles.Except(existingFiles).ToList();
+        var existingFiles = requiredFiles.Where(File.Exists).ToList();
+        var missingFiles = requiredFiles.Except(existingFiles).ToList();
 
         var someFilesPresent = existingFiles.Count > 0 && missingFiles.Count > 0;
         if (someFilesPresent)
         {
+            // LogError has no two-argument overload that does not also take an exception, so the
+            // target goes into the format string rather than being passed alongside the file list.
             logger.LogError(
-                "Switch native support is partially configured. Missing files:\n{0}\n" +
+                target + " native support is partially configured. Missing files:\n{0}\n" +
                 "Please add all required files to enable native support, or remove all files to fall back on no-op stubs.\n" +
                 "Build sentry-switch and copy the libraries to the expected locations. " +
                 "See: https://github.com/getsentry/sentry-switch",
@@ -75,26 +103,26 @@ internal static void ConfigureStub(IDiagnosticLogger logger, bool nativeSupportE
         var allFilesPresent = missingFiles.Count == 0;
         if (allFilesPresent)
         {
-            logger.LogInfo("Switch native libraries found:\n{0}",
-                string.Join("\n", existingFiles.Select(f => $"  - {f}")));
-            importer.SetCompatibleWithPlatform(BuildTarget.Switch, false);
+            logger.LogInfo("{0} native libraries found:\n{1}",
+                target, string.Join("\n", existingFiles.Select(f => $"  - {f}")));
+            importer.SetCompatibleWithPlatform(target, false);
         }
         else
         {
             if (nativeSupportEnabled)
             {
                 logger.LogWarning(
-                    "Switch native support is enabled but required files are missing:\n{0}\n" +
+                    "{0} native support is enabled but required files are missing:\n{1}\n" +
                     "Build sentry-switch and copy the libraries to the expected locations. " +
                     "See: https://github.com/getsentry/sentry-switch",
-                    string.Join("\n", missingFiles.Select(f => $"  - {f}"))
+                    target, string.Join("\n", missingFiles.Select(f => $"  - {f}"))
                 );
             }
             else
             {
-                logger.LogDebug("Switch native support is disabled. Enabling stubs (native calls will be no-op).");
+                logger.LogDebug("{0} native support is disabled. Enabling stubs (native calls will be no-op).", target);
             }
-            importer.SetCompatibleWithPlatform(BuildTarget.Switch, true);
+            importer.SetCompatibleWithPlatform(target, true);
         }
 
         importer.SaveAndReimport();

src/Sentry.Unity.Native/SentryNativeSwitch.cs

@@ -28,8 +28,21 @@ public static class SentryNativeSwitch
     [DllImport("__Internal")]
     private static extern IntPtr sentry_switch_utils_get_default_user_id();
 
+    [DllImport("__Internal")]
+    private static extern int sentry_switch_utils_is_network_available();
+
     private static IDiagnosticLogger? Logger;
 
+    /// <summary>
+    /// Queries the network interface manager without submitting a network request.
+    /// </summary>
+    /// <remarks>
+    /// Unity's <c>Application.internetReachability</c> reports the console as reachable even while
+    /// it is offline, and every send attempted in that state raises the system's "connect to the
+    /// internet" dialog. Asking the native SDK first is what keeps the dialog off the screen.
+    /// </remarks>
+    internal static bool IsNetworkAvailable() => sentry_switch_utils_is_network_available() == 1;
+
     /// <summary>
     /// Configures the native support for Nintendo Switch.
     /// </summary>
@@ -72,6 +85,11 @@ internal static void Configure(SentryUnityOptions options, RuntimePlatform platf
             return;
         }
 
+        // Wired up before the storage and native SDK setup below: the probe only needs the native
+        // library to be linked, so the transport keeps the benefit even if either of those fails.
+        Logger?.LogDebug("Using the native SDK to determine network availability.");
+        options.NetworkAvailabilityProbe = IsNetworkAvailable;
+
         Logger?.LogDebug("Mounting temporary storage for sentry-switch.");
 
         if (sentry_switch_utils_mount() != 1)

src/Sentry.Unity/Integrations/IApplication.cs

@@ -17,6 +17,7 @@ internal interface IApplication
     string UnityVersion { get; }
     string PersistentDataPath { get; }
     RuntimePlatform Platform { get; }
+    NetworkReachability InternetReachability { get; }
 }
 
 /// <summary>
@@ -54,6 +55,8 @@ private ApplicationAdapter()
 
     public RuntimePlatform Platform => Application.platform;
 
+    public NetworkReachability InternetReachability => Application.internetReachability;
+
     private void OnLogMessageReceived(string condition, string stackTrace, LogType type)
         => LogMessageReceived?.Invoke(condition, stackTrace, type);
 

src/Sentry.Unity/Properties/AssemblyInfo.cs

@@ -3,6 +3,7 @@
 [assembly: InternalsVisibleTo("Sentry.Unity.Native")]
 [assembly: InternalsVisibleTo("Sentry.Unity.Native.PlayStation")]
 [assembly: InternalsVisibleTo("Sentry.Unity.Native.Switch")]
+[assembly: InternalsVisibleTo("Sentry.Unity.Native.Switch2")]
 [assembly: InternalsVisibleTo("Sentry.Unity.Native.Xbox")]
 [assembly: InternalsVisibleTo("Sentry.Unity.Tests")]
 [assembly: InternalsVisibleTo("Sentry.Unity.Editor")]

src/Sentry.Unity/SentryUnityOptions.cs

@@ -494,6 +494,18 @@ internal string? DefaultUserId
     /// </summary>
     internal Action? NativeSupportCloseCallback { get; set; } = null;
 
+    /// <summary>
+    /// Reports whether the network is currently usable, when the platform can answer that more
+    /// reliably than <see cref="UnityEngine.Application.internetReachability"/>.
+    /// </summary>
+    /// <remarks>
+    /// Set by the platform configuration where a native probe exists. On Nintendo Switch this
+    /// matters twice over: reachability reports the console as reachable while it is offline, and
+    /// merely attempting a connection there raises the system's "connect to the internet" dialog.
+    /// Must not block - it is called on the main thread before each send.
+    /// </remarks>
+    internal Func<bool>? NetworkAvailabilityProbe { get; set; } = null;
+
     internal List<string> SdkIntegrationNames { get; set; } = new();
 
     internal ISentryUnityInfo UnityInfo { get; private set; }

src/Sentry.Unity/SentryUnityOptionsExtensions.cs

@@ -49,9 +49,27 @@ internal static bool IsValid(this SentryUnityOptions options)
         return true;
     }
 
+    /// <summary>
+    /// <c>RuntimePlatform.Switch2</c> was only added in Unity 6000.3. This assembly is compiled
+    /// against a single Unity version while the SDK still supports 2021.3, so Switch 2 is matched
+    /// by name instead of by enum member - referencing the member directly would stop the SDK from
+    /// building against the editors that predate it.
+    /// </summary>
+    internal const string Switch2PlatformName = "Switch2";
+
+    internal static bool IsSwitch2(this RuntimePlatform platform) =>
+        string.Equals(platform.ToString(), Switch2PlatformName, StringComparison.Ordinal);
+
     internal static bool IsNativeSupportEnabled(this SentryUnityOptions options, RuntimePlatform? platform = null)
     {
         platform ??= ApplicationAdapter.Instance.Platform;
+
+        // Switch 2 reuses the Switch native support, and therefore its option.
+        if (platform.Value.IsSwitch2())
+        {
+            return options.SwitchNativeSupportEnabled;
+        }
+
         return platform switch
         {
             RuntimePlatform.Android => options.AndroidNativeSupportEnabled,