From db39522ab7242512e3672cc40568f2466c14e2bb Mon Sep 17 00:00:00 2001 From: Alexander Dinauer Date: Mon, 16 Nov 2026 15:02:47 +0100 Subject: [PATCH 1/2] fix(core): Preserve both ends of stack traces Retain the 50 oldest and 200 newest frames for exception and thread stack traces. Align the SDK frame budget with Relay while bounding frame conversion work. Fixes #4818 --- .../io/sentry/SentryStackTraceFactory.java | 78 ++++++++++++------- .../io/sentry/SentryExceptionFactoryTest.kt | 21 ++++- .../io/sentry/SentryStackTraceFactoryTest.kt | 40 ++++++++-- .../java/io/sentry/SentryThreadFactoryTest.kt | 20 +++++ 4 files changed, 120 insertions(+), 39 deletions(-) diff --git a/sentry/src/main/java/io/sentry/SentryStackTraceFactory.java b/sentry/src/main/java/io/sentry/SentryStackTraceFactory.java index 3a36228784d..1c44642d16d 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 55472ae6738..cbd051440a8 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 d93d7f6f027..35cfc8ae2e2 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 c2eda19efc4..9673c25c48f 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() From c41ce99bc4b2b319c2e37e395c548e03efe4c69e Mon Sep 17 00:00:00 2001 From: Alexander Dinauer Date: Mon, 16 Nov 2026 15:03:58 +0100 Subject: [PATCH 2/2] changelog --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index cdc4d0f5eb9..cfab491d58e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -85,6 +85,7 @@ ### Fixes +- Preserve the oldest and newest frames when truncating deep stack traces ([#6623](https://github.com/getsentry/sentry-java/pull/6623)) - Add opt-in support for matching GraphQL ignored error types against classification specifications via `sentry.graphql.enable-specification-error-type-filtering` ([#6092](https://github.com/getsentry/sentry-java/pull/6092)) - Session Replay: Fix `SentryOkHttpInterceptor` hanging forever on responses whose body has no known length, such as Server-Sent Events or a gzipped response, when network details are enabled for the URL ([#6231](https://github.com/getsentry/sentry-java/pull/6231)) - Session Replay: `SentryOkHttpInterceptor` now captures network request and response details only while Session Replay is recording or buffering ([#6486](https://github.com/getsentry/sentry-java/pull/6486))