feat: Add option to exclude certain HTTP statuses from tracing

AGENTS.md

@@ -139,6 +139,19 @@ gh pr view --json number -q '.number'
 - Maintain **backwards compatibility** — avoid breaking public API without strong justification
 - Platform-specific code lives in `src/Sentry/Platforms/` and is conditionally compiled
 
+## Adding New Options (AOT Compatibility)
+
+`SentryOptions` is **not** bound directly from configuration. Instead, a parallel `BindableSentryOptions` class (`src/Sentry/BindableSentryOptions.cs`) exists for AOT-safe configuration binding.
+
+When adding a configurable property to any of the classes descending from `SentryOptions`:
+
+1. Add the property to `SentryOptions` as normal.
+2. Add a matching **nullable** property to `BindableSentryOptions`. Use only simple/primitive types the source generator can handle. For complex types (e.g., `IReadOnlyList<StringOrRegex>`), use a simpler surrogate (e.g., `List<string>?`) and convert in `ApplyTo`.
+3. Add a line in `BindableSentryOptions.ApplyTo`: `options.MyProp = MyProp ?? options.MyProp;`
+4. Run the relevant bindable options test (e.g., `BindableSentryOptionsTests`) — the `BindableProperties_MatchOptionsProperties` test will fail if any bindable property is missing from the bindable class.
+
+The same pattern applies to `BindableSentryAspNetCoreOptions`, `BindableSentryMauiOptions`, `BindableSentryLoggingOptions`, and the platform-specific partial classes under `src/Sentry/Platforms/`.
+
 ## Commit Attribution
 
 AI commits MUST include:

src/Sentry/BindableSentryOptions.cs

@@ -38,6 +38,7 @@ internal partial class BindableSentryOptions
     public string? CacheDirectoryPath { get; set; }
     public bool? CaptureFailedRequests { get; set; }
     public List<string>? FailedRequestTargets { get; set; }
+    public List<int>? TraceIgnoreStatusCodes { get; set; }
     public bool? DisableFileWrite { get; set; }
     public TimeSpan? InitCacheFlushTimeout { get; set; }
     public Dictionary<string, string>? DefaultTags { get; set; }
@@ -90,6 +91,7 @@ public void ApplyTo(SentryOptions options)
         options.CacheDirectoryPath = CacheDirectoryPath ?? options.CacheDirectoryPath;
         options.CaptureFailedRequests = CaptureFailedRequests ?? options.CaptureFailedRequests;
         options.FailedRequestTargets = FailedRequestTargets?.Select(s => new StringOrRegex(s)).ToList() ?? options.FailedRequestTargets;
+        options.TraceIgnoreStatusCodes = TraceIgnoreStatusCodes?.Select(code => new HttpStatusCodeRange(code)).ToList<HttpStatusCodeRange>() ?? options.TraceIgnoreStatusCodes;
         options.DisableFileWrite = DisableFileWrite ?? options.DisableFileWrite;
         options.InitCacheFlushTimeout = InitCacheFlushTimeout ?? options.InitCacheFlushTimeout;
         options.DefaultTags = DefaultTags ?? options.DefaultTags;

src/Sentry/Internal/TraceIgnoreStatusCodeTransactionProcessor.cs

@@ -0,0 +1,31 @@
+using Sentry.Extensibility;
+using Sentry.Internal.OpenTelemetry;
+
+namespace Sentry.Internal;
+
+internal class TraceIgnoreStatusCodeTransactionProcessor : ISentryTransactionProcessor
+{
+    private readonly SentryOptions _options;
+
+    public TraceIgnoreStatusCodeTransactionProcessor(SentryOptions options)
+    {
+        _options = options;
+    }
+
+    public SentryTransaction? Process(SentryTransaction transaction)
+    {
+        if (_options.TraceIgnoreStatusCodes.Count == 0)
+        {
+            return transaction;
+        }
+
+        if (transaction.Data.TryGetValue(OtelSemanticConventions.AttributeHttpResponseStatusCode, out var statusCodeObj)
+            && statusCodeObj is int statusCode
+            && _options.TraceIgnoreStatusCodes.ContainsStatusCode(statusCode))
+        {
+            return null;
+        }
+
+        return transaction;
+    }
+}

src/Sentry/SentryOptions.cs

