implemented inApp prefix for stacktraces

sentry-core/src/main/java/io/sentry/core/MainEventProcessor.java

@@ -5,13 +5,18 @@
 public class MainEventProcessor implements EventProcessor {
 
   private final SentryOptions options;
-  private final SentryThreadFactory sentryThreadFactory = new SentryThreadFactory();
-  private final SentryStackTraceFactory sentryStackTraceFactory = new SentryStackTraceFactory();
-  private final SentryExceptionFactory sentryExceptionFactory =
-      new SentryExceptionFactory(sentryStackTraceFactory);
+  private final SentryThreadFactory sentryThreadFactory;
+  private final SentryExceptionFactory sentryExceptionFactory;
 
-  MainEventProcessor(SentryOptions options) {
+  MainEventProcessor(
+      final SentryOptions options,
+      final SentryThreadFactory sentryThreadFactory,
+      final SentryExceptionFactory sentryExceptionFactory) {
     this.options = Objects.requireNonNull(options, "The SentryOptions is required.");
+    this.sentryThreadFactory =
+        Objects.requireNonNull(sentryThreadFactory, "The SentryThreadFactory is required.");
+    this.sentryExceptionFactory =
+        Objects.requireNonNull(sentryExceptionFactory, "The SentryExceptionFactory is required.");
   }
 
   @Override

sentry-core/src/main/java/io/sentry/core/SentryExceptionFactory.java

@@ -18,7 +18,7 @@ class SentryExceptionFactory {
 
   private final SentryStackTraceFactory sentryStackTraceFactory;
 
-  public SentryExceptionFactory(SentryStackTraceFactory sentryStackTraceFactory) {
+  public SentryExceptionFactory(final SentryStackTraceFactory sentryStackTraceFactory) {
     this.sentryStackTraceFactory =
         Objects.requireNonNull(sentryStackTraceFactory, "The SentryStackTraceFactory is required.");
   }

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

@@ -28,6 +28,7 @@ public class SentryOptions {
   private String environment;
   private Proxy proxy;
   private Double sampling;
+  private String inAppPrefix = "io.sentry";
 
   public void addEventProcessor(EventProcessor eventProcessor) {
     eventProcessors.add(eventProcessor);
@@ -187,6 +188,14 @@ public void setSampling(Double sampling) {
     this.sampling = sampling;
   }
 
+  public String getInAppPrefix() {
+    return inAppPrefix;
+  }
+
+  public void setInAppPrefix(String inAppPrefix) {
+    this.inAppPrefix = inAppPrefix;
+  }
+
   public interface BeforeSendCallback {
     SentryEvent execute(SentryEvent event);
   }
@@ -196,7 +205,12 @@ public interface BeforeBreadcrumbCallback {
   }
 
   public SentryOptions() {
-    eventProcessors.add(new MainEventProcessor(this));
+    SentryStackTraceFactory sentryStackTraceFactory = new SentryStackTraceFactory(this.inAppPrefix);
+    SentryExceptionFactory sentryExceptionFactory =
+        new SentryExceptionFactory(sentryStackTraceFactory);
+    SentryThreadFactory sentryThreadFactory = new SentryThreadFactory(sentryStackTraceFactory);
+
+    eventProcessors.add(new MainEventProcessor(this, sentryThreadFactory, sentryExceptionFactory));
     integrations.add(new UncaughtExceptionHandlerIntegration());
   }
 }

sentry-core/src/main/java/io/sentry/core/SentryStackTraceFactory.java

@@ -2,12 +2,24 @@
 
 import io.sentry.core.protocol.SentryStackFrame;
 import io.sentry.core.util.Nullable;
+import io.sentry.core.util.VisibleForTesting;
 import java.util.ArrayList;
 import java.util.List;
 
 /** class responsible for converting Java StackTraceElements to SentryStackFrames */
 class SentryStackTraceFactory {
 
+  private final String inAppPrefix;
+  @VisibleForTesting boolean inAppEnabled = false;
+
+  public SentryStackTraceFactory(@Nullable final String inAppPrefix) {
+    this.inAppPrefix = inAppPrefix;
+
+    if (this.inAppPrefix != null && !this.inAppPrefix.isEmpty()) {
+      inAppEnabled = true;
+    }
+  }
+
   /**
    * convert an Array of Java StackTraceElements to a list of SentryStackFrames
    *
@@ -20,6 +32,14 @@ List<SentryStackFrame> getStackFrames(@Nullable final StackTraceElement[] elemen
     if (elements != null) {
       for (StackTraceElement item : elements) {
         SentryStackFrame sentryStackFrame = new SentryStackFrame();
+
+        // https://docs.sentry.io/development/sdk-dev/features/#in-app-frames
+        if (inAppEnabled && item.getClassName().startsWith(inAppPrefix)) {
+          sentryStackFrame.setInApp(true);
+        } else {
+          sentryStackFrame.setInApp(false);
+        }
+
         sentryStackFrame.setModule(item.getClassName());
         sentryStackFrame.setFunction(item.getMethodName());
         sentryStackFrame.setFilename(item.getFileName());

sentry-core/src/main/java/io/sentry/core/SentryThreadFactory.java

@@ -4,12 +4,20 @@
 import io.sentry.core.protocol.SentryStackTrace;
 import io.sentry.core.protocol.SentryThread;
 import io.sentry.core.util.Nullable;
+import io.sentry.core.util.Objects;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 
 class SentryThreadFactory {
 
+  private final SentryStackTraceFactory sentryStackTraceFactory;
+
+  public SentryThreadFactory(SentryStackTraceFactory sentryStackTraceFactory) {
+    this.sentryStackTraceFactory =
+        Objects.requireNonNull(sentryStackTraceFactory, "The SentryStackTraceFactory is required.");
+  }
+
   // Assumes its being called from the crashed thread.
   List<SentryThread> getCurrentThreadsForCrash() {
     return getCurrentThreads(Thread.currentThread());
@@ -49,7 +57,6 @@ private SentryThread getSentryThread(
     }
     sentryThread.setCurrent(thread == currentThread);
 
-    SentryStackTraceFactory sentryStackTraceFactory = new SentryStackTraceFactory();
     List<SentryStackFrame> frames = sentryStackTraceFactory.getStackFrames(stackFramesElements);
 
     if (frames.size() > 0) {

sentry-core/src/test/java/io/sentry/core/SentryExceptionFactoryTest.kt

@@ -7,7 +7,7 @@ import kotlin.test.assertEquals
 import kotlin.test.assertTrue
 
 class SentryExceptionFactoryTest {
-    private val sut = SentryExceptionFactory(SentryStackTraceFactory())
+    private val sut = SentryExceptionFactory(SentryStackTraceFactory("io.sentry"))
 
     @Test
     fun `when getSentryExceptions is called passing an Exception, not empty result`() {

sentry-core/src/test/java/io/sentry/core/SentryStackTraceFactoryTest.kt

@@ -2,9 +2,11 @@ package io.sentry.core
 
 import kotlin.test.Test
 import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
 
 class SentryStackTraceFactoryTest {
-    private val sut = SentryStackTraceFactory()
+    private val sut = SentryStackTraceFactory("io.sentry")
 
     @Test
     fun `when getStackFrames is called passing a valid Array, not empty result`() {
@@ -29,4 +31,37 @@ class SentryStackTraceFactoryTest {
         assertEquals(-2, stackFrames[0].lineno)
         assertEquals(true, stackFrames[0].isNative)
     }
+
+    @Test
+    fun `when getStackFrames is called passing a valid inAppPrefix, inAppEnabled should be true`() {
+        assertTrue(sut.inAppEnabled)
+    }
+
+    @Test
+    fun `when getStackFrames is called passing an empty inAppPrefix, inAppEnabled should be false`() {
+        assertFalse(SentryStackTraceFactory("").inAppEnabled)
+    }
+
+    @Test
+    fun `when getStackFrames is called passing a null inAppPrefix, inAppEnabled should be false`() {
+        assertFalse(SentryStackTraceFactory(null).inAppEnabled)
+    }
+
+    @Test
+    fun `when getStackFrames is called passing a valid inAppPrefix, inApp should be true if prefix matches it`() {
+        val element = StackTraceElement("io.sentry.MyActivity", "method", "fileName", -2)
+        val elements = arrayOf(element)
+        val sentryElements = sut.getStackFrames(elements)
+
+        assertTrue(sentryElements.first().inApp)
+    }
+
+    @Test
+    fun `when getStackFrames is called passing a valid inAppPrefix, inApp should be false if prefix doesnt matches it`() {
+        val element = StackTraceElement("io.myapp.MyActivity", "method", "fileName", -2)
+        val elements = arrayOf(element)
+        val sentryElements = sut.getStackFrames(elements)
+
+        assertFalse(sentryElements.first().inApp)
+    }
 }

sentry-core/src/test/java/io/sentry/core/SentryThreadFactoryTest.kt

@@ -6,7 +6,7 @@ import kotlin.test.assertTrue
 
 class SentryThreadFactoryTest {
 
-    private val sut = SentryThreadFactory()
+    private val sut = SentryThreadFactory(SentryStackTraceFactory("io.sentry"))
 
     @Test
     fun `when getCurrentThreads is called, not empty result`() {