fix(core): Support dedup exclusions in option sources

Allow deduplication exclusions to be configured through external properties,
Android manifest metadata, and Spring Boot binding.

Preserve built-in defaults when unset and replace them when explicitly
configured, including empty lists.

Refs GH-6365

Co-Authored-By: Claude <noreply@anthropic.com>

Author: adinauer

sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java

@@ -188,6 +188,9 @@ final class ManifestMetadataReader {
 
   static final String IGNORED_ERRORS = "io.sentry.ignored-errors";
 
+  static final String IGNORED_ERRORS_FOR_DEDUPLICATION =
+      "io.sentry.ignored-errors-for-deduplication";
+
   static final String IN_APP_INCLUDES = "io.sentry.in-app-includes";
 
   static final String IN_APP_EXCLUDES = "io.sentry.in-app-excludes";
@@ -736,6 +739,12 @@ static void applyMetadata(
 
         options.setIgnoredErrors(readList(metadata, logger, IGNORED_ERRORS));
 
+        final @Nullable List<String> ignoredErrorsForDeduplication =
+            readList(metadata, logger, IGNORED_ERRORS_FOR_DEDUPLICATION);
+        if (ignoredErrorsForDeduplication != null) {
+          options.setIgnoredErrorsForDeduplication(ignoredErrorsForDeduplication);
+        }
+
         final @Nullable List<String> includes = readList(metadata, logger, IN_APP_INCLUDES);
         if (includes != null && !includes.isEmpty()) {
           for (final @NotNull String include : includes) {

sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt

@@ -2113,6 +2113,45 @@ class ManifestMetadataReaderTest {
     )
   }
 
+  @Test
+  fun `applyMetadata reads ignored errors for deduplication if found`() {
+    val bundle =
+      bundleOf(
+        ManifestMetadataReader.IGNORED_ERRORS_FOR_DEDUPLICATION to
+          "example.FirstException,example.SecondException"
+      )
+    val context = fixture.getContext(metaData = bundle)
+
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    assertThat(fixture.options.ignoredErrorsForDeduplication)
+      .containsExactly(
+        FilterString("example.FirstException"),
+        FilterString("example.SecondException"),
+      )
+      .inOrder()
+  }
+
+  @Test
+  fun `applyMetadata preserves default ignored errors for deduplication if missing`() {
+    val context = fixture.getContext()
+
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    assertThat(fixture.options.ignoredErrorsForDeduplication)
+      .containsExactly(FilterString("io.netty.handler.timeout.ReadTimeoutException"))
+  }
+
+  @Test
+  fun `applyMetadata empty ignored errors for deduplication removes the default`() {
+    val bundle = bundleOf(ManifestMetadataReader.IGNORED_ERRORS_FOR_DEDUPLICATION to "")
+    val context = fixture.getContext(metaData = bundle)
+
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    assertThat(fixture.options.ignoredErrorsForDeduplication).isEmpty()
+  }
+
   @Test
   fun `applyMetadata reads inAppIncludes to options and sets the value if found`() {
     // Arrange

sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryAutoConfigurationTest.kt

@@ -228,6 +228,7 @@ class SentryAutoConfigurationTest {
         "sentry.send-modules=false",
         "sentry.ignored-checkins=slug1,slugB",
         "sentry.ignored-errors=Some error,Another .*",
+        "sentry.ignored-errors-for-deduplication=example.FirstException,example.SecondException",
         "sentry.ignored-transactions=transactionName1,transactionNameB",
         "sentry.enable-backpressure-handling=false",
         "sentry.enable-database-transaction-tracing=true",
@@ -283,6 +284,11 @@ class SentryAutoConfigurationTest {
           .containsOnly(FilterString("slug1"), FilterString("slugB"))
         assertThat(options.ignoredErrors)
           .containsOnly(FilterString("Some error"), FilterString("Another .*"))
+        assertThat(options.ignoredErrorsForDeduplication)
+          .containsOnly(
+            FilterString("example.FirstException"),
+            FilterString("example.SecondException"),
+          )
         assertThat(options.ignoredTransactions)
           .containsOnly(FilterString("transactionName1"), FilterString("transactionNameB"))
         assertThat(options.isEnableBackpressureHandling).isEqualTo(false)
@@ -357,6 +363,19 @@ class SentryAutoConfigurationTest {
       }
   }
 
+  @Test
+  fun `empty ignored errors for deduplication removes the default`() {
+    contextRunner
+      .withPropertyValues(
+        "sentry.dsn=http://key@localhost/proj",
+        "sentry.ignored-errors-for-deduplication=",
+      )
+      .run {
+        val options = it.getBean(SentryProperties::class.java)
+        assertThat(options.ignoredErrorsForDeduplication).isEmpty()
+      }
+  }
+
   @Test
   fun `when traces sample rate is set to null and tracing is enabled, traces sample rate should be set to 0`() {
     contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj").run {

sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryAutoConfigurationTest.kt

@@ -231,6 +231,7 @@ class SentryAutoConfigurationTest {
         "sentry.send-modules=false",
         "sentry.ignored-checkins=slug1,slugB",
         "sentry.ignored-errors=Some error,Another .*",
+        "sentry.ignored-errors-for-deduplication=example.FirstException,example.SecondException",
         "sentry.ignored-transactions=transactionName1,transactionNameB",
         "sentry.enable-backpressure-handling=false",
         "sentry.enable-database-transaction-tracing=true",
@@ -288,6 +289,11 @@ class SentryAutoConfigurationTest {
           .containsOnly(FilterString("slug1"), FilterString("slugB"))
         assertThat(options.ignoredErrors)
           .containsOnly(FilterString("Some error"), FilterString("Another .*"))
+        assertThat(options.ignoredErrorsForDeduplication)
+          .containsOnly(
+            FilterString("example.FirstException"),
+            FilterString("example.SecondException"),
+          )
         assertThat(options.ignoredTransactions)
           .containsOnly(FilterString("transactionName1"), FilterString("transactionNameB"))
         assertThat(options.isEnableBackpressureHandling).isEqualTo(false)
@@ -365,6 +371,19 @@ class SentryAutoConfigurationTest {
       }
   }
 
+  @Test
+  fun `empty ignored errors for deduplication removes the default`() {
+    contextRunner
+      .withPropertyValues(
+        "sentry.dsn=http://key@localhost/proj",
+        "sentry.ignored-errors-for-deduplication=",
+      )
+      .run {
+        val options = it.getBean(SentryProperties::class.java)
+        assertThat(options.ignoredErrorsForDeduplication).isEmpty()
+      }
+  }
+
   @Test
   fun `when traces sample rate is set to null and tracing is enabled, traces sample rate should be set to 0`() {
     contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj").run {

sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryAutoConfigurationTest.kt

@@ -229,6 +229,7 @@ class SentryAutoConfigurationTest {
         "sentry.send-modules=false",
         "sentry.ignored-checkins=slug1,slugB",
         "sentry.ignored-errors=Some error,Another .*",
+        "sentry.ignored-errors-for-deduplication=example.FirstException,example.SecondException",
         "sentry.ignored-transactions=transactionName1,transactionNameB",
         "sentry.enable-backpressure-handling=false",
         "sentry.enable-database-transaction-tracing=true",
@@ -286,6 +287,11 @@ class SentryAutoConfigurationTest {
           .containsOnly(FilterString("slug1"), FilterString("slugB"))
         assertThat(options.ignoredErrors)
           .containsOnly(FilterString("Some error"), FilterString("Another .*"))
+        assertThat(options.ignoredErrorsForDeduplication)
+          .containsOnly(
+            FilterString("example.FirstException"),
+            FilterString("example.SecondException"),
+          )
         assertThat(options.ignoredTransactions)
           .containsOnly(FilterString("transactionName1"), FilterString("transactionNameB"))
         assertThat(options.isEnableBackpressureHandling).isEqualTo(false)
@@ -363,6 +369,19 @@ class SentryAutoConfigurationTest {
       }
   }
 
+  @Test
+  fun `empty ignored errors for deduplication removes the default`() {
+    contextRunner
+      .withPropertyValues(
+        "sentry.dsn=http://key@localhost/proj",
+        "sentry.ignored-errors-for-deduplication=",
+      )
+      .run {
+        val options = it.getBean(SentryProperties::class.java)
+        assertThat(options.ignoredErrorsForDeduplication).isEmpty()
+      }
+  }
+
   @Test
   fun `when traces sample rate is set to null and tracing is enabled, traces sample rate should be set to 0`() {
     dsnEnabledRunner.run {

sentry/api/sentry.api

@@ -564,6 +564,7 @@ public final class io/sentry/ExternalOptions {
 	public fun getIdleTimeout ()Ljava/lang/Long;
 	public fun getIgnoredCheckIns ()Ljava/util/List;
 	public fun getIgnoredErrors ()Ljava/util/List;
+	public fun getIgnoredErrorsForDeduplication ()Ljava/util/List;
 	public fun getIgnoredExceptionsForType ()Ljava/util/Set;
 	public fun getIgnoredTransactions ()Ljava/util/List;
 	public fun getInAppExcludes ()Ljava/util/List;
@@ -621,6 +622,7 @@ public final class io/sentry/ExternalOptions {
 	public fun setIdleTimeout (Ljava/lang/Long;)V
 	public fun setIgnoredCheckIns (Ljava/util/List;)V
 	public fun setIgnoredErrors (Ljava/util/List;)V
+	public fun setIgnoredErrorsForDeduplication (Ljava/util/List;)V
 	public fun setIgnoredTransactions (Ljava/util/List;)V
 	public fun setMaxRequestBodySize (Lio/sentry/SentryOptions$RequestSize;)V
 	public fun setOrgId (Ljava/lang/String;)V

sentry/src/main/java/io/sentry/ExternalOptions.java

@@ -40,6 +40,7 @@ public final class ExternalOptions {
   private final @NotNull Set<Class<? extends Throwable>> ignoredExceptionsForType =
       new CopyOnWriteArraySet<>();
   private @Nullable List<String> ignoredErrors;
+  private @Nullable List<String> ignoredErrorsForDeduplication;
   private @Nullable Boolean printUncaughtStackTrace;
   private @Nullable Boolean sendClientReports;
   private @NotNull Set<String> bundleIds = new CopyOnWriteArraySet<>();
@@ -148,6 +149,8 @@ public final class ExternalOptions {
         propertiesProvider.getLongProperty("session-flush-timeout-millis"));
 
     options.setIgnoredErrors(propertiesProvider.getListOrNull("ignored-errors"));
+    options.setIgnoredErrorsForDeduplication(
+        propertiesProvider.getListOrNull("ignored-errors-for-deduplication"));
 
     options.setEnabled(propertiesProvider.getBooleanProperty("enabled"));
 
@@ -549,6 +552,15 @@ public void setIgnoredErrors(final @Nullable List<String> ignoredErrors) {
     this.ignoredErrors = ignoredErrors;
   }
 
+  public @Nullable List<String> getIgnoredErrorsForDeduplication() {
+    return ignoredErrorsForDeduplication;
+  }
+
+  public void setIgnoredErrorsForDeduplication(
+      final @Nullable List<String> ignoredErrorsForDeduplication) {
+    this.ignoredErrorsForDeduplication = ignoredErrorsForDeduplication;
+  }
+
   public @Nullable Boolean getSendClientReports() {
     return sendClientReports;
   }

sentry/src/main/java/io/sentry/SentryOptions.java

@@ -3809,6 +3809,11 @@ public void merge(final @NotNull ExternalOptions options) {
       final List<String> ignoredExceptions = new ArrayList<>(options.getIgnoredErrors());
       setIgnoredErrors(ignoredExceptions);
     }
+    if (options.getIgnoredErrorsForDeduplication() != null) {
+      final List<String> ignoredErrorsForDeduplication =
+          new ArrayList<>(options.getIgnoredErrorsForDeduplication());
+      setIgnoredErrorsForDeduplication(ignoredErrorsForDeduplication);
+    }
     if (options.isEnableBackpressureHandling() != null) {
       setEnableBackpressureHandling(options.isEnableBackpressureHandling());
     }

sentry/src/test/java/io/sentry/ExternalOptionsTest.kt

@@ -333,6 +333,29 @@ class ExternalOptionsTest {
     withPropertiesFile("Another .*", logger) { options -> assertNull(options.ignoredErrors) }
   }
 
+  @Test
+  fun `creates options with ignored errors for deduplication using external properties`() {
+    withPropertiesFile(
+      "ignored-errors-for-deduplication=example.FirstException,example.SecondException"
+    ) { options ->
+      assertThat(options.ignoredErrorsForDeduplication)
+        .containsExactly("example.FirstException", "example.SecondException")
+        .inOrder()
+    }
+  }
+
+  @Test
+  fun `creates options with empty ignored errors for deduplication using external properties`() {
+    withPropertiesFile("ignored-errors-for-deduplication=") { options ->
+      assertThat(options.ignoredErrorsForDeduplication).containsExactly("")
+    }
+  }
+
+  @Test
+  fun `creates options with null ignored errors for deduplication if missing`() {
+    withPropertiesFile { options -> assertThat(options.ignoredErrorsForDeduplication).isNull() }
+  }
+
   @Test
   fun `creates options with single bundle ID using external properties`() {
     withPropertiesFile("bundle-ids=12ea7a02-46ac-44c0-a5bb-6d1fd9586411") { options ->

sentry/src/test/java/io/sentry/SentryOptionsTest.kt

@@ -571,6 +571,8 @@ class SentryOptionsTest {
     externalOptions.ignoredCheckIns = listOf("slug1", "slug-B")
     externalOptions.ignoredTransactions = listOf("transactionName1", "transaction-name-B")
     externalOptions.ignoredErrors = listOf("Some error", "Another .*")
+    externalOptions.ignoredErrorsForDeduplication =
+      listOf("example.FirstException", "example.SecondException")
     externalOptions.isEnableBackpressureHandling = false
     externalOptions.isEnableDatabaseTransactionTracing = true
     externalOptions.isEnableCacheTracing = true
@@ -635,6 +637,10 @@ class SentryOptionsTest {
       listOf(FilterString("Some error"), FilterString("Another .*")),
       options.ignoredErrors,
     )
+    assertEquals(
+      listOf(FilterString("example.FirstException"), FilterString("example.SecondException")),
+      options.ignoredErrorsForDeduplication,
+    )
     assertFalse(options.isEnableBackpressureHandling)
     assertTrue(options.isEnableDatabaseTransactionTracing)
     assertTrue(options.isEnableCacheTracing)
@@ -1070,6 +1076,44 @@ class SentryOptionsTest {
       .inOrder()
   }
 
+  @Test
+  fun `merging options without ignored errors for deduplication preserves the default`() {
+    val options = SentryOptions()
+
+    options.merge(ExternalOptions())
+
+    assertThat(options.ignoredErrorsForDeduplication)
+      .containsExactly(FilterString("io.netty.handler.timeout.ReadTimeoutException"))
+  }
+
+  @Test
+  fun `merging ignored errors for deduplication replaces the default`() {
+    val options = SentryOptions()
+    val externalOptions =
+      ExternalOptions().apply {
+        ignoredErrorsForDeduplication = listOf("example.FirstException", "example.SecondException")
+      }
+
+    options.merge(externalOptions)
+
+    assertThat(options.ignoredErrorsForDeduplication)
+      .containsExactly(
+        FilterString("example.FirstException"),
+        FilterString("example.SecondException"),
+      )
+      .inOrder()
+  }
+
+  @Test
+  fun `merging empty ignored errors for deduplication removes the default`() {
+    val options = SentryOptions()
+    val externalOptions = ExternalOptions().apply { ignoredErrorsForDeduplication = listOf("") }
+
+    options.merge(externalOptions)
+
+    assertThat(options.ignoredErrorsForDeduplication).isEmpty()
+  }
+
   @Test
   fun `merging options when ignoredErrors is not set preserves the previous value`() {
     val externalOptions = ExternalOptions()