@@ -857,6 +857,12 @@ public IDiagnosticLogger? DiagnosticLogger
         (500, 599)
     };
 
+    /// <summary>
+    /// <para>Transactions will be dropped if the HTTP Response status code matches any of the configured ranges.</para>
+    /// <para>Defaults to an empty collection (all transactions are captured regardless of status code).</para>
+    /// </summary>
+    public IList<HttpStatusCodeRange> TraceIgnoreStatusCodes { get; set; } = [];
+
     // The default failed request target list will match anything, but adding to the list should clear that.
     private Lazy<IList<StringOrRegex>> _failedRequestTargets = new(() =>
         new AutoClearingList<StringOrRegex>(
@@ -1317,9 +1323,9 @@ public SentryOptions()
         SettingLocator = new SettingLocator(this);
         _lazyInstallationId = new(() => new InstallationIdHelper(this).TryGetInstallationId());
 
-        TransactionProcessorsProviders = new() {
-            () => TransactionProcessors ?? Enumerable.Empty<ISentryTransactionProcessor>()
-        };
+        TransactionProcessorsProviders = [
+            () => [.. TransactionProcessors ?? [], new TraceIgnoreStatusCodeTransactionProcessor(this)]
+        ];
 
         _clientReportRecorder = new Lazy<IClientReportRecorder>(() => new ClientReportRecorder(this));
 

test/Sentry.Tests/ApiApprovalTests.Run.DotNet10_0.verified.txt

@@ -838,6 +838,7 @@ namespace Sentry
         public string SpotlightUrl { get; set; }
         public Sentry.StackTraceMode StackTraceMode { get; set; }
         public System.Collections.Generic.IList<Sentry.StringOrRegex> TagFilters { get; set; }
+        public System.Collections.Generic.IList<Sentry.HttpStatusCodeRange> TraceIgnoreStatusCodes { get; set; }
         public System.Collections.Generic.IList<Sentry.StringOrRegex> TracePropagationTargets { get; set; }
         public double? TracesSampleRate { get; set; }
         public System.Func<Sentry.TransactionSamplingContext, double?>? TracesSampler { get; set; }

test/Sentry.Tests/ApiApprovalTests.Run.DotNet8_0.verified.txt

@@ -838,6 +838,7 @@ namespace Sentry
         public string SpotlightUrl { get; set; }
         public Sentry.StackTraceMode StackTraceMode { get; set; }
         public System.Collections.Generic.IList<Sentry.StringOrRegex> TagFilters { get; set; }
+        public System.Collections.Generic.IList<Sentry.HttpStatusCodeRange> TraceIgnoreStatusCodes { get; set; }
         public System.Collections.Generic.IList<Sentry.StringOrRegex> TracePropagationTargets { get; set; }
         public double? TracesSampleRate { get; set; }
         public System.Func<Sentry.TransactionSamplingContext, double?>? TracesSampler { get; set; }

test/Sentry.Tests/ApiApprovalTests.Run.DotNet9_0.verified.txt

@@ -838,6 +838,7 @@ namespace Sentry
         public string SpotlightUrl { get; set; }
         public Sentry.StackTraceMode StackTraceMode { get; set; }
         public System.Collections.Generic.IList<Sentry.StringOrRegex> TagFilters { get; set; }
+        public System.Collections.Generic.IList<Sentry.HttpStatusCodeRange> TraceIgnoreStatusCodes { get; set; }
         public System.Collections.Generic.IList<Sentry.StringOrRegex> TracePropagationTargets { get; set; }
         public double? TracesSampleRate { get; set; }
         public System.Func<Sentry.TransactionSamplingContext, double?>? TracesSampler { get; set; }

test/Sentry.Tests/ApiApprovalTests.Run.Net4_8.verified.txt

@@ -825,6 +825,7 @@ namespace Sentry
         public string SpotlightUrl { get; set; }
         public Sentry.StackTraceMode StackTraceMode { get; set; }
         public System.Collections.Generic.IList<Sentry.StringOrRegex> TagFilters { get; set; }
+        public System.Collections.Generic.IList<Sentry.HttpStatusCodeRange> TraceIgnoreStatusCodes { get; set; }
         public System.Collections.Generic.IList<Sentry.StringOrRegex> TracePropagationTargets { get; set; }
         public double? TracesSampleRate { get; set; }
         public System.Func<Sentry.TransactionSamplingContext, double?>? TracesSampler { get; set; }

test/Sentry.Tests/TraceIgnoreStatusCodeTransactionProcessorTests.cs

@@ -0,0 +1,126 @@
+using Sentry.Internal.OpenTelemetry;
+
+namespace Sentry.Tests;
+
+public class TraceIgnoreStatusCodeTransactionProcessorTests
+{
+    private static SentryOptions OptionsWithIgnoredCodes(params HttpStatusCodeRange[] ranges)
+    {
+        var options = new SentryOptions();
+        foreach (var range in ranges)
+        {
+            options.TraceIgnoreStatusCodes.Add(range);
+        }
+        return options;
+    }
+
+    private static SentryTransaction TransactionWithStatusCode(int statusCode)
+    {
+        var transaction = new SentryTransaction("name", "operation");
+        transaction.SetData(OtelSemanticConventions.AttributeHttpResponseStatusCode, statusCode);
+        return transaction;
+    }
+
+    [Fact]
+    public void Process_EmptyIgnoreList_ReturnsTransaction()
+    {
+        // Arrange
+        var options = new SentryOptions();
+        var processor = new TraceIgnoreStatusCodeTransactionProcessor(options);
+        var transaction = TransactionWithStatusCode(404);
+
+        // Act
+        var result = processor.Process(transaction);
+
+        // Assert
+        result.Should().BeSameAs(transaction);
+    }
+
+    [Fact]
+    public void Process_StatusCodeNotInIgnoreList_ReturnsTransaction()
+    {
+        // Arrange
+        var options = OptionsWithIgnoredCodes(404);
+        var processor = new TraceIgnoreStatusCodeTransactionProcessor(options);
+        var transaction = TransactionWithStatusCode(200);
+
+        // Act
+        var result = processor.Process(transaction);
+
+        // Assert
+        result.Should().BeSameAs(transaction);
+    }
+
+    [Fact]
+    public void Process_StatusCodeInIgnoreList_ReturnsNull()
+    {
+        // Arrange
+        var options = OptionsWithIgnoredCodes(404);
+        var processor = new TraceIgnoreStatusCodeTransactionProcessor(options);
+        var transaction = TransactionWithStatusCode(404);
+
+        // Act
+        var result = processor.Process(transaction);
+
+        // Assert
+        result.Should().BeNull();
+    }
+
+    [Fact]
+    public void Process_StatusCodeInIgnoredRange_ReturnsNull()
+    {
+        // Arrange
+        var options = OptionsWithIgnoredCodes((400, 499));
+        var processor = new TraceIgnoreStatusCodeTransactionProcessor(options);
+        var transaction = TransactionWithStatusCode(404);
+
+        // Act
+        var result = processor.Process(transaction);
+
+        // Assert
+        result.Should().BeNull();
+    }
+
+    [Fact]
+    public void Process_StatusCodeOutsideIgnoredRange_ReturnsTransaction()
+    {
+        // Arrange
+        var options = OptionsWithIgnoredCodes((400, 499));
+        var processor = new TraceIgnoreStatusCodeTransactionProcessor(options);
+        var transaction = TransactionWithStatusCode(500);
+
+        // Act
+        var result = processor.Process(transaction);
+
+        // Assert
+        result.Should().BeSameAs(transaction);
+    }
+
+    [Fact]
+    public void Process_NoStatusCodeExtra_ReturnsTransaction()
+    {
+        // Arrange
+        var options = OptionsWithIgnoredCodes(404);
+        var processor = new TraceIgnoreStatusCodeTransactionProcessor(options);
+        var transaction = new SentryTransaction("name", "operation");
+
+        // Act
+        var result = processor.Process(transaction);
+
+        // Assert
+        result.Should().BeSameAs(transaction);
+    }
+
+    [Fact]
+    public void Process_MultipleIgnoredCodes_MatchesAny()
+    {
+        // Arrange
+        var options = OptionsWithIgnoredCodes(404, 429);
+        var processor = new TraceIgnoreStatusCodeTransactionProcessor(options);
+
+        // Act & Assert
+        processor.Process(TransactionWithStatusCode(404)).Should().BeNull();
+        processor.Process(TransactionWithStatusCode(429)).Should().BeNull();
+        processor.Process(TransactionWithStatusCode(200)).Should().NotBeNull();
+    }
+}