diff --git a/CHANGELOG.md b/CHANGELOG.md index be7899e2dd..6da86d5add 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -86,6 +86,7 @@ ### Improvements +- Preserve the oldest and newest frames when truncating deep stack traces ([#6623](https://github.com/getsentry/sentry-java/pull/6623)) - Promote check-in APIs from experimental to stable ([#6422](https://github.com/getsentry/sentry-java/pull/6422)) - Promote the backpressure handling option from experimental to stable ([#6423](https://github.com/getsentry/sentry-java/pull/6423)) - Promote structured logs APIs from experimental to stable ([#6424](https://github.com/getsentry/sentry-java/pull/6424)) diff --git a/sentry/src/main/java/io/sentry/SentryStackTraceFactory.java b/sentry/src/main/java/io/sentry/SentryStackTraceFactory.java index 611be4fc41..ecf910d0e1 100644 --- a/sentry/src/main/java/io/sentry/SentryStackTraceFactory.java +++ b/sentry/src/main/java/io/sentry/SentryStackTraceFactory.java @@ -13,7 +13,8 @@ @ApiStatus.Internal public final class SentryStackTraceFactory { - private static final int STACKTRACE_FRAME_LIMIT = 100; + private static final int NEWEST_FRAMES_LIMIT = 200; + private static final int OLDEST_FRAMES_LIMIT = 50; private final @NotNull SentryOptions options; public SentryStackTraceFactory(final @NotNull SentryOptions options) { @@ -32,38 +33,25 @@ public List getStackFrames( List sentryStackFrames = null; if (elements != null && elements.length > 0) { - sentryStackFrames = new ArrayList<>(); - for (StackTraceElement item : elements) { - if (item != null) { - - // we don't want to add our own frames - final String className = item.getClassName(); - if (!includeSentryFrames - && (className.startsWith("io.sentry.") - && !className.startsWith("io.sentry.samples.") - && !className.startsWith("io.sentry.mobile."))) { - continue; - } + int frameCount = 0; + for (final StackTraceElement item : elements) { + if (shouldIncludeFrame(item, includeSentryFrames)) { + frameCount++; + } + } - final SentryStackFrame sentryStackFrame = new SentryStackFrame(); - // https://docs.sentry.io/development/sdk-dev/features/#in-app-frames - sentryStackFrame.setInApp(isInApp(className)); - sentryStackFrame.setModule(className); - sentryStackFrame.setFunction(item.getMethodName()); - sentryStackFrame.setFilename(item.getFileName()); - // Protocol doesn't accept negative line numbers. - // The runtime seem to use -2 as a way to signal a native method - if (item.getLineNumber() >= 0) { - sentryStackFrame.setLineno(item.getLineNumber()); - } - sentryStackFrame.setNative(item.isNativeMethod()); - sentryStackFrames.add(sentryStackFrame); + sentryStackFrames = + new ArrayList<>(Math.min(frameCount, NEWEST_FRAMES_LIMIT + OLDEST_FRAMES_LIMIT)); + int frameIndex = 0; + for (final StackTraceElement item : elements) { + if (!shouldIncludeFrame(item, includeSentryFrames)) { + continue; + } - // hard cap to not exceed payload size limit - if (sentryStackFrames.size() >= STACKTRACE_FRAME_LIMIT) { - break; - } + if (frameIndex < NEWEST_FRAMES_LIMIT || frameIndex >= frameCount - OLDEST_FRAMES_LIMIT) { + sentryStackFrames.add(getSentryStackFrame(item)); } + frameIndex++; } Collections.reverse(sentryStackFrames); } @@ -71,6 +59,36 @@ public List getStackFrames( return sentryStackFrames; } + private static boolean shouldIncludeFrame( + final @Nullable StackTraceElement item, final boolean includeSentryFrames) { + if (item == null) { + return false; + } + + final String className = item.getClassName(); + return includeSentryFrames + || !className.startsWith("io.sentry.") + || className.startsWith("io.sentry.samples.") + || className.startsWith("io.sentry.mobile."); + } + + private @NotNull SentryStackFrame getSentryStackFrame(final @NotNull StackTraceElement item) { + final SentryStackFrame sentryStackFrame = new SentryStackFrame(); + final String className = item.getClassName(); + // https://docs.sentry.io/development/sdk-dev/features/#in-app-frames + sentryStackFrame.setInApp(isInApp(className)); + sentryStackFrame.setModule(className); + sentryStackFrame.setFunction(item.getMethodName()); + sentryStackFrame.setFilename(item.getFileName()); + // Protocol doesn't accept negative line numbers. + // The runtime seem to use -2 as a way to signal a native method + if (item.getLineNumber() >= 0) { + sentryStackFrame.setLineno(item.getLineNumber()); + } + sentryStackFrame.setNative(item.isNativeMethod()); + return sentryStackFrame; + } + /** * Provides the logic to decide whether a className is part of the includes or excludes list of * strings. The bias is towards includes, meaning once a className starts with a prefix in the diff --git a/sentry/src/test/java/io/sentry/SentryExceptionFactoryTest.kt b/sentry/src/test/java/io/sentry/SentryExceptionFactoryTest.kt index 191d681c21..e4a106b79e 100644 --- a/sentry/src/test/java/io/sentry/SentryExceptionFactoryTest.kt +++ b/sentry/src/test/java/io/sentry/SentryExceptionFactoryTest.kt @@ -1,5 +1,6 @@ package io.sentry +import com.google.common.truth.Truth.assertThat import io.sentry.exception.ExceptionMechanismException import io.sentry.protocol.Mechanism import io.sentry.protocol.SentryStackFrame @@ -44,7 +45,8 @@ class SentryExceptionFactoryTest { @Test fun `when frames are null, do not set a stack trace object`() { val stackTraceFactory = mock() - whenever(stackTraceFactory.getStackFrames(any(), eq(false))).thenReturn(null) + whenever(stackTraceFactory.getStackFrames(any>(), eq(false))) + .thenReturn(null) val sut = fixture.getSut(stackTraceFactory) val exception = Exception("Exception") @@ -57,7 +59,8 @@ class SentryExceptionFactoryTest { @Test fun `when frames are empty, do not set a stack trace object`() { val stackTraceFactory = mock() - whenever(stackTraceFactory.getStackFrames(any(), eq(false))).thenReturn(emptyList()) + whenever(stackTraceFactory.getStackFrames(any>(), eq(false))) + .thenReturn(emptyList()) val sut = fixture.getSut(stackTraceFactory) val exception = Exception("Exception") @@ -67,6 +70,20 @@ class SentryExceptionFactoryTest { assertNull(sentryExceptions[0].stacktrace) } + @Test + fun `limits exception stack trace to 50 oldest and 200 newest frames`() { + val exception = Exception("Exception") + exception.stackTrace = Array(300) { StackTraceElement("frame-$it", "method", "File.java", it) } + + val frames = fixture.getSut().getSentryExceptions(exception).single().stacktrace!!.frames!! + + assertThat(frames).hasSize(250) + assertThat(frames[0].module).isEqualTo("frame-299") + assertThat(frames[49].module).isEqualTo("frame-250") + assertThat(frames[50].module).isEqualTo("frame-199") + assertThat(frames[249].module).isEqualTo("frame-0") + } + @Test fun `when getSentryExceptions is called passing a ExceptionMechanism, it should set its fields`() { val mechanism = Mechanism() diff --git a/sentry/src/test/java/io/sentry/SentryStackTraceFactoryTest.kt b/sentry/src/test/java/io/sentry/SentryStackTraceFactoryTest.kt index 507181eeaa..c84bda5eea 100644 --- a/sentry/src/test/java/io/sentry/SentryStackTraceFactoryTest.kt +++ b/sentry/src/test/java/io/sentry/SentryStackTraceFactoryTest.kt @@ -1,5 +1,6 @@ package io.sentry +import com.google.common.truth.Truth.assertThat import java.lang.Exception import kotlin.test.Test import kotlin.test.assertEquals @@ -284,15 +285,40 @@ class SentryStackTraceFactoryTest { } @Test - fun `caps number of stack frames to STACKTRACE_FRAME_LIMIT to not exceed payload size limit`() { - val exception = Exception() - exception.stackTrace = arrayOf() - repeat(120) { exception.stackTrace += generateStackTrace("com.me.stackoverflow") } + fun `does not truncate stack frames within the limit`() { + val stackTrace = Array(250) { generateStackTrace("frame-$it") } - val sut = SentryStackTraceFactory(SentryOptions()) - val sentryFrames = sut.getStackFrames(exception.stackTrace, false) + val sentryFrames = sut.getStackFrames(stackTrace, false) + + assertThat(sentryFrames).hasSize(250) + } + + @Test + fun `retains 50 oldest and 200 newest stack frames`() { + val stackTrace = Array(300) { generateStackTrace("frame-$it") } + + val sentryFrames = sut.getStackFrames(stackTrace, false)!! - assertEquals(100, sentryFrames!!.size) + assertThat(sentryFrames).hasSize(250) + assertThat(sentryFrames[0].module).isEqualTo("frame-299") + assertThat(sentryFrames[49].module).isEqualTo("frame-250") + assertThat(sentryFrames[50].module).isEqualTo("frame-199") + assertThat(sentryFrames[249].module).isEqualTo("frame-0") + } + + @Test + fun `filters sentry frames before applying stack frame limit`() { + val stackTrace = + Array(50) { generateStackTrace("io.sentry.frame-$it") } + + Array(300) { generateStackTrace("frame-$it") } + + val sentryFrames = sut.getStackFrames(stackTrace, false)!! + + assertThat(sentryFrames).hasSize(250) + assertThat(sentryFrames[0].module).isEqualTo("frame-299") + assertThat(sentryFrames[49].module).isEqualTo("frame-250") + assertThat(sentryFrames[50].module).isEqualTo("frame-199") + assertThat(sentryFrames[249].module).isEqualTo("frame-0") } private fun generateStackTrace(className: String?) = diff --git a/sentry/src/test/java/io/sentry/SentryThreadFactoryTest.kt b/sentry/src/test/java/io/sentry/SentryThreadFactoryTest.kt index 7f89c56448..fba092f025 100644 --- a/sentry/src/test/java/io/sentry/SentryThreadFactoryTest.kt +++ b/sentry/src/test/java/io/sentry/SentryThreadFactoryTest.kt @@ -1,5 +1,6 @@ package io.sentry +import com.google.common.truth.Truth.assertThat import kotlin.test.Test import kotlin.test.assertEquals import kotlin.test.assertFalse @@ -91,6 +92,25 @@ class SentryThreadFactoryTest { assertNotNull(threads!!.firstOrNull { it.id == currentThread.id }) } + @Test + fun `limits thread stack trace to 50 oldest and 200 newest frames`() { + val sut = fixture.getSut() + val thread = Thread() + val stackTrace = Array(300) { StackTraceElement("frame-$it", "method", "File.java", it) } + + val sentryThread = + sut.getCurrentThreads(mutableMapOf(thread to stackTrace), null, false, true)!!.single { + it.id == thread.id + } + val frames = sentryThread.stacktrace!!.frames!! + + assertThat(frames).hasSize(250) + assertThat(frames[0].module).isEqualTo("frame-299") + assertThat(frames[49].module).isEqualTo("frame-250") + assertThat(frames[50].module).isEqualTo("frame-199") + assertThat(frames[249].module).isEqualTo("frame-0") + } + @Test fun `When passing empty param to getCurrentThreads, returns null`() { val sut = fixture.getSut()