From dd197b9c3213ce15f8ec257058c833e2d9d0bac5 Mon Sep 17 00:00:00 2001 From: Alexander Dinauer Date: Wed, 11 Nov 2026 12:14:36 +0100 Subject: [PATCH 01/19] collection: Ignore HTTP Status From a32bc6eb7700fa443a338929863e7e0b24ca8569 Mon Sep 17 00:00:00 2001 From: Alexander Dinauer Date: Wed, 11 Nov 2026 12:16:24 +0100 Subject: [PATCH 02/19] feat(tracing): [Ignore HTTP Status 1] Add sentry.kind to server instrumentation Classify incoming Spring and OpenTelemetry server spans with sentry.kind and record numeric HTTP response statuses for later filtering. Refs #4735 Refs #4736 Refs #6555 --- .../opentelemetry/SentrySpanExporter.java | 14 ++ .../src/test/kotlin/SentrySpanExporterTest.kt | 186 ++++++++++++++++++ .../spring7/tracing/SentryTracingFilter.java | 15 +- .../webflux/AbstractSentryWebFilter.java | 16 +- .../tracing/SentryTracingFilterTest.kt | 37 +++- .../webflux/SentryWebFluxTracingFilterTest.kt | 35 +++- .../integrationtest/PersonIntegrationTest.kt | 9 + .../PersonWebfluxIntegrationTest.kt | 9 + .../integrationtest/PersonIntegrationTest.kt | 9 + .../PersonWebfluxIntegrationTest.kt | 9 + .../integrationtest/PersonIntegrationTest.kt | 9 + .../PersonWebfluxIntegrationTest.kt | 9 + .../jakarta/tracing/SentryTracingFilter.java | 15 +- .../webflux/AbstractSentryWebFilter.java | 16 +- .../tracing/SentryTracingFilterTest.kt | 37 +++- .../webflux/SentryWebFluxTracingFilterTest.kt | 35 +++- .../spring/tracing/SentryTracingFilter.java | 15 +- .../spring/webflux/SentryWebFilter.java | 16 +- .../spring/tracing/SentryTracingFilterTest.kt | 37 +++- .../webflux/SentryWebFluxTracingFilterTest.kt | 35 +++- sentry/api/sentry.api | 1 + .../java/io/sentry/SpanDataConvention.java | 1 + 22 files changed, 532 insertions(+), 33 deletions(-) create mode 100644 sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/SentrySpanExporterTest.kt diff --git a/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SentrySpanExporter.java b/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SentrySpanExporter.java index 3cc492a9e4c..571fddc6e83 100644 --- a/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SentrySpanExporter.java +++ b/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SentrySpanExporter.java @@ -6,6 +6,7 @@ import static io.sentry.opentelemetry.OtelSpanUtils.maybeTransferOtelAttribute; import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.trace.SpanKind; import io.opentelemetry.api.trace.StatusCode; import io.opentelemetry.sdk.common.CompletableResultCode; import io.opentelemetry.sdk.trace.data.SpanData; @@ -28,6 +29,7 @@ import io.sentry.SentryLevel; import io.sentry.SentryLongDate; import io.sentry.SpanContext; +import io.sentry.SpanDataConvention; import io.sentry.SpanId; import io.sentry.SpanOptions; import io.sentry.SpanStatus; @@ -240,6 +242,7 @@ private void createAndFinishSpanForOtelSpan( setOtelInstrumentationInfo(spanData, sentryChildSpan); setOtelSpanKind(spanData, sentryChildSpan); transferSpanDetails(sentrySpanMaybe, sentryChildSpan); + setSentrySpanKind(spanData, sentryChildSpan); for (SpanNode childNode : spanNode.getChildren()) { createAndFinishSpanForOtelSpan(childNode, sentryChildSpan, remaining); @@ -355,6 +358,10 @@ private void transferSpanDetails( setOtelInstrumentationInfo(span, sentryTransaction); setOtelSpanKind(span, sentryTransaction); transferSpanDetails(sentrySpanMaybe, sentryTransaction); + setSentrySpanKind(span, sentryTransaction); + if (SpanKind.SERVER.equals(span.getKind())) { + maybeTransferOtelAttribute(span, sentryTransaction, HttpAttributes.HTTP_RESPONSE_STATUS_CODE); + } maybeTransferOtelAttribute(span, sentryTransaction, ThreadIncubatingAttributes.THREAD_ID); maybeTransferOtelAttribute(span, sentryTransaction, ThreadIncubatingAttributes.THREAD_NAME); @@ -555,6 +562,13 @@ private void setOtelSpanKind(final @NotNull SpanData otelSpan, final @NotNull IS sentrySpan.setData("otel.kind", otelSpan.getKind().name()); } + private void setSentrySpanKind( + final @NotNull SpanData otelSpan, final @NotNull ISpan sentrySpan) { + if (SpanKind.SERVER.equals(otelSpan.getKind())) { + sentrySpan.setData(SpanDataConvention.SENTRY_KIND_KEY, "server"); + } + } + @Override public CompletableResultCode flush() { scopes.flush(10000); diff --git a/sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/SentrySpanExporterTest.kt b/sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/SentrySpanExporterTest.kt new file mode 100644 index 00000000000..84b852e6f15 --- /dev/null +++ b/sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/SentrySpanExporterTest.kt @@ -0,0 +1,186 @@ +package io.sentry.opentelemetry + +import com.google.common.truth.Truth.assertThat +import io.opentelemetry.api.trace.SpanKind +import io.opentelemetry.context.Context +import io.opentelemetry.sdk.OpenTelemetrySdk +import io.opentelemetry.sdk.trace.SdkTracerProvider +import io.opentelemetry.sdk.trace.export.SimpleSpanProcessor +import io.opentelemetry.semconv.HttpAttributes +import io.sentry.ISentryClient +import io.sentry.NoOpScopes +import io.sentry.Sentry +import io.sentry.SentryOptions +import io.sentry.SpanDataConvention +import io.sentry.TransactionContext +import io.sentry.TransactionOptions +import io.sentry.protocol.SentryId +import io.sentry.protocol.SentryTransaction +import io.sentry.test.createSentryClientMock +import io.sentry.test.createTestScopes +import java.util.concurrent.TimeUnit +import kotlin.test.AfterTest +import kotlin.test.Test +import org.mockito.kotlin.anyOrNull +import org.mockito.kotlin.argumentCaptor +import org.mockito.kotlin.atLeastOnce +import org.mockito.kotlin.verify +import org.mockito.kotlin.whenever + +class SentrySpanExporterTest { + private val options = + SentryOptions().apply { + dsn = "https://key@sentry.io/proj" + tracesSampleRate = 1.0 + } + private val client: ISentryClient = createSentryClientMock() + private val scopes = createTestScopes(options).also { it.bindClient(client) } + private val exporter = SentrySpanExporter(scopes) + + init { + whenever( + client.captureTransaction(anyOrNull(), anyOrNull(), anyOrNull(), anyOrNull(), anyOrNull()) + ) + .thenReturn(SentryId()) + Sentry.setCurrentScopes(scopes) + } + + @AfterTest + fun tearDown() { + Sentry.setCurrentScopes(NoOpScopes.getInstance()) + } + + @Test + fun `server roots and children get server kind and root response status`() { + withOpenTelemetry { openTelemetry -> + val tracer = openTelemetry.getTracer("test") + val root = + tracer + .spanBuilder("server-root") + .setSpanKind(SpanKind.SERVER) + .setAttribute(HttpAttributes.HTTP_RESPONSE_STATUS_CODE, 404L) + .startSpan() + val child = + tracer + .spanBuilder("server-child") + .setParent(root.storeInContext(Context.root())) + .setSpanKind(SpanKind.SERVER) + .startSpan() + + child.end() + root.end() + } + + val transaction = capturedTransactions().single() + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(404L) + assertThat(transaction.contexts.trace!!.data["otel.kind"]).isEqualTo("SERVER") + assertThat(transaction.spans).hasSize(1) + assertThat(transaction.spans.single().data!![SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(transaction.spans.single().data!!["otel.kind"]).isEqualTo("SERVER") + } + + @Test + fun `client and internal roots do not get server data`() { + withOpenTelemetry { openTelemetry -> + val tracer = openTelemetry.getTracer("test") + tracer + .spanBuilder("client-root") + .setSpanKind(SpanKind.CLIENT) + .setAttribute(HttpAttributes.HTTP_RESPONSE_STATUS_CODE, 404L) + .startSpan() + .end() + tracer + .spanBuilder("internal-root") + .setSpanKind(SpanKind.INTERNAL) + .setAttribute(HttpAttributes.HTTP_RESPONSE_STATUS_CODE, 500L) + .startSpan() + .end() + } + + val transactions = capturedTransactions().associateBy { it.transaction } + assertThat(transactions.keys).containsExactly("client-root", "internal-root") + assertThat(transactions["client-root"]!!.contexts.trace!!.data) + .doesNotContainKey(SpanDataConvention.SENTRY_KIND_KEY) + assertThat(transactions["client-root"]!!.contexts.trace!!.data) + .doesNotContainKey(SpanDataConvention.HTTP_STATUS_CODE_KEY) + assertThat(transactions["internal-root"]!!.contexts.trace!!.data) + .doesNotContainKey(SpanDataConvention.SENTRY_KIND_KEY) + assertThat(transactions["internal-root"]!!.contexts.trace!!.data) + .doesNotContainKey(SpanDataConvention.HTTP_STATUS_CODE_KEY) + } + + @Test + fun `rpc server root does not fabricate HTTP response status`() { + withOpenTelemetry { openTelemetry -> + openTelemetry + .getTracer("test") + .spanBuilder("rpc-server") + .setSpanKind(SpanKind.SERVER) + .startSpan() + .end() + } + + val transaction = capturedTransactions().single() + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(transaction.contexts.trace!!.data) + .doesNotContainKey(SpanDataConvention.HTTP_STATUS_CODE_KEY) + } + + @Test + fun `Sentry server marker survives default OTel internal kind`() { + withOpenTelemetry(includeSentrySpanProcessor = true) { openTelemetry -> + options.spanFactory = OtelSpanFactory(openTelemetry) + val transaction = + scopes.startTransaction( + TransactionContext("native-server", "http.server"), + TransactionOptions(), + ) + transaction.setData(SpanDataConvention.SENTRY_KIND_KEY, "server") + transaction.setData(SpanDataConvention.HTTP_STATUS_CODE_KEY, 404) + transaction.finish() + } + + val transaction = capturedTransactions().single() + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(404) + assertThat(transaction.contexts.trace!!.data["otel.kind"]).isEqualTo("INTERNAL") + } + + private fun withOpenTelemetry( + includeSentrySpanProcessor: Boolean = false, + callback: (OpenTelemetrySdk) -> Unit, + ) { + val providerBuilder = SdkTracerProvider.builder() + if (includeSentrySpanProcessor) { + providerBuilder.addSpanProcessor(OtelSentrySpanProcessor(scopes)) + } + val provider = providerBuilder.addSpanProcessor(SimpleSpanProcessor.create(exporter)).build() + val openTelemetry = OpenTelemetrySdk.builder().setTracerProvider(provider).build() + try { + callback(openTelemetry) + provider.forceFlush().join(10, TimeUnit.SECONDS) + } finally { + provider.close() + } + } + + private fun capturedTransactions(): List { + val transaction = argumentCaptor() + verify(client, atLeastOnce()) + .captureTransaction( + transaction.capture(), + anyOrNull(), + anyOrNull(), + anyOrNull(), + anyOrNull(), + ) + return transaction.allValues + } +} diff --git a/sentry-spring-7/src/main/java/io/sentry/spring7/tracing/SentryTracingFilter.java b/sentry-spring-7/src/main/java/io/sentry/spring7/tracing/SentryTracingFilter.java index a978c57d9c3..23796f187b3 100644 --- a/sentry-spring-7/src/main/java/io/sentry/spring7/tracing/SentryTracingFilter.java +++ b/sentry-spring-7/src/main/java/io/sentry/spring7/tracing/SentryTracingFilter.java @@ -9,6 +9,7 @@ import io.sentry.ITransaction; import io.sentry.ScopesAdapter; import io.sentry.SentryTraceHeader; +import io.sentry.SpanDataConvention; import io.sentry.SpanStatus; import io.sentry.TransactionContext; import io.sentry.TransactionOptions; @@ -164,6 +165,7 @@ private void doFilterWithTransaction( if (transactionName != null) { transaction.setName(transactionName, transactionNameSource); transaction.setOperation(TRANSACTION_OP); + transaction.setData(SpanDataConvention.HTTP_STATUS_CODE_KEY, httpResponse.getStatus()); // if exception has been thrown, transaction status is already set to INTERNAL_ERROR, and // httpResponse.getStatus() returns 200. if (transaction.getStatus() == null) { @@ -240,15 +242,20 @@ private ITransaction startTransaction( transactionOptions.setBindToScope(true); transactionOptions.setOrigin(TRACE_ORIGIN); + final @NotNull ITransaction transaction; if (transactionContext != null) { transactionContext.setName(name); transactionContext.setTransactionNameSource(TransactionNameSource.URL); transactionContext.setOperation("http.server"); - return scopes.startTransaction(transactionContext, transactionOptions); + transaction = scopes.startTransaction(transactionContext, transactionOptions); + } else { + transaction = + scopes.startTransaction( + new TransactionContext(name, TransactionNameSource.URL, "http.server"), + transactionOptions); } - - return scopes.startTransaction( - new TransactionContext(name, TransactionNameSource.URL, "http.server"), transactionOptions); + transaction.setData(SpanDataConvention.SENTRY_KIND_KEY, "server"); + return transaction; } } diff --git a/sentry-spring-7/src/main/java/io/sentry/spring7/webflux/AbstractSentryWebFilter.java b/sentry-spring-7/src/main/java/io/sentry/spring7/webflux/AbstractSentryWebFilter.java index 898c9fd5937..0301159bb4d 100644 --- a/sentry-spring-7/src/main/java/io/sentry/spring7/webflux/AbstractSentryWebFilter.java +++ b/sentry-spring-7/src/main/java/io/sentry/spring7/webflux/AbstractSentryWebFilter.java @@ -13,6 +13,7 @@ import io.sentry.NoOpScopes; import io.sentry.Sentry; import io.sentry.SentryTraceHeader; +import io.sentry.SpanDataConvention; import io.sentry.SpanStatus; import io.sentry.TransactionContext; import io.sentry.TransactionOptions; @@ -126,6 +127,7 @@ private void finishTransaction(ServerWebExchange exchange, ITransaction transact if (response != null) { final @Nullable HttpStatusCode statusCode = response.getStatusCode(); if (statusCode != null) { + transaction.setData(SpanDataConvention.HTTP_STATUS_CODE_KEY, statusCode.value()); transaction .getContexts() .withResponse( @@ -154,16 +156,20 @@ private void finishTransaction(ServerWebExchange exchange, ITransaction transact transactionOptions.setBindToScope(true); transactionOptions.setOrigin(origin); + final @NotNull ITransaction transaction; if (transactionContext != null) { transactionContext.setName(name); transactionContext.setTransactionNameSource(TransactionNameSource.URL); transactionContext.setOperation(TRANSACTION_OP); - return scopes.startTransaction(transactionContext, transactionOptions); + transaction = scopes.startTransaction(transactionContext, transactionOptions); + } else { + transaction = + scopes.startTransaction( + new TransactionContext(name, TransactionNameSource.URL, TRANSACTION_OP), + transactionOptions); } - - return scopes.startTransaction( - new TransactionContext(name, TransactionNameSource.URL, TRANSACTION_OP), - transactionOptions); + transaction.setData(SpanDataConvention.SENTRY_KIND_KEY, "server"); + return transaction; } } diff --git a/sentry-spring-7/src/test/kotlin/io/sentry/spring7/tracing/SentryTracingFilterTest.kt b/sentry-spring-7/src/test/kotlin/io/sentry/spring7/tracing/SentryTracingFilterTest.kt index fae0f19ebe6..cf98fdc4542 100644 --- a/sentry-spring-7/src/test/kotlin/io/sentry/spring7/tracing/SentryTracingFilterTest.kt +++ b/sentry-spring-7/src/test/kotlin/io/sentry/spring7/tracing/SentryTracingFilterTest.kt @@ -5,6 +5,7 @@ import io.sentry.IScopes import io.sentry.PropagationContext import io.sentry.SentryOptions import io.sentry.SentryTracer +import io.sentry.SpanDataConvention import io.sentry.SpanId import io.sentry.SpanStatus import io.sentry.TraceContext @@ -134,6 +135,10 @@ class SentryTracingFilterTest { assertThat(it.transaction).isEqualTo("POST /product/{id}") assertThat(it.contexts.trace!!.status).isEqualTo(SpanStatus.OK) assertThat(it.contexts.trace!!.operation).isEqualTo("http.server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) }, anyOrNull(), anyOrNull(), @@ -160,6 +165,26 @@ class SentryTracingFilterTest { ) } + @Test + fun `records not found response status`() { + val filter = fixture.getSut(status = 404) + + filter.doFilter(fixture.request, fixture.response, fixture.chain) + + verify(fixture.scopes) + .captureTransaction( + check { + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(404) + }, + anyOrNull(), + anyOrNull(), + anyOrNull(), + ) + } + @Test fun `sets correct span status based on the response status`() { val filter = fixture.getSut(status = 500) @@ -214,7 +239,13 @@ class SentryTracingFilterTest { verify(fixture.scopes) .captureTransaction( - check { assertThat(it.contexts.trace!!.parentSpanId).isEqualTo(parentSpanId) }, + check { + assertThat(it.contexts.trace!!.parentSpanId).isEqualTo(parentSpanId) + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) + }, anyOrNull(), anyOrNull(), anyOrNull(), @@ -429,6 +460,10 @@ class SentryTracingFilterTest { assertThat(it.transaction).isEqualTo("POST /product/{id}") assertThat(it.contexts.trace!!.status).isEqualTo(SpanStatus.OK) assertThat(it.contexts.trace!!.operation).isEqualTo("http.server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) }, anyOrNull(), anyOrNull(), diff --git a/sentry-spring-7/src/test/kotlin/io/sentry/spring7/webflux/SentryWebFluxTracingFilterTest.kt b/sentry-spring-7/src/test/kotlin/io/sentry/spring7/webflux/SentryWebFluxTracingFilterTest.kt index c6c65b560db..a5b31f73c2d 100644 --- a/sentry-spring-7/src/test/kotlin/io/sentry/spring7/webflux/SentryWebFluxTracingFilterTest.kt +++ b/sentry-spring-7/src/test/kotlin/io/sentry/spring7/webflux/SentryWebFluxTracingFilterTest.kt @@ -9,6 +9,7 @@ import io.sentry.ScopeCallback import io.sentry.Sentry import io.sentry.SentryOptions import io.sentry.SentryTracer +import io.sentry.SpanDataConvention import io.sentry.SpanId import io.sentry.SpanStatus import io.sentry.TraceContext @@ -143,6 +144,32 @@ class SentryWebFluxTracingFilterTest { assertThat(it.contexts.trace!!.status).isEqualTo(SpanStatus.OK) assertThat(it.contexts.trace!!.operation).isEqualTo("http.server") assertThat(it.contexts.response!!.statusCode).isEqualTo(200) + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) + }, + anyOrNull(), + anyOrNull(), + anyOrNull(), + ) + } + } + + @Test + fun `records not found response status`() { + val filter = fixture.getSut(status = HttpStatus.NOT_FOUND) + + withMockScopes { + filter.filter(fixture.exchange, fixture.chain).block() + + verify(fixture.scopes) + .captureTransaction( + check { + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(404) }, anyOrNull(), anyOrNull(), @@ -215,7 +242,13 @@ class SentryWebFluxTracingFilterTest { verify(fixture.scopes) .captureTransaction( - check { assertThat(it.contexts.trace!!.parentSpanId).isEqualTo(parentSpanId) }, + check { + assertThat(it.contexts.trace!!.parentSpanId).isEqualTo(parentSpanId) + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) + }, anyOrNull(), anyOrNull(), anyOrNull(), diff --git a/sentry-spring-boot-4/src/integrationTest/kotlin/io/sentry/spring/boot4/integrationtest/PersonIntegrationTest.kt b/sentry-spring-boot-4/src/integrationTest/kotlin/io/sentry/spring/boot4/integrationtest/PersonIntegrationTest.kt index 30543274d5d..afb633e66e8 100644 --- a/sentry-spring-boot-4/src/integrationTest/kotlin/io/sentry/spring/boot4/integrationtest/PersonIntegrationTest.kt +++ b/sentry-spring-boot-4/src/integrationTest/kotlin/io/sentry/spring/boot4/integrationtest/PersonIntegrationTest.kt @@ -2,6 +2,7 @@ package io.sentry.spring.boot4.integrationtest import com.google.common.truth.Truth.assertThat import io.sentry.Sentry +import io.sentry.SpanDataConvention import io.sentry.protocol.FeatureFlag import io.sentry.test.event import io.sentry.test.hasFlag @@ -45,6 +46,10 @@ class PersonIntegrationTest : IntegrationTest() { } == true } .transaction()!! + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) assertThat( transaction.hasOp( "http.server", @@ -83,6 +88,10 @@ class PersonIntegrationTest : IntegrationTest() { val transaction = server.awaitEnvelope { it.transaction()?.transaction == "POST /person/" }.transaction()!! + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) assertThat(transaction.hasSpanWithOp("PersonService.create")).isTrue() assertThat( transaction.hasSpanWithOpAndDescription( diff --git a/sentry-spring-boot-4/src/integrationTestWebflux/kotlin/io/sentry/spring/boot4/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt b/sentry-spring-boot-4/src/integrationTestWebflux/kotlin/io/sentry/spring/boot4/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt index 8151eb4a8a1..15aab17c410 100644 --- a/sentry-spring-boot-4/src/integrationTestWebflux/kotlin/io/sentry/spring/boot4/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt +++ b/sentry-spring-boot-4/src/integrationTestWebflux/kotlin/io/sentry/spring/boot4/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt @@ -2,6 +2,7 @@ package io.sentry.spring.boot4.webfluxintegrationtest import com.google.common.truth.Truth.assertThat import io.sentry.Sentry +import io.sentry.SpanDataConvention import io.sentry.test.event import io.sentry.test.hasFlag import io.sentry.test.hasLogWithAttribute @@ -30,6 +31,10 @@ class PersonWebfluxIntegrationTest : WebfluxIntegrationTest() { val transaction = server.awaitEnvelope { it.transaction()?.transaction == "GET /person/{id}" }.transaction()!! assertThat(transaction.contexts.trace!!.operation).isEqualTo("http.server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(500) val logs = server @@ -55,6 +60,10 @@ class PersonWebfluxIntegrationTest : WebfluxIntegrationTest() { val transaction = server.awaitEnvelope { it.transaction()?.transaction == "POST /person/" }.transaction()!! assertThat(transaction.contexts.trace!!.operation).isEqualTo("http.server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) } @Test diff --git a/sentry-spring-boot-jakarta/src/integrationTest/kotlin/io/sentry/spring/boot/jakarta/integrationtest/PersonIntegrationTest.kt b/sentry-spring-boot-jakarta/src/integrationTest/kotlin/io/sentry/spring/boot/jakarta/integrationtest/PersonIntegrationTest.kt index 3f8ba722099..1728424fbc1 100644 --- a/sentry-spring-boot-jakarta/src/integrationTest/kotlin/io/sentry/spring/boot/jakarta/integrationtest/PersonIntegrationTest.kt +++ b/sentry-spring-boot-jakarta/src/integrationTest/kotlin/io/sentry/spring/boot/jakarta/integrationtest/PersonIntegrationTest.kt @@ -2,6 +2,7 @@ package io.sentry.spring.boot.jakarta.integrationtest import com.google.common.truth.Truth.assertThat import io.sentry.Sentry +import io.sentry.SpanDataConvention import io.sentry.protocol.FeatureFlag import io.sentry.test.event import io.sentry.test.hasFlag @@ -45,6 +46,10 @@ class PersonIntegrationTest : IntegrationTest() { } == true } .transaction()!! + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) assertThat( transaction.hasOp( "http.server", @@ -83,6 +88,10 @@ class PersonIntegrationTest : IntegrationTest() { val transaction = server.awaitEnvelope { it.transaction()?.transaction == "POST /person/" }.transaction()!! + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) assertThat(transaction.hasSpanWithOp("PersonService.create")).isTrue() assertThat( transaction.hasSpanWithOpAndDescription( diff --git a/sentry-spring-boot-jakarta/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/jakarta/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt b/sentry-spring-boot-jakarta/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/jakarta/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt index c72ed553235..662ffc961dc 100644 --- a/sentry-spring-boot-jakarta/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/jakarta/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt +++ b/sentry-spring-boot-jakarta/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/jakarta/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt @@ -2,6 +2,7 @@ package io.sentry.spring.boot.jakarta.webfluxintegrationtest import com.google.common.truth.Truth.assertThat import io.sentry.Sentry +import io.sentry.SpanDataConvention import io.sentry.test.event import io.sentry.test.hasFlag import io.sentry.test.hasLogWithAttribute @@ -30,6 +31,10 @@ class PersonWebfluxIntegrationTest : WebfluxIntegrationTest() { val transaction = server.awaitEnvelope { it.transaction()?.transaction == "GET /person/{id}" }.transaction()!! assertThat(transaction.contexts.trace!!.operation).isEqualTo("http.server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(500) val logs = server @@ -55,6 +60,10 @@ class PersonWebfluxIntegrationTest : WebfluxIntegrationTest() { val transaction = server.awaitEnvelope { it.transaction()?.transaction == "POST /person/" }.transaction()!! assertThat(transaction.contexts.trace!!.operation).isEqualTo("http.server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) } @Test diff --git a/sentry-spring-boot/src/integrationTest/kotlin/io/sentry/spring/boot/integrationtest/PersonIntegrationTest.kt b/sentry-spring-boot/src/integrationTest/kotlin/io/sentry/spring/boot/integrationtest/PersonIntegrationTest.kt index 5a15d818166..045bfa37a96 100644 --- a/sentry-spring-boot/src/integrationTest/kotlin/io/sentry/spring/boot/integrationtest/PersonIntegrationTest.kt +++ b/sentry-spring-boot/src/integrationTest/kotlin/io/sentry/spring/boot/integrationtest/PersonIntegrationTest.kt @@ -2,6 +2,7 @@ package io.sentry.spring.boot.integrationtest import com.google.common.truth.Truth.assertThat import io.sentry.Sentry +import io.sentry.SpanDataConvention import io.sentry.protocol.FeatureFlag import io.sentry.test.event import io.sentry.test.hasFlag @@ -45,6 +46,10 @@ class PersonIntegrationTest : IntegrationTest() { } == true } .transaction()!! + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) assertThat( transaction.hasOp( "http.server", @@ -83,6 +88,10 @@ class PersonIntegrationTest : IntegrationTest() { val transaction = server.awaitEnvelope { it.transaction()?.transaction == "POST /person/" }.transaction()!! + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) assertThat(transaction.hasSpanWithOp("PersonService.create")).isTrue() assertThat( transaction.hasSpanWithOpAndDescription( diff --git a/sentry-spring-boot/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt b/sentry-spring-boot/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt index 379d6a5913d..0210da8ba64 100644 --- a/sentry-spring-boot/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt +++ b/sentry-spring-boot/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt @@ -2,6 +2,7 @@ package io.sentry.spring.boot.webfluxintegrationtest import com.google.common.truth.Truth.assertThat import io.sentry.Sentry +import io.sentry.SpanDataConvention import io.sentry.test.event import io.sentry.test.hasFlag import io.sentry.test.hasLogWithAttribute @@ -30,6 +31,10 @@ class PersonWebfluxIntegrationTest : WebfluxIntegrationTest() { val transaction = server.awaitEnvelope { it.transaction()?.transaction == "GET /person/{id}" }.transaction()!! assertThat(transaction.contexts.trace!!.operation).isEqualTo("http.server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(500) val logs = server @@ -55,6 +60,10 @@ class PersonWebfluxIntegrationTest : WebfluxIntegrationTest() { val transaction = server.awaitEnvelope { it.transaction()?.transaction == "POST /person/" }.transaction()!! assertThat(transaction.contexts.trace!!.operation).isEqualTo("http.server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) } @Test diff --git a/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/tracing/SentryTracingFilter.java b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/tracing/SentryTracingFilter.java index 4832e1c21ff..55a0cc1faeb 100644 --- a/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/tracing/SentryTracingFilter.java +++ b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/tracing/SentryTracingFilter.java @@ -9,6 +9,7 @@ import io.sentry.ITransaction; import io.sentry.ScopesAdapter; import io.sentry.SentryTraceHeader; +import io.sentry.SpanDataConvention; import io.sentry.SpanStatus; import io.sentry.TransactionContext; import io.sentry.TransactionOptions; @@ -164,6 +165,7 @@ private void doFilterWithTransaction( if (transactionName != null) { transaction.setName(transactionName, transactionNameSource); transaction.setOperation(TRANSACTION_OP); + transaction.setData(SpanDataConvention.HTTP_STATUS_CODE_KEY, httpResponse.getStatus()); // if exception has been thrown, transaction status is already set to INTERNAL_ERROR, and // httpResponse.getStatus() returns 200. if (transaction.getStatus() == null) { @@ -240,15 +242,20 @@ private ITransaction startTransaction( transactionOptions.setBindToScope(true); transactionOptions.setOrigin(TRACE_ORIGIN); + final @NotNull ITransaction transaction; if (transactionContext != null) { transactionContext.setName(name); transactionContext.setTransactionNameSource(TransactionNameSource.URL); transactionContext.setOperation("http.server"); - return scopes.startTransaction(transactionContext, transactionOptions); + transaction = scopes.startTransaction(transactionContext, transactionOptions); + } else { + transaction = + scopes.startTransaction( + new TransactionContext(name, TransactionNameSource.URL, "http.server"), + transactionOptions); } - - return scopes.startTransaction( - new TransactionContext(name, TransactionNameSource.URL, "http.server"), transactionOptions); + transaction.setData(SpanDataConvention.SENTRY_KIND_KEY, "server"); + return transaction; } } diff --git a/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/webflux/AbstractSentryWebFilter.java b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/webflux/AbstractSentryWebFilter.java index a3edfd54c83..2468b43d20f 100644 --- a/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/webflux/AbstractSentryWebFilter.java +++ b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/webflux/AbstractSentryWebFilter.java @@ -13,6 +13,7 @@ import io.sentry.NoOpScopes; import io.sentry.Sentry; import io.sentry.SentryTraceHeader; +import io.sentry.SpanDataConvention; import io.sentry.SpanStatus; import io.sentry.TransactionContext; import io.sentry.TransactionOptions; @@ -126,6 +127,7 @@ private void finishTransaction(ServerWebExchange exchange, ITransaction transact if (response != null) { final @Nullable HttpStatusCode statusCode = response.getStatusCode(); if (statusCode != null) { + transaction.setData(SpanDataConvention.HTTP_STATUS_CODE_KEY, statusCode.value()); transaction .getContexts() .withResponse( @@ -154,16 +156,20 @@ private void finishTransaction(ServerWebExchange exchange, ITransaction transact transactionOptions.setBindToScope(true); transactionOptions.setOrigin(origin); + final @NotNull ITransaction transaction; if (transactionContext != null) { transactionContext.setName(name); transactionContext.setTransactionNameSource(TransactionNameSource.URL); transactionContext.setOperation(TRANSACTION_OP); - return scopes.startTransaction(transactionContext, transactionOptions); + transaction = scopes.startTransaction(transactionContext, transactionOptions); + } else { + transaction = + scopes.startTransaction( + new TransactionContext(name, TransactionNameSource.URL, TRANSACTION_OP), + transactionOptions); } - - return scopes.startTransaction( - new TransactionContext(name, TransactionNameSource.URL, TRANSACTION_OP), - transactionOptions); + transaction.setData(SpanDataConvention.SENTRY_KIND_KEY, "server"); + return transaction; } } diff --git a/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/tracing/SentryTracingFilterTest.kt b/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/tracing/SentryTracingFilterTest.kt index 61fabb6d478..18d3ae096b6 100644 --- a/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/tracing/SentryTracingFilterTest.kt +++ b/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/tracing/SentryTracingFilterTest.kt @@ -5,6 +5,7 @@ import io.sentry.IScopes import io.sentry.PropagationContext import io.sentry.SentryOptions import io.sentry.SentryTracer +import io.sentry.SpanDataConvention import io.sentry.SpanId import io.sentry.SpanStatus import io.sentry.TraceContext @@ -134,6 +135,10 @@ class SentryTracingFilterTest { assertThat(it.transaction).isEqualTo("POST /product/{id}") assertThat(it.contexts.trace!!.status).isEqualTo(SpanStatus.OK) assertThat(it.contexts.trace!!.operation).isEqualTo("http.server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) }, anyOrNull(), anyOrNull(), @@ -160,6 +165,26 @@ class SentryTracingFilterTest { ) } + @Test + fun `records not found response status`() { + val filter = fixture.getSut(status = 404) + + filter.doFilter(fixture.request, fixture.response, fixture.chain) + + verify(fixture.scopes) + .captureTransaction( + check { + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(404) + }, + anyOrNull(), + anyOrNull(), + anyOrNull(), + ) + } + @Test fun `sets correct span status based on the response status`() { val filter = fixture.getSut(status = 500) @@ -214,7 +239,13 @@ class SentryTracingFilterTest { verify(fixture.scopes) .captureTransaction( - check { assertThat(it.contexts.trace!!.parentSpanId).isEqualTo(parentSpanId) }, + check { + assertThat(it.contexts.trace!!.parentSpanId).isEqualTo(parentSpanId) + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) + }, anyOrNull(), anyOrNull(), anyOrNull(), @@ -429,6 +460,10 @@ class SentryTracingFilterTest { assertThat(it.transaction).isEqualTo("POST /product/{id}") assertThat(it.contexts.trace!!.status).isEqualTo(SpanStatus.OK) assertThat(it.contexts.trace!!.operation).isEqualTo("http.server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) }, anyOrNull(), anyOrNull(), diff --git a/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/webflux/SentryWebFluxTracingFilterTest.kt b/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/webflux/SentryWebFluxTracingFilterTest.kt index 0a01b4cbcc4..9fe7351b1ef 100644 --- a/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/webflux/SentryWebFluxTracingFilterTest.kt +++ b/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/webflux/SentryWebFluxTracingFilterTest.kt @@ -9,6 +9,7 @@ import io.sentry.ScopeCallback import io.sentry.Sentry import io.sentry.SentryOptions import io.sentry.SentryTracer +import io.sentry.SpanDataConvention import io.sentry.SpanId import io.sentry.SpanStatus import io.sentry.TraceContext @@ -143,6 +144,32 @@ class SentryWebFluxTracingFilterTest { assertThat(it.contexts.trace!!.status).isEqualTo(SpanStatus.OK) assertThat(it.contexts.trace!!.operation).isEqualTo("http.server") assertThat(it.contexts.response!!.statusCode).isEqualTo(200) + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) + }, + anyOrNull(), + anyOrNull(), + anyOrNull(), + ) + } + } + + @Test + fun `records not found response status`() { + val filter = fixture.getSut(status = HttpStatus.NOT_FOUND) + + withMockScopes { + filter.filter(fixture.exchange, fixture.chain).block() + + verify(fixture.scopes) + .captureTransaction( + check { + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(404) }, anyOrNull(), anyOrNull(), @@ -215,7 +242,13 @@ class SentryWebFluxTracingFilterTest { verify(fixture.scopes) .captureTransaction( - check { assertThat(it.contexts.trace!!.parentSpanId).isEqualTo(parentSpanId) }, + check { + assertThat(it.contexts.trace!!.parentSpanId).isEqualTo(parentSpanId) + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) + }, anyOrNull(), anyOrNull(), anyOrNull(), diff --git a/sentry-spring/src/main/java/io/sentry/spring/tracing/SentryTracingFilter.java b/sentry-spring/src/main/java/io/sentry/spring/tracing/SentryTracingFilter.java index 02da16feaca..e1056690761 100644 --- a/sentry-spring/src/main/java/io/sentry/spring/tracing/SentryTracingFilter.java +++ b/sentry-spring/src/main/java/io/sentry/spring/tracing/SentryTracingFilter.java @@ -9,6 +9,7 @@ import io.sentry.ITransaction; import io.sentry.ScopesAdapter; import io.sentry.SentryTraceHeader; +import io.sentry.SpanDataConvention; import io.sentry.SpanStatus; import io.sentry.TransactionContext; import io.sentry.TransactionOptions; @@ -163,6 +164,7 @@ private void doFilterWithTransaction( if (transactionName != null) { transaction.setName(transactionName, transactionNameSource); transaction.setOperation(TRANSACTION_OP); + transaction.setData(SpanDataConvention.HTTP_STATUS_CODE_KEY, httpResponse.getStatus()); // if exception has been thrown, transaction status is already set to INTERNAL_ERROR, and // httpResponse.getStatus() returns 200. if (transaction.getStatus() == null) { @@ -239,15 +241,20 @@ private ITransaction startTransaction( transactionOptions.setBindToScope(true); transactionOptions.setOrigin(TRACE_ORIGIN); + final @NotNull ITransaction transaction; if (transactionContext != null) { transactionContext.setName(name); transactionContext.setTransactionNameSource(TransactionNameSource.URL); transactionContext.setOperation("http.server"); - return scopes.startTransaction(transactionContext, transactionOptions); + transaction = scopes.startTransaction(transactionContext, transactionOptions); + } else { + transaction = + scopes.startTransaction( + new TransactionContext(name, TransactionNameSource.URL, "http.server"), + transactionOptions); } - - return scopes.startTransaction( - new TransactionContext(name, TransactionNameSource.URL, "http.server"), transactionOptions); + transaction.setData(SpanDataConvention.SENTRY_KIND_KEY, "server"); + return transaction; } } diff --git a/sentry-spring/src/main/java/io/sentry/spring/webflux/SentryWebFilter.java b/sentry-spring/src/main/java/io/sentry/spring/webflux/SentryWebFilter.java index 031f579d4e4..9f907b206dd 100644 --- a/sentry-spring/src/main/java/io/sentry/spring/webflux/SentryWebFilter.java +++ b/sentry-spring/src/main/java/io/sentry/spring/webflux/SentryWebFilter.java @@ -13,6 +13,7 @@ import io.sentry.NoOpScopes; import io.sentry.Sentry; import io.sentry.SentryTraceHeader; +import io.sentry.SpanDataConvention; import io.sentry.SpanStatus; import io.sentry.TransactionContext; import io.sentry.TransactionOptions; @@ -132,17 +133,21 @@ private boolean shouldTraceRequest( transactionOptions.setBindToScope(true); transactionOptions.setOrigin(TRACE_ORIGIN); + final @NotNull ITransaction transaction; if (transactionContext != null) { transactionContext.setName(name); transactionContext.setTransactionNameSource(TransactionNameSource.URL); transactionContext.setOperation(TRANSACTION_OP); - return scopes.startTransaction(transactionContext, transactionOptions); + transaction = scopes.startTransaction(transactionContext, transactionOptions); + } else { + transaction = + scopes.startTransaction( + new TransactionContext(name, TransactionNameSource.URL, TRANSACTION_OP), + transactionOptions); } - - return scopes.startTransaction( - new TransactionContext(name, TransactionNameSource.URL, TRANSACTION_OP), - transactionOptions); + transaction.setData(SpanDataConvention.SENTRY_KIND_KEY, "server"); + return transaction; } private void finishTransaction(ServerWebExchange exchange, ITransaction transaction) { @@ -155,6 +160,7 @@ private void finishTransaction(ServerWebExchange exchange, ITransaction transact if (response != null) { final @Nullable Integer rawStatusCode = response.getRawStatusCode(); if (rawStatusCode != null) { + transaction.setData(SpanDataConvention.HTTP_STATUS_CODE_KEY, rawStatusCode); transaction .getContexts() .withResponse( diff --git a/sentry-spring/src/test/kotlin/io/sentry/spring/tracing/SentryTracingFilterTest.kt b/sentry-spring/src/test/kotlin/io/sentry/spring/tracing/SentryTracingFilterTest.kt index acfcdb4ebab..5e5f689f73c 100644 --- a/sentry-spring/src/test/kotlin/io/sentry/spring/tracing/SentryTracingFilterTest.kt +++ b/sentry-spring/src/test/kotlin/io/sentry/spring/tracing/SentryTracingFilterTest.kt @@ -5,6 +5,7 @@ import io.sentry.IScopes import io.sentry.PropagationContext import io.sentry.SentryOptions import io.sentry.SentryTracer +import io.sentry.SpanDataConvention import io.sentry.SpanId import io.sentry.SpanStatus import io.sentry.TraceContext @@ -134,6 +135,10 @@ class SentryTracingFilterTest { assertThat(it.transaction).isEqualTo("POST /product/{id}") assertThat(it.contexts.trace!!.status).isEqualTo(SpanStatus.OK) assertThat(it.contexts.trace!!.operation).isEqualTo("http.server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) }, anyOrNull(), anyOrNull(), @@ -160,6 +165,26 @@ class SentryTracingFilterTest { ) } + @Test + fun `records not found response status`() { + val filter = fixture.getSut(status = 404) + + filter.doFilter(fixture.request, fixture.response, fixture.chain) + + verify(fixture.scopes) + .captureTransaction( + check { + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(404) + }, + anyOrNull(), + anyOrNull(), + anyOrNull(), + ) + } + @Test fun `sets correct span status based on the response status`() { val filter = fixture.getSut(status = 500) @@ -214,7 +239,13 @@ class SentryTracingFilterTest { verify(fixture.scopes) .captureTransaction( - check { assertThat(it.contexts.trace!!.parentSpanId).isEqualTo(parentSpanId) }, + check { + assertThat(it.contexts.trace!!.parentSpanId).isEqualTo(parentSpanId) + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) + }, anyOrNull(), anyOrNull(), anyOrNull(), @@ -429,6 +460,10 @@ class SentryTracingFilterTest { assertThat(it.transaction).isEqualTo("POST /product/{id}") assertThat(it.contexts.trace!!.status).isEqualTo(SpanStatus.OK) assertThat(it.contexts.trace!!.operation).isEqualTo("http.server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) }, anyOrNull(), anyOrNull(), diff --git a/sentry-spring/src/test/kotlin/io/sentry/spring/webflux/SentryWebFluxTracingFilterTest.kt b/sentry-spring/src/test/kotlin/io/sentry/spring/webflux/SentryWebFluxTracingFilterTest.kt index 326b5979991..88fe80cab0d 100644 --- a/sentry-spring/src/test/kotlin/io/sentry/spring/webflux/SentryWebFluxTracingFilterTest.kt +++ b/sentry-spring/src/test/kotlin/io/sentry/spring/webflux/SentryWebFluxTracingFilterTest.kt @@ -9,6 +9,7 @@ import io.sentry.ScopeCallback import io.sentry.Sentry import io.sentry.SentryOptions import io.sentry.SentryTracer +import io.sentry.SpanDataConvention import io.sentry.SpanId import io.sentry.SpanStatus import io.sentry.TraceContext @@ -144,6 +145,32 @@ class SentryWebFluxTracingFilterTest { assertThat(it.contexts.trace!!.status).isEqualTo(SpanStatus.OK) assertThat(it.contexts.trace!!.operation).isEqualTo("http.server") assertThat(it.contexts.response!!.statusCode).isEqualTo(200) + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) + }, + anyOrNull(), + anyOrNull(), + anyOrNull(), + ) + } + } + + @Test + fun `records not found response status`() { + val filter = fixture.getSut(status = HttpStatus.NOT_FOUND) + + withMockScopes { + filter.filter(fixture.exchange, fixture.chain).block() + + verify(fixture.scopes) + .captureTransaction( + check { + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(404) }, anyOrNull(), anyOrNull(), @@ -216,7 +243,13 @@ class SentryWebFluxTracingFilterTest { verify(fixture.scopes) .captureTransaction( - check { assertThat(it.contexts.trace!!.parentSpanId).isEqualTo(parentSpanId) }, + check { + assertThat(it.contexts.trace!!.parentSpanId).isEqualTo(parentSpanId) + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) + }, anyOrNull(), anyOrNull(), anyOrNull(), diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api index b3c312169a3..49e5242da7f 100644 --- a/sentry/api/sentry.api +++ b/sentry/api/sentry.api @@ -4360,6 +4360,7 @@ public abstract interface class io/sentry/SpanDataConvention { public static final field MESSAGING_OPERATION_TYPE Ljava/lang/String; public static final field MESSAGING_SYSTEM Ljava/lang/String; public static final field PROFILER_ID Ljava/lang/String; + public static final field SENTRY_KIND_KEY Ljava/lang/String; public static final field THREAD_ID Ljava/lang/String; public static final field THREAD_NAME Ljava/lang/String; } diff --git a/sentry/src/main/java/io/sentry/SpanDataConvention.java b/sentry/src/main/java/io/sentry/SpanDataConvention.java index 4ede74505cb..93760fb8dc4 100644 --- a/sentry/src/main/java/io/sentry/SpanDataConvention.java +++ b/sentry/src/main/java/io/sentry/SpanDataConvention.java @@ -12,6 +12,7 @@ public interface SpanDataConvention { String HTTP_FRAGMENT_KEY = "http.fragment"; String HTTP_METHOD_KEY = "http.request.method"; String HTTP_STATUS_CODE_KEY = "http.response.status_code"; + String SENTRY_KIND_KEY = "sentry.kind"; String HTTP_RESPONSE_CONTENT_LENGTH_KEY = "http.response_content_length"; String BLOCKED_MAIN_THREAD_KEY = "blocked_main_thread"; String CALL_STACK_KEY = "call_stack"; From 54d0dcae0448efa34c7d54a0c772a9e9ecf202af Mon Sep 17 00:00:00 2001 From: Alexander Dinauer Date: Thu, 12 Nov 2026 15:28:30 +0100 Subject: [PATCH 03/19] fix(spring): Omit unreliable HTTP status on escaping exceptions Avoid recording a provisional response status before the container handles an escaping exception. Preserve transaction finishing and error status, and verify omission across all three servlet integrations. Refs #6557 Co-Authored-By: Claude --- .../io/sentry/spring7/tracing/SentryTracingFilter.java | 7 ++++++- .../io/sentry/spring7/tracing/SentryTracingFilterTest.kt | 6 +++++- .../spring/boot4/integrationtest/PersonIntegrationTest.kt | 4 ++-- .../boot/jakarta/integrationtest/PersonIntegrationTest.kt | 4 ++-- .../spring/boot/integrationtest/PersonIntegrationTest.kt | 4 ++-- .../sentry/spring/jakarta/tracing/SentryTracingFilter.java | 7 ++++++- .../spring/jakarta/tracing/SentryTracingFilterTest.kt | 6 +++++- .../java/io/sentry/spring/tracing/SentryTracingFilter.java | 7 ++++++- .../io/sentry/spring/tracing/SentryTracingFilterTest.kt | 6 +++++- 9 files changed, 39 insertions(+), 12 deletions(-) diff --git a/sentry-spring-7/src/main/java/io/sentry/spring7/tracing/SentryTracingFilter.java b/sentry-spring-7/src/main/java/io/sentry/spring7/tracing/SentryTracingFilter.java index 23796f187b3..39e2fc3ec9e 100644 --- a/sentry-spring-7/src/main/java/io/sentry/spring7/tracing/SentryTracingFilter.java +++ b/sentry-spring-7/src/main/java/io/sentry/spring7/tracing/SentryTracingFilter.java @@ -140,8 +140,10 @@ private void doFilterWithTransaction( final @Nullable ITransaction transaction = getOrStartTransaction(httpRequest, transactionContext); + boolean filterChainCompleted = false; try { filterChain.doFilter(httpRequest, httpResponse); + filterChainCompleted = true; } catch (Throwable e) { if (transaction != null) { // exceptions that are not handled by Spring @@ -165,7 +167,10 @@ private void doFilterWithTransaction( if (transactionName != null) { transaction.setName(transactionName, transactionNameSource); transaction.setOperation(TRANSACTION_OP); - transaction.setData(SpanDataConvention.HTTP_STATUS_CODE_KEY, httpResponse.getStatus()); + // An escaping exception may be mapped to an HTTP status later by the container. + if (filterChainCompleted) { + transaction.setData(SpanDataConvention.HTTP_STATUS_CODE_KEY, httpResponse.getStatus()); + } // if exception has been thrown, transaction status is already set to INTERNAL_ERROR, and // httpResponse.getStatus() returns 200. if (transaction.getStatus() == null) { diff --git a/sentry-spring-7/src/test/kotlin/io/sentry/spring7/tracing/SentryTracingFilterTest.kt b/sentry-spring-7/src/test/kotlin/io/sentry/spring7/tracing/SentryTracingFilterTest.kt index cf98fdc4542..7bdb93e786a 100644 --- a/sentry-spring-7/src/test/kotlin/io/sentry/spring7/tracing/SentryTracingFilterTest.kt +++ b/sentry-spring-7/src/test/kotlin/io/sentry/spring7/tracing/SentryTracingFilterTest.kt @@ -276,7 +276,11 @@ class SentryTracingFilterTest { } catch (_: Exception) {} verify(fixture.scopes) .captureTransaction( - check { assertThat(it.status).isEqualTo(SpanStatus.INTERNAL_ERROR) }, + check { + assertThat(it.status).isEqualTo(SpanStatus.INTERNAL_ERROR) + assertThat(it.contexts.trace!!.data) + .doesNotContainKey(SpanDataConvention.HTTP_STATUS_CODE_KEY) + }, anyOrNull(), anyOrNull(), anyOrNull(), diff --git a/sentry-spring-boot-4/src/integrationTest/kotlin/io/sentry/spring/boot4/integrationtest/PersonIntegrationTest.kt b/sentry-spring-boot-4/src/integrationTest/kotlin/io/sentry/spring/boot4/integrationtest/PersonIntegrationTest.kt index afb633e66e8..23b86c38867 100644 --- a/sentry-spring-boot-4/src/integrationTest/kotlin/io/sentry/spring/boot4/integrationtest/PersonIntegrationTest.kt +++ b/sentry-spring-boot-4/src/integrationTest/kotlin/io/sentry/spring/boot4/integrationtest/PersonIntegrationTest.kt @@ -48,8 +48,8 @@ class PersonIntegrationTest : IntegrationTest() { .transaction()!! assertThat(transaction.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) .isEqualTo("server") - assertThat(transaction.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) - .isEqualTo(200) + assertThat(transaction.contexts.trace!!.data) + .doesNotContainKey(SpanDataConvention.HTTP_STATUS_CODE_KEY) assertThat( transaction.hasOp( "http.server", diff --git a/sentry-spring-boot-jakarta/src/integrationTest/kotlin/io/sentry/spring/boot/jakarta/integrationtest/PersonIntegrationTest.kt b/sentry-spring-boot-jakarta/src/integrationTest/kotlin/io/sentry/spring/boot/jakarta/integrationtest/PersonIntegrationTest.kt index 1728424fbc1..97b80afa3cc 100644 --- a/sentry-spring-boot-jakarta/src/integrationTest/kotlin/io/sentry/spring/boot/jakarta/integrationtest/PersonIntegrationTest.kt +++ b/sentry-spring-boot-jakarta/src/integrationTest/kotlin/io/sentry/spring/boot/jakarta/integrationtest/PersonIntegrationTest.kt @@ -48,8 +48,8 @@ class PersonIntegrationTest : IntegrationTest() { .transaction()!! assertThat(transaction.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) .isEqualTo("server") - assertThat(transaction.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) - .isEqualTo(200) + assertThat(transaction.contexts.trace!!.data) + .doesNotContainKey(SpanDataConvention.HTTP_STATUS_CODE_KEY) assertThat( transaction.hasOp( "http.server", diff --git a/sentry-spring-boot/src/integrationTest/kotlin/io/sentry/spring/boot/integrationtest/PersonIntegrationTest.kt b/sentry-spring-boot/src/integrationTest/kotlin/io/sentry/spring/boot/integrationtest/PersonIntegrationTest.kt index 045bfa37a96..43dd6bb5f07 100644 --- a/sentry-spring-boot/src/integrationTest/kotlin/io/sentry/spring/boot/integrationtest/PersonIntegrationTest.kt +++ b/sentry-spring-boot/src/integrationTest/kotlin/io/sentry/spring/boot/integrationtest/PersonIntegrationTest.kt @@ -48,8 +48,8 @@ class PersonIntegrationTest : IntegrationTest() { .transaction()!! assertThat(transaction.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) .isEqualTo("server") - assertThat(transaction.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) - .isEqualTo(200) + assertThat(transaction.contexts.trace!!.data) + .doesNotContainKey(SpanDataConvention.HTTP_STATUS_CODE_KEY) assertThat( transaction.hasOp( "http.server", diff --git a/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/tracing/SentryTracingFilter.java b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/tracing/SentryTracingFilter.java index 55a0cc1faeb..ddc1c25ec72 100644 --- a/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/tracing/SentryTracingFilter.java +++ b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/tracing/SentryTracingFilter.java @@ -140,8 +140,10 @@ private void doFilterWithTransaction( final @Nullable ITransaction transaction = getOrStartTransaction(httpRequest, transactionContext); + boolean filterChainCompleted = false; try { filterChain.doFilter(httpRequest, httpResponse); + filterChainCompleted = true; } catch (Throwable e) { if (transaction != null) { // exceptions that are not handled by Spring @@ -165,7 +167,10 @@ private void doFilterWithTransaction( if (transactionName != null) { transaction.setName(transactionName, transactionNameSource); transaction.setOperation(TRANSACTION_OP); - transaction.setData(SpanDataConvention.HTTP_STATUS_CODE_KEY, httpResponse.getStatus()); + // An escaping exception may be mapped to an HTTP status later by the container. + if (filterChainCompleted) { + transaction.setData(SpanDataConvention.HTTP_STATUS_CODE_KEY, httpResponse.getStatus()); + } // if exception has been thrown, transaction status is already set to INTERNAL_ERROR, and // httpResponse.getStatus() returns 200. if (transaction.getStatus() == null) { diff --git a/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/tracing/SentryTracingFilterTest.kt b/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/tracing/SentryTracingFilterTest.kt index 18d3ae096b6..376083a41b7 100644 --- a/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/tracing/SentryTracingFilterTest.kt +++ b/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/tracing/SentryTracingFilterTest.kt @@ -276,7 +276,11 @@ class SentryTracingFilterTest { } catch (_: Exception) {} verify(fixture.scopes) .captureTransaction( - check { assertThat(it.status).isEqualTo(SpanStatus.INTERNAL_ERROR) }, + check { + assertThat(it.status).isEqualTo(SpanStatus.INTERNAL_ERROR) + assertThat(it.contexts.trace!!.data) + .doesNotContainKey(SpanDataConvention.HTTP_STATUS_CODE_KEY) + }, anyOrNull(), anyOrNull(), anyOrNull(), diff --git a/sentry-spring/src/main/java/io/sentry/spring/tracing/SentryTracingFilter.java b/sentry-spring/src/main/java/io/sentry/spring/tracing/SentryTracingFilter.java index e1056690761..9a74b27c234 100644 --- a/sentry-spring/src/main/java/io/sentry/spring/tracing/SentryTracingFilter.java +++ b/sentry-spring/src/main/java/io/sentry/spring/tracing/SentryTracingFilter.java @@ -139,8 +139,10 @@ private void doFilterWithTransaction( final @Nullable ITransaction transaction = getOrStartTransaction(httpRequest, transactionContext); + boolean filterChainCompleted = false; try { filterChain.doFilter(httpRequest, httpResponse); + filterChainCompleted = true; } catch (Throwable e) { if (transaction != null) { // exceptions that are not handled by Spring @@ -164,7 +166,10 @@ private void doFilterWithTransaction( if (transactionName != null) { transaction.setName(transactionName, transactionNameSource); transaction.setOperation(TRANSACTION_OP); - transaction.setData(SpanDataConvention.HTTP_STATUS_CODE_KEY, httpResponse.getStatus()); + // An escaping exception may be mapped to an HTTP status later by the container. + if (filterChainCompleted) { + transaction.setData(SpanDataConvention.HTTP_STATUS_CODE_KEY, httpResponse.getStatus()); + } // if exception has been thrown, transaction status is already set to INTERNAL_ERROR, and // httpResponse.getStatus() returns 200. if (transaction.getStatus() == null) { diff --git a/sentry-spring/src/test/kotlin/io/sentry/spring/tracing/SentryTracingFilterTest.kt b/sentry-spring/src/test/kotlin/io/sentry/spring/tracing/SentryTracingFilterTest.kt index 5e5f689f73c..c21100e539b 100644 --- a/sentry-spring/src/test/kotlin/io/sentry/spring/tracing/SentryTracingFilterTest.kt +++ b/sentry-spring/src/test/kotlin/io/sentry/spring/tracing/SentryTracingFilterTest.kt @@ -276,7 +276,11 @@ class SentryTracingFilterTest { } catch (_: Exception) {} verify(fixture.scopes) .captureTransaction( - check { assertThat(it.status).isEqualTo(SpanStatus.INTERNAL_ERROR) }, + check { + assertThat(it.status).isEqualTo(SpanStatus.INTERNAL_ERROR) + assertThat(it.contexts.trace!!.data) + .doesNotContainKey(SpanDataConvention.HTTP_STATUS_CODE_KEY) + }, anyOrNull(), anyOrNull(), anyOrNull(), From b80bf5956dc4155b51908d424a13c44c6321c86d Mon Sep 17 00:00:00 2001 From: Alexander Dinauer Date: Wed, 11 Nov 2026 13:30:40 +0100 Subject: [PATCH 04/19] feat(core): [Ignore HTTP Status 2] Add tracing status configuration Add an unset option for ignored incoming server HTTP status codes and ranges. Parse external configuration without clearing existing values when all entries are invalid, and support Spring Boot binding across all supported versions. This PR only adds configuration surfaces; filtering remains unchanged. Refs #4735 --- .../boot4/SentryAutoConfigurationTest.kt | 17 +++++ .../jakarta/SentryAutoConfigurationTest.kt | 17 +++++ .../boot/SentryAutoConfigurationTest.kt | 17 +++++ sentry/api/sentry.api | 5 ++ .../main/java/io/sentry/ExternalOptions.java | 35 ++++++++++ .../java/io/sentry/HttpStatusCodeRange.java | 58 +++++++++++++++ .../main/java/io/sentry/SentryOptions.java | 31 ++++++++ .../java/io/sentry/ExternalOptionsTest.kt | 70 +++++++++++++++++++ .../java/io/sentry/HttpStatusCodeRangeTest.kt | 43 ++++++++++++ .../test/java/io/sentry/SentryOptionsTest.kt | 47 +++++++++++++ 10 files changed, 340 insertions(+) diff --git a/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryAutoConfigurationTest.kt b/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryAutoConfigurationTest.kt index 7360e732da7..41f60072cb8 100644 --- a/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryAutoConfigurationTest.kt +++ b/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryAutoConfigurationTest.kt @@ -263,6 +263,7 @@ class SentryAutoConfigurationTest { "sentry.ignored-checkins=slug1,slugB", "sentry.ignored-errors=Some error,Another .*", "sentry.ignored-transactions=transactionName1,transactionNameB", + "sentry.trace-ignore-status-codes=404,500-599", "sentry.enable-backpressure-handling=false", "sentry.enable-database-transaction-tracing=true", "sentry.enable-cache-tracing=true", @@ -316,6 +317,10 @@ class SentryAutoConfigurationTest { assertThat(options.ignoredCheckIns).containsOnly("slug1", "slugB") assertThat(options.ignoredErrors).containsOnly("Some error", "Another .*") assertThat(options.ignoredTransactions).containsOnly("transactionName1", "transactionNameB") + assertThat(options.traceIgnoreStatusCodes).hasSize(2) + assertThat(options.traceIgnoreStatusCodes!![0].isInRange(404)).isTrue() + assertThat(options.traceIgnoreStatusCodes!![1].isInRange(500)).isTrue() + assertThat(options.traceIgnoreStatusCodes!![1].isInRange(599)).isTrue() assertThat(options.isEnableBackpressureHandling).isEqualTo(false) assertThat(options.isEnableDatabaseTransactionTracing).isEqualTo(true) assertThat(options.isEnableCacheTracing).isEqualTo(true) @@ -336,6 +341,18 @@ class SentryAutoConfigurationTest { } } + @Test + fun `empty ignored server HTTP status codes disable the configuration`() { + contextRunner + .withPropertyValues( + "sentry.dsn=http://key@localhost/proj", + "sentry.trace-ignore-status-codes=", + ) + .run { + assertThat(it.getBean(SentryProperties::class.java).traceIgnoreStatusCodes).isEmpty() + } + } + @Test fun `data collection properties are applied to SentryOptions`() { contextRunner diff --git a/sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryAutoConfigurationTest.kt b/sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryAutoConfigurationTest.kt index fc2dd676ec3..7dd5f7d92d9 100644 --- a/sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryAutoConfigurationTest.kt +++ b/sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryAutoConfigurationTest.kt @@ -266,6 +266,7 @@ class SentryAutoConfigurationTest { "sentry.ignored-checkins=slug1,slugB", "sentry.ignored-errors=Some error,Another .*", "sentry.ignored-transactions=transactionName1,transactionNameB", + "sentry.trace-ignore-status-codes=404,500-599", "sentry.enable-backpressure-handling=false", "sentry.enable-database-transaction-tracing=true", "sentry.enable-spotlight=true", @@ -321,6 +322,10 @@ class SentryAutoConfigurationTest { assertThat(options.ignoredCheckIns).containsOnly("slug1", "slugB") assertThat(options.ignoredErrors).containsOnly("Some error", "Another .*") assertThat(options.ignoredTransactions).containsOnly("transactionName1", "transactionNameB") + assertThat(options.traceIgnoreStatusCodes).hasSize(2) + assertThat(options.traceIgnoreStatusCodes!![0].isInRange(404)).isTrue() + assertThat(options.traceIgnoreStatusCodes!![1].isInRange(500)).isTrue() + assertThat(options.traceIgnoreStatusCodes!![1].isInRange(599)).isTrue() assertThat(options.isEnableBackpressureHandling).isEqualTo(false) assertThat(options.isEnableDatabaseTransactionTracing).isEqualTo(true) assertThat(options.isForceInit).isEqualTo(true) @@ -344,6 +349,18 @@ class SentryAutoConfigurationTest { } } + @Test + fun `empty ignored server HTTP status codes disable the configuration`() { + contextRunner + .withPropertyValues( + "sentry.dsn=http://key@localhost/proj", + "sentry.trace-ignore-status-codes=", + ) + .run { + assertThat(it.getBean(SentryProperties::class.java).traceIgnoreStatusCodes).isEmpty() + } + } + @Test fun `data collection properties are applied to SentryOptions`() { contextRunner diff --git a/sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryAutoConfigurationTest.kt b/sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryAutoConfigurationTest.kt index 28b190de232..cbb06d39e01 100644 --- a/sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryAutoConfigurationTest.kt +++ b/sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryAutoConfigurationTest.kt @@ -264,6 +264,7 @@ class SentryAutoConfigurationTest { "sentry.ignored-checkins=slug1,slugB", "sentry.ignored-errors=Some error,Another .*", "sentry.ignored-transactions=transactionName1,transactionNameB", + "sentry.trace-ignore-status-codes=404,500-599", "sentry.enable-backpressure-handling=false", "sentry.enable-database-transaction-tracing=true", "sentry.enable-spotlight=true", @@ -319,6 +320,10 @@ class SentryAutoConfigurationTest { assertThat(options.ignoredCheckIns).containsOnly("slug1", "slugB") assertThat(options.ignoredErrors).containsOnly("Some error", "Another .*") assertThat(options.ignoredTransactions).containsOnly("transactionName1", "transactionNameB") + assertThat(options.traceIgnoreStatusCodes).hasSize(2) + assertThat(options.traceIgnoreStatusCodes!![0].isInRange(404)).isTrue() + assertThat(options.traceIgnoreStatusCodes!![1].isInRange(500)).isTrue() + assertThat(options.traceIgnoreStatusCodes!![1].isInRange(599)).isTrue() assertThat(options.isEnableBackpressureHandling).isEqualTo(false) assertThat(options.isEnableDatabaseTransactionTracing).isEqualTo(true) assertThat(options.isForceInit).isEqualTo(true) @@ -342,6 +347,18 @@ class SentryAutoConfigurationTest { } } + @Test + fun `empty ignored server HTTP status codes disable the configuration`() { + contextRunner + .withPropertyValues( + "sentry.dsn=http://key@localhost/proj", + "sentry.trace-ignore-status-codes=", + ) + .run { + assertThat(it.getBean(SentryProperties::class.java).traceIgnoreStatusCodes).isEmpty() + } + } + @Test fun `data collection properties are applied to SentryOptions`() { contextRunner diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api index 49e5242da7f..132fd7c56c4 100644 --- a/sentry/api/sentry.api +++ b/sentry/api/sentry.api @@ -587,6 +587,7 @@ public final class io/sentry/ExternalOptions { public fun getShutdownTimeoutMillis ()Ljava/lang/Long; public fun getSpotlightConnectionUrl ()Ljava/lang/String; public fun getTags ()Ljava/util/Map; + public fun getTraceIgnoreStatusCodes ()Ljava/util/List; public fun getTracePropagationTargets ()Ljava/util/List; public fun getTracesSampleRate ()Ljava/lang/Double; public fun isCaptureOpenTelemetryEvents ()Ljava/lang/Boolean; @@ -644,6 +645,7 @@ public final class io/sentry/ExternalOptions { public fun setSpotlightConnectionUrl (Ljava/lang/String;)V public fun setStrictTraceContinuation (Ljava/lang/Boolean;)V public fun setTag (Ljava/lang/String;Ljava/lang/String;)V + public fun setTraceIgnoreStatusCodes (Ljava/util/List;)V public fun setTracesSampleRate (Ljava/lang/Double;)V } @@ -710,6 +712,7 @@ public final class io/sentry/HttpStatusCodeRange { public fun (I)V public fun (II)V public fun isInRange (I)Z + public static fun valueOf (Ljava/lang/String;)Lio/sentry/HttpStatusCodeRange; } public abstract interface class io/sentry/IAppStartExtender { @@ -3616,6 +3619,7 @@ public class io/sentry/SentryOptions : io/sentry/transport/RateLimiterConfig { public fun getTags ()Ljava/util/Map; public fun getThreadChecker ()Lio/sentry/util/thread/IThreadChecker; public fun getTimerExecutorService ()Lio/sentry/ISentryExecutorService; + public fun getTraceIgnoreStatusCodes ()Ljava/util/List; public fun getTracePropagationTargets ()Ljava/util/List; public fun getTracesSampleRate ()Ljava/lang/Double; public fun getTracesSampler ()Lio/sentry/SentryOptions$TracesSamplerCallback; @@ -3785,6 +3789,7 @@ public class io/sentry/SentryOptions : io/sentry/transport/RateLimiterConfig { public fun setTag (Ljava/lang/String;Ljava/lang/String;)V public fun setThreadChecker (Lio/sentry/util/thread/IThreadChecker;)V public fun setTimerExecutorService (Lio/sentry/ISentryExecutorService;)V + public fun setTraceIgnoreStatusCodes (Ljava/util/List;)V public fun setTraceOptionsRequests (Z)V public fun setTracePropagationTargets (Ljava/util/List;)V public fun setTraceSampling (Z)V diff --git a/sentry/src/main/java/io/sentry/ExternalOptions.java b/sentry/src/main/java/io/sentry/ExternalOptions.java index efeb005f7b5..4610a5cd31f 100644 --- a/sentry/src/main/java/io/sentry/ExternalOptions.java +++ b/sentry/src/main/java/io/sentry/ExternalOptions.java @@ -50,6 +50,7 @@ public final class ExternalOptions { private @Nullable List ignoredCheckIns; private @Nullable List ignoredTransactions; + private @Nullable List traceIgnoreStatusCodes; private @Nullable Boolean sendModules; private @Nullable Boolean sendDefaultPii; @@ -160,6 +161,7 @@ public final class ExternalOptions { options.setIgnoredCheckIns(propertiesProvider.getListOrNull("ignored-checkins")); options.setIgnoredTransactions(propertiesProvider.getListOrNull("ignored-transactions")); + options.setTraceIgnoreStatusCodes(parseTraceIgnoreStatusCodes(propertiesProvider, logger)); options.setEnableBackpressureHandling( propertiesProvider.getBooleanProperty("enable-backpressure-handling")); @@ -243,6 +245,30 @@ public final class ExternalOptions { return options; } + private static @Nullable List parseTraceIgnoreStatusCodes( + final @NotNull PropertiesProvider propertiesProvider, final @NotNull ILogger logger) { + final String value = propertiesProvider.getProperty("trace-ignore-status-codes"); + if (value == null) { + return null; + } + if (value.trim().isEmpty()) { + return new ArrayList<>(); + } + + final List ranges = new ArrayList<>(); + for (final String token : value.split(",", -1)) { + try { + ranges.add(HttpStatusCodeRange.valueOf(token)); + } catch (IllegalArgumentException e) { + logger.log( + SentryLevel.WARNING, + "Ignoring invalid HTTP status code range in trace-ignore-status-codes: %s", + token); + } + } + return ranges.isEmpty() ? null : ranges; + } + private static @Nullable DataCollection parseDataCollection( final @NotNull PropertiesProvider propertiesProvider) { final DataCollection dataCollection = new DataCollection(); @@ -622,6 +648,15 @@ public void setIgnoredTransactions(final @Nullable List ignoredTransacti return ignoredTransactions; } + public void setTraceIgnoreStatusCodes( + final @Nullable List traceIgnoreStatusCodes) { + this.traceIgnoreStatusCodes = traceIgnoreStatusCodes; + } + + public @Nullable List getTraceIgnoreStatusCodes() { + return traceIgnoreStatusCodes; + } + public void setEnableBackpressureHandling(final @Nullable Boolean enableBackpressureHandling) { this.enableBackpressureHandling = enableBackpressureHandling; } diff --git a/sentry/src/main/java/io/sentry/HttpStatusCodeRange.java b/sentry/src/main/java/io/sentry/HttpStatusCodeRange.java index 690ab115c5c..be56ab2154e 100644 --- a/sentry/src/main/java/io/sentry/HttpStatusCodeRange.java +++ b/sentry/src/main/java/io/sentry/HttpStatusCodeRange.java @@ -1,5 +1,8 @@ package io.sentry; +import org.jetbrains.annotations.ApiStatus; +import org.jetbrains.annotations.NotNull; + /** * The Http status code range. Example for a range: 400 to 499, 500 to 599, 400 to 599 The range is * inclusive so the min and max is considered part of the range. @@ -10,6 +13,9 @@ public final class HttpStatusCodeRange { public static final int DEFAULT_MIN = 500; public static final int DEFAULT_MAX = 599; + private static final int MIN_HTTP_STATUS_CODE = 100; + private static final int MAX_HTTP_STATUS_CODE = 599; + private final int min; private final int max; @@ -23,6 +29,58 @@ public HttpStatusCodeRange(final int statusCode) { this.max = statusCode; } + /** + * Parses a single HTTP status code or an inclusive range such as {@code 404} or {@code 500-599}. + * + * @param value the status code or range + * @return the parsed range + * @throws IllegalArgumentException if the value is malformed, outside 100-599, or reversed + */ + @ApiStatus.Internal + public static @NotNull HttpStatusCodeRange valueOf(final @NotNull String value) { + final String trimmedValue = value.trim(); + final int separatorIndex = trimmedValue.indexOf('-'); + if (separatorIndex < 0) { + return new HttpStatusCodeRange(parseStatusCode(trimmedValue)); + } + if (separatorIndex == 0 + || separatorIndex == trimmedValue.length() - 1 + || separatorIndex != trimmedValue.lastIndexOf('-')) { + throw invalidRange(value); + } + + final int min = parseStatusCode(trimmedValue.substring(0, separatorIndex).trim()); + final int max = parseStatusCode(trimmedValue.substring(separatorIndex + 1).trim()); + if (min > max) { + throw invalidRange(value); + } + return new HttpStatusCodeRange(min, max); + } + + private static int parseStatusCode(final @NotNull String value) { + for (int i = 0; i < value.length(); i++) { + if (!Character.isDigit(value.charAt(i))) { + throw invalidRange(value); + } + } + + final int statusCode; + try { + statusCode = Integer.parseInt(value); + } catch (NumberFormatException e) { + throw invalidRange(value); + } + if (statusCode < MIN_HTTP_STATUS_CODE || statusCode > MAX_HTTP_STATUS_CODE) { + throw invalidRange(value); + } + return statusCode; + } + + private static @NotNull IllegalArgumentException invalidRange(final @NotNull String value) { + return new IllegalArgumentException( + "HTTP status code range must contain values from 100 to 599: " + value); + } + public boolean isInRange(final int statusCode) { return statusCode >= min && statusCode <= max; } diff --git a/sentry/src/main/java/io/sentry/SentryOptions.java b/sentry/src/main/java/io/sentry/SentryOptions.java index 71dd4588e33..efbc0de9ae0 100644 --- a/sentry/src/main/java/io/sentry/SentryOptions.java +++ b/sentry/src/main/java/io/sentry/SentryOptions.java @@ -598,6 +598,8 @@ public class SentryOptions implements RateLimiterConfig { */ private @Nullable List ignoredTransactions = null; + private @Nullable List traceIgnoreStatusCodes = null; + @ApiStatus.Experimental private @NotNull IBackpressureMonitor backpressureMonitor = NoOpBackpressureMonitor.getInstance(); @@ -3147,6 +3149,32 @@ public void setIgnoredTransactions(final @Nullable List ignoredTransacti } } + /** + * Returns the HTTP status codes and inclusive ranges for which incoming server transactions are + * not sent to Sentry. An empty list disables this filter. + * + * @return the configured HTTP status code ranges, or {@code null} if unset + */ + public @Nullable List getTraceIgnoreStatusCodes() { + return traceIgnoreStatusCodes; + } + + /** + * Sets the HTTP status codes and inclusive ranges for which incoming server transactions are not + * sent to Sentry. For example, configure {@code new HttpStatusCodeRange(404)} for one status or + * {@code new HttpStatusCodeRange(500, 599)} for an inclusive range. External configuration + * accepts comma-separated codes and ranges such as {@code 404,410,500-599}. An empty list + * disables this filter. + * + * @param traceIgnoreStatusCodes the HTTP status code ranges, or {@code null} to leave the option + * unset + */ + public void setTraceIgnoreStatusCodes( + final @Nullable List traceIgnoreStatusCodes) { + this.traceIgnoreStatusCodes = + traceIgnoreStatusCodes == null ? null : new ArrayList<>(traceIgnoreStatusCodes); + } + /** Returns the current {@link SentryDateProvider} that is used to retrieve the current date. */ @ApiStatus.Internal public @NotNull SentryDateProvider getDateProvider() { @@ -3823,6 +3851,9 @@ public void merge(final @NotNull ExternalOptions options) { final List ignoredTransactions = new ArrayList<>(options.getIgnoredTransactions()); setIgnoredTransactions(ignoredTransactions); } + if (options.getTraceIgnoreStatusCodes() != null) { + setTraceIgnoreStatusCodes(options.getTraceIgnoreStatusCodes()); + } if (options.getIgnoredErrors() != null) { final List ignoredExceptions = new ArrayList<>(options.getIgnoredErrors()); setIgnoredErrors(ignoredExceptions); diff --git a/sentry/src/test/java/io/sentry/ExternalOptionsTest.kt b/sentry/src/test/java/io/sentry/ExternalOptionsTest.kt index 349058e4b3b..bd767dc1ce8 100644 --- a/sentry/src/test/java/io/sentry/ExternalOptionsTest.kt +++ b/sentry/src/test/java/io/sentry/ExternalOptionsTest.kt @@ -14,6 +14,7 @@ import org.junit.rules.TemporaryFolder import org.mockito.kotlin.any import org.mockito.kotlin.eq import org.mockito.kotlin.mock +import org.mockito.kotlin.times import org.mockito.kotlin.verify class ExternalOptionsTest { @@ -408,6 +409,75 @@ class ExternalOptionsTest { withPropertiesFile("Another .*", logger) { options -> assertNull(options.ignoredTransactions) } } + @Test + fun `ignored server HTTP status codes are null if missing`() { + withPropertiesFile { assertThat(it.traceIgnoreStatusCodes).isNull() } + } + + @Test + fun `creates empty ignored server HTTP status codes from empty input`() { + withPropertiesFile("trace-ignore-status-codes=") { + assertThat(it.traceIgnoreStatusCodes).isEmpty() + } + } + + @Test + fun `creates ignored server HTTP status codes and ranges`() { + withPropertiesFile("trace-ignore-status-codes=404, 410 , 500-599") { options -> + val ranges = options.traceIgnoreStatusCodes + assertThat(ranges).hasSize(3) + assertThat(ranges!![0].isInRange(404)).isTrue() + assertThat(ranges[1].isInRange(410)).isTrue() + assertThat(ranges[2].isInRange(500)).isTrue() + assertThat(ranges[2].isInRange(599)).isTrue() + } + } + + @Test + fun `ignores invalid entries while preserving valid ignored server HTTP status codes`() { + val logger = mock() + withPropertiesFile( + "trace-ignore-status-codes=404,invalid,600,500-400", + logger, + ) { options -> + val ranges = options.traceIgnoreStatusCodes + assertThat(ranges).hasSize(1) + assertThat(ranges!![0].isInRange(404)).isTrue() + } + verify(logger, times(3)).log(eq(SentryLevel.WARNING), any(), any()) + } + + @Test + fun `all invalid ignored server HTTP status codes leave existing configuration unchanged`() { + withPropertiesFile("trace-ignore-status-codes=invalid,600,500-400") { externalOptions -> + assertThat(externalOptions.traceIgnoreStatusCodes).isNull() + + val options = + SentryOptions().apply { + traceIgnoreStatusCodes = listOf(HttpStatusCodeRange(410)) + } + options.merge(externalOptions) + + assertThat(options.traceIgnoreStatusCodes).hasSize(1) + assertThat(options.traceIgnoreStatusCodes!![0].isInRange(410)).isTrue() + } + } + + @Test + fun `system property takes precedence for ignored server HTTP status codes`() { + System.setProperty("sentry.trace-ignore-status-codes", "410") + try { + withPropertiesFile("trace-ignore-status-codes=404") { options -> + val ranges = options.traceIgnoreStatusCodes + assertThat(ranges).hasSize(1) + assertThat(ranges!![0].isInRange(410)).isTrue() + assertThat(ranges[0].isInRange(404)).isFalse() + } + } finally { + System.clearProperty("sentry.trace-ignore-status-codes") + } + } + @Test fun `creates options with enableBackpressureHandling set to false`() { withPropertiesFile("enable-backpressure-handling=false") { options -> diff --git a/sentry/src/test/java/io/sentry/HttpStatusCodeRangeTest.kt b/sentry/src/test/java/io/sentry/HttpStatusCodeRangeTest.kt index b50806b0a00..fc9f4801606 100644 --- a/sentry/src/test/java/io/sentry/HttpStatusCodeRangeTest.kt +++ b/sentry/src/test/java/io/sentry/HttpStatusCodeRangeTest.kt @@ -1,6 +1,7 @@ package io.sentry import kotlin.test.Test +import kotlin.test.assertFailsWith import kotlin.test.assertFalse import kotlin.test.assertTrue @@ -53,4 +54,46 @@ class HttpStatusCodeRangeTest { assertFalse(range.isInRange(600)) } + + @Test + fun `parses a single status code`() { + val range = HttpStatusCodeRange.valueOf("404") + + assertTrue(range.isInRange(404)) + assertFalse(range.isInRange(405)) + } + + @Test + fun `parses an inclusive range with whitespace`() { + val range = HttpStatusCodeRange.valueOf(" 500 - 599 ") + + assertTrue(range.isInRange(500)) + assertTrue(range.isInRange(599)) + assertFalse(range.isInRange(499)) + } + + @Test + fun `parses HTTP status boundaries`() { + assertTrue(HttpStatusCodeRange.valueOf("100-599").isInRange(100)) + assertTrue(HttpStatusCodeRange.valueOf("100-599").isInRange(599)) + } + + @Test + fun `rejects malformed ranges`() { + listOf("", "invalid", "+404", "404-", "-404", "400-499-599").forEach { + assertFailsWith { HttpStatusCodeRange.valueOf(it) } + } + } + + @Test + fun `rejects reversed ranges`() { + assertFailsWith { HttpStatusCodeRange.valueOf("500-400") } + } + + @Test + fun `rejects status codes outside HTTP range`() { + listOf("99", "600", "99-200", "500-600").forEach { + assertFailsWith { HttpStatusCodeRange.valueOf(it) } + } + } } diff --git a/sentry/src/test/java/io/sentry/SentryOptionsTest.kt b/sentry/src/test/java/io/sentry/SentryOptionsTest.kt index 2a33e9b53f1..b1fe1242642 100644 --- a/sentry/src/test/java/io/sentry/SentryOptionsTest.kt +++ b/sentry/src/test/java/io/sentry/SentryOptionsTest.kt @@ -570,6 +570,8 @@ class SentryOptionsTest { externalOptions.isSendModules = false externalOptions.ignoredCheckIns = listOf("slug1", "slug-B") externalOptions.ignoredTransactions = listOf("transactionName1", "transaction-name-B") + externalOptions.traceIgnoreStatusCodes = + listOf(HttpStatusCodeRange(404), HttpStatusCodeRange(500, 599)) externalOptions.ignoredErrors = listOf("Some error", "Another .*") externalOptions.isEnableBackpressureHandling = false externalOptions.isEnableDatabaseTransactionTracing = true @@ -631,6 +633,10 @@ class SentryOptionsTest { listOf("transactionName1", "transaction-name-B"), options.ignoredTransactions, ) + assertThat(options.traceIgnoreStatusCodes).hasSize(2) + assertThat(options.traceIgnoreStatusCodes!![0].isInRange(404)).isTrue() + assertThat(options.traceIgnoreStatusCodes!![1].isInRange(500)).isTrue() + assertThat(options.traceIgnoreStatusCodes!![1].isInRange(599)).isTrue() assertEquals( listOf("Some error", "Another .*"), options.ignoredErrors, @@ -1081,6 +1087,47 @@ class SentryOptionsTest { assertNull(options.ignoredSpanOrigins) } + @Test + fun `ignored server HTTP status codes for tracing are unset by default`() { + assertNull(SentryOptions().traceIgnoreStatusCodes) + } + + @Test + fun `ignored server HTTP status code setter preserves empty and custom ranges`() { + val options = SentryOptions() + + options.traceIgnoreStatusCodes = emptyList() + assertThat(options.traceIgnoreStatusCodes).isEmpty() + + options.traceIgnoreStatusCodes = listOf(HttpStatusCodeRange(404), HttpStatusCodeRange(500, 599)) + assertThat(options.traceIgnoreStatusCodes).hasSize(2) + assertThat(options.traceIgnoreStatusCodes!![0].isInRange(404)).isTrue() + assertThat(options.traceIgnoreStatusCodes!![1].isInRange(599)).isTrue() + } + + @Test + fun `merging empty ignored server HTTP status codes replaces the previous value`() { + val externalOptions = ExternalOptions() + externalOptions.traceIgnoreStatusCodes = emptyList() + val options = SentryOptions() + options.traceIgnoreStatusCodes = listOf(HttpStatusCodeRange(404)) + + options.merge(externalOptions) + + assertThat(options.traceIgnoreStatusCodes).isEmpty() + } + + @Test + fun `merging options when ignored server HTTP status codes are not set preserves previous value`() { + val options = SentryOptions() + options.traceIgnoreStatusCodes = listOf(HttpStatusCodeRange(410)) + + options.merge(ExternalOptions()) + + assertThat(options.traceIgnoreStatusCodes).hasSize(1) + assertThat(options.traceIgnoreStatusCodes!![0].isInRange(410)).isTrue() + } + @Test fun `merging options when ignoredErrors is not set preserves the previous value`() { val externalOptions = ExternalOptions() From a018c6830fd6a7e19addb2a7c401bb0c20d72892 Mon Sep 17 00:00:00 2001 From: Alexander Dinauer Date: Wed, 11 Nov 2026 16:16:52 +0100 Subject: [PATCH 05/19] feat(tracing): Filter configured incoming HTTP statuses Drop completed incoming server HTTP transactions when their root response status matches a configured range. Preserve lifecycle finalization while skipping processors, callbacks, envelope creation, and replay registration for filtered transactions. Record transaction, span, and profile losses, clean up temporary profile traces, and cover Spring Boot servlet and WebFlux integrations. Fixes #4735 --- CHANGELOG.md | 33 ++++ .../boot4/integrationtest/IntegrationTest.kt | 1 + .../integrationtest/PersonIntegrationTest.kt | 11 ++ .../PersonWebfluxIntegrationTest.kt | 11 ++ .../WebfluxIntegrationTest.kt | 1 + .../integrationtest/IntegrationTest.kt | 1 + .../integrationtest/PersonIntegrationTest.kt | 11 ++ .../PersonWebfluxIntegrationTest.kt | 11 ++ .../WebfluxIntegrationTest.kt | 1 + sentry-spring-boot/README.md | 13 ++ .../boot/integrationtest/IntegrationTest.kt | 1 + .../integrationtest/PersonIntegrationTest.kt | 11 ++ .../PersonWebfluxIntegrationTest.kt | 11 ++ .../WebfluxIntegrationTest.kt | 1 + .../src/main/java/io/sentry/SentryClient.java | 90 ++++++++++ .../test/java/io/sentry/SentryClientTest.kt | 165 +++++++++++++++++- .../test/java/io/sentry/SentryTracerTest.kt | 28 +++ 17 files changed, 400 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index a3d0cec6fc1..aef807a4725 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -67,6 +67,39 @@ ### Features +- Drop incoming server transactions whose root HTTP response status matches `traceIgnoreStatusCodes`. Configure individual statuses such as `404`, inclusive ranges such as `400-499` or `500-599`, or combine them. + + Java: + + ```java + import io.sentry.HttpStatusCodeRange; + import java.util.Arrays; + + options.setTraceIgnoreStatusCodes( + Arrays.asList(new HttpStatusCodeRange(404), new HttpStatusCodeRange(500, 599))); + ``` + + `sentry.properties`: + + ```properties + trace-ignore-status-codes=404,500-599 + ``` + + Spring Boot `application.properties`: + + ```properties + sentry.trace-ignore-status-codes=404,500-599 + ``` + + Spring Boot `application.yml`: + + ```yaml + sentry: + trace-ignore-status-codes: + - "404" + - "500-599" + ``` + - Monitor every Spring `@Scheduled` method with Sentry Crons by setting `sentry.monitor-scheduled-tasks=true`, without adding `@SentryCheckIn` to each method. Sentry creates each monitor from the method's `@Scheduled` schedule. Exclude methods with `sentry.exclude-scheduled-tasks` ([#6275](https://github.com/getsentry/sentry-java/pull/6275), [#6276](https://github.com/getsentry/sentry-java/pull/6276), [#6277](https://github.com/getsentry/sentry-java/pull/6277)) - Quartz `SentryJobListener` can send a monitor config derived from the trigger with check-ins, so Sentry creates or updates the monitor from code. Set the `sentry-upsert-monitor-config` job or trigger data key to `"true"` to send the schedule ([#6216](https://github.com/getsentry/sentry-java/pull/6216)) - Send a monitor config derived from Spring `@Scheduled` with `@SentryCheckIn` check-ins, so Sentry creates or updates the monitor from code. Set `@SentryCheckIn(upsertMonitorConfig = true)` to send the schedule ([#6215](https://github.com/getsentry/sentry-java/pull/6215)) diff --git a/sentry-spring-boot-4/src/integrationTest/kotlin/io/sentry/spring/boot4/integrationtest/IntegrationTest.kt b/sentry-spring-boot-4/src/integrationTest/kotlin/io/sentry/spring/boot4/integrationtest/IntegrationTest.kt index f61ad6c3826..ed7c9965864 100644 --- a/sentry-spring-boot-4/src/integrationTest/kotlin/io/sentry/spring/boot4/integrationtest/IntegrationTest.kt +++ b/sentry-spring-boot-4/src/integrationTest/kotlin/io/sentry/spring/boot4/integrationtest/IntegrationTest.kt @@ -29,6 +29,7 @@ import org.springframework.test.context.junit4.SpringRunner properties = [ "sentry.traces-sample-rate=1.0", + "sentry.trace-ignore-status-codes=404", "sentry.clients.ok-http-enabled=true", "sentry.enable-cache-tracing=true", "sentry.enable-queue-tracing=true", diff --git a/sentry-spring-boot-4/src/integrationTest/kotlin/io/sentry/spring/boot4/integrationtest/PersonIntegrationTest.kt b/sentry-spring-boot-4/src/integrationTest/kotlin/io/sentry/spring/boot4/integrationtest/PersonIntegrationTest.kt index afb633e66e8..ee18a3b7233 100644 --- a/sentry-spring-boot-4/src/integrationTest/kotlin/io/sentry/spring/boot4/integrationtest/PersonIntegrationTest.kt +++ b/sentry-spring-boot-4/src/integrationTest/kotlin/io/sentry/spring/boot4/integrationtest/PersonIntegrationTest.kt @@ -102,6 +102,17 @@ class PersonIntegrationTest : IntegrationTest() { .isTrue() } + @Test + fun `configured not found response does not send a transaction`() { + val path = "/missing-ignored-status" + + val response = restTemplate.getForEntity(path, String::class.java) + + assertThat(response.statusCode.value()).isEqualTo(404) + Sentry.flush(5000) + server.assertNoEnvelope { it.transaction()?.request?.url?.endsWith(path) == true } + } + @Test fun `creating a person starts a profile linked to the transaction`() { val response = diff --git a/sentry-spring-boot-4/src/integrationTestWebflux/kotlin/io/sentry/spring/boot4/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt b/sentry-spring-boot-4/src/integrationTestWebflux/kotlin/io/sentry/spring/boot4/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt index 15aab17c410..7af3dbcfdf4 100644 --- a/sentry-spring-boot-4/src/integrationTestWebflux/kotlin/io/sentry/spring/boot4/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt +++ b/sentry-spring-boot-4/src/integrationTestWebflux/kotlin/io/sentry/spring/boot4/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt @@ -66,6 +66,17 @@ class PersonWebfluxIntegrationTest : WebfluxIntegrationTest() { .isEqualTo(200) } + @Test + fun `configured not found response does not send a transaction`() { + val path = "/missing-ignored-status" + + val response = restTemplate.getForEntity(path, String::class.java) + + assertThat(response.statusCode.value()).isEqualTo(404) + Sentry.flush(5000) + server.assertNoEnvelope { it.transaction()?.request?.url?.endsWith(path) == true } + } + @Test fun `creating a person starts a profile linked to the transaction`() { val response = diff --git a/sentry-spring-boot-4/src/integrationTestWebflux/kotlin/io/sentry/spring/boot4/webfluxintegrationtest/WebfluxIntegrationTest.kt b/sentry-spring-boot-4/src/integrationTestWebflux/kotlin/io/sentry/spring/boot4/webfluxintegrationtest/WebfluxIntegrationTest.kt index 360dcbb1617..d510cc6625a 100644 --- a/sentry-spring-boot-4/src/integrationTestWebflux/kotlin/io/sentry/spring/boot4/webfluxintegrationtest/WebfluxIntegrationTest.kt +++ b/sentry-spring-boot-4/src/integrationTestWebflux/kotlin/io/sentry/spring/boot4/webfluxintegrationtest/WebfluxIntegrationTest.kt @@ -26,6 +26,7 @@ import org.springframework.test.context.junit4.SpringRunner properties = [ "sentry.traces-sample-rate=1.0", + "sentry.trace-ignore-status-codes=404", "sentry.enable-cache-tracing=true", "sentry.logs.enabled=true", "sentry.reactive.thread-local-accessor-enabled=true", diff --git a/sentry-spring-boot-jakarta/src/integrationTest/kotlin/io/sentry/spring/boot/jakarta/integrationtest/IntegrationTest.kt b/sentry-spring-boot-jakarta/src/integrationTest/kotlin/io/sentry/spring/boot/jakarta/integrationtest/IntegrationTest.kt index d539470ae93..5b247e5a792 100644 --- a/sentry-spring-boot-jakarta/src/integrationTest/kotlin/io/sentry/spring/boot/jakarta/integrationtest/IntegrationTest.kt +++ b/sentry-spring-boot-jakarta/src/integrationTest/kotlin/io/sentry/spring/boot/jakarta/integrationtest/IntegrationTest.kt @@ -29,6 +29,7 @@ import org.springframework.test.context.junit4.SpringRunner properties = [ "sentry.traces-sample-rate=1.0", + "sentry.trace-ignore-status-codes=404", "sentry.clients.ok-http-enabled=true", "sentry.enable-cache-tracing=true", "sentry.enable-queue-tracing=true", diff --git a/sentry-spring-boot-jakarta/src/integrationTest/kotlin/io/sentry/spring/boot/jakarta/integrationtest/PersonIntegrationTest.kt b/sentry-spring-boot-jakarta/src/integrationTest/kotlin/io/sentry/spring/boot/jakarta/integrationtest/PersonIntegrationTest.kt index 1728424fbc1..919034786d6 100644 --- a/sentry-spring-boot-jakarta/src/integrationTest/kotlin/io/sentry/spring/boot/jakarta/integrationtest/PersonIntegrationTest.kt +++ b/sentry-spring-boot-jakarta/src/integrationTest/kotlin/io/sentry/spring/boot/jakarta/integrationtest/PersonIntegrationTest.kt @@ -102,6 +102,17 @@ class PersonIntegrationTest : IntegrationTest() { .isTrue() } + @Test + fun `configured not found response does not send a transaction`() { + val path = "/missing-ignored-status" + + val response = restTemplate.getForEntity(path, String::class.java) + + assertThat(response.statusCode.value()).isEqualTo(404) + Sentry.flush(5000) + server.assertNoEnvelope { it.transaction()?.request?.url?.endsWith(path) == true } + } + @Test fun `creating a person starts a profile linked to the transaction`() { val response = diff --git a/sentry-spring-boot-jakarta/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/jakarta/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt b/sentry-spring-boot-jakarta/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/jakarta/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt index 662ffc961dc..f437453e3b7 100644 --- a/sentry-spring-boot-jakarta/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/jakarta/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt +++ b/sentry-spring-boot-jakarta/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/jakarta/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt @@ -66,6 +66,17 @@ class PersonWebfluxIntegrationTest : WebfluxIntegrationTest() { .isEqualTo(200) } + @Test + fun `configured not found response does not send a transaction`() { + val path = "/missing-ignored-status" + + val response = restTemplate.getForEntity(path, String::class.java) + + assertThat(response.statusCode.value()).isEqualTo(404) + Sentry.flush(5000) + server.assertNoEnvelope { it.transaction()?.request?.url?.endsWith(path) == true } + } + @Test fun `creating a person starts a profile linked to the transaction`() { val response = diff --git a/sentry-spring-boot-jakarta/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/jakarta/webfluxintegrationtest/WebfluxIntegrationTest.kt b/sentry-spring-boot-jakarta/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/jakarta/webfluxintegrationtest/WebfluxIntegrationTest.kt index 4d314719e35..d11d38ff0b7 100644 --- a/sentry-spring-boot-jakarta/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/jakarta/webfluxintegrationtest/WebfluxIntegrationTest.kt +++ b/sentry-spring-boot-jakarta/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/jakarta/webfluxintegrationtest/WebfluxIntegrationTest.kt @@ -26,6 +26,7 @@ import org.springframework.test.context.junit4.SpringRunner properties = [ "sentry.traces-sample-rate=1.0", + "sentry.trace-ignore-status-codes=404", "sentry.enable-cache-tracing=true", "sentry.logs.enabled=true", "sentry.reactive.thread-local-accessor-enabled=true", diff --git a/sentry-spring-boot/README.md b/sentry-spring-boot/README.md index 45ac8d72649..8791331b9b1 100644 --- a/sentry-spring-boot/README.md +++ b/sentry-spring-boot/README.md @@ -4,3 +4,16 @@ This integration is ideal to Spring Boot users. It buids on top of [Sentry's cor and also integrates well with logback or log4j2 if those are used in the application. For more information check out [Sentry Spring Boot documentation](https://docs.sentry.io/platforms/java/guides/spring-boot/). + +## Ignoring server transactions by HTTP status + +Set `sentry.trace-ignore-status-codes` to a comma-separated list of individual +status codes and inclusive ranges: + +```properties +sentry.trace-ignore-status-codes=404,500-599 +``` + +Matching incoming server transactions are not sent to Sentry. The filter reads the root +transaction's HTTP response status; child span statuses do not affect it. The option is disabled +when it is unset or empty. diff --git a/sentry-spring-boot/src/integrationTest/kotlin/io/sentry/spring/boot/integrationtest/IntegrationTest.kt b/sentry-spring-boot/src/integrationTest/kotlin/io/sentry/spring/boot/integrationtest/IntegrationTest.kt index a83f50a73f3..03c4214b917 100644 --- a/sentry-spring-boot/src/integrationTest/kotlin/io/sentry/spring/boot/integrationtest/IntegrationTest.kt +++ b/sentry-spring-boot/src/integrationTest/kotlin/io/sentry/spring/boot/integrationtest/IntegrationTest.kt @@ -29,6 +29,7 @@ import org.springframework.test.context.junit4.SpringRunner properties = [ "sentry.traces-sample-rate=1.0", + "sentry.trace-ignore-status-codes=404", "sentry.clients.ok-http-enabled=true", "sentry.enable-cache-tracing=true", "sentry.enable-queue-tracing=true", diff --git a/sentry-spring-boot/src/integrationTest/kotlin/io/sentry/spring/boot/integrationtest/PersonIntegrationTest.kt b/sentry-spring-boot/src/integrationTest/kotlin/io/sentry/spring/boot/integrationtest/PersonIntegrationTest.kt index 045bfa37a96..fa17b781b01 100644 --- a/sentry-spring-boot/src/integrationTest/kotlin/io/sentry/spring/boot/integrationtest/PersonIntegrationTest.kt +++ b/sentry-spring-boot/src/integrationTest/kotlin/io/sentry/spring/boot/integrationtest/PersonIntegrationTest.kt @@ -102,6 +102,17 @@ class PersonIntegrationTest : IntegrationTest() { .isTrue() } + @Test + fun `configured not found response does not send a transaction`() { + val path = "/missing-ignored-status" + + val response = restTemplate.getForEntity(path, String::class.java) + + assertThat(response.statusCode.value()).isEqualTo(404) + Sentry.flush(5000) + server.assertNoEnvelope { it.transaction()?.request?.url?.endsWith(path) == true } + } + @Test fun `creating a person starts a profile linked to the transaction`() { val response = diff --git a/sentry-spring-boot/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt b/sentry-spring-boot/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt index 0210da8ba64..35c00694d6f 100644 --- a/sentry-spring-boot/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt +++ b/sentry-spring-boot/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt @@ -66,6 +66,17 @@ class PersonWebfluxIntegrationTest : WebfluxIntegrationTest() { .isEqualTo(200) } + @Test + fun `configured not found response does not send a transaction`() { + val path = "/missing-ignored-status" + + val response = restTemplate.getForEntity(path, String::class.java) + + assertThat(response.statusCode.value()).isEqualTo(404) + Sentry.flush(5000) + server.assertNoEnvelope { it.transaction()?.request?.url?.endsWith(path) == true } + } + @Test fun `creating a person starts a profile linked to the transaction`() { val response = diff --git a/sentry-spring-boot/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/webfluxintegrationtest/WebfluxIntegrationTest.kt b/sentry-spring-boot/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/webfluxintegrationtest/WebfluxIntegrationTest.kt index f222e37b4ef..a626555e26a 100644 --- a/sentry-spring-boot/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/webfluxintegrationtest/WebfluxIntegrationTest.kt +++ b/sentry-spring-boot/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/webfluxintegrationtest/WebfluxIntegrationTest.kt @@ -26,6 +26,7 @@ import org.springframework.test.context.junit4.SpringRunner properties = [ "sentry.traces-sample-rate=1.0", + "sentry.trace-ignore-status-codes=404", "sentry.logs.enabled=true", "sentry.profile-session-sample-rate=1.0", "sentry.profile-lifecycle=TRACE", diff --git a/sentry/src/main/java/io/sentry/SentryClient.java b/sentry/src/main/java/io/sentry/SentryClient.java index e0b1901f9b8..b2121e5db1f 100644 --- a/sentry/src/main/java/io/sentry/SentryClient.java +++ b/sentry/src/main/java/io/sentry/SentryClient.java @@ -21,6 +21,7 @@ import io.sentry.transport.RateLimiter; import io.sentry.util.*; import java.io.Closeable; +import java.io.File; import java.io.IOException; import java.util.ArrayList; import java.util.Collection; @@ -1024,6 +1025,30 @@ public void captureSession(final @NotNull Session session, final @Nullable Hint return SentryId.EMPTY_ID; } + final @Nullable Integer ignoredHttpStatusCode = getIgnoredHttpStatusCode(transaction); + if (ignoredHttpStatusCode != null) { + options + .getLogger() + .log( + SentryLevel.DEBUG, + "Transaction was dropped as HTTP status code %d is ignored", + ignoredHttpStatusCode); + options + .getClientReportRecorder() + .recordLostEvent(DiscardReason.EVENT_PROCESSOR, DataCategory.Transaction); + options + .getClientReportRecorder() + .recordLostEvent( + DiscardReason.EVENT_PROCESSOR, DataCategory.Span, transaction.getSpans().size() + 1); + if (profilingTraceData != null) { + options + .getClientReportRecorder() + .recordLostEvent(DiscardReason.EVENT_PROCESSOR, DataCategory.Profile); + } + deleteProfilingTraceFile(profilingTraceData); + return SentryId.EMPTY_ID; + } + SentryId sentryId = SentryId.EMPTY_ID; if (transaction.getEventId() != null) { sentryId = transaction.getEventId(); @@ -1096,6 +1121,71 @@ public void captureSession(final @NotNull Session session, final @Nullable Hint return sentryId; } + private @Nullable Integer getIgnoredHttpStatusCode(final @NotNull SentryTransaction transaction) { + final @Nullable List ignoredHttpStatusCodes = + options.getTraceIgnoreStatusCodes(); + if (ignoredHttpStatusCodes == null || ignoredHttpStatusCodes.isEmpty()) { + return null; + } + + final @Nullable SpanContext trace = transaction.getContexts().getTrace(); + if (trace == null + || !"server".equals(trace.getData().get(SpanDataConvention.SENTRY_KIND_KEY))) { + return null; + } + + final @Nullable Object httpStatusCodeValue = + trace.getData().get(SpanDataConvention.HTTP_STATUS_CODE_KEY); + final int httpStatusCode; + if (httpStatusCodeValue instanceof Integer) { + httpStatusCode = (Integer) httpStatusCodeValue; + } else if (httpStatusCodeValue instanceof Long) { + final long longHttpStatusCode = (Long) httpStatusCodeValue; + if (longHttpStatusCode < 100 || longHttpStatusCode > 599) { + return null; + } + httpStatusCode = (int) longHttpStatusCode; + } else { + return null; + } + + if (httpStatusCode < 100 || httpStatusCode > 599) { + return null; + } + for (final @Nullable HttpStatusCodeRange ignoredHttpStatusCode : ignoredHttpStatusCodes) { + if (ignoredHttpStatusCode != null && ignoredHttpStatusCode.isInRange(httpStatusCode)) { + return httpStatusCode; + } + } + return null; + } + + private void deleteProfilingTraceFile(final @Nullable ProfilingTraceData profilingTraceData) { + if (profilingTraceData == null) { + return; + } + + final @NotNull File traceFile = profilingTraceData.getTraceFile(); + try { + if (!traceFile.delete()) { + options + .getLogger() + .log( + SentryLevel.WARNING, + "Failed to delete profiling trace file %s for an ignored transaction", + traceFile.getPath()); + } + } catch (SecurityException e) { + options + .getLogger() + .log( + SentryLevel.WARNING, + e, + "Failed to delete profiling trace file %s for an ignored transaction", + traceFile.getPath()); + } + } + @ApiStatus.Internal @Override public @NotNull SentryId captureProfileChunk( diff --git a/sentry/src/test/java/io/sentry/SentryClientTest.kt b/sentry/src/test/java/io/sentry/SentryClientTest.kt index 6e359e56b9f..fe55ef2d15b 100644 --- a/sentry/src/test/java/io/sentry/SentryClientTest.kt +++ b/sentry/src/test/java/io/sentry/SentryClientTest.kt @@ -89,6 +89,7 @@ class SentryClientTest { var loggerBatchProcessorFactory = mock() var metricsBatchProcessor = mock() var metricsBatchProcessorFactory = mock() + val logger = mock() val maxAttachmentSize: Long = (5 * 1024 * 1024).toLong() val scopes = mock() val sentryTracer: SentryTracer @@ -102,7 +103,7 @@ class SentryClientTest { isDebug = true setDiagnosticLevel(SentryLevel.DEBUG) setSerializer(JsonSerializer(this)) - setLogger(mock()) + setLogger(this@Fixture.logger) maxAttachmentSize = this@Fixture.maxAttachmentSize setTransportFactory(factory) logs.setLoggerBatchProcessorFactory(loggerBatchProcessorFactory) @@ -1383,6 +1384,161 @@ class SentryClientTest { assertEquals(SentryId.EMPTY_ID, eventId) } + @Test + fun `server transaction with ignored HTTP status is dropped before callbacks`() { + fixture.sentryOptions.setTraceIgnoreStatusCodes( + listOf(HttpStatusCodeRange(404)) + ) + val processor = mock() + val beforeSend = mock() + val replayController = mock() + fixture.sentryOptions.addEventProcessor(processor) + fixture.sentryOptions.beforeSendTransaction = beforeSend + fixture.sentryOptions.setReplayController(replayController) + val transaction = createServerTransaction(404) + + val eventId = + fixture + .getSut() + .captureTransaction( + transaction, + fixture.sentryTracer.traceContext(), + null, + null, + fixture.profilingTraceData, + ) + + assertThat(eventId).isEqualTo(SentryId.EMPTY_ID) + assertThat(fixture.profilingTraceFile.exists()).isFalse() + verify(processor, never()).process(any(), anyOrNull()) + verify(beforeSend, never()).execute(any(), anyOrNull()) + verifyNoInteractions(replayController) + verify(fixture.transport, never()).send(any(), anyOrNull()) + assertClientReport( + fixture.sentryOptions.clientReportRecorder, + listOf( + DiscardedEvent(DiscardReason.EVENT_PROCESSOR.reason, DataCategory.Transaction.category, 1), + DiscardedEvent(DiscardReason.EVENT_PROCESSOR.reason, DataCategory.Span.category, 2), + DiscardedEvent(DiscardReason.EVENT_PROCESSOR.reason, DataCategory.Profile.category, 1), + ), + ) + } + + @Test + fun `server transaction with ignored HTTP status range accepts OTel long value`() { + fixture.sentryOptions.setTraceIgnoreStatusCodes( + listOf(HttpStatusCodeRange(500, 599)) + ) + + val eventId = + fixture + .getSut() + .captureTransaction(createServerTransaction(503L), fixture.sentryTracer.traceContext()) + + assertThat(eventId).isEqualTo(SentryId.EMPTY_ID) + verify(fixture.transport, never()).send(any(), anyOrNull()) + } + + @Test + fun `HTTP status filter is disabled for an empty configuration`() { + fixture.sentryOptions.setTraceIgnoreStatusCodes(emptyList()) + + fixture + .getSut() + .captureTransaction(createServerTransaction(404), fixture.sentryTracer.traceContext()) + + verify(fixture.transport).send(any(), anyOrNull()) + } + + @Test + fun `HTTP status filter only applies to server transactions`() { + fixture.sentryOptions.setTraceIgnoreStatusCodes( + listOf(HttpStatusCodeRange(404)) + ) + val clientTransaction = createServerTransaction(404) + clientTransaction.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY] = "client" + val missingKindTransaction = createServerTransaction(404) + missingKindTransaction.contexts.trace!!.data.remove(SpanDataConvention.SENTRY_KIND_KEY) + val sut = fixture.getSut() + + sut.captureTransaction(clientTransaction, fixture.sentryTracer.traceContext()) + sut.captureTransaction(missingKindTransaction, fixture.sentryTracer.traceContext()) + + verify(fixture.transport, times(2)).send(any(), anyOrNull()) + } + + @Test + fun `HTTP status filter ignores missing and invalid root status values`() { + fixture.sentryOptions.setTraceIgnoreStatusCodes( + listOf(HttpStatusCodeRange(404)) + ) + val invalidStatusValues = listOf("404", 404.0, 404.5f, 99, 600, Long.MAX_VALUE) + val sut = fixture.getSut() + + invalidStatusValues.forEach { statusCode -> + sut.captureTransaction( + createServerTransaction(statusCode), + fixture.sentryTracer.traceContext(), + ) + } + val missingStatusTransaction = createServerTransaction(200) + missingStatusTransaction.contexts.trace!!.data.remove(SpanDataConvention.HTTP_STATUS_CODE_KEY) + sut.captureTransaction(missingStatusTransaction, fixture.sentryTracer.traceContext()) + + verify(fixture.transport, times(invalidStatusValues.size + 1)).send(any(), anyOrNull()) + } + + @Test + fun `HTTP status filter does not read child span attributes`() { + fixture.sentryOptions.setTraceIgnoreStatusCodes( + listOf(HttpStatusCodeRange(404)) + ) + val tracer = + SentryTracer( + TransactionContext("child-status-transaction", "op", TracesSamplingDecision(true)), + fixture.scopes, + ) + tracer.startChild("child").apply { + setData(SpanDataConvention.SENTRY_KIND_KEY, "server") + setData(SpanDataConvention.HTTP_STATUS_CODE_KEY, 404) + finish() + } + val transaction = SentryTransaction(tracer) + + fixture.getSut().captureTransaction(transaction, tracer.traceContext()) + + verify(fixture.transport).send(any(), anyOrNull()) + } + + @Test + fun `profiling trace deletion failure for ignored transaction is logged`() { + fixture.sentryOptions.setTraceIgnoreStatusCodes( + listOf(HttpStatusCodeRange(404)) + ) + val traceFile = mock() + whenever(traceFile.delete()).thenReturn(false) + whenever(traceFile.path).thenReturn("undeletable.trace") + val profilingTraceData = ProfilingTraceData(traceFile, fixture.sentryTracer) + + fixture + .getSut() + .captureTransaction( + createServerTransaction(404), + fixture.sentryTracer.traceContext(), + null, + null, + profilingTraceData, + ) + + verify(traceFile).delete() + verify(fixture.logger) + .log( + SentryLevel.WARNING, + "Failed to delete profiling trace file %s for an ignored transaction", + "undeletable.trace", + ) + } + @Test fun `backfillable events are only wired through backfilling processors`() { val backfillingProcessor = mock() @@ -4536,6 +4692,13 @@ class SentryClientTest { } } + private fun createServerTransaction(statusCode: Any): SentryTransaction { + return SentryTransaction(fixture.sentryTracer).apply { + contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY] = "server" + contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY] = statusCode + } + } + private fun createSession(release: String = "rel"): Session { return Session("dis", User(), "env", release) } diff --git a/sentry/src/test/java/io/sentry/SentryTracerTest.kt b/sentry/src/test/java/io/sentry/SentryTracerTest.kt index 20232f56b4d..b14700fba17 100644 --- a/sentry/src/test/java/io/sentry/SentryTracerTest.kt +++ b/sentry/src/test/java/io/sentry/SentryTracerTest.kt @@ -239,6 +239,34 @@ class SentryTracerTest { verify(transactionProfiler).onTransactionFinish(any(), anyOrNull(), anyOrNull()) } + @Test + fun `ignored HTTP status configuration does not skip profiling and performance finalization`() { + val transactionProfiler = mock() + val performanceCollector = mock() + val profilingTraceData = mock() + whenever(transactionProfiler.onTransactionFinish(any(), anyOrNull(), anyOrNull())) + .thenReturn(profilingTraceData) + val tracer = + fixture.getSut( + optionsConfiguration = { + it.profilesSampleRate = 1.0 + it.setTransactionProfiler(transactionProfiler) + it.setTraceIgnoreStatusCodes(listOf(HttpStatusCodeRange(404))) + }, + samplingDecision = TracesSamplingDecision(true, null, true, null), + performanceCollector = performanceCollector, + ) + tracer.setData(SpanDataConvention.SENTRY_KIND_KEY, "server") + tracer.setData(SpanDataConvention.HTTP_STATUS_CODE_KEY, 404) + + tracer.finish() + + verify(performanceCollector).stop(tracer) + verify(transactionProfiler).onTransactionFinish(eq(tracer), anyOrNull(), eq(fixture.options)) + verify(fixture.scopes) + .captureTransaction(any(), anyOrNull(), anyOrNull(), eq(profilingTraceData)) + } + @Test fun `when continuous profiler is running, profile context is set`() { val continuousProfiler = mock() From 199172dafa98bf4eb88eb0813423ceeec44169ac Mon Sep 17 00:00:00 2001 From: Alexander Dinauer Date: Wed, 11 Nov 2026 16:17:43 +0100 Subject: [PATCH 06/19] chore: Link HTTP status filter changelog entry Reference PR #6566 from the user-facing feature entry now that the stacked pull request has been created. --- CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index aef807a4725..3be6c06d934 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -67,7 +67,7 @@ ### Features -- Drop incoming server transactions whose root HTTP response status matches `traceIgnoreStatusCodes`. Configure individual statuses such as `404`, inclusive ranges such as `400-499` or `500-599`, or combine them. +- Drop incoming server transactions whose root HTTP response status matches `traceIgnoreStatusCodes`. Configure individual statuses such as `404`, inclusive ranges such as `400-499` or `500-599`, or combine them ([#6566](https://github.com/getsentry/sentry-java/pull/6566)). Java: From b9bad2a4c20d9c7434c35bcae8a2ac071930054e Mon Sep 17 00:00:00 2001 From: Alexander Dinauer Date: Wed, 11 Nov 2026 16:32:16 +0100 Subject: [PATCH 07/19] feat(tracing): [Ignore HTTP Status 4] Ignore incoming 404s by default Stop sending incoming server transactions that finish with HTTP 404 unless users replace or clear the ignored status configuration. Document the opt-out and cover native Spring and OpenTelemetry paths across supported Spring Boot generations. Fixes #4736 --- CHANGELOG.md | 38 ++++++++++++++ .../boot4/integrationtest/IntegrationTest.kt | 1 - .../integrationtest/PersonIntegrationTest.kt | 2 +- .../PersonIntegrationTest.kt | 12 +++++ .../PersonIntegrationTest.kt | 10 ++++ .../PersonWebfluxIntegrationTest.kt | 2 +- .../WebfluxIntegrationTest.kt | 1 - .../boot4/SentryAutoConfigurationTest.kt | 9 ++++ .../integrationtest/IntegrationTest.kt | 1 - .../integrationtest/PersonIntegrationTest.kt | 2 +- .../PersonIntegrationTest.kt | 12 +++++ .../PersonIntegrationTest.kt | 10 ++++ .../PersonWebfluxIntegrationTest.kt | 2 +- .../WebfluxIntegrationTest.kt | 1 - .../jakarta/SentryAutoConfigurationTest.kt | 9 ++++ sentry-spring-boot/README.md | 24 +++++++-- .../boot/integrationtest/IntegrationTest.kt | 1 - .../integrationtest/PersonIntegrationTest.kt | 2 +- .../PersonIntegrationTest.kt | 12 +++++ .../PersonIntegrationTest.kt | 10 ++++ .../PersonWebfluxIntegrationTest.kt | 2 +- .../WebfluxIntegrationTest.kt | 1 - .../boot/SentryAutoConfigurationTest.kt | 9 ++++ .../main/java/io/sentry/SentryOptions.java | 23 +++++---- .../test/java/io/sentry/SentryClientTest.kt | 50 +++++++++---------- .../test/java/io/sentry/SentryOptionsTest.kt | 39 ++++++++++++--- 26 files changed, 226 insertions(+), 59 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 3be6c06d934..18370342f96 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -52,6 +52,44 @@ `logsEnabled` argument. Pass `false` to keep Sentry Logs disabled. - Disable tracing for HTTP `OPTIONS` requests by default. Set `traceOptionsRequests` to `true` to preserve the previous behavior ([#6254](https://github.com/getsentry/sentry-java/pull/6254)) +- Incoming HTTP server transactions that finish with status 404 are no longer sent to Sentry by + default. This includes matched endpoints that intentionally return 404. Outgoing HTTP requests + that receive a 404 are unaffected. + + Restore the previous behavior and trace every incoming HTTP status with an empty configuration: + + Java: + + ```java + import java.util.Collections; + + options.setTraceIgnoreStatusCodes(Collections.emptyList()); + ``` + + `sentry.properties`: + + ```properties + trace-ignore-status-codes= + ``` + + Spring Boot `application.properties`: + + ```properties + sentry.trace-ignore-status-codes= + ``` + + Spring Boot `application.yml`: + + ```yaml + sentry: + trace-ignore-status-codes: [] + ``` + + The final response status is only known after sampling and request handling. The transaction may + already have propagated a sampled trace to downstream services, which can still report their + segments. Local child spans are discarded with the ignored transaction. Continuous profile + chunks are reported independently. External OTLP export does not pass through `SentryClient` and + is not filtered by this option. - Remove the Apache HttpClient transport and stop publishing `sentry-apache-http-client-5` ([#6214](https://github.com/getsentry/sentry-java/pull/6214)) - Remove the deprecated `Instrumenter` enum, option, span context property, and `startChild` overloads ([#6252](https://github.com/getsentry/sentry-java/pull/6252)) - Remove deprecated OpenTelemetry integration classes and the legacy `SentrySpanStorage` ([#6243](https://github.com/getsentry/sentry-java/pull/6243)) diff --git a/sentry-spring-boot-4/src/integrationTest/kotlin/io/sentry/spring/boot4/integrationtest/IntegrationTest.kt b/sentry-spring-boot-4/src/integrationTest/kotlin/io/sentry/spring/boot4/integrationtest/IntegrationTest.kt index ed7c9965864..f61ad6c3826 100644 --- a/sentry-spring-boot-4/src/integrationTest/kotlin/io/sentry/spring/boot4/integrationtest/IntegrationTest.kt +++ b/sentry-spring-boot-4/src/integrationTest/kotlin/io/sentry/spring/boot4/integrationtest/IntegrationTest.kt @@ -29,7 +29,6 @@ import org.springframework.test.context.junit4.SpringRunner properties = [ "sentry.traces-sample-rate=1.0", - "sentry.trace-ignore-status-codes=404", "sentry.clients.ok-http-enabled=true", "sentry.enable-cache-tracing=true", "sentry.enable-queue-tracing=true", diff --git a/sentry-spring-boot-4/src/integrationTest/kotlin/io/sentry/spring/boot4/integrationtest/PersonIntegrationTest.kt b/sentry-spring-boot-4/src/integrationTest/kotlin/io/sentry/spring/boot4/integrationtest/PersonIntegrationTest.kt index ee18a3b7233..f6045b89b7e 100644 --- a/sentry-spring-boot-4/src/integrationTest/kotlin/io/sentry/spring/boot4/integrationtest/PersonIntegrationTest.kt +++ b/sentry-spring-boot-4/src/integrationTest/kotlin/io/sentry/spring/boot4/integrationtest/PersonIntegrationTest.kt @@ -103,7 +103,7 @@ class PersonIntegrationTest : IntegrationTest() { } @Test - fun `configured not found response does not send a transaction`() { + fun `default not found response does not send a transaction`() { val path = "/missing-ignored-status" val response = restTemplate.getForEntity(path, String::class.java) diff --git a/sentry-spring-boot-4/src/integrationTestOtelAgent/kotlin/io/sentry/spring/boot4/otelagentintegrationtest/PersonIntegrationTest.kt b/sentry-spring-boot-4/src/integrationTestOtelAgent/kotlin/io/sentry/spring/boot4/otelagentintegrationtest/PersonIntegrationTest.kt index 09d7aecda14..7d81b9389ff 100644 --- a/sentry-spring-boot-4/src/integrationTestOtelAgent/kotlin/io/sentry/spring/boot4/otelagentintegrationtest/PersonIntegrationTest.kt +++ b/sentry-spring-boot-4/src/integrationTestOtelAgent/kotlin/io/sentry/spring/boot4/otelagentintegrationtest/PersonIntegrationTest.kt @@ -20,6 +20,18 @@ import org.springframework.http.HttpHeaders class PersonIntegrationTest : IntegrationTest() { + @Test + fun `default not found response does not send a transaction`() { + val path = "/missing-default-ignored-status" + + val response = restTemplate.getForEntity(path, String::class.java) + + assertThat(response.statusCode.value()).isEqualTo(404) + server.assertNoEnvelope(millis = 1_000) { + it.transaction()?.request?.url?.endsWith(path) == true + } + } + @Test fun `failed request reports errors, spans with their flags, and logs`() { val response = restTemplate.getForEntity("/person/11", String::class.java) diff --git a/sentry-spring-boot-4/src/integrationTestOtelNoAgent/kotlin/io/sentry/spring/boot4/otelnoagentintegrationtest/PersonIntegrationTest.kt b/sentry-spring-boot-4/src/integrationTestOtelNoAgent/kotlin/io/sentry/spring/boot4/otelnoagentintegrationtest/PersonIntegrationTest.kt index 6e0359c459b..4274747cee7 100644 --- a/sentry-spring-boot-4/src/integrationTestOtelNoAgent/kotlin/io/sentry/spring/boot4/otelnoagentintegrationtest/PersonIntegrationTest.kt +++ b/sentry-spring-boot-4/src/integrationTestOtelNoAgent/kotlin/io/sentry/spring/boot4/otelnoagentintegrationtest/PersonIntegrationTest.kt @@ -21,6 +21,16 @@ import org.springframework.http.HttpHeaders class PersonIntegrationTest : IntegrationTest() { + @Test + fun `default not found response does not send a transaction`() { + val path = "/missing-default-ignored-status" + + val response = restTemplate.getForEntity(path, String::class.java) + + assertThat(response.statusCode.value()).isEqualTo(404) + server.assertNoEnvelope { it.transaction()?.request?.url?.endsWith(path) == true } + } + @Test fun `failed request reports errors, nested spans with their flags, and logs`() { val response = restTemplate.getForEntity("/person/11", String::class.java) diff --git a/sentry-spring-boot-4/src/integrationTestWebflux/kotlin/io/sentry/spring/boot4/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt b/sentry-spring-boot-4/src/integrationTestWebflux/kotlin/io/sentry/spring/boot4/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt index 7af3dbcfdf4..8a283f7d046 100644 --- a/sentry-spring-boot-4/src/integrationTestWebflux/kotlin/io/sentry/spring/boot4/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt +++ b/sentry-spring-boot-4/src/integrationTestWebflux/kotlin/io/sentry/spring/boot4/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt @@ -67,7 +67,7 @@ class PersonWebfluxIntegrationTest : WebfluxIntegrationTest() { } @Test - fun `configured not found response does not send a transaction`() { + fun `default not found response does not send a transaction`() { val path = "/missing-ignored-status" val response = restTemplate.getForEntity(path, String::class.java) diff --git a/sentry-spring-boot-4/src/integrationTestWebflux/kotlin/io/sentry/spring/boot4/webfluxintegrationtest/WebfluxIntegrationTest.kt b/sentry-spring-boot-4/src/integrationTestWebflux/kotlin/io/sentry/spring/boot4/webfluxintegrationtest/WebfluxIntegrationTest.kt index d510cc6625a..360dcbb1617 100644 --- a/sentry-spring-boot-4/src/integrationTestWebflux/kotlin/io/sentry/spring/boot4/webfluxintegrationtest/WebfluxIntegrationTest.kt +++ b/sentry-spring-boot-4/src/integrationTestWebflux/kotlin/io/sentry/spring/boot4/webfluxintegrationtest/WebfluxIntegrationTest.kt @@ -26,7 +26,6 @@ import org.springframework.test.context.junit4.SpringRunner properties = [ "sentry.traces-sample-rate=1.0", - "sentry.trace-ignore-status-codes=404", "sentry.enable-cache-tracing=true", "sentry.logs.enabled=true", "sentry.reactive.thread-local-accessor-enabled=true", diff --git a/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryAutoConfigurationTest.kt b/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryAutoConfigurationTest.kt index 41f60072cb8..989135c8cbb 100644 --- a/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryAutoConfigurationTest.kt +++ b/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryAutoConfigurationTest.kt @@ -341,6 +341,15 @@ class SentryAutoConfigurationTest { } } + @Test + fun `ignored server HTTP status codes default to 404`() { + contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj").run { + val ranges = it.getBean(SentryProperties::class.java).traceIgnoreStatusCodes + assertThat(ranges).hasSize(1) + assertThat(ranges!!.single().isInRange(404)).isTrue() + } + } + @Test fun `empty ignored server HTTP status codes disable the configuration`() { contextRunner diff --git a/sentry-spring-boot-jakarta/src/integrationTest/kotlin/io/sentry/spring/boot/jakarta/integrationtest/IntegrationTest.kt b/sentry-spring-boot-jakarta/src/integrationTest/kotlin/io/sentry/spring/boot/jakarta/integrationtest/IntegrationTest.kt index 5b247e5a792..d539470ae93 100644 --- a/sentry-spring-boot-jakarta/src/integrationTest/kotlin/io/sentry/spring/boot/jakarta/integrationtest/IntegrationTest.kt +++ b/sentry-spring-boot-jakarta/src/integrationTest/kotlin/io/sentry/spring/boot/jakarta/integrationtest/IntegrationTest.kt @@ -29,7 +29,6 @@ import org.springframework.test.context.junit4.SpringRunner properties = [ "sentry.traces-sample-rate=1.0", - "sentry.trace-ignore-status-codes=404", "sentry.clients.ok-http-enabled=true", "sentry.enable-cache-tracing=true", "sentry.enable-queue-tracing=true", diff --git a/sentry-spring-boot-jakarta/src/integrationTest/kotlin/io/sentry/spring/boot/jakarta/integrationtest/PersonIntegrationTest.kt b/sentry-spring-boot-jakarta/src/integrationTest/kotlin/io/sentry/spring/boot/jakarta/integrationtest/PersonIntegrationTest.kt index 919034786d6..40638a251c5 100644 --- a/sentry-spring-boot-jakarta/src/integrationTest/kotlin/io/sentry/spring/boot/jakarta/integrationtest/PersonIntegrationTest.kt +++ b/sentry-spring-boot-jakarta/src/integrationTest/kotlin/io/sentry/spring/boot/jakarta/integrationtest/PersonIntegrationTest.kt @@ -103,7 +103,7 @@ class PersonIntegrationTest : IntegrationTest() { } @Test - fun `configured not found response does not send a transaction`() { + fun `default not found response does not send a transaction`() { val path = "/missing-ignored-status" val response = restTemplate.getForEntity(path, String::class.java) diff --git a/sentry-spring-boot-jakarta/src/integrationTestOtelAgent/kotlin/io/sentry/spring/boot/jakarta/otelagentintegrationtest/PersonIntegrationTest.kt b/sentry-spring-boot-jakarta/src/integrationTestOtelAgent/kotlin/io/sentry/spring/boot/jakarta/otelagentintegrationtest/PersonIntegrationTest.kt index 62b2012163a..f9526f4e6ff 100644 --- a/sentry-spring-boot-jakarta/src/integrationTestOtelAgent/kotlin/io/sentry/spring/boot/jakarta/otelagentintegrationtest/PersonIntegrationTest.kt +++ b/sentry-spring-boot-jakarta/src/integrationTestOtelAgent/kotlin/io/sentry/spring/boot/jakarta/otelagentintegrationtest/PersonIntegrationTest.kt @@ -20,6 +20,18 @@ import org.springframework.http.HttpHeaders class PersonIntegrationTest : IntegrationTest() { + @Test + fun `default not found response does not send a transaction`() { + val path = "/missing-default-ignored-status" + + val response = restTemplate.getForEntity(path, String::class.java) + + assertThat(response.statusCode.value()).isEqualTo(404) + server.assertNoEnvelope(millis = 1_000) { + it.transaction()?.request?.url?.endsWith(path) == true + } + } + @Test fun `failed request reports errors, spans with their flags, and logs`() { val response = restTemplate.getForEntity("/person/11", String::class.java) diff --git a/sentry-spring-boot-jakarta/src/integrationTestOtelNoAgent/kotlin/io/sentry/spring/boot/jakarta/otelnoagentintegrationtest/PersonIntegrationTest.kt b/sentry-spring-boot-jakarta/src/integrationTestOtelNoAgent/kotlin/io/sentry/spring/boot/jakarta/otelnoagentintegrationtest/PersonIntegrationTest.kt index e2ca6eb7b56..07e068ff7a6 100644 --- a/sentry-spring-boot-jakarta/src/integrationTestOtelNoAgent/kotlin/io/sentry/spring/boot/jakarta/otelnoagentintegrationtest/PersonIntegrationTest.kt +++ b/sentry-spring-boot-jakarta/src/integrationTestOtelNoAgent/kotlin/io/sentry/spring/boot/jakarta/otelnoagentintegrationtest/PersonIntegrationTest.kt @@ -21,6 +21,16 @@ import org.springframework.http.HttpHeaders class PersonIntegrationTest : IntegrationTest() { + @Test + fun `default not found response does not send a transaction`() { + val path = "/missing-default-ignored-status" + + val response = restTemplate.getForEntity(path, String::class.java) + + assertThat(response.statusCode.value()).isEqualTo(404) + server.assertNoEnvelope { it.transaction()?.request?.url?.endsWith(path) == true } + } + @Test fun `failed request reports errors, nested spans with their flags, and logs`() { val response = restTemplate.getForEntity("/person/11", String::class.java) diff --git a/sentry-spring-boot-jakarta/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/jakarta/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt b/sentry-spring-boot-jakarta/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/jakarta/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt index f437453e3b7..dcc87e293af 100644 --- a/sentry-spring-boot-jakarta/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/jakarta/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt +++ b/sentry-spring-boot-jakarta/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/jakarta/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt @@ -67,7 +67,7 @@ class PersonWebfluxIntegrationTest : WebfluxIntegrationTest() { } @Test - fun `configured not found response does not send a transaction`() { + fun `default not found response does not send a transaction`() { val path = "/missing-ignored-status" val response = restTemplate.getForEntity(path, String::class.java) diff --git a/sentry-spring-boot-jakarta/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/jakarta/webfluxintegrationtest/WebfluxIntegrationTest.kt b/sentry-spring-boot-jakarta/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/jakarta/webfluxintegrationtest/WebfluxIntegrationTest.kt index d11d38ff0b7..4d314719e35 100644 --- a/sentry-spring-boot-jakarta/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/jakarta/webfluxintegrationtest/WebfluxIntegrationTest.kt +++ b/sentry-spring-boot-jakarta/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/jakarta/webfluxintegrationtest/WebfluxIntegrationTest.kt @@ -26,7 +26,6 @@ import org.springframework.test.context.junit4.SpringRunner properties = [ "sentry.traces-sample-rate=1.0", - "sentry.trace-ignore-status-codes=404", "sentry.enable-cache-tracing=true", "sentry.logs.enabled=true", "sentry.reactive.thread-local-accessor-enabled=true", diff --git a/sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryAutoConfigurationTest.kt b/sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryAutoConfigurationTest.kt index 7dd5f7d92d9..0888249f935 100644 --- a/sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryAutoConfigurationTest.kt +++ b/sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryAutoConfigurationTest.kt @@ -349,6 +349,15 @@ class SentryAutoConfigurationTest { } } + @Test + fun `ignored server HTTP status codes default to 404`() { + contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj").run { + val ranges = it.getBean(SentryProperties::class.java).traceIgnoreStatusCodes + assertThat(ranges).hasSize(1) + assertThat(ranges!!.single().isInRange(404)).isTrue() + } + } + @Test fun `empty ignored server HTTP status codes disable the configuration`() { contextRunner diff --git a/sentry-spring-boot/README.md b/sentry-spring-boot/README.md index 8791331b9b1..4d6f6c9c1a3 100644 --- a/sentry-spring-boot/README.md +++ b/sentry-spring-boot/README.md @@ -7,13 +7,27 @@ For more information check out [Sentry Spring Boot documentation](https://docs.s ## Ignoring server transactions by HTTP status -Set `sentry.trace-ignore-status-codes` to a comma-separated list of individual -status codes and inclusive ranges: +Incoming server transactions that finish with HTTP status 404 are not sent to Sentry by default. +Set `sentry.trace-ignore-status-codes` to replace the default with a +comma-separated list of individual status codes and inclusive ranges: ```properties sentry.trace-ignore-status-codes=404,500-599 ``` -Matching incoming server transactions are not sent to Sentry. The filter reads the root -transaction's HTTP response status; child span statuses do not affect it. The option is disabled -when it is unset or empty. +Use an empty value to trace every incoming HTTP status: + +```properties +sentry.trace-ignore-status-codes= +``` + +For YAML configuration, use an empty list: + +```yaml +sentry: + trace-ignore-status-codes: [] +``` + +The filter reads the root transaction's HTTP response status; child span statuses do not affect it. +Filtering happens after the response status is known, so the request may already have propagated a +sampled trace, and local child spans are discarded with the transaction. diff --git a/sentry-spring-boot/src/integrationTest/kotlin/io/sentry/spring/boot/integrationtest/IntegrationTest.kt b/sentry-spring-boot/src/integrationTest/kotlin/io/sentry/spring/boot/integrationtest/IntegrationTest.kt index 03c4214b917..a83f50a73f3 100644 --- a/sentry-spring-boot/src/integrationTest/kotlin/io/sentry/spring/boot/integrationtest/IntegrationTest.kt +++ b/sentry-spring-boot/src/integrationTest/kotlin/io/sentry/spring/boot/integrationtest/IntegrationTest.kt @@ -29,7 +29,6 @@ import org.springframework.test.context.junit4.SpringRunner properties = [ "sentry.traces-sample-rate=1.0", - "sentry.trace-ignore-status-codes=404", "sentry.clients.ok-http-enabled=true", "sentry.enable-cache-tracing=true", "sentry.enable-queue-tracing=true", diff --git a/sentry-spring-boot/src/integrationTest/kotlin/io/sentry/spring/boot/integrationtest/PersonIntegrationTest.kt b/sentry-spring-boot/src/integrationTest/kotlin/io/sentry/spring/boot/integrationtest/PersonIntegrationTest.kt index fa17b781b01..84009cc9151 100644 --- a/sentry-spring-boot/src/integrationTest/kotlin/io/sentry/spring/boot/integrationtest/PersonIntegrationTest.kt +++ b/sentry-spring-boot/src/integrationTest/kotlin/io/sentry/spring/boot/integrationtest/PersonIntegrationTest.kt @@ -103,7 +103,7 @@ class PersonIntegrationTest : IntegrationTest() { } @Test - fun `configured not found response does not send a transaction`() { + fun `default not found response does not send a transaction`() { val path = "/missing-ignored-status" val response = restTemplate.getForEntity(path, String::class.java) diff --git a/sentry-spring-boot/src/integrationTestOtelAgent/kotlin/io/sentry/spring/boot/otelagentintegrationtest/PersonIntegrationTest.kt b/sentry-spring-boot/src/integrationTestOtelAgent/kotlin/io/sentry/spring/boot/otelagentintegrationtest/PersonIntegrationTest.kt index 53a52f77412..e979aa0e04e 100644 --- a/sentry-spring-boot/src/integrationTestOtelAgent/kotlin/io/sentry/spring/boot/otelagentintegrationtest/PersonIntegrationTest.kt +++ b/sentry-spring-boot/src/integrationTestOtelAgent/kotlin/io/sentry/spring/boot/otelagentintegrationtest/PersonIntegrationTest.kt @@ -20,6 +20,18 @@ import org.springframework.http.HttpHeaders class PersonIntegrationTest : IntegrationTest() { + @Test + fun `default not found response does not send a transaction`() { + val path = "/missing-default-ignored-status" + + val response = restTemplate.getForEntity(path, String::class.java) + + assertThat(response.statusCode.value()).isEqualTo(404) + server.assertNoEnvelope(millis = 1_000) { + it.transaction()?.request?.url?.endsWith(path) == true + } + } + @Test fun `failed request reports errors, spans with their flags, and logs`() { val response = restTemplate.getForEntity("/person/11", String::class.java) diff --git a/sentry-spring-boot/src/integrationTestOtelNoAgent/kotlin/io/sentry/spring/boot/otelnoagentintegrationtest/PersonIntegrationTest.kt b/sentry-spring-boot/src/integrationTestOtelNoAgent/kotlin/io/sentry/spring/boot/otelnoagentintegrationtest/PersonIntegrationTest.kt index 6e9b1c1038b..c9a5ffb72bc 100644 --- a/sentry-spring-boot/src/integrationTestOtelNoAgent/kotlin/io/sentry/spring/boot/otelnoagentintegrationtest/PersonIntegrationTest.kt +++ b/sentry-spring-boot/src/integrationTestOtelNoAgent/kotlin/io/sentry/spring/boot/otelnoagentintegrationtest/PersonIntegrationTest.kt @@ -21,6 +21,16 @@ import org.springframework.http.HttpHeaders class PersonIntegrationTest : IntegrationTest() { + @Test + fun `default not found response does not send a transaction`() { + val path = "/missing-default-ignored-status" + + val response = restTemplate.getForEntity(path, String::class.java) + + assertThat(response.statusCode.value()).isEqualTo(404) + server.assertNoEnvelope { it.transaction()?.request?.url?.endsWith(path) == true } + } + @Test fun `failed request reports errors, nested spans with their flags, and logs`() { val response = restTemplate.getForEntity("/person/11", String::class.java) diff --git a/sentry-spring-boot/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt b/sentry-spring-boot/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt index 35c00694d6f..57584cba90a 100644 --- a/sentry-spring-boot/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt +++ b/sentry-spring-boot/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt @@ -67,7 +67,7 @@ class PersonWebfluxIntegrationTest : WebfluxIntegrationTest() { } @Test - fun `configured not found response does not send a transaction`() { + fun `default not found response does not send a transaction`() { val path = "/missing-ignored-status" val response = restTemplate.getForEntity(path, String::class.java) diff --git a/sentry-spring-boot/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/webfluxintegrationtest/WebfluxIntegrationTest.kt b/sentry-spring-boot/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/webfluxintegrationtest/WebfluxIntegrationTest.kt index a626555e26a..f222e37b4ef 100644 --- a/sentry-spring-boot/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/webfluxintegrationtest/WebfluxIntegrationTest.kt +++ b/sentry-spring-boot/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/webfluxintegrationtest/WebfluxIntegrationTest.kt @@ -26,7 +26,6 @@ import org.springframework.test.context.junit4.SpringRunner properties = [ "sentry.traces-sample-rate=1.0", - "sentry.trace-ignore-status-codes=404", "sentry.logs.enabled=true", "sentry.profile-session-sample-rate=1.0", "sentry.profile-lifecycle=TRACE", diff --git a/sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryAutoConfigurationTest.kt b/sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryAutoConfigurationTest.kt index cbb06d39e01..f492486cab3 100644 --- a/sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryAutoConfigurationTest.kt +++ b/sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryAutoConfigurationTest.kt @@ -347,6 +347,15 @@ class SentryAutoConfigurationTest { } } + @Test + fun `ignored server HTTP status codes default to 404`() { + contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj").run { + val ranges = it.getBean(SentryProperties::class.java).traceIgnoreStatusCodes + assertThat(ranges).hasSize(1) + assertThat(ranges!!.single().isInRange(404)).isTrue() + } + } + @Test fun `empty ignored server HTTP status codes disable the configuration`() { contextRunner diff --git a/sentry/src/main/java/io/sentry/SentryOptions.java b/sentry/src/main/java/io/sentry/SentryOptions.java index efbc0de9ae0..d936582bcdf 100644 --- a/sentry/src/main/java/io/sentry/SentryOptions.java +++ b/sentry/src/main/java/io/sentry/SentryOptions.java @@ -598,7 +598,8 @@ public class SentryOptions implements RateLimiterConfig { */ private @Nullable List ignoredTransactions = null; - private @Nullable List traceIgnoreStatusCodes = null; + private @Nullable List traceIgnoreStatusCodes = + new ArrayList<>(Collections.singletonList(new HttpStatusCodeRange(404))); @ApiStatus.Experimental private @NotNull IBackpressureMonitor backpressureMonitor = NoOpBackpressureMonitor.getInstance(); @@ -3151,9 +3152,10 @@ public void setIgnoredTransactions(final @Nullable List ignoredTransacti /** * Returns the HTTP status codes and inclusive ranges for which incoming server transactions are - * not sent to Sentry. An empty list disables this filter. + * not sent to Sentry. Defaults to a single range containing 404. An empty list disables this + * filter. * - * @return the configured HTTP status code ranges, or {@code null} if unset + * @return the configured HTTP status code ranges, or {@code null} if explicitly set to null */ public @Nullable List getTraceIgnoreStatusCodes() { return traceIgnoreStatusCodes; @@ -3163,16 +3165,18 @@ public void setIgnoredTransactions(final @Nullable List ignoredTransacti * Sets the HTTP status codes and inclusive ranges for which incoming server transactions are not * sent to Sentry. For example, configure {@code new HttpStatusCodeRange(404)} for one status or * {@code new HttpStatusCodeRange(500, 599)} for an inclusive range. External configuration - * accepts comma-separated codes and ranges such as {@code 404,410,500-599}. An empty list - * disables this filter. + * accepts comma-separated codes and ranges such as {@code 404,410,500-599}. An empty list or + * {@code null} disables this filter. * - * @param traceIgnoreStatusCodes the HTTP status code ranges, or {@code null} to leave the option - * unset + * @param traceIgnoreStatusCodes the HTTP status code ranges, or {@code null} to + * disable the filter */ public void setTraceIgnoreStatusCodes( final @Nullable List traceIgnoreStatusCodes) { this.traceIgnoreStatusCodes = - traceIgnoreStatusCodes == null ? null : new ArrayList<>(traceIgnoreStatusCodes); + traceIgnoreStatusCodes == null + ? null + : new ArrayList<>(traceIgnoreStatusCodes); } /** Returns the current {@link SentryDateProvider} that is used to retrieve the current date. */ @@ -3852,7 +3856,8 @@ public void merge(final @NotNull ExternalOptions options) { setIgnoredTransactions(ignoredTransactions); } if (options.getTraceIgnoreStatusCodes() != null) { - setTraceIgnoreStatusCodes(options.getTraceIgnoreStatusCodes()); + setTraceIgnoreStatusCodes( + options.getTraceIgnoreStatusCodes()); } if (options.getIgnoredErrors() != null) { final List ignoredExceptions = new ArrayList<>(options.getIgnoredErrors()); diff --git a/sentry/src/test/java/io/sentry/SentryClientTest.kt b/sentry/src/test/java/io/sentry/SentryClientTest.kt index fe55ef2d15b..30c34449284 100644 --- a/sentry/src/test/java/io/sentry/SentryClientTest.kt +++ b/sentry/src/test/java/io/sentry/SentryClientTest.kt @@ -1385,10 +1385,7 @@ class SentryClientTest { } @Test - fun `server transaction with ignored HTTP status is dropped before callbacks`() { - fixture.sentryOptions.setTraceIgnoreStatusCodes( - listOf(HttpStatusCodeRange(404)) - ) + fun `server transaction with default ignored HTTP status is dropped before callbacks`() { val processor = mock() val beforeSend = mock() val replayController = mock() @@ -1425,18 +1422,29 @@ class SentryClientTest { } @Test - fun `server transaction with ignored HTTP status range accepts OTel long value`() { + fun `default HTTP status filter retains server 200`() { + fixture + .getSut() + .captureTransaction(createServerTransaction(200), fixture.sentryTracer.traceContext()) + + verify(fixture.transport).send(any(), anyOrNull()) + } + + @Test + fun `custom HTTP status range replaces default and accepts OTel long value`() { fixture.sentryOptions.setTraceIgnoreStatusCodes( listOf(HttpStatusCodeRange(500, 599)) ) + val sut = fixture.getSut() - val eventId = - fixture - .getSut() - .captureTransaction(createServerTransaction(503L), fixture.sentryTracer.traceContext()) + val ignoredEventId = + sut.captureTransaction(createServerTransaction(503L), fixture.sentryTracer.traceContext()) + val retainedEventId = + sut.captureTransaction(createServerTransaction(404), fixture.sentryTracer.traceContext()) - assertThat(eventId).isEqualTo(SentryId.EMPTY_ID) - verify(fixture.transport, never()).send(any(), anyOrNull()) + assertThat(ignoredEventId).isEqualTo(SentryId.EMPTY_ID) + assertThat(retainedEventId).isNotEqualTo(SentryId.EMPTY_ID) + verify(fixture.transport).send(any(), anyOrNull()) } @Test @@ -1451,10 +1459,7 @@ class SentryClientTest { } @Test - fun `HTTP status filter only applies to server transactions`() { - fixture.sentryOptions.setTraceIgnoreStatusCodes( - listOf(HttpStatusCodeRange(404)) - ) + fun `default HTTP status filter only applies to server transactions`() { val clientTransaction = createServerTransaction(404) clientTransaction.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY] = "client" val missingKindTransaction = createServerTransaction(404) @@ -1468,10 +1473,7 @@ class SentryClientTest { } @Test - fun `HTTP status filter ignores missing and invalid root status values`() { - fixture.sentryOptions.setTraceIgnoreStatusCodes( - listOf(HttpStatusCodeRange(404)) - ) + fun `default HTTP status filter ignores missing and invalid root status values`() { val invalidStatusValues = listOf("404", 404.0, 404.5f, 99, 600, Long.MAX_VALUE) val sut = fixture.getSut() @@ -1489,10 +1491,7 @@ class SentryClientTest { } @Test - fun `HTTP status filter does not read child span attributes`() { - fixture.sentryOptions.setTraceIgnoreStatusCodes( - listOf(HttpStatusCodeRange(404)) - ) + fun `default HTTP status filter does not read child span attributes`() { val tracer = SentryTracer( TransactionContext("child-status-transaction", "op", TracesSamplingDecision(true)), @@ -1511,10 +1510,7 @@ class SentryClientTest { } @Test - fun `profiling trace deletion failure for ignored transaction is logged`() { - fixture.sentryOptions.setTraceIgnoreStatusCodes( - listOf(HttpStatusCodeRange(404)) - ) + fun `profiling trace deletion failure for default ignored transaction is logged`() { val traceFile = mock() whenever(traceFile.delete()).thenReturn(false) whenever(traceFile.path).thenReturn("undeletable.trace") diff --git a/sentry/src/test/java/io/sentry/SentryOptionsTest.kt b/sentry/src/test/java/io/sentry/SentryOptionsTest.kt index b1fe1242642..6efbfc703d6 100644 --- a/sentry/src/test/java/io/sentry/SentryOptionsTest.kt +++ b/sentry/src/test/java/io/sentry/SentryOptionsTest.kt @@ -1088,29 +1088,46 @@ class SentryOptionsTest { } @Test - fun `ignored server HTTP status codes for tracing are unset by default`() { - assertNull(SentryOptions().traceIgnoreStatusCodes) + fun `ignored server HTTP status codes for tracing default to 404`() { + val ranges = SentryOptions().traceIgnoreStatusCodes + + assertThat(ranges).hasSize(1) + assertThat(ranges!!.single().isInRange(404)).isTrue() + } + + @Test + fun `default ignored server HTTP status code lists are independent`() { + val first = SentryOptions().traceIgnoreStatusCodes!! + val second = SentryOptions().traceIgnoreStatusCodes!! + + first.clear() + + assertThat(second).hasSize(1) + assertThat(second.single().isInRange(404)).isTrue() } @Test - fun `ignored server HTTP status code setter preserves empty and custom ranges`() { + fun `ignored server HTTP status code setter preserves null, empty and custom ranges`() { val options = SentryOptions() + options.traceIgnoreStatusCodes = null + assertThat(options.traceIgnoreStatusCodes).isNull() + options.traceIgnoreStatusCodes = emptyList() assertThat(options.traceIgnoreStatusCodes).isEmpty() - options.traceIgnoreStatusCodes = listOf(HttpStatusCodeRange(404), HttpStatusCodeRange(500, 599)) + options.traceIgnoreStatusCodes = + listOf(HttpStatusCodeRange(404), HttpStatusCodeRange(500, 599)) assertThat(options.traceIgnoreStatusCodes).hasSize(2) assertThat(options.traceIgnoreStatusCodes!![0].isInRange(404)).isTrue() assertThat(options.traceIgnoreStatusCodes!![1].isInRange(599)).isTrue() } @Test - fun `merging empty ignored server HTTP status codes replaces the previous value`() { + fun `merging empty ignored server HTTP status codes clears the default`() { val externalOptions = ExternalOptions() externalOptions.traceIgnoreStatusCodes = emptyList() val options = SentryOptions() - options.traceIgnoreStatusCodes = listOf(HttpStatusCodeRange(404)) options.merge(externalOptions) @@ -1128,6 +1145,16 @@ class SentryOptionsTest { assertThat(options.traceIgnoreStatusCodes!![0].isInRange(410)).isTrue() } + @Test + fun `merging options when ignored server HTTP status codes are not set preserves default`() { + val options = SentryOptions() + + options.merge(ExternalOptions()) + + assertThat(options.traceIgnoreStatusCodes).hasSize(1) + assertThat(options.traceIgnoreStatusCodes!!.single().isInRange(404)).isTrue() + } + @Test fun `merging options when ignoredErrors is not set preserves the previous value`() { val externalOptions = ExternalOptions() From becc6d04de058c5a759395672cb52b24ce83ff44 Mon Sep 17 00:00:00 2001 From: Alexander Dinauer Date: Wed, 11 Nov 2026 16:34:18 +0100 Subject: [PATCH 08/19] changelog --- CHANGELOG.md | 2 +- sentry/src/main/java/io/sentry/SentryOptions.java | 11 ++++------- sentry/src/test/java/io/sentry/SentryClientTest.kt | 4 +--- sentry/src/test/java/io/sentry/SentryOptionsTest.kt | 3 +-- 4 files changed, 7 insertions(+), 13 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 18370342f96..e602ff2d604 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -89,7 +89,7 @@ already have propagated a sampled trace to downstream services, which can still report their segments. Local child spans are discarded with the ignored transaction. Continuous profile chunks are reported independently. External OTLP export does not pass through `SentryClient` and - is not filtered by this option. + is not filtered by this option ([#6567](https://github.com/getsentry/sentry-java/pull/6567)) - Remove the Apache HttpClient transport and stop publishing `sentry-apache-http-client-5` ([#6214](https://github.com/getsentry/sentry-java/pull/6214)) - Remove the deprecated `Instrumenter` enum, option, span context property, and `startChild` overloads ([#6252](https://github.com/getsentry/sentry-java/pull/6252)) - Remove deprecated OpenTelemetry integration classes and the legacy `SentrySpanStorage` ([#6243](https://github.com/getsentry/sentry-java/pull/6243)) diff --git a/sentry/src/main/java/io/sentry/SentryOptions.java b/sentry/src/main/java/io/sentry/SentryOptions.java index d936582bcdf..3fec7e91762 100644 --- a/sentry/src/main/java/io/sentry/SentryOptions.java +++ b/sentry/src/main/java/io/sentry/SentryOptions.java @@ -3168,15 +3168,13 @@ public void setIgnoredTransactions(final @Nullable List ignoredTransacti * accepts comma-separated codes and ranges such as {@code 404,410,500-599}. An empty list or * {@code null} disables this filter. * - * @param traceIgnoreStatusCodes the HTTP status code ranges, or {@code null} to - * disable the filter + * @param traceIgnoreStatusCodes the HTTP status code ranges, or {@code null} to disable the + * filter */ public void setTraceIgnoreStatusCodes( final @Nullable List traceIgnoreStatusCodes) { this.traceIgnoreStatusCodes = - traceIgnoreStatusCodes == null - ? null - : new ArrayList<>(traceIgnoreStatusCodes); + traceIgnoreStatusCodes == null ? null : new ArrayList<>(traceIgnoreStatusCodes); } /** Returns the current {@link SentryDateProvider} that is used to retrieve the current date. */ @@ -3856,8 +3854,7 @@ public void merge(final @NotNull ExternalOptions options) { setIgnoredTransactions(ignoredTransactions); } if (options.getTraceIgnoreStatusCodes() != null) { - setTraceIgnoreStatusCodes( - options.getTraceIgnoreStatusCodes()); + setTraceIgnoreStatusCodes(options.getTraceIgnoreStatusCodes()); } if (options.getIgnoredErrors() != null) { final List ignoredExceptions = new ArrayList<>(options.getIgnoredErrors()); diff --git a/sentry/src/test/java/io/sentry/SentryClientTest.kt b/sentry/src/test/java/io/sentry/SentryClientTest.kt index 30c34449284..f88130250c1 100644 --- a/sentry/src/test/java/io/sentry/SentryClientTest.kt +++ b/sentry/src/test/java/io/sentry/SentryClientTest.kt @@ -1432,9 +1432,7 @@ class SentryClientTest { @Test fun `custom HTTP status range replaces default and accepts OTel long value`() { - fixture.sentryOptions.setTraceIgnoreStatusCodes( - listOf(HttpStatusCodeRange(500, 599)) - ) + fixture.sentryOptions.setTraceIgnoreStatusCodes(listOf(HttpStatusCodeRange(500, 599))) val sut = fixture.getSut() val ignoredEventId = diff --git a/sentry/src/test/java/io/sentry/SentryOptionsTest.kt b/sentry/src/test/java/io/sentry/SentryOptionsTest.kt index 6efbfc703d6..6a80635bd40 100644 --- a/sentry/src/test/java/io/sentry/SentryOptionsTest.kt +++ b/sentry/src/test/java/io/sentry/SentryOptionsTest.kt @@ -1116,8 +1116,7 @@ class SentryOptionsTest { options.traceIgnoreStatusCodes = emptyList() assertThat(options.traceIgnoreStatusCodes).isEmpty() - options.traceIgnoreStatusCodes = - listOf(HttpStatusCodeRange(404), HttpStatusCodeRange(500, 599)) + options.traceIgnoreStatusCodes = listOf(HttpStatusCodeRange(404), HttpStatusCodeRange(500, 599)) assertThat(options.traceIgnoreStatusCodes).hasSize(2) assertThat(options.traceIgnoreStatusCodes!![0].isInRange(404)).isTrue() assertThat(options.traceIgnoreStatusCodes!![1].isInRange(599)).isTrue() From 7b048a02e4e8266f1a5b49c5e56982a4650af06a Mon Sep 17 00:00:00 2001 From: Alexander Dinauer Date: Mon, 16 Nov 2026 07:04:36 +0100 Subject: [PATCH 09/19] fix(spring): Bind integer HTTP status codes from YAML Support unquoted numeric entries in Spring Boot YAML lists while preserving status code validation across Boot 2, 3, and 4. Refs #4735 Co-Authored-By: Claude --- .../boot4/SentryAutoConfigurationTest.kt | 25 +++++++++++++++++++ .../jakarta/SentryAutoConfigurationTest.kt | 25 +++++++++++++++++++ .../boot/SentryAutoConfigurationTest.kt | 25 +++++++++++++++++++ sentry/api/sentry.api | 1 + .../java/io/sentry/HttpStatusCodeRange.java | 19 +++++++++++++- .../java/io/sentry/HttpStatusCodeRangeTest.kt | 11 ++++++++ 6 files changed, 105 insertions(+), 1 deletion(-) diff --git a/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryAutoConfigurationTest.kt b/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryAutoConfigurationTest.kt index 41f60072cb8..e21346f07af 100644 --- a/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryAutoConfigurationTest.kt +++ b/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryAutoConfigurationTest.kt @@ -85,6 +85,7 @@ import org.springframework.context.annotation.Bean import org.springframework.context.annotation.Configuration import org.springframework.core.Ordered import org.springframework.core.annotation.Order +import org.springframework.core.env.MapPropertySource import org.springframework.scheduling.annotation.EnableScheduling import org.springframework.scheduling.annotation.Scheduled import org.springframework.scheduling.quartz.SchedulerFactoryBean @@ -341,6 +342,30 @@ class SentryAutoConfigurationTest { } } + @Test + fun `YAML list binds integer ignored server HTTP status codes`() { + dsnEnabledRunner + .withInitializer { context -> + // YAML exposes unquoted numbers as Integer values in indexed property sources. + context.environment.propertySources.addFirst( + MapPropertySource( + "yaml", + mapOf( + "sentry.trace-ignore-status-codes[0]" to 404, + "sentry.trace-ignore-status-codes[1]" to "500-599", + ), + ) + ) + } + .run { + val ranges = it.getBean(SentryProperties::class.java).traceIgnoreStatusCodes + assertThat(ranges).hasSize(2) + assertThat(ranges!![0].isInRange(404)).isTrue() + assertThat(ranges[1].isInRange(500)).isTrue() + assertThat(ranges[1].isInRange(599)).isTrue() + } + } + @Test fun `empty ignored server HTTP status codes disable the configuration`() { contextRunner diff --git a/sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryAutoConfigurationTest.kt b/sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryAutoConfigurationTest.kt index 7dd5f7d92d9..df95c4fe635 100644 --- a/sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryAutoConfigurationTest.kt +++ b/sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryAutoConfigurationTest.kt @@ -88,6 +88,7 @@ import org.springframework.context.annotation.Bean import org.springframework.context.annotation.Configuration import org.springframework.core.Ordered import org.springframework.core.annotation.Order +import org.springframework.core.env.MapPropertySource import org.springframework.scheduling.annotation.EnableScheduling import org.springframework.scheduling.annotation.Scheduled import org.springframework.scheduling.quartz.SchedulerFactoryBean @@ -349,6 +350,30 @@ class SentryAutoConfigurationTest { } } + @Test + fun `YAML list binds integer ignored server HTTP status codes`() { + dsnEnabledRunner + .withInitializer { context -> + // YAML exposes unquoted numbers as Integer values in indexed property sources. + context.environment.propertySources.addFirst( + MapPropertySource( + "yaml", + mapOf( + "sentry.trace-ignore-status-codes[0]" to 404, + "sentry.trace-ignore-status-codes[1]" to "500-599", + ), + ) + ) + } + .run { + val ranges = it.getBean(SentryProperties::class.java).traceIgnoreStatusCodes + assertThat(ranges).hasSize(2) + assertThat(ranges!![0].isInRange(404)).isTrue() + assertThat(ranges[1].isInRange(500)).isTrue() + assertThat(ranges[1].isInRange(599)).isTrue() + } + } + @Test fun `empty ignored server HTTP status codes disable the configuration`() { contextRunner diff --git a/sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryAutoConfigurationTest.kt b/sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryAutoConfigurationTest.kt index cbb06d39e01..1af23f3b814 100644 --- a/sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryAutoConfigurationTest.kt +++ b/sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryAutoConfigurationTest.kt @@ -88,6 +88,7 @@ import org.springframework.context.annotation.Bean import org.springframework.context.annotation.Configuration import org.springframework.core.Ordered import org.springframework.core.annotation.Order +import org.springframework.core.env.MapPropertySource import org.springframework.scheduling.annotation.EnableScheduling import org.springframework.scheduling.annotation.Scheduled import org.springframework.scheduling.quartz.SchedulerFactoryBean @@ -347,6 +348,30 @@ class SentryAutoConfigurationTest { } } + @Test + fun `YAML list binds integer ignored server HTTP status codes`() { + dsnEnabledRunner + .withInitializer { context -> + // YAML exposes unquoted numbers as Integer values in indexed property sources. + context.environment.propertySources.addFirst( + MapPropertySource( + "yaml", + mapOf( + "sentry.trace-ignore-status-codes[0]" to 404, + "sentry.trace-ignore-status-codes[1]" to "500-599", + ), + ) + ) + } + .run { + val ranges = it.getBean(SentryProperties::class.java).traceIgnoreStatusCodes + assertThat(ranges).hasSize(2) + assertThat(ranges!![0].isInRange(404)).isTrue() + assertThat(ranges[1].isInRange(500)).isTrue() + assertThat(ranges[1].isInRange(599)).isTrue() + } + } + @Test fun `empty ignored server HTTP status codes disable the configuration`() { contextRunner diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api index 132fd7c56c4..8f187e97a01 100644 --- a/sentry/api/sentry.api +++ b/sentry/api/sentry.api @@ -712,6 +712,7 @@ public final class io/sentry/HttpStatusCodeRange { public fun (I)V public fun (II)V public fun isInRange (I)Z + public static fun valueOf (Ljava/lang/Integer;)Lio/sentry/HttpStatusCodeRange; public static fun valueOf (Ljava/lang/String;)Lio/sentry/HttpStatusCodeRange; } diff --git a/sentry/src/main/java/io/sentry/HttpStatusCodeRange.java b/sentry/src/main/java/io/sentry/HttpStatusCodeRange.java index be56ab2154e..ccd69b2cbd4 100644 --- a/sentry/src/main/java/io/sentry/HttpStatusCodeRange.java +++ b/sentry/src/main/java/io/sentry/HttpStatusCodeRange.java @@ -57,6 +57,19 @@ public HttpStatusCodeRange(final int statusCode) { return new HttpStatusCodeRange(min, max); } + /** + * Converts an integer HTTP status code to a range containing only that status. Configuration + * binding uses this overload for unquoted numeric YAML list entries. + * + * @param value the status code + * @return the status code range + * @throws IllegalArgumentException if the value is outside 100-599 + */ + @ApiStatus.Internal + public static @NotNull HttpStatusCodeRange valueOf(final @NotNull Integer value) { + return new HttpStatusCodeRange(validateStatusCode(value, value.toString())); + } + private static int parseStatusCode(final @NotNull String value) { for (int i = 0; i < value.length(); i++) { if (!Character.isDigit(value.charAt(i))) { @@ -70,8 +83,12 @@ private static int parseStatusCode(final @NotNull String value) { } catch (NumberFormatException e) { throw invalidRange(value); } + return validateStatusCode(statusCode, value); + } + + private static int validateStatusCode(final int statusCode, final @NotNull String originalValue) { if (statusCode < MIN_HTTP_STATUS_CODE || statusCode > MAX_HTTP_STATUS_CODE) { - throw invalidRange(value); + throw invalidRange(originalValue); } return statusCode; } diff --git a/sentry/src/test/java/io/sentry/HttpStatusCodeRangeTest.kt b/sentry/src/test/java/io/sentry/HttpStatusCodeRangeTest.kt index fc9f4801606..9862ca84998 100644 --- a/sentry/src/test/java/io/sentry/HttpStatusCodeRangeTest.kt +++ b/sentry/src/test/java/io/sentry/HttpStatusCodeRangeTest.kt @@ -63,6 +63,14 @@ class HttpStatusCodeRangeTest { assertFalse(range.isInRange(405)) } + @Test + fun `parses an integer status code`() { + val range = HttpStatusCodeRange.valueOf(404) + + assertTrue(range.isInRange(404)) + assertFalse(range.isInRange(405)) + } + @Test fun `parses an inclusive range with whitespace`() { val range = HttpStatusCodeRange.valueOf(" 500 - 599 ") @@ -95,5 +103,8 @@ class HttpStatusCodeRangeTest { listOf("99", "600", "99-200", "500-600").forEach { assertFailsWith { HttpStatusCodeRange.valueOf(it) } } + listOf(99, 600).forEach { + assertFailsWith { HttpStatusCodeRange.valueOf(it) } + } } } From 2a02d6dd5c91b2357cefc9468092fedb80fb1766 Mon Sep 17 00:00:00 2001 From: Sentry Github Bot Date: Tue, 17 Nov 2026 08:18:40 +0000 Subject: [PATCH 10/19] Format code --- .../test/java/io/sentry/SentryClientTest.kt | 24 +++++-------------- 1 file changed, 6 insertions(+), 18 deletions(-) diff --git a/sentry/src/test/java/io/sentry/SentryClientTest.kt b/sentry/src/test/java/io/sentry/SentryClientTest.kt index fe55ef2d15b..8f7ddd4d706 100644 --- a/sentry/src/test/java/io/sentry/SentryClientTest.kt +++ b/sentry/src/test/java/io/sentry/SentryClientTest.kt @@ -1386,9 +1386,7 @@ class SentryClientTest { @Test fun `server transaction with ignored HTTP status is dropped before callbacks`() { - fixture.sentryOptions.setTraceIgnoreStatusCodes( - listOf(HttpStatusCodeRange(404)) - ) + fixture.sentryOptions.setTraceIgnoreStatusCodes(listOf(HttpStatusCodeRange(404))) val processor = mock() val beforeSend = mock() val replayController = mock() @@ -1426,9 +1424,7 @@ class SentryClientTest { @Test fun `server transaction with ignored HTTP status range accepts OTel long value`() { - fixture.sentryOptions.setTraceIgnoreStatusCodes( - listOf(HttpStatusCodeRange(500, 599)) - ) + fixture.sentryOptions.setTraceIgnoreStatusCodes(listOf(HttpStatusCodeRange(500, 599))) val eventId = fixture @@ -1452,9 +1448,7 @@ class SentryClientTest { @Test fun `HTTP status filter only applies to server transactions`() { - fixture.sentryOptions.setTraceIgnoreStatusCodes( - listOf(HttpStatusCodeRange(404)) - ) + fixture.sentryOptions.setTraceIgnoreStatusCodes(listOf(HttpStatusCodeRange(404))) val clientTransaction = createServerTransaction(404) clientTransaction.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY] = "client" val missingKindTransaction = createServerTransaction(404) @@ -1469,9 +1463,7 @@ class SentryClientTest { @Test fun `HTTP status filter ignores missing and invalid root status values`() { - fixture.sentryOptions.setTraceIgnoreStatusCodes( - listOf(HttpStatusCodeRange(404)) - ) + fixture.sentryOptions.setTraceIgnoreStatusCodes(listOf(HttpStatusCodeRange(404))) val invalidStatusValues = listOf("404", 404.0, 404.5f, 99, 600, Long.MAX_VALUE) val sut = fixture.getSut() @@ -1490,9 +1482,7 @@ class SentryClientTest { @Test fun `HTTP status filter does not read child span attributes`() { - fixture.sentryOptions.setTraceIgnoreStatusCodes( - listOf(HttpStatusCodeRange(404)) - ) + fixture.sentryOptions.setTraceIgnoreStatusCodes(listOf(HttpStatusCodeRange(404))) val tracer = SentryTracer( TransactionContext("child-status-transaction", "op", TracesSamplingDecision(true)), @@ -1512,9 +1502,7 @@ class SentryClientTest { @Test fun `profiling trace deletion failure for ignored transaction is logged`() { - fixture.sentryOptions.setTraceIgnoreStatusCodes( - listOf(HttpStatusCodeRange(404)) - ) + fixture.sentryOptions.setTraceIgnoreStatusCodes(listOf(HttpStatusCodeRange(404))) val traceFile = mock() whenever(traceFile.delete()).thenReturn(false) whenever(traceFile.path).thenReturn("undeletable.trace") From cf2f6fc302238f32691549f2137cb5d93a9275a5 Mon Sep 17 00:00:00 2001 From: Alexander Dinauer Date: Tue, 17 Nov 2026 11:07:00 +0100 Subject: [PATCH 11/19] feat(tracing): Align ignored status defaults with spec Default traceIgnoreStatusCodes to 301-303, 305-399, and 401-404 instead of only 404. Update documentation and boundary coverage so excluded gaps remain captured. Refs #4736 Co-Authored-By: Claude --- CHANGELOG.md | 6 ++--- .../boot4/SentryAutoConfigurationTest.kt | 13 +++++++--- .../jakarta/SentryAutoConfigurationTest.kt | 13 +++++++--- sentry-spring-boot/README.md | 4 +-- .../boot/SentryAutoConfigurationTest.kt | 13 +++++++--- .../main/java/io/sentry/SentryOptions.java | 9 +++++-- .../test/java/io/sentry/SentryClientTest.kt | 25 +++++++++++++++---- .../test/java/io/sentry/SentryOptionsTest.kt | 23 +++++++++++------ 8 files changed, 74 insertions(+), 32 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index e602ff2d604..8ed609d1f23 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -52,9 +52,9 @@ `logsEnabled` argument. Pass `false` to keep Sentry Logs disabled. - Disable tracing for HTTP `OPTIONS` requests by default. Set `traceOptionsRequests` to `true` to preserve the previous behavior ([#6254](https://github.com/getsentry/sentry-java/pull/6254)) -- Incoming HTTP server transactions that finish with status 404 are no longer sent to Sentry by - default. This includes matched endpoints that intentionally return 404. Outgoing HTTP requests - that receive a 404 are unaffected. +- Incoming HTTP server transactions that finish with status 301-303, 305-399, or 401-404 are no + longer sent to Sentry by default. This includes matched endpoints that intentionally return one + of these statuses. Outgoing HTTP requests with matching statuses are unaffected. Restore the previous behavior and trace every incoming HTTP status with an empty configuration: diff --git a/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryAutoConfigurationTest.kt b/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryAutoConfigurationTest.kt index eb88d735113..f2d02ce4825 100644 --- a/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryAutoConfigurationTest.kt +++ b/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryAutoConfigurationTest.kt @@ -343,11 +343,16 @@ class SentryAutoConfigurationTest { } @Test - fun `ignored server HTTP status codes default to 404`() { + fun `ignored server HTTP status codes use the spec defaults`() { contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj").run { - val ranges = it.getBean(SentryProperties::class.java).traceIgnoreStatusCodes - assertThat(ranges).hasSize(1) - assertThat(ranges!!.single().isInRange(404)).isTrue() + val ranges = it.getBean(SentryProperties::class.java).traceIgnoreStatusCodes!! + assertThat(ranges).hasSize(3) + listOf(301, 303, 305, 399, 401, 404).forEach { statusCode -> + assertThat(ranges.any { it.isInRange(statusCode) }).isTrue() + } + listOf(300, 304, 400, 405).forEach { statusCode -> + assertThat(ranges.any { it.isInRange(statusCode) }).isFalse() + } } } diff --git a/sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryAutoConfigurationTest.kt b/sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryAutoConfigurationTest.kt index d5305fcab45..a7630082a74 100644 --- a/sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryAutoConfigurationTest.kt +++ b/sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryAutoConfigurationTest.kt @@ -351,11 +351,16 @@ class SentryAutoConfigurationTest { } @Test - fun `ignored server HTTP status codes default to 404`() { + fun `ignored server HTTP status codes use the spec defaults`() { contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj").run { - val ranges = it.getBean(SentryProperties::class.java).traceIgnoreStatusCodes - assertThat(ranges).hasSize(1) - assertThat(ranges!!.single().isInRange(404)).isTrue() + val ranges = it.getBean(SentryProperties::class.java).traceIgnoreStatusCodes!! + assertThat(ranges).hasSize(3) + listOf(301, 303, 305, 399, 401, 404).forEach { statusCode -> + assertThat(ranges.any { it.isInRange(statusCode) }).isTrue() + } + listOf(300, 304, 400, 405).forEach { statusCode -> + assertThat(ranges.any { it.isInRange(statusCode) }).isFalse() + } } } diff --git a/sentry-spring-boot/README.md b/sentry-spring-boot/README.md index 4d6f6c9c1a3..b5be441e901 100644 --- a/sentry-spring-boot/README.md +++ b/sentry-spring-boot/README.md @@ -7,8 +7,8 @@ For more information check out [Sentry Spring Boot documentation](https://docs.s ## Ignoring server transactions by HTTP status -Incoming server transactions that finish with HTTP status 404 are not sent to Sentry by default. -Set `sentry.trace-ignore-status-codes` to replace the default with a +Incoming server transactions that finish with HTTP status 301-303, 305-399, or 401-404 are not +sent to Sentry by default. Set `sentry.trace-ignore-status-codes` to replace the default with a comma-separated list of individual status codes and inclusive ranges: ```properties diff --git a/sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryAutoConfigurationTest.kt b/sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryAutoConfigurationTest.kt index 3076bb532ce..2cdec61d620 100644 --- a/sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryAutoConfigurationTest.kt +++ b/sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryAutoConfigurationTest.kt @@ -349,11 +349,16 @@ class SentryAutoConfigurationTest { } @Test - fun `ignored server HTTP status codes default to 404`() { + fun `ignored server HTTP status codes use the spec defaults`() { contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj").run { - val ranges = it.getBean(SentryProperties::class.java).traceIgnoreStatusCodes - assertThat(ranges).hasSize(1) - assertThat(ranges!!.single().isInRange(404)).isTrue() + val ranges = it.getBean(SentryProperties::class.java).traceIgnoreStatusCodes!! + assertThat(ranges).hasSize(3) + listOf(301, 303, 305, 399, 401, 404).forEach { statusCode -> + assertThat(ranges.any { it.isInRange(statusCode) }).isTrue() + } + listOf(300, 304, 400, 405).forEach { statusCode -> + assertThat(ranges.any { it.isInRange(statusCode) }).isFalse() + } } } diff --git a/sentry/src/main/java/io/sentry/SentryOptions.java b/sentry/src/main/java/io/sentry/SentryOptions.java index 3fec7e91762..b32769c6823 100644 --- a/sentry/src/main/java/io/sentry/SentryOptions.java +++ b/sentry/src/main/java/io/sentry/SentryOptions.java @@ -40,6 +40,7 @@ import io.sentry.util.thread.NoOpThreadChecker; import java.io.File; import java.util.ArrayList; +import java.util.Arrays; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; @@ -599,7 +600,11 @@ public class SentryOptions implements RateLimiterConfig { private @Nullable List ignoredTransactions = null; private @Nullable List traceIgnoreStatusCodes = - new ArrayList<>(Collections.singletonList(new HttpStatusCodeRange(404))); + new ArrayList<>( + Arrays.asList( + new HttpStatusCodeRange(301, 303), + new HttpStatusCodeRange(305, 399), + new HttpStatusCodeRange(401, 404))); @ApiStatus.Experimental private @NotNull IBackpressureMonitor backpressureMonitor = NoOpBackpressureMonitor.getInstance(); @@ -3152,7 +3157,7 @@ public void setIgnoredTransactions(final @Nullable List ignoredTransacti /** * Returns the HTTP status codes and inclusive ranges for which incoming server transactions are - * not sent to Sentry. Defaults to a single range containing 404. An empty list disables this + * not sent to Sentry. Defaults to 301-303, 305-399, and 401-404. An empty list disables this * filter. * * @return the configured HTTP status code ranges, or {@code null} if explicitly set to null diff --git a/sentry/src/test/java/io/sentry/SentryClientTest.kt b/sentry/src/test/java/io/sentry/SentryClientTest.kt index f88130250c1..b60ce2f97d9 100644 --- a/sentry/src/test/java/io/sentry/SentryClientTest.kt +++ b/sentry/src/test/java/io/sentry/SentryClientTest.kt @@ -1422,12 +1422,27 @@ class SentryClientTest { } @Test - fun `default HTTP status filter retains server 200`() { - fixture - .getSut() - .captureTransaction(createServerTransaction(200), fixture.sentryTracer.traceContext()) + fun `default HTTP status filter drops the spec ranges`() { + val sut = fixture.getSut() - verify(fixture.transport).send(any(), anyOrNull()) + listOf(301, 303, 305, 399, 401, 404).forEach { + val eventId = + sut.captureTransaction(createServerTransaction(it), fixture.sentryTracer.traceContext()) + assertThat(eventId).isEqualTo(SentryId.EMPTY_ID) + } + + verify(fixture.transport, never()).send(any(), anyOrNull()) + } + + @Test + fun `default HTTP status filter retains statuses outside the spec ranges`() { + val sut = fixture.getSut() + + listOf(200, 300, 304, 400, 405).forEach { + sut.captureTransaction(createServerTransaction(it), fixture.sentryTracer.traceContext()) + } + + verify(fixture.transport, times(5)).send(any(), anyOrNull()) } @Test diff --git a/sentry/src/test/java/io/sentry/SentryOptionsTest.kt b/sentry/src/test/java/io/sentry/SentryOptionsTest.kt index 6a80635bd40..7da0b5ced72 100644 --- a/sentry/src/test/java/io/sentry/SentryOptionsTest.kt +++ b/sentry/src/test/java/io/sentry/SentryOptionsTest.kt @@ -1088,11 +1088,16 @@ class SentryOptionsTest { } @Test - fun `ignored server HTTP status codes for tracing default to 404`() { - val ranges = SentryOptions().traceIgnoreStatusCodes + fun `ignored server HTTP status codes for tracing use the spec defaults`() { + val ranges = SentryOptions().traceIgnoreStatusCodes!! - assertThat(ranges).hasSize(1) - assertThat(ranges!!.single().isInRange(404)).isTrue() + assertThat(ranges).hasSize(3) + listOf(301, 303, 305, 399, 401, 404).forEach { + assertThat(ranges.any { range -> range.isInRange(it) }).isTrue() + } + listOf(300, 304, 400, 405).forEach { + assertThat(ranges.any { range -> range.isInRange(it) }).isFalse() + } } @Test @@ -1102,8 +1107,9 @@ class SentryOptionsTest { first.clear() - assertThat(second).hasSize(1) - assertThat(second.single().isInRange(404)).isTrue() + assertThat(second).hasSize(3) + assertThat(second.any { it.isInRange(301) }).isTrue() + assertThat(second.any { it.isInRange(404) }).isTrue() } @Test @@ -1150,8 +1156,9 @@ class SentryOptionsTest { options.merge(ExternalOptions()) - assertThat(options.traceIgnoreStatusCodes).hasSize(1) - assertThat(options.traceIgnoreStatusCodes!!.single().isInRange(404)).isTrue() + assertThat(options.traceIgnoreStatusCodes).hasSize(3) + assertThat(options.traceIgnoreStatusCodes!!.any { it.isInRange(301) }).isTrue() + assertThat(options.traceIgnoreStatusCodes!!.any { it.isInRange(404) }).isTrue() } @Test From 3ad504c71b85730b9d5d0de4c68d5755917a5e6f Mon Sep 17 00:00:00 2001 From: Alexander Dinauer Date: Thu, 19 Nov 2026 10:48:43 +0100 Subject: [PATCH 12/19] fix(core): Make trace ignore statuses thread-safe Store traceIgnoreStatusCodes in a copy-on-write list so callers can mutate the exposed configuration while transactions iterate it. Mark the replaceable reference volatile so setter updates are visible across threads. Refs #4736 Co-Authored-By: Claude --- sentry/src/main/java/io/sentry/SentryOptions.java | 6 +++--- sentry/src/test/java/io/sentry/SentryOptionsTest.kt | 13 +++++++++++++ 2 files changed, 16 insertions(+), 3 deletions(-) diff --git a/sentry/src/main/java/io/sentry/SentryOptions.java b/sentry/src/main/java/io/sentry/SentryOptions.java index b32769c6823..c8979b3ada4 100644 --- a/sentry/src/main/java/io/sentry/SentryOptions.java +++ b/sentry/src/main/java/io/sentry/SentryOptions.java @@ -599,8 +599,8 @@ public class SentryOptions implements RateLimiterConfig { */ private @Nullable List ignoredTransactions = null; - private @Nullable List traceIgnoreStatusCodes = - new ArrayList<>( + private volatile @Nullable List traceIgnoreStatusCodes = + new CopyOnWriteArrayList<>( Arrays.asList( new HttpStatusCodeRange(301, 303), new HttpStatusCodeRange(305, 399), @@ -3179,7 +3179,7 @@ public void setIgnoredTransactions(final @Nullable List ignoredTransacti public void setTraceIgnoreStatusCodes( final @Nullable List traceIgnoreStatusCodes) { this.traceIgnoreStatusCodes = - traceIgnoreStatusCodes == null ? null : new ArrayList<>(traceIgnoreStatusCodes); + traceIgnoreStatusCodes == null ? null : new CopyOnWriteArrayList<>(traceIgnoreStatusCodes); } /** Returns the current {@link SentryDateProvider} that is used to retrieve the current date. */ diff --git a/sentry/src/test/java/io/sentry/SentryOptionsTest.kt b/sentry/src/test/java/io/sentry/SentryOptionsTest.kt index 7da0b5ced72..e18c1d8de36 100644 --- a/sentry/src/test/java/io/sentry/SentryOptionsTest.kt +++ b/sentry/src/test/java/io/sentry/SentryOptionsTest.kt @@ -10,6 +10,7 @@ import io.sentry.util.LazyEvaluator import io.sentry.util.StringUtils import java.io.File import java.net.Proxy +import java.util.concurrent.CopyOnWriteArrayList import kotlin.test.Test import kotlin.test.assertEquals import kotlin.test.assertFailsWith @@ -1091,6 +1092,7 @@ class SentryOptionsTest { fun `ignored server HTTP status codes for tracing use the spec defaults`() { val ranges = SentryOptions().traceIgnoreStatusCodes!! + assertThat(ranges).isInstanceOf(CopyOnWriteArrayList::class.java) assertThat(ranges).hasSize(3) listOf(301, 303, 305, 399, 401, 404).forEach { assertThat(ranges.any { range -> range.isInRange(it) }).isTrue() @@ -1112,6 +1114,16 @@ class SentryOptionsTest { assertThat(second.any { it.isInRange(404) }).isTrue() } + @Test + fun `ignored server HTTP status code iteration uses a stable snapshot`() { + val ranges = SentryOptions().traceIgnoreStatusCodes!! + val iterator = ranges.iterator() + + ranges.clear() + + assertThat(iterator.asSequence().toList()).hasSize(3) + } + @Test fun `ignored server HTTP status code setter preserves null, empty and custom ranges`() { val options = SentryOptions() @@ -1123,6 +1135,7 @@ class SentryOptionsTest { assertThat(options.traceIgnoreStatusCodes).isEmpty() options.traceIgnoreStatusCodes = listOf(HttpStatusCodeRange(404), HttpStatusCodeRange(500, 599)) + assertThat(options.traceIgnoreStatusCodes).isInstanceOf(CopyOnWriteArrayList::class.java) assertThat(options.traceIgnoreStatusCodes).hasSize(2) assertThat(options.traceIgnoreStatusCodes!![0].isInRange(404)).isTrue() assertThat(options.traceIgnoreStatusCodes!![1].isInRange(599)).isTrue() From 7562d98848d1053b97305fa6414a4be26733dde7 Mon Sep 17 00:00:00 2001 From: Alexander Dinauer Date: Thu, 19 Nov 2026 11:04:00 +0100 Subject: [PATCH 13/19] feat(core): Add Sentry span kind constants Expose the values supported by the sentry.kind convention and use the server constant across Spring and OpenTelemetry instrumentation. This keeps convention keys and values separate while avoiding duplicated literals. Refs #4735 Co-Authored-By: Claude --- .../sentry/opentelemetry/SentrySpanExporter.java | 3 ++- .../spring7/tracing/SentryTracingFilter.java | 3 ++- .../spring7/webflux/AbstractSentryWebFilter.java | 3 ++- .../jakarta/tracing/SentryTracingFilter.java | 3 ++- .../jakarta/webflux/AbstractSentryWebFilter.java | 3 ++- .../spring/tracing/SentryTracingFilter.java | 3 ++- .../io/sentry/spring/webflux/SentryWebFilter.java | 3 ++- sentry/api/sentry.api | 8 ++++++++ .../src/main/java/io/sentry/SentrySpanKind.java | 12 ++++++++++++ .../src/test/java/io/sentry/SentrySpanKindTest.kt | 15 +++++++++++++++ 10 files changed, 49 insertions(+), 7 deletions(-) create mode 100644 sentry/src/main/java/io/sentry/SentrySpanKind.java create mode 100644 sentry/src/test/java/io/sentry/SentrySpanKindTest.kt diff --git a/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SentrySpanExporter.java b/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SentrySpanExporter.java index 571fddc6e83..c442bc3b216 100644 --- a/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SentrySpanExporter.java +++ b/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SentrySpanExporter.java @@ -28,6 +28,7 @@ import io.sentry.SentryInstantDate; import io.sentry.SentryLevel; import io.sentry.SentryLongDate; +import io.sentry.SentrySpanKind; import io.sentry.SpanContext; import io.sentry.SpanDataConvention; import io.sentry.SpanId; @@ -565,7 +566,7 @@ private void setOtelSpanKind(final @NotNull SpanData otelSpan, final @NotNull IS private void setSentrySpanKind( final @NotNull SpanData otelSpan, final @NotNull ISpan sentrySpan) { if (SpanKind.SERVER.equals(otelSpan.getKind())) { - sentrySpan.setData(SpanDataConvention.SENTRY_KIND_KEY, "server"); + sentrySpan.setData(SpanDataConvention.SENTRY_KIND_KEY, SentrySpanKind.SERVER); } } diff --git a/sentry-spring-7/src/main/java/io/sentry/spring7/tracing/SentryTracingFilter.java b/sentry-spring-7/src/main/java/io/sentry/spring7/tracing/SentryTracingFilter.java index 39e2fc3ec9e..8d9904e5bd4 100644 --- a/sentry-spring-7/src/main/java/io/sentry/spring7/tracing/SentryTracingFilter.java +++ b/sentry-spring-7/src/main/java/io/sentry/spring7/tracing/SentryTracingFilter.java @@ -8,6 +8,7 @@ import io.sentry.IScopes; import io.sentry.ITransaction; import io.sentry.ScopesAdapter; +import io.sentry.SentrySpanKind; import io.sentry.SentryTraceHeader; import io.sentry.SpanDataConvention; import io.sentry.SpanStatus; @@ -260,7 +261,7 @@ private ITransaction startTransaction( new TransactionContext(name, TransactionNameSource.URL, "http.server"), transactionOptions); } - transaction.setData(SpanDataConvention.SENTRY_KIND_KEY, "server"); + transaction.setData(SpanDataConvention.SENTRY_KIND_KEY, SentrySpanKind.SERVER); return transaction; } } diff --git a/sentry-spring-7/src/main/java/io/sentry/spring7/webflux/AbstractSentryWebFilter.java b/sentry-spring-7/src/main/java/io/sentry/spring7/webflux/AbstractSentryWebFilter.java index 0301159bb4d..53f2ed2ad54 100644 --- a/sentry-spring-7/src/main/java/io/sentry/spring7/webflux/AbstractSentryWebFilter.java +++ b/sentry-spring-7/src/main/java/io/sentry/spring7/webflux/AbstractSentryWebFilter.java @@ -12,6 +12,7 @@ import io.sentry.ITransaction; import io.sentry.NoOpScopes; import io.sentry.Sentry; +import io.sentry.SentrySpanKind; import io.sentry.SentryTraceHeader; import io.sentry.SpanDataConvention; import io.sentry.SpanStatus; @@ -169,7 +170,7 @@ private void finishTransaction(ServerWebExchange exchange, ITransaction transact new TransactionContext(name, TransactionNameSource.URL, TRANSACTION_OP), transactionOptions); } - transaction.setData(SpanDataConvention.SENTRY_KIND_KEY, "server"); + transaction.setData(SpanDataConvention.SENTRY_KIND_KEY, SentrySpanKind.SERVER); return transaction; } } diff --git a/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/tracing/SentryTracingFilter.java b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/tracing/SentryTracingFilter.java index ddc1c25ec72..9259dce62ba 100644 --- a/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/tracing/SentryTracingFilter.java +++ b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/tracing/SentryTracingFilter.java @@ -8,6 +8,7 @@ import io.sentry.IScopes; import io.sentry.ITransaction; import io.sentry.ScopesAdapter; +import io.sentry.SentrySpanKind; import io.sentry.SentryTraceHeader; import io.sentry.SpanDataConvention; import io.sentry.SpanStatus; @@ -260,7 +261,7 @@ private ITransaction startTransaction( new TransactionContext(name, TransactionNameSource.URL, "http.server"), transactionOptions); } - transaction.setData(SpanDataConvention.SENTRY_KIND_KEY, "server"); + transaction.setData(SpanDataConvention.SENTRY_KIND_KEY, SentrySpanKind.SERVER); return transaction; } } diff --git a/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/webflux/AbstractSentryWebFilter.java b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/webflux/AbstractSentryWebFilter.java index 2468b43d20f..8b8252bac57 100644 --- a/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/webflux/AbstractSentryWebFilter.java +++ b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/webflux/AbstractSentryWebFilter.java @@ -12,6 +12,7 @@ import io.sentry.ITransaction; import io.sentry.NoOpScopes; import io.sentry.Sentry; +import io.sentry.SentrySpanKind; import io.sentry.SentryTraceHeader; import io.sentry.SpanDataConvention; import io.sentry.SpanStatus; @@ -169,7 +170,7 @@ private void finishTransaction(ServerWebExchange exchange, ITransaction transact new TransactionContext(name, TransactionNameSource.URL, TRANSACTION_OP), transactionOptions); } - transaction.setData(SpanDataConvention.SENTRY_KIND_KEY, "server"); + transaction.setData(SpanDataConvention.SENTRY_KIND_KEY, SentrySpanKind.SERVER); return transaction; } } diff --git a/sentry-spring/src/main/java/io/sentry/spring/tracing/SentryTracingFilter.java b/sentry-spring/src/main/java/io/sentry/spring/tracing/SentryTracingFilter.java index 9a74b27c234..6371134cdec 100644 --- a/sentry-spring/src/main/java/io/sentry/spring/tracing/SentryTracingFilter.java +++ b/sentry-spring/src/main/java/io/sentry/spring/tracing/SentryTracingFilter.java @@ -8,6 +8,7 @@ import io.sentry.IScopes; import io.sentry.ITransaction; import io.sentry.ScopesAdapter; +import io.sentry.SentrySpanKind; import io.sentry.SentryTraceHeader; import io.sentry.SpanDataConvention; import io.sentry.SpanStatus; @@ -259,7 +260,7 @@ private ITransaction startTransaction( new TransactionContext(name, TransactionNameSource.URL, "http.server"), transactionOptions); } - transaction.setData(SpanDataConvention.SENTRY_KIND_KEY, "server"); + transaction.setData(SpanDataConvention.SENTRY_KIND_KEY, SentrySpanKind.SERVER); return transaction; } } diff --git a/sentry-spring/src/main/java/io/sentry/spring/webflux/SentryWebFilter.java b/sentry-spring/src/main/java/io/sentry/spring/webflux/SentryWebFilter.java index 9f907b206dd..0743b6bb0ea 100644 --- a/sentry-spring/src/main/java/io/sentry/spring/webflux/SentryWebFilter.java +++ b/sentry-spring/src/main/java/io/sentry/spring/webflux/SentryWebFilter.java @@ -12,6 +12,7 @@ import io.sentry.ITransaction; import io.sentry.NoOpScopes; import io.sentry.Sentry; +import io.sentry.SentrySpanKind; import io.sentry.SentryTraceHeader; import io.sentry.SpanDataConvention; import io.sentry.SpanStatus; @@ -146,7 +147,7 @@ private boolean shouldTraceRequest( new TransactionContext(name, TransactionNameSource.URL, TRANSACTION_OP), transactionOptions); } - transaction.setData(SpanDataConvention.SENTRY_KIND_KEY, "server"); + transaction.setData(SpanDataConvention.SENTRY_KIND_KEY, SentrySpanKind.SERVER); return transaction; } diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api index 49e5242da7f..e1465518e76 100644 --- a/sentry/api/sentry.api +++ b/sentry/api/sentry.api @@ -4043,6 +4043,14 @@ public final class io/sentry/SentryReplayOptions$SentryReplayQuality : java/lang public static fun values ()[Lio/sentry/SentryReplayOptions$SentryReplayQuality; } +public final class io/sentry/SentrySpanKind { + public static final field CLIENT Ljava/lang/String; + public static final field CONSUMER Ljava/lang/String; + public static final field INTERNAL Ljava/lang/String; + public static final field PRODUCER Ljava/lang/String; + public static final field SERVER Ljava/lang/String; +} + public final class io/sentry/SentryStackTraceFactory { public fun (Lio/sentry/SentryOptions;)V public fun getInAppCallStack ()Ljava/util/List; diff --git a/sentry/src/main/java/io/sentry/SentrySpanKind.java b/sentry/src/main/java/io/sentry/SentrySpanKind.java new file mode 100644 index 00000000000..50e20b0328b --- /dev/null +++ b/sentry/src/main/java/io/sentry/SentrySpanKind.java @@ -0,0 +1,12 @@ +package io.sentry; + +/** Values supported by the {@code sentry.kind} span data attribute. */ +public final class SentrySpanKind { + public static final String CLIENT = "client"; + public static final String SERVER = "server"; + public static final String PRODUCER = "producer"; + public static final String CONSUMER = "consumer"; + public static final String INTERNAL = "internal"; + + private SentrySpanKind() {} +} diff --git a/sentry/src/test/java/io/sentry/SentrySpanKindTest.kt b/sentry/src/test/java/io/sentry/SentrySpanKindTest.kt new file mode 100644 index 00000000000..8f09a54c884 --- /dev/null +++ b/sentry/src/test/java/io/sentry/SentrySpanKindTest.kt @@ -0,0 +1,15 @@ +package io.sentry + +import com.google.common.truth.Truth.assertThat +import kotlin.test.Test + +class SentrySpanKindTest { + @Test + fun `values match the sentry kind convention`() { + assertThat(SentrySpanKind.CLIENT).isEqualTo("client") + assertThat(SentrySpanKind.SERVER).isEqualTo("server") + assertThat(SentrySpanKind.PRODUCER).isEqualTo("producer") + assertThat(SentrySpanKind.CONSUMER).isEqualTo("consumer") + assertThat(SentrySpanKind.INTERNAL).isEqualTo("internal") + } +} From 19c9599b99830fa39416e42dbf86433a2974a559 Mon Sep 17 00:00:00 2001 From: Alexander Dinauer Date: Thu, 19 Nov 2026 11:06:40 +0100 Subject: [PATCH 14/19] ref(tracing): Use span kind constant for filtering Use the shared server span-kind value when identifying server transactions for HTTP status filtering. Refs #4735 Co-Authored-By: Claude --- sentry/src/main/java/io/sentry/SentryClient.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sentry/src/main/java/io/sentry/SentryClient.java b/sentry/src/main/java/io/sentry/SentryClient.java index b2121e5db1f..67a4c5125f0 100644 --- a/sentry/src/main/java/io/sentry/SentryClient.java +++ b/sentry/src/main/java/io/sentry/SentryClient.java @@ -1130,7 +1130,7 @@ public void captureSession(final @NotNull Session session, final @Nullable Hint final @Nullable SpanContext trace = transaction.getContexts().getTrace(); if (trace == null - || !"server".equals(trace.getData().get(SpanDataConvention.SENTRY_KIND_KEY))) { + || !SentrySpanKind.SERVER.equals(trace.getData().get(SpanDataConvention.SENTRY_KIND_KEY))) { return null; } From d72b66f1be878639f75b5105a88067fb44776f85 Mon Sep 17 00:00:00 2001 From: Alexander Dinauer Date: Thu, 19 Nov 2026 11:15:53 +0100 Subject: [PATCH 15/19] ref(core): Share ignored transaction accounting Extract the duplicated client-report accounting used when transactions are filtered by name or HTTP status. Refs #4735 Co-Authored-By: Claude --- .../src/main/java/io/sentry/SentryClient.java | 26 +++++++++---------- 1 file changed, 12 insertions(+), 14 deletions(-) diff --git a/sentry/src/main/java/io/sentry/SentryClient.java b/sentry/src/main/java/io/sentry/SentryClient.java index 67a4c5125f0..0b12ad79e03 100644 --- a/sentry/src/main/java/io/sentry/SentryClient.java +++ b/sentry/src/main/java/io/sentry/SentryClient.java @@ -1015,13 +1015,7 @@ public void captureSession(final @NotNull Session session, final @Nullable Hint SentryLevel.DEBUG, "Transaction was dropped as transaction name %s is ignored", transaction.getTransaction()); - options - .getClientReportRecorder() - .recordLostEvent(DiscardReason.EVENT_PROCESSOR, DataCategory.Transaction); - options - .getClientReportRecorder() - .recordLostEvent( - DiscardReason.EVENT_PROCESSOR, DataCategory.Span, transaction.getSpans().size() + 1); + recordLostTransactionAndSpans(transaction); return SentryId.EMPTY_ID; } @@ -1033,13 +1027,7 @@ public void captureSession(final @NotNull Session session, final @Nullable Hint SentryLevel.DEBUG, "Transaction was dropped as HTTP status code %d is ignored", ignoredHttpStatusCode); - options - .getClientReportRecorder() - .recordLostEvent(DiscardReason.EVENT_PROCESSOR, DataCategory.Transaction); - options - .getClientReportRecorder() - .recordLostEvent( - DiscardReason.EVENT_PROCESSOR, DataCategory.Span, transaction.getSpans().size() + 1); + recordLostTransactionAndSpans(transaction); if (profilingTraceData != null) { options .getClientReportRecorder() @@ -1121,6 +1109,16 @@ public void captureSession(final @NotNull Session session, final @Nullable Hint return sentryId; } + private void recordLostTransactionAndSpans(final @NotNull SentryTransaction transaction) { + options + .getClientReportRecorder() + .recordLostEvent(DiscardReason.EVENT_PROCESSOR, DataCategory.Transaction); + options + .getClientReportRecorder() + .recordLostEvent( + DiscardReason.EVENT_PROCESSOR, DataCategory.Span, transaction.getSpans().size() + 1); + } + private @Nullable Integer getIgnoredHttpStatusCode(final @NotNull SentryTransaction transaction) { final @Nullable List ignoredHttpStatusCodes = options.getTraceIgnoreStatusCodes(); From 4a173f28e1665c34d71f7143bfbfff009400d647 Mon Sep 17 00:00:00 2001 From: Alexander Dinauer Date: Thu, 19 Nov 2026 11:23:21 +0100 Subject: [PATCH 16/19] ref(core): Simplify HTTP status conversion Handle the supported integer status types through Number after validating the runtime type, preserving fail-open behavior for other numeric values. Refs #4735 Co-Authored-By: Claude --- sentry/src/main/java/io/sentry/SentryClient.java | 16 ++++------------ 1 file changed, 4 insertions(+), 12 deletions(-) diff --git a/sentry/src/main/java/io/sentry/SentryClient.java b/sentry/src/main/java/io/sentry/SentryClient.java index 0b12ad79e03..40f545b9b3b 100644 --- a/sentry/src/main/java/io/sentry/SentryClient.java +++ b/sentry/src/main/java/io/sentry/SentryClient.java @@ -1134,22 +1134,14 @@ private void recordLostTransactionAndSpans(final @NotNull SentryTransaction tran final @Nullable Object httpStatusCodeValue = trace.getData().get(SpanDataConvention.HTTP_STATUS_CODE_KEY); - final int httpStatusCode; - if (httpStatusCodeValue instanceof Integer) { - httpStatusCode = (Integer) httpStatusCodeValue; - } else if (httpStatusCodeValue instanceof Long) { - final long longHttpStatusCode = (Long) httpStatusCodeValue; - if (longHttpStatusCode < 100 || longHttpStatusCode > 599) { - return null; - } - httpStatusCode = (int) longHttpStatusCode; - } else { + if (!(httpStatusCodeValue instanceof Integer || httpStatusCodeValue instanceof Long)) { return null; } - - if (httpStatusCode < 100 || httpStatusCode > 599) { + final long longHttpStatusCode = ((Number) httpStatusCodeValue).longValue(); + if (longHttpStatusCode < 100 || longHttpStatusCode > 599) { return null; } + final int httpStatusCode = (int) longHttpStatusCode; for (final @Nullable HttpStatusCodeRange ignoredHttpStatusCode : ignoredHttpStatusCodes) { if (ignoredHttpStatusCode != null && ignoredHttpStatusCode.isInRange(httpStatusCode)) { return httpStatusCode; From 90a5ac4c1d45aec816b985f0fec3c9c1ab2be22e Mon Sep 17 00:00:00 2001 From: Sentry Github Bot Date: Thu, 19 Nov 2026 12:43:59 +0000 Subject: [PATCH 17/19] Format code --- .../src/test/kotlin/SentrySpanExporterTest.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/SentrySpanExporterTest.kt b/sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/SentrySpanExporterTest.kt index 84b852e6f15..77bb0682dbd 100644 --- a/sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/SentrySpanExporterTest.kt +++ b/sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/SentrySpanExporterTest.kt @@ -39,7 +39,7 @@ class SentrySpanExporterTest { init { whenever( - client.captureTransaction(anyOrNull(), anyOrNull(), anyOrNull(), anyOrNull(), anyOrNull()) + client.captureTransaction(anyOrNull(), anyOrNull(), anyOrNull(), anyOrNull(), anyOrNull()), ) .thenReturn(SentryId()) Sentry.setCurrentScopes(scopes) From 97d463a517b48241845bf2e451c774102f02ceb8 Mon Sep 17 00:00:00 2001 From: Alexander Dinauer Date: Thu, 19 Nov 2026 13:48:18 +0100 Subject: [PATCH 18/19] docs(changelog): Document ignored status defaults State the default traceIgnoreStatusCodes ranges in the feature entry so users understand which incoming transactions are filtered without additional configuration. Refs #4736 Co-Authored-By: Claude --- CHANGELOG.md | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 7b5e975e4aa..3c80979841f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -110,7 +110,11 @@ ### Features -- Drop incoming server transactions whose root HTTP response status matches `traceIgnoreStatusCodes`. Configure individual statuses such as `404`, inclusive ranges such as `400-499` or `500-599`, or combine them ([#6566](https://github.com/getsentry/sentry-java/pull/6566)). +- Drop incoming server transactions whose root HTTP response status matches + `traceIgnoreStatusCodes`. The option defaults to `301-303`, `305-399`, and `401-404`. Replace + the default with individual statuses such as `404`, inclusive ranges such as `400-499` or + `500-599`, or a combination of statuses and ranges + ([#6566](https://github.com/getsentry/sentry-java/pull/6566)). Java: From e61179ff6377b5929c9133863f7c407b8651c191 Mon Sep 17 00:00:00 2001 From: Sentry Github Bot Date: Thu, 19 Nov 2026 12:53:24 +0000 Subject: [PATCH 19/19] Format code --- .../io/sentry/spring/boot4/SentryAutoConfigurationTest.kt | 2 +- .../sentry/spring/boot/jakarta/SentryAutoConfigurationTest.kt | 2 +- .../kotlin/io/sentry/spring/boot/SentryAutoConfigurationTest.kt | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryAutoConfigurationTest.kt b/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryAutoConfigurationTest.kt index cfdaafa5bd5..fd714046809 100644 --- a/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryAutoConfigurationTest.kt +++ b/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryAutoConfigurationTest.kt @@ -371,7 +371,7 @@ class SentryAutoConfigurationTest { "sentry.trace-ignore-status-codes[0]" to 404, "sentry.trace-ignore-status-codes[1]" to "500-599", ), - ) + ), ) } .run { diff --git a/sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryAutoConfigurationTest.kt b/sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryAutoConfigurationTest.kt index 262a8722599..e581b8fc1ac 100644 --- a/sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryAutoConfigurationTest.kt +++ b/sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryAutoConfigurationTest.kt @@ -379,7 +379,7 @@ class SentryAutoConfigurationTest { "sentry.trace-ignore-status-codes[0]" to 404, "sentry.trace-ignore-status-codes[1]" to "500-599", ), - ) + ), ) } .run { diff --git a/sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryAutoConfigurationTest.kt b/sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryAutoConfigurationTest.kt index 869ce004578..8c9b641ef0a 100644 --- a/sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryAutoConfigurationTest.kt +++ b/sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryAutoConfigurationTest.kt @@ -377,7 +377,7 @@ class SentryAutoConfigurationTest { "sentry.trace-ignore-status-codes[0]" to 404, "sentry.trace-ignore-status-codes[1]" to "500-599", ), - ) + ), ) } .run {