diff --git a/CHANGELOG.md b/CHANGELOG.md index be7899e2dd..3c80979841 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -57,6 +57,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 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: + + 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 ([#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)) @@ -72,6 +110,43 @@ ### Features +- 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: + + ```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" + ``` + - Add policy-controlled URL query parameters and fragments to Ktor HTTP client spans ([#6433](https://github.com/getsentry/sentry-java/pull/6433)) - Session Replay: Add `Sentry.replay().pauseTouchTracking()` and `resumeTouchTracking()` to stop recording touches on sensitive screens, such as a custom PIN pad, while the screen recording continues. Touch tracking stays paused until `resumeTouchTracking()` is called, also for new replays and after `resume()` ([#6546](https://github.com/getsentry/sentry-java/pull/6546)) 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 cd5063d188..259fdd942b 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; @@ -27,7 +28,9 @@ 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; import io.sentry.SpanOptions; import io.sentry.SpanStatus; @@ -240,6 +243,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 +359,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); @@ -554,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, SentrySpanKind.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 0000000000..77bb0682db --- /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 a978c57d9c..8d9904e5bd 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,7 +8,9 @@ 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; import io.sentry.TransactionContext; import io.sentry.TransactionOptions; @@ -139,8 +141,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,6 +168,10 @@ private void doFilterWithTransaction( if (transactionName != null) { transaction.setName(transactionName, transactionNameSource); transaction.setOperation(TRANSACTION_OP); + // 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) { @@ -240,15 +248,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, 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 729dacbb0e..9fc324e6f9 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,7 +12,9 @@ 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; import io.sentry.TransactionContext; import io.sentry.TransactionOptions; @@ -126,6 +128,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(sentryResponse -> { @@ -153,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, SentrySpanKind.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 f3ed0769cd..18512b4d8a 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 @@ -137,6 +138,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(), @@ -163,6 +168,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) @@ -217,7 +242,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(), @@ -248,7 +279,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(), @@ -432,6 +467,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 d1a3459aba..c712328774 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 @@ -146,6 +147,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(), @@ -218,7 +245,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 48a17e7337..320bf002be 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) + .doesNotContainKey(SpanDataConvention.HTTP_STATUS_CODE_KEY) 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( @@ -93,6 +102,17 @@ class PersonIntegrationTest : IntegrationTest() { .isTrue() } + @Test + fun `default 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/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 cf2f5a4490..4fb71bc142 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 8ee19218dc..07bb65591e 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 8151eb4a8a..8a283f7d04 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,21 @@ 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 + fun `default 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 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 778d2ff263..fd71404680 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 @@ -264,6 +265,7 @@ class SentryAutoConfigurationTest { "sentry.ignored-errors=Some error,Another .*", "sentry.ignored-errors-for-deduplication=example.FirstException,example.SecondException", "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", @@ -319,6 +321,10 @@ class SentryAutoConfigurationTest { assertThat(options.ignoredErrorsForDeduplication) .containsOnly("example.FirstException", "example.SecondException") 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) @@ -339,6 +345,56 @@ class SentryAutoConfigurationTest { } } + @Test + 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(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() + } + } + } + + @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 + .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/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 cde6542b29..bb4e3a985c 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) + .doesNotContainKey(SpanDataConvention.HTTP_STATUS_CODE_KEY) 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( @@ -93,6 +102,17 @@ class PersonIntegrationTest : IntegrationTest() { .isTrue() } + @Test + fun `default 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/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 720af739ed..3c230d2eb7 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 2a84acf328..8de7af8825 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 c72ed55323..dcc87e293a 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,21 @@ 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 + fun `default 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 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 e3867e7408..e581b8fc1a 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 @@ -267,6 +268,7 @@ class SentryAutoConfigurationTest { "sentry.ignored-errors=Some error,Another .*", "sentry.ignored-errors-for-deduplication=example.FirstException,example.SecondException", "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", @@ -324,6 +326,10 @@ class SentryAutoConfigurationTest { assertThat(options.ignoredErrorsForDeduplication) .containsOnly("example.FirstException", "example.SecondException") 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) @@ -347,6 +353,56 @@ class SentryAutoConfigurationTest { } } + @Test + 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(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() + } + } + } + + @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 + .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/README.md b/sentry-spring-boot/README.md index 45ac8d7264..b5be441e90 100644 --- a/sentry-spring-boot/README.md +++ b/sentry-spring-boot/README.md @@ -4,3 +4,30 @@ 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 + +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 +sentry.trace-ignore-status-codes=404,500-599 +``` + +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/PersonIntegrationTest.kt b/sentry-spring-boot/src/integrationTest/kotlin/io/sentry/spring/boot/integrationtest/PersonIntegrationTest.kt index d6b7d8c1f5..6636c4fe28 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) + .doesNotContainKey(SpanDataConvention.HTTP_STATUS_CODE_KEY) 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( @@ -93,6 +102,17 @@ class PersonIntegrationTest : IntegrationTest() { .isTrue() } + @Test + fun `default 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/integrationTestOtelAgent/kotlin/io/sentry/spring/boot/otelagentintegrationtest/PersonIntegrationTest.kt b/sentry-spring-boot/src/integrationTestOtelAgent/kotlin/io/sentry/spring/boot/otelagentintegrationtest/PersonIntegrationTest.kt index 4b341af6f6..dae928e4a9 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 2ca952969b..2758ef8610 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 379d6a5913..57584cba90 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,21 @@ 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 + fun `default 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 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 258154ebb3..8c9b641ef0 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 @@ -265,6 +266,7 @@ class SentryAutoConfigurationTest { "sentry.ignored-errors=Some error,Another .*", "sentry.ignored-errors-for-deduplication=example.FirstException,example.SecondException", "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", @@ -322,6 +324,10 @@ class SentryAutoConfigurationTest { assertThat(options.ignoredErrorsForDeduplication) .containsOnly("example.FirstException", "example.SecondException") 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) @@ -345,6 +351,56 @@ class SentryAutoConfigurationTest { } } + @Test + 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(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() + } + } + } + + @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 + .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-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 4832e1c21f..9259dce62b 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,7 +8,9 @@ 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; import io.sentry.TransactionContext; import io.sentry.TransactionOptions; @@ -139,8 +141,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,6 +168,10 @@ private void doFilterWithTransaction( if (transactionName != null) { transaction.setName(transactionName, transactionNameSource); transaction.setOperation(TRANSACTION_OP); + // 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) { @@ -240,15 +248,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, 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 395de1eb97..7e58d4f65d 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,7 +12,9 @@ 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; import io.sentry.TransactionContext; import io.sentry.TransactionOptions; @@ -126,6 +128,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(sentryResponse -> { @@ -153,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, SentrySpanKind.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 a13911b3f8..c7bc91e3a9 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 @@ -137,6 +138,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(), @@ -163,6 +168,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) @@ -217,7 +242,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(), @@ -248,7 +279,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(), @@ -432,6 +467,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 035a5266ef..8688e09c02 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 @@ -146,6 +147,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(), @@ -218,7 +245,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 02da16feac..6371134cde 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,7 +8,9 @@ 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; import io.sentry.TransactionContext; import io.sentry.TransactionOptions; @@ -138,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 @@ -163,6 +167,10 @@ private void doFilterWithTransaction( if (transactionName != null) { transaction.setName(transactionName, transactionNameSource); transaction.setOperation(TRANSACTION_OP); + // 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) { @@ -239,15 +247,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, 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 65153e475e..3c1ce6793d 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,7 +12,9 @@ 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; import io.sentry.TransactionContext; import io.sentry.TransactionOptions; @@ -129,17 +131,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, SentrySpanKind.SERVER); + return transaction; } private void finishTransaction(ServerWebExchange exchange, ITransaction transaction) { @@ -152,6 +158,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(sentryResponse -> { 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 9039fa01e3..5fa12ce14f 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 @@ -137,6 +138,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(), @@ -163,6 +168,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) @@ -217,7 +242,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(), @@ -248,7 +279,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(), @@ -432,6 +467,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 c72506e7e9..67d2872965 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 @@ -147,6 +148,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(), @@ -219,7 +246,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 b5a9276b85..aef699711a 100644 --- a/sentry/api/sentry.api +++ b/sentry/api/sentry.api @@ -591,6 +591,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; @@ -649,6 +650,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 } @@ -715,6 +717,8 @@ 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; } public abstract interface class io/sentry/IAppStartExtender { @@ -3634,6 +3638,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; @@ -3803,6 +3808,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 setTracesSampleRate (Ljava/lang/Double;)V @@ -4060,6 +4066,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; @@ -4377,6 +4391,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/ExternalOptions.java b/sentry/src/main/java/io/sentry/ExternalOptions.java index 168e582379..0053e6a644 100644 --- a/sentry/src/main/java/io/sentry/ExternalOptions.java +++ b/sentry/src/main/java/io/sentry/ExternalOptions.java @@ -51,6 +51,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; @@ -163,6 +164,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")); @@ -246,6 +248,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(); @@ -634,6 +660,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 690ab115c5..ccd69b2cbd 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,75 @@ 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); + } + + /** + * 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))) { + throw invalidRange(value); + } + } + + final int statusCode; + try { + statusCode = Integer.parseInt(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(originalValue); + } + 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/SentryClient.java b/sentry/src/main/java/io/sentry/SentryClient.java index b502743262..fee066e1e6 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; @@ -1011,13 +1012,25 @@ public void captureSession(final @NotNull Session session, final @Nullable Hint SentryLevel.DEBUG, "Transaction was dropped as transaction name %s is ignored", transaction.getTransaction()); + recordLostTransactionAndSpans(transaction); + return SentryId.EMPTY_ID; + } + + final @Nullable Integer ignoredHttpStatusCode = getIgnoredHttpStatusCode(transaction); + if (ignoredHttpStatusCode != null) { options - .getClientReportRecorder() - .recordLostEvent(DiscardReason.EVENT_PROCESSOR, DataCategory.Transaction); - options - .getClientReportRecorder() - .recordLostEvent( - DiscardReason.EVENT_PROCESSOR, DataCategory.Span, transaction.getSpans().size() + 1); + .getLogger() + .log( + SentryLevel.DEBUG, + "Transaction was dropped as HTTP status code %d is ignored", + ignoredHttpStatusCode); + recordLostTransactionAndSpans(transaction); + if (profilingTraceData != null) { + options + .getClientReportRecorder() + .recordLostEvent(DiscardReason.EVENT_PROCESSOR, DataCategory.Profile); + } + deleteProfilingTraceFile(profilingTraceData); return SentryId.EMPTY_ID; } @@ -1093,6 +1106,73 @@ 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(); + if (ignoredHttpStatusCodes == null || ignoredHttpStatusCodes.isEmpty()) { + return null; + } + + final @Nullable SpanContext trace = transaction.getContexts().getTrace(); + if (trace == null + || !SentrySpanKind.SERVER.equals(trace.getData().get(SpanDataConvention.SENTRY_KIND_KEY))) { + return null; + } + + final @Nullable Object httpStatusCodeValue = + trace.getData().get(SpanDataConvention.HTTP_STATUS_CODE_KEY); + if (!(httpStatusCodeValue instanceof Integer || httpStatusCodeValue instanceof Long)) { + return null; + } + 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; + } + } + 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/main/java/io/sentry/SentryOptions.java b/sentry/src/main/java/io/sentry/SentryOptions.java index 5ba97164a5..115c4d391b 100644 --- a/sentry/src/main/java/io/sentry/SentryOptions.java +++ b/sentry/src/main/java/io/sentry/SentryOptions.java @@ -605,6 +605,13 @@ public class SentryOptions implements RateLimiterConfig { */ private @Nullable List ignoredTransactions = null; + private volatile @Nullable List traceIgnoreStatusCodes = + new CopyOnWriteArrayList<>( + Arrays.asList( + new HttpStatusCodeRange(301, 303), + new HttpStatusCodeRange(305, 399), + new HttpStatusCodeRange(401, 404))); + @ApiStatus.Experimental private @NotNull IBackpressureMonitor backpressureMonitor = NoOpBackpressureMonitor.getInstance(); @@ -3189,6 +3196,33 @@ 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 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 + */ + 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 or + * {@code null} disables this 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 CopyOnWriteArrayList<>(traceIgnoreStatusCodes); + } + /** Returns the current {@link SentryDateProvider} that is used to retrieve the current date. */ @ApiStatus.Internal public @NotNull SentryDateProvider getDateProvider() { @@ -3865,6 +3899,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/main/java/io/sentry/SentrySpanKind.java b/sentry/src/main/java/io/sentry/SentrySpanKind.java new file mode 100644 index 0000000000..50e20b0328 --- /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/main/java/io/sentry/SpanDataConvention.java b/sentry/src/main/java/io/sentry/SpanDataConvention.java index 4ede74505c..93760fb8dc 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"; diff --git a/sentry/src/test/java/io/sentry/ExternalOptionsTest.kt b/sentry/src/test/java/io/sentry/ExternalOptionsTest.kt index fda34716b9..8e98e6c60b 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 { @@ -431,6 +432,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 b50806b0a0..9862ca8499 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,57 @@ 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 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 ") + + 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) } + } + listOf(99, 600).forEach { + assertFailsWith { HttpStatusCodeRange.valueOf(it) } + } + } } diff --git a/sentry/src/test/java/io/sentry/SentryClientTest.kt b/sentry/src/test/java/io/sentry/SentryClientTest.kt index c1e96f842b..f854ef9e09 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) @@ -1382,6 +1383,170 @@ class SentryClientTest { assertEquals(SentryId.EMPTY_ID, eventId) } + @Test + fun `server transaction with default ignored HTTP status is dropped before callbacks`() { + 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 `default HTTP status filter drops the spec ranges`() { + val sut = fixture.getSut() + + 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 + fun `custom HTTP status range replaces default and accepts OTel long value`() { + fixture.sentryOptions.setTraceIgnoreStatusCodes(listOf(HttpStatusCodeRange(500, 599))) + val sut = fixture.getSut() + + val ignoredEventId = + sut.captureTransaction(createServerTransaction(503L), fixture.sentryTracer.traceContext()) + val retainedEventId = + sut.captureTransaction(createServerTransaction(404), fixture.sentryTracer.traceContext()) + + assertThat(ignoredEventId).isEqualTo(SentryId.EMPTY_ID) + assertThat(retainedEventId).isNotEqualTo(SentryId.EMPTY_ID) + verify(fixture.transport).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 `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) + 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 `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() + + 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 `default HTTP status filter does not read child span attributes`() { + 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 default ignored transaction is logged`() { + 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() @@ -4535,6 +4700,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/SentryOptionsTest.kt b/sentry/src/test/java/io/sentry/SentryOptionsTest.kt index 222f5a21fd..be373db8de 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 @@ -570,6 +571,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.ignoredErrorsForDeduplication = listOf("example.FirstException", "example.SecondException") @@ -633,6 +636,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, @@ -1173,6 +1180,92 @@ class SentryOptionsTest { assertNull(options.ignoredSpanOrigins) } + @Test + 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() + } + listOf(300, 304, 400, 405).forEach { + assertThat(ranges.any { range -> range.isInRange(it) }).isFalse() + } + } + + @Test + fun `default ignored server HTTP status code lists are independent`() { + val first = SentryOptions().traceIgnoreStatusCodes!! + val second = SentryOptions().traceIgnoreStatusCodes!! + + first.clear() + + assertThat(second).hasSize(3) + assertThat(second.any { it.isInRange(301) }).isTrue() + 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() + + options.traceIgnoreStatusCodes = null + assertThat(options.traceIgnoreStatusCodes).isNull() + + options.traceIgnoreStatusCodes = emptyList() + 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() + } + + @Test + fun `merging empty ignored server HTTP status codes clears the default`() { + val externalOptions = ExternalOptions() + externalOptions.traceIgnoreStatusCodes = emptyList() + val options = SentryOptions() + + 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 ignored server HTTP status codes are not set preserves default`() { + val options = SentryOptions() + + options.merge(ExternalOptions()) + + assertThat(options.traceIgnoreStatusCodes).hasSize(3) + assertThat(options.traceIgnoreStatusCodes!!.any { it.isInRange(301) }).isTrue() + assertThat(options.traceIgnoreStatusCodes!!.any { it.isInRange(404) }).isTrue() + } + @Test fun `merging options when ignoredErrors is not set preserves the previous value`() { val externalOptions = ExternalOptions() 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 0000000000..8f09a54c88 --- /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") + } +} diff --git a/sentry/src/test/java/io/sentry/SentryTracerTest.kt b/sentry/src/test/java/io/sentry/SentryTracerTest.kt index f1b76c6fec..6fddf93e98 100644 --- a/sentry/src/test/java/io/sentry/SentryTracerTest.kt +++ b/sentry/src/test/java/io/sentry/SentryTracerTest.kt @@ -318,6 +318,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()