Add option to ignore exceptions by type. (#1352)

Fixes #1306

CHANGELOG.md

@@ -1,5 +1,7 @@
 # Unreleased
 
+* Feat: Add option to ignore exceptions by type (#1352)
+
 # 4.4.0-alpha.1
 
 * Bump: sentry-native to 0.4.8

sentry-spring-boot-starter/src/main/java/io/sentry/spring/boot/SentryAutoConfiguration.java

@@ -109,6 +109,11 @@ static class HubConfiguration {
       if (options.getTracesSampleRate() == null) {
         options.setTracesSampleRate(0.0);
       }
+      // Spring Boot sets ignored exceptions in runtime using reflection - where the generic
+      // information is lost
+      // its technically possible to set non-throwable class to `ignoredExceptionsForType` set
+      // here we make sure that only classes that extend throwable are set on this field
+      options.getIgnoredExceptionsForType().removeIf(it -> !Throwable.class.isAssignableFrom(it));
       Sentry.init(options);
       return HubAdapter.getInstance();
     }

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

@@ -27,6 +27,7 @@ import io.sentry.test.checkEvent
 import io.sentry.transport.ITransport
 import io.sentry.transport.ITransportGate
 import io.sentry.transport.apache.ApacheHttpClientTransportFactory
+import java.lang.RuntimeException
 import javax.servlet.Filter
 import kotlin.test.Test
 import kotlin.test.assertEquals
@@ -142,7 +143,8 @@ class SentryAutoConfigurationTest {
             "sentry.enable-tracing=true",
             "sentry.traces-sample-rate=0.3",
             "sentry.tags.tag1=tag1-value",
-            "sentry.tags.tag2=tag2-value"
+            "sentry.tags.tag2=tag2-value",
+            "sentry.ignored-exceptions-for-type=java.lang.RuntimeException,java.lang.IllegalStateException,io.sentry.Sentry"
         ).run {
             val options = it.getBean(SentryProperties::class.java)
             assertThat(options.readTimeoutMillis).isEqualTo(10)
@@ -169,6 +171,7 @@ class SentryAutoConfigurationTest {
             assertThat(options.isEnableTracing).isTrue()
             assertThat(options.tracesSampleRate).isEqualTo(0.3)
             assertThat(options.tags).containsEntry("tag1", "tag1-value").containsEntry("tag2", "tag2-value")
+            assertThat(options.ignoredExceptionsForType).containsOnly(RuntimeException::class.java, IllegalStateException::class.java)
         }
     }
 

sentry/api/sentry.api

@@ -719,11 +719,12 @@ public final class io/sentry/SentryLevel : java/lang/Enum {
 public class io/sentry/SentryOptions {
 	public fun <init> ()V
 	public fun addEventProcessor (Lio/sentry/EventProcessor;)V
+	public fun addIgnoredExceptionForType (Ljava/lang/Class;)V
 	public fun addInAppExclude (Ljava/lang/String;)V
 	public fun addInAppInclude (Ljava/lang/String;)V
 	public fun addIntegration (Lio/sentry/Integration;)V
 	public fun addScopeObserver (Lio/sentry/IScopeObserver;)V
-	public static fun from (Lio/sentry/config/PropertiesProvider;)Lio/sentry/SentryOptions;
+	public static fun from (Lio/sentry/config/PropertiesProvider;Lio/sentry/ILogger;)Lio/sentry/SentryOptions;
 	public fun getBeforeBreadcrumb ()Lio/sentry/SentryOptions$BeforeBreadcrumbCallback;
 	public fun getBeforeSend ()Lio/sentry/SentryOptions$BeforeSendCallback;
 	public fun getCacheDirPath ()Ljava/lang/String;
@@ -740,6 +741,7 @@ public class io/sentry/SentryOptions {
 	public fun getEventProcessors ()Ljava/util/List;
 	public fun getFlushTimeoutMillis ()J
 	public fun getHostnameVerifier ()Ljavax/net/ssl/HostnameVerifier;
+	public fun getIgnoredExceptionsForType ()Ljava/util/Set;
 	public fun getInAppExcludes ()Ljava/util/List;
 	public fun getInAppIncludes ()Ljava/util/List;
 	public fun getIntegrations ()Ljava/util/List;

sentry/src/main/java/io/sentry/Sentry.java

@@ -184,7 +184,7 @@ private static synchronized void init(
 
   private static boolean initConfigurations(final @NotNull SentryOptions options) {
     if (options.isEnableExternalConfiguration()) {
-      options.merge(SentryOptions.from(PropertiesProviderFactory.create()));
+      options.merge(SentryOptions.from(PropertiesProviderFactory.create(), options.getLogger()));
     }
 
     final String dsn = options.getDsn();

sentry/src/main/java/io/sentry/SentryClient.java

@@ -94,16 +94,26 @@ public boolean isEnabled() {
       }
     }
 
+    SentryId sentryId = SentryId.EMPTY_ID;
+
     if (event != null) {
+      if (event.getOriginThrowable() != null
+          && options.containsIgnoredExceptionForType(event.getOriginThrowable())) {
+        options
+            .getLogger()
+            .log(
+                SentryLevel.DEBUG,
+                "Event was dropped as the exception %s is ignored",
+                event.getOriginThrowable().getClass());
+        return sentryId;
+      }
       event = executeBeforeSend(event, hint);
 
       if (event == null) {
         options.getLogger().log(SentryLevel.DEBUG, "Event was dropped by beforeSend");
       }
     }
 
-    SentryId sentryId = SentryId.EMPTY_ID;
-
     if (event != null) {
       sentryId = event.getEventId();
     }

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

@@ -10,10 +10,13 @@
 import java.io.File;
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.CopyOnWriteArraySet;
 import javax.net.ssl.HostnameVerifier;
 import javax.net.ssl.SSLSocketFactory;
 import org.jetbrains.annotations.ApiStatus;
@@ -36,6 +39,10 @@ public class SentryOptions {
    */
   private final @NotNull List<EventProcessor> eventProcessors = new CopyOnWriteArrayList<>();
 
+  /** Exceptions that once captured will not be sent to Sentry as {@link SentryEvent}. */
+  private final @NotNull Set<Class<? extends Throwable>> ignoredExceptionsForType =
+      new CopyOnWriteArraySet<>();
+
   /**
    * Code that provides middlewares, bindings or hooks into certain frameworks or environments,
    * along with code that inserts those bindings and activates them.
@@ -267,7 +274,9 @@ public class SentryOptions {
    * @param propertiesProvider the properties provider
    * @return the sentry options
    */
-  public static @NotNull SentryOptions from(final @NotNull PropertiesProvider propertiesProvider) {
+  @SuppressWarnings("unchecked")
+  public static @NotNull SentryOptions from(
+      final @NotNull PropertiesProvider propertiesProvider, final @NotNull ILogger logger) {
     final SentryOptions options = new SentryOptions();
     options.setDsn(propertiesProvider.getProperty("dsn"));
     options.setEnvironment(propertiesProvider.getProperty("environment"));
@@ -299,6 +308,27 @@ public class SentryOptions {
     for (final String inAppExclude : propertiesProvider.getList("in-app-excludes")) {
       options.addInAppExclude(inAppExclude);
     }
+    for (final String ignoredExceptionType :
+        propertiesProvider.getList("ignored-exceptions-for-type")) {
+      try {
+        Class<?> clazz = Class.forName(ignoredExceptionType);
+        if (Throwable.class.isAssignableFrom(clazz)) {
+          options.addIgnoredExceptionForType((Class<? extends Throwable>) clazz);
+        } else {
+          logger.log(
+              SentryLevel.WARNING,
+              "Skipping setting %s as ignored-exception-for-type. Reason: %s does not extend Throwable",
+              ignoredExceptionType,
+              ignoredExceptionType);
+        }
+      } catch (ClassNotFoundException e) {
+        logger.log(
+            SentryLevel.WARNING,
+            "Skipping setting %s as ignored-exception-for-type. Reason: %s class is not found",
+            ignoredExceptionType,
+            ignoredExceptionType);
+      }
+    }
     return options;
   }
 
@@ -1278,6 +1308,36 @@ public boolean isTracingEnabled() {
     return getTracesSampleRate() != null || getTracesSampler() != null;
   }
 
+  /**
+   * Returns the list of exception classes that once captured will not be sent to Sentry as {@link
+   * SentryEvent}.
+   *
+   * @return the list of exception classes that once captured will not be sent to Sentry as {@link
+   *     SentryEvent}.
+   */
+  public @NotNull Set<Class<? extends Throwable>> getIgnoredExceptionsForType() {
+    return ignoredExceptionsForType;
+  }
+
+  /**
+   * Adds exception type to the list of ignored exceptions.
+   *
+   * @param exceptionType - the exception type
+   */
+  public void addIgnoredExceptionForType(final @NotNull Class<? extends Throwable> exceptionType) {
+    this.ignoredExceptionsForType.add(exceptionType);
+  }
+
+  /**
+   * Checks if the type of exception given by parameter is ignored.
+   *
+   * @param throwable the throwable
+   * @return if the type of exception is ignored
+   */
+  boolean containsIgnoredExceptionForType(final @NotNull Throwable throwable) {
+    return this.ignoredExceptionsForType.contains(throwable.getClass());
+  }
+
   /** The BeforeSend callback */
   public interface BeforeSendCallback {
 
@@ -1410,6 +1470,10 @@ void merge(final @NotNull SentryOptions options) {
     for (final String inAppExclude : inAppExcludes) {
       addInAppExclude(inAppExclude);
     }
+    for (final Class<? extends Throwable> exceptionType :
+        new HashSet<>(options.getIgnoredExceptionsForType())) {
+      addIgnoredExceptionForType(exceptionType);
+    }
   }
 
   private @NotNull SdkVersion createSdkVersion() {

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

@@ -10,6 +10,7 @@ import com.nhaarman.mockitokotlin2.mockingDetails
 import com.nhaarman.mockitokotlin2.never
 import com.nhaarman.mockitokotlin2.verify
 import com.nhaarman.mockitokotlin2.verifyNoMoreInteractions
+import com.nhaarman.mockitokotlin2.verifyZeroInteractions
 import com.nhaarman.mockitokotlin2.whenever
 import io.sentry.exception.InvalidDsnException
 import io.sentry.exception.SentryEnvelopeException
@@ -29,6 +30,7 @@ import java.io.ByteArrayInputStream
 import java.io.ByteArrayOutputStream
 import java.io.IOException
 import java.io.InputStreamReader
+import java.lang.IllegalStateException
 import java.lang.RuntimeException
 import java.nio.charset.Charset
 import java.util.Arrays
@@ -903,6 +905,14 @@ class SentryClientTest {
         assertEquals("abc", transaction.platform)
     }
 
+    @Test
+    fun `when exception type is ignored, capturing event does not send it`() {
+        fixture.sentryOptions.addIgnoredExceptionForType(IllegalStateException::class.java)
+        val sut = fixture.getSut()
+        sut.captureException(IllegalStateException())
+        verifyZeroInteractions(fixture.transport)
+    }
+
     private fun createScope(): Scope {
         return Scope(SentryOptions()).apply {
             addBreadcrumb(Breadcrumb().apply {