Merge branch 'main' into 2710-macos_version

Author: aritchie

.github/workflows/codeql-analysis.yml

@@ -35,7 +35,7 @@ jobs:
         uses: ./.github/actions/environment
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@dd746615b3b9d728a6a37ca2045b68ca76d4841a # pin@v2
+        uses: github/codeql-action/init@9e8d0789d4a0fa9ceb6b1738f7e269594bdd67f0 # pin@v2
         with:
           languages: csharp
 
@@ -49,6 +49,6 @@ jobs:
         run: dotnet build Sentry-CI-CodeQL.slnf --no-restore --nologo
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@dd746615b3b9d728a6a37ca2045b68ca76d4841a # pin@v2
+        uses: github/codeql-action/analyze@9e8d0789d4a0fa9ceb6b1738f7e269594bdd67f0 # pin@v2
         with:
           category: '/language:csharp'

.github/workflows/release.yml

@@ -20,7 +20,7 @@ jobs:
     steps:
       - name: Get auth token
         id: token
-        uses: actions/create-github-app-token@136412a57a7081aa63c935a2cc2918f76c34f514 # v1.11.2
+        uses: actions/create-github-app-token@67e27a7eb7db372a1c61a7f9bdab8699e9ee57f7 # v1.11.3
         with:
           app-id: ${{ vars.SENTRY_RELEASE_BOT_CLIENT_ID }}
           private-key: ${{ secrets.SENTRY_RELEASE_BOT_PRIVATE_KEY }}

CHANGELOG.md

@@ -4,16 +4,17 @@
 
 ### Fixes
 
+- Native SIGSEGV errors resulting from managed NullReferenceExceptions are now suppressed on Android ([#3903](https://github.com/getsentry/sentry-dotnet/pull/3903))
 - OTel activities that are marked as not recorded are no longer sent to Sentry ([#3890](https://github.com/getsentry/sentry-dotnet/pull/3890))
 - Fixed envelopes with oversized attachments getting stuck in __processing ([#3938](https://github.com/getsentry/sentry-dotnet/pull/3938))
 - Unknown stack frames in profiles on .NET 8+ ([#3942](https://github.com/getsentry/sentry-dotnet/pull/3942))
 - Deduplicate profiling stack frames ([#3941](https://github.com/getsentry/sentry-dotnet/pull/3941))
 - OperatingSystem will now return macOS as OS name instead of 'Darwin' as well as the proper version. ([#2710](https://github.com/getsentry/sentry-dotnet/pull/3956))
+- Ignore null value on CocoaScopeObserver.SetTag ([#3948](https://github.com/getsentry/sentry-dotnet/pull/3948))
 
 ## 5.1.0
 
 ### Significant change in behavior
-
 - The User.IpAddress is now only set to `{{auto}}` when `SendDefaultPii` is enabled. This change gives you control over IP address collection directly on the client ([#3893](https://github.com/getsentry/sentry-dotnet/pull/3893))
 
 ### Features

src/Sentry/Http/HttpTransportBase.cs

@@ -271,6 +271,7 @@ private void ExtractRateLimits(HttpHeaders responseHeaders)
 
         // Join to a string to handle both single-header and multi-header cases
         var rateLimitsEncoded = string.Join(",", rateLimitHeaderValues);
+        _options.LogDebug("Parsing rate limit headers: {0}", rateLimitsEncoded);
 
         // Parse and order by retry-after so that the longer rate limits are set last (and not overwritten)
         var rateLimits = RateLimit.ParseMany(rateLimitsEncoded).OrderBy(rl => rl.RetryAfter);

src/Sentry/Platforms/Android/AndroidOptions.cs

@@ -25,5 +25,21 @@ public class AndroidOptions
         /// </summary>
         /// <seealso cref="LogCatIntegration" />
         public int LogCatMaxLines { get; set; } = 1000;
+
+        /// <summary>
+        /// <para>
+        /// Whether to suppress capturing SIGSEGV (Segfault) errors in the Native SDK.
+        /// </para>
+        /// <para>
+        /// When managed code results in a NullReferenceException, this also causes a SIGSEGV (Segfault). Duplicate
+        /// events (one managed and one native) can be prevented by suppressing native Segfaults, which may be
+        /// convenient.
+        /// </para>
+        /// <para>
+        /// Enabling this may prevent the capture of Segfault originating from native (not managed) code... so it may
+        /// prevent the capture of genuine native Segfault errors.
+        /// </para>
+        /// </summary>
+        public bool SuppressSegfaults { get; set; } = false;
     }
 }

src/Sentry/Platforms/Android/BindableAndroidSentryOptions.cs

@@ -14,11 +14,13 @@ public class AndroidOptions
     {
         public LogCatIntegrationType? LogCatIntegration { get; set; }
         public int? LogCatMaxLines { get; set; }
+        public bool? SuppressSegfaults { get; set; }
 
         public void ApplyTo(SentryOptions.AndroidOptions options)
         {
             options.LogCatIntegration = LogCatIntegration ?? options.LogCatIntegration;
             options.LogCatMaxLines = LogCatMaxLines ?? options.LogCatMaxLines;
+            options.SuppressSegfaults = SuppressSegfaults ?? options.SuppressSegfaults;
         }
     }
 }

src/Sentry/Platforms/Android/SentrySdk.cs

@@ -3,6 +3,7 @@
 using Sentry.Android;
 using Sentry.Android.Callbacks;
 using Sentry.Android.Extensions;
+using Sentry.Extensibility;
 using Sentry.JavaSdk.Android.Core;
 
 // Don't let the Sentry Android SDK auto-init, as we do that manually in SentrySdk.Init
@@ -99,10 +100,7 @@ private static void InitSentryAndroidSdk(SentryOptions options)
                 }
             }
 
-            if (options.Native.EnableBeforeSend && options.BeforeSendInternal is { } beforeSend)
-            {
-                o.BeforeSend = new BeforeSendCallback(beforeSend, options, o);
-            }
+            o.BeforeSend = new BeforeSendCallback(BeforeSendWrapper(options), options, o);
 
             // These options are from SentryAndroidOptions
             o.AttachScreenshot = options.Native.AttachScreenshot;
@@ -172,6 +170,26 @@ private static void InitSentryAndroidSdk(SentryOptions options)
         // TODO: Pause/Resume
     }
 
+    internal static Func<SentryEvent, SentryHint, SentryEvent?> BeforeSendWrapper(SentryOptions options)
+    {
+        return (evt, hint) =>
+        {
+            // Suppress SIGSEGV errors.
+            // See: https://github.com/getsentry/sentry-dotnet/pull/3903
+            if (options.Android.SuppressSegfaults
+                && evt.SentryExceptions?.FirstOrDefault() is { Type: "SIGSEGV", Value: "Segfault" })
+            {
+                options.LogDebug("Suppressing SIGSEGV (this will be thrown as a managed exception instead)");
+                return null;
+            }
+
+            // Call the user defined BeforeSend callback, if it's defined - otherwise return the event as-is
+            return (options.Native.EnableBeforeSend && options.BeforeSendInternal is { } beforeSend)
+                ? beforeSend(evt, hint)
+                : evt;
+        };
+    }
+
     private static void AndroidEnvironment_UnhandledExceptionRaiser(object? _, RaiseThrowableEventArgs e)
     {
         var description = "This exception was caught by the Android global error handler.";

src/Sentry/Platforms/Cocoa/CocoaScopeObserver.cs

@@ -67,6 +67,12 @@ public void SetExtra(string key, object? value)
 
     public void SetTag(string key, string value)
     {
+        if (value is null)
+        {
+            _options.LogDebug("Tag with key '{0}' was null. Use Unset to remove tags instead.", key);
+            return;
+        }
+
         try
         {
             SentryCocoaSdk.ConfigureScope(scope => scope.SetTagValue(value, key));

test/Sentry.Tests/Platforms/Android/SentrySdkTests.cs

@@ -0,0 +1,116 @@
+#if ANDROID
+namespace Sentry.Tests.Platforms.Android;
+
+public class SentrySdkTests
+{
+    [Fact]
+    public void BeforeSendWrapper_Suppress_SIGSEGV_ReturnsNull()
+    {
+        // Arrange
+        var options = new SentryOptions();
+        options.Android.SuppressSegfaults = true;
+        var evt = new SentryEvent
+        {
+            SentryExceptions = new[]
+            {
+                new SentryException
+                {
+                    Type = "SIGSEGV",
+                    Value = "Segfault"
+                }
+            }
+        };
+        var hint = new SentryHint();
+
+        // Act
+        var result = SentrySdk.BeforeSendWrapper(options).Invoke(evt, hint);
+
+        // Assert
+        result.Should().BeNull();
+    }
+
+    [Fact]
+    public void BeforeSendWrapper_DontSupress_SIGSEGV_ReturnsEvent()
+    {
+        // Arrange
+        var options = new SentryOptions();
+        options.Android.SuppressSegfaults = false;
+        var evt = new SentryEvent
+        {
+            SentryExceptions = new[]
+            {
+                new SentryException
+                {
+                    Type = "SIGSEGV",
+                    Value = "Segfault"
+                }
+            }
+        };
+        var hint = new SentryHint();
+
+        // Act
+        var result = SentrySdk.BeforeSendWrapper(options).Invoke(evt, hint);
+
+        // Assert
+        result.Should().Be(evt);
+    }
+
+    [Fact]
+    public void BeforeSendWrapper_BeforeSendCallbackDefined_CallsBeforeSend()
+    {
+        // Arrange
+        var beforeSend = Substitute.For<Func<SentryEvent, SentryHint, SentryEvent>>();
+        beforeSend.Invoke(Arg.Any<SentryEvent>(), Arg.Any<SentryHint>()).Returns(callInfo => callInfo.Arg<SentryEvent>());
+
+        var options = new SentryOptions();
+        options.Native.EnableBeforeSend = true;
+        options.SetBeforeSend(beforeSend);
+        var evt = new SentryEvent();
+        var hint = new SentryHint();
+
+        // Act
+        var result = SentrySdk.BeforeSendWrapper(options).Invoke(evt, hint);
+
+        // Assert
+        beforeSend.Received(1).Invoke(Arg.Any<SentryEvent>(), Arg.Any<SentryHint>());
+        result.Should().Be(evt);
+    }
+
+    [Fact]
+    public void BeforeSendWrapper_NoBeforeSendCallback_ReturnsEvent()
+    {
+        // Arrange
+        var options = new SentryOptions();
+        options.Native.EnableBeforeSend = true;
+        var evt = new SentryEvent();
+        var hint = new SentryHint();
+
+        // Act
+        var result = SentrySdk.BeforeSendWrapper(options).Invoke(evt, hint);
+
+        // Assert
+        result.Should().Be(evt);
+    }
+
+    [Fact]
+    public void BeforeSendWrapper_NativeBeforeSendDisabled_ReturnsEvent()
+    {
+        // Arrange
+        var beforeSend = Substitute.For<Func<SentryEvent, SentryHint, SentryEvent>>();
+        beforeSend.Invoke(Arg.Any<SentryEvent>(), Arg.Any<SentryHint>()).Returns(_ => null);
+
+        var options = new SentryOptions();
+        options.SetBeforeSend(beforeSend);
+        options.Native.EnableBeforeSend = false;
+        var evt = new SentryEvent();
+        var hint = new SentryHint();
+
+        // Act
+        var result = SentrySdk.BeforeSendWrapper(options).Invoke(evt, hint);
+
+        // Assert
+        beforeSend.DidNotReceive().Invoke(Arg.Any<SentryEvent>(), Arg.Any<SentryHint>());
+        result.Should().Be(evt);
+    }
+}
+#endif

test/Sentry.Tests/ScopeTests.cs

@@ -615,6 +615,24 @@ public void Filtered_tags_are_not_set()
 
         scope.Tags.Should().OnlyContain(pair => pair.Key == "AzFunctions" && pair.Value == "rule");
     }
+
+    [Fact]
+    public void SetTag_NullValue_DoesNotThrowArgumentNullException()
+    {
+        var scope = new Scope();
+
+        ArgumentNullException exception = null;
+        try
+        {
+            scope.SetTag("IAmNull", null);
+        }
+        catch (ArgumentNullException e)
+        {
+            exception = e;
+        }
+
+        Assert.Null(exception);
+    }
 }
 
 public static class ScopeTestExtensions