From a32bc6eb7700fa443a338929863e7e0b24ca8569 Mon Sep 17 00:00:00 2001 From: Alexander Dinauer Date: Wed, 11 Nov 2026 12:16:24 +0100 Subject: [PATCH 1/3] feat(tracing): [Ignore HTTP Status 1] Add sentry.kind to server instrumentation Classify incoming Spring and OpenTelemetry server spans with sentry.kind and record numeric HTTP response statuses for later filtering. Refs #4735 Refs #4736 Refs #6555 --- .../opentelemetry/SentrySpanExporter.java | 14 ++ .../src/test/kotlin/SentrySpanExporterTest.kt | 186 ++++++++++++++++++ .../spring7/tracing/SentryTracingFilter.java | 15 +- .../webflux/AbstractSentryWebFilter.java | 16 +- .../tracing/SentryTracingFilterTest.kt | 37 +++- .../webflux/SentryWebFluxTracingFilterTest.kt | 35 +++- .../integrationtest/PersonIntegrationTest.kt | 9 + .../PersonWebfluxIntegrationTest.kt | 9 + .../integrationtest/PersonIntegrationTest.kt | 9 + .../PersonWebfluxIntegrationTest.kt | 9 + .../integrationtest/PersonIntegrationTest.kt | 9 + .../PersonWebfluxIntegrationTest.kt | 9 + .../jakarta/tracing/SentryTracingFilter.java | 15 +- .../webflux/AbstractSentryWebFilter.java | 16 +- .../tracing/SentryTracingFilterTest.kt | 37 +++- .../webflux/SentryWebFluxTracingFilterTest.kt | 35 +++- .../spring/tracing/SentryTracingFilter.java | 15 +- .../spring/webflux/SentryWebFilter.java | 16 +- .../spring/tracing/SentryTracingFilterTest.kt | 37 +++- .../webflux/SentryWebFluxTracingFilterTest.kt | 35 +++- sentry/api/sentry.api | 1 + .../java/io/sentry/SpanDataConvention.java | 1 + 22 files changed, 532 insertions(+), 33 deletions(-) create mode 100644 sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/SentrySpanExporterTest.kt diff --git a/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SentrySpanExporter.java b/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SentrySpanExporter.java index 3cc492a9e4c..571fddc6e83 100644 --- a/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SentrySpanExporter.java +++ b/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SentrySpanExporter.java @@ -6,6 +6,7 @@ import static io.sentry.opentelemetry.OtelSpanUtils.maybeTransferOtelAttribute; import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.trace.SpanKind; import io.opentelemetry.api.trace.StatusCode; import io.opentelemetry.sdk.common.CompletableResultCode; import io.opentelemetry.sdk.trace.data.SpanData; @@ -28,6 +29,7 @@ import io.sentry.SentryLevel; import io.sentry.SentryLongDate; import io.sentry.SpanContext; +import io.sentry.SpanDataConvention; import io.sentry.SpanId; import io.sentry.SpanOptions; import io.sentry.SpanStatus; @@ -240,6 +242,7 @@ private void createAndFinishSpanForOtelSpan( setOtelInstrumentationInfo(spanData, sentryChildSpan); setOtelSpanKind(spanData, sentryChildSpan); transferSpanDetails(sentrySpanMaybe, sentryChildSpan); + setSentrySpanKind(spanData, sentryChildSpan); for (SpanNode childNode : spanNode.getChildren()) { createAndFinishSpanForOtelSpan(childNode, sentryChildSpan, remaining); @@ -355,6 +358,10 @@ private void transferSpanDetails( setOtelInstrumentationInfo(span, sentryTransaction); setOtelSpanKind(span, sentryTransaction); transferSpanDetails(sentrySpanMaybe, sentryTransaction); + setSentrySpanKind(span, sentryTransaction); + if (SpanKind.SERVER.equals(span.getKind())) { + maybeTransferOtelAttribute(span, sentryTransaction, HttpAttributes.HTTP_RESPONSE_STATUS_CODE); + } maybeTransferOtelAttribute(span, sentryTransaction, ThreadIncubatingAttributes.THREAD_ID); maybeTransferOtelAttribute(span, sentryTransaction, ThreadIncubatingAttributes.THREAD_NAME); @@ -555,6 +562,13 @@ private void setOtelSpanKind(final @NotNull SpanData otelSpan, final @NotNull IS sentrySpan.setData("otel.kind", otelSpan.getKind().name()); } + private void setSentrySpanKind( + final @NotNull SpanData otelSpan, final @NotNull ISpan sentrySpan) { + if (SpanKind.SERVER.equals(otelSpan.getKind())) { + sentrySpan.setData(SpanDataConvention.SENTRY_KIND_KEY, "server"); + } + } + @Override public CompletableResultCode flush() { scopes.flush(10000); diff --git a/sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/SentrySpanExporterTest.kt b/sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/SentrySpanExporterTest.kt new file mode 100644 index 00000000000..84b852e6f15 --- /dev/null +++ b/sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/SentrySpanExporterTest.kt @@ -0,0 +1,186 @@ +package io.sentry.opentelemetry + +import com.google.common.truth.Truth.assertThat +import io.opentelemetry.api.trace.SpanKind +import io.opentelemetry.context.Context +import io.opentelemetry.sdk.OpenTelemetrySdk +import io.opentelemetry.sdk.trace.SdkTracerProvider +import io.opentelemetry.sdk.trace.export.SimpleSpanProcessor +import io.opentelemetry.semconv.HttpAttributes +import io.sentry.ISentryClient +import io.sentry.NoOpScopes +import io.sentry.Sentry +import io.sentry.SentryOptions +import io.sentry.SpanDataConvention +import io.sentry.TransactionContext +import io.sentry.TransactionOptions +import io.sentry.protocol.SentryId +import io.sentry.protocol.SentryTransaction +import io.sentry.test.createSentryClientMock +import io.sentry.test.createTestScopes +import java.util.concurrent.TimeUnit +import kotlin.test.AfterTest +import kotlin.test.Test +import org.mockito.kotlin.anyOrNull +import org.mockito.kotlin.argumentCaptor +import org.mockito.kotlin.atLeastOnce +import org.mockito.kotlin.verify +import org.mockito.kotlin.whenever + +class SentrySpanExporterTest { + private val options = + SentryOptions().apply { + dsn = "https://key@sentry.io/proj" + tracesSampleRate = 1.0 + } + private val client: ISentryClient = createSentryClientMock() + private val scopes = createTestScopes(options).also { it.bindClient(client) } + private val exporter = SentrySpanExporter(scopes) + + init { + whenever( + client.captureTransaction(anyOrNull(), anyOrNull(), anyOrNull(), anyOrNull(), anyOrNull()) + ) + .thenReturn(SentryId()) + Sentry.setCurrentScopes(scopes) + } + + @AfterTest + fun tearDown() { + Sentry.setCurrentScopes(NoOpScopes.getInstance()) + } + + @Test + fun `server roots and children get server kind and root response status`() { + withOpenTelemetry { openTelemetry -> + val tracer = openTelemetry.getTracer("test") + val root = + tracer + .spanBuilder("server-root") + .setSpanKind(SpanKind.SERVER) + .setAttribute(HttpAttributes.HTTP_RESPONSE_STATUS_CODE, 404L) + .startSpan() + val child = + tracer + .spanBuilder("server-child") + .setParent(root.storeInContext(Context.root())) + .setSpanKind(SpanKind.SERVER) + .startSpan() + + child.end() + root.end() + } + + val transaction = capturedTransactions().single() + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(404L) + assertThat(transaction.contexts.trace!!.data["otel.kind"]).isEqualTo("SERVER") + assertThat(transaction.spans).hasSize(1) + assertThat(transaction.spans.single().data!![SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(transaction.spans.single().data!!["otel.kind"]).isEqualTo("SERVER") + } + + @Test + fun `client and internal roots do not get server data`() { + withOpenTelemetry { openTelemetry -> + val tracer = openTelemetry.getTracer("test") + tracer + .spanBuilder("client-root") + .setSpanKind(SpanKind.CLIENT) + .setAttribute(HttpAttributes.HTTP_RESPONSE_STATUS_CODE, 404L) + .startSpan() + .end() + tracer + .spanBuilder("internal-root") + .setSpanKind(SpanKind.INTERNAL) + .setAttribute(HttpAttributes.HTTP_RESPONSE_STATUS_CODE, 500L) + .startSpan() + .end() + } + + val transactions = capturedTransactions().associateBy { it.transaction } + assertThat(transactions.keys).containsExactly("client-root", "internal-root") + assertThat(transactions["client-root"]!!.contexts.trace!!.data) + .doesNotContainKey(SpanDataConvention.SENTRY_KIND_KEY) + assertThat(transactions["client-root"]!!.contexts.trace!!.data) + .doesNotContainKey(SpanDataConvention.HTTP_STATUS_CODE_KEY) + assertThat(transactions["internal-root"]!!.contexts.trace!!.data) + .doesNotContainKey(SpanDataConvention.SENTRY_KIND_KEY) + assertThat(transactions["internal-root"]!!.contexts.trace!!.data) + .doesNotContainKey(SpanDataConvention.HTTP_STATUS_CODE_KEY) + } + + @Test + fun `rpc server root does not fabricate HTTP response status`() { + withOpenTelemetry { openTelemetry -> + openTelemetry + .getTracer("test") + .spanBuilder("rpc-server") + .setSpanKind(SpanKind.SERVER) + .startSpan() + .end() + } + + val transaction = capturedTransactions().single() + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(transaction.contexts.trace!!.data) + .doesNotContainKey(SpanDataConvention.HTTP_STATUS_CODE_KEY) + } + + @Test + fun `Sentry server marker survives default OTel internal kind`() { + withOpenTelemetry(includeSentrySpanProcessor = true) { openTelemetry -> + options.spanFactory = OtelSpanFactory(openTelemetry) + val transaction = + scopes.startTransaction( + TransactionContext("native-server", "http.server"), + TransactionOptions(), + ) + transaction.setData(SpanDataConvention.SENTRY_KIND_KEY, "server") + transaction.setData(SpanDataConvention.HTTP_STATUS_CODE_KEY, 404) + transaction.finish() + } + + val transaction = capturedTransactions().single() + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(404) + assertThat(transaction.contexts.trace!!.data["otel.kind"]).isEqualTo("INTERNAL") + } + + private fun withOpenTelemetry( + includeSentrySpanProcessor: Boolean = false, + callback: (OpenTelemetrySdk) -> Unit, + ) { + val providerBuilder = SdkTracerProvider.builder() + if (includeSentrySpanProcessor) { + providerBuilder.addSpanProcessor(OtelSentrySpanProcessor(scopes)) + } + val provider = providerBuilder.addSpanProcessor(SimpleSpanProcessor.create(exporter)).build() + val openTelemetry = OpenTelemetrySdk.builder().setTracerProvider(provider).build() + try { + callback(openTelemetry) + provider.forceFlush().join(10, TimeUnit.SECONDS) + } finally { + provider.close() + } + } + + private fun capturedTransactions(): List { + val transaction = argumentCaptor() + verify(client, atLeastOnce()) + .captureTransaction( + transaction.capture(), + anyOrNull(), + anyOrNull(), + anyOrNull(), + anyOrNull(), + ) + return transaction.allValues + } +} diff --git a/sentry-spring-7/src/main/java/io/sentry/spring7/tracing/SentryTracingFilter.java b/sentry-spring-7/src/main/java/io/sentry/spring7/tracing/SentryTracingFilter.java index a978c57d9c3..23796f187b3 100644 --- a/sentry-spring-7/src/main/java/io/sentry/spring7/tracing/SentryTracingFilter.java +++ b/sentry-spring-7/src/main/java/io/sentry/spring7/tracing/SentryTracingFilter.java @@ -9,6 +9,7 @@ import io.sentry.ITransaction; import io.sentry.ScopesAdapter; import io.sentry.SentryTraceHeader; +import io.sentry.SpanDataConvention; import io.sentry.SpanStatus; import io.sentry.TransactionContext; import io.sentry.TransactionOptions; @@ -164,6 +165,7 @@ private void doFilterWithTransaction( if (transactionName != null) { transaction.setName(transactionName, transactionNameSource); transaction.setOperation(TRANSACTION_OP); + transaction.setData(SpanDataConvention.HTTP_STATUS_CODE_KEY, httpResponse.getStatus()); // if exception has been thrown, transaction status is already set to INTERNAL_ERROR, and // httpResponse.getStatus() returns 200. if (transaction.getStatus() == null) { @@ -240,15 +242,20 @@ private ITransaction startTransaction( transactionOptions.setBindToScope(true); transactionOptions.setOrigin(TRACE_ORIGIN); + final @NotNull ITransaction transaction; if (transactionContext != null) { transactionContext.setName(name); transactionContext.setTransactionNameSource(TransactionNameSource.URL); transactionContext.setOperation("http.server"); - return scopes.startTransaction(transactionContext, transactionOptions); + transaction = scopes.startTransaction(transactionContext, transactionOptions); + } else { + transaction = + scopes.startTransaction( + new TransactionContext(name, TransactionNameSource.URL, "http.server"), + transactionOptions); } - - return scopes.startTransaction( - new TransactionContext(name, TransactionNameSource.URL, "http.server"), transactionOptions); + transaction.setData(SpanDataConvention.SENTRY_KIND_KEY, "server"); + return transaction; } } diff --git a/sentry-spring-7/src/main/java/io/sentry/spring7/webflux/AbstractSentryWebFilter.java b/sentry-spring-7/src/main/java/io/sentry/spring7/webflux/AbstractSentryWebFilter.java index 898c9fd5937..0301159bb4d 100644 --- a/sentry-spring-7/src/main/java/io/sentry/spring7/webflux/AbstractSentryWebFilter.java +++ b/sentry-spring-7/src/main/java/io/sentry/spring7/webflux/AbstractSentryWebFilter.java @@ -13,6 +13,7 @@ import io.sentry.NoOpScopes; import io.sentry.Sentry; import io.sentry.SentryTraceHeader; +import io.sentry.SpanDataConvention; import io.sentry.SpanStatus; import io.sentry.TransactionContext; import io.sentry.TransactionOptions; @@ -126,6 +127,7 @@ private void finishTransaction(ServerWebExchange exchange, ITransaction transact if (response != null) { final @Nullable HttpStatusCode statusCode = response.getStatusCode(); if (statusCode != null) { + transaction.setData(SpanDataConvention.HTTP_STATUS_CODE_KEY, statusCode.value()); transaction .getContexts() .withResponse( @@ -154,16 +156,20 @@ private void finishTransaction(ServerWebExchange exchange, ITransaction transact transactionOptions.setBindToScope(true); transactionOptions.setOrigin(origin); + final @NotNull ITransaction transaction; if (transactionContext != null) { transactionContext.setName(name); transactionContext.setTransactionNameSource(TransactionNameSource.URL); transactionContext.setOperation(TRANSACTION_OP); - return scopes.startTransaction(transactionContext, transactionOptions); + transaction = scopes.startTransaction(transactionContext, transactionOptions); + } else { + transaction = + scopes.startTransaction( + new TransactionContext(name, TransactionNameSource.URL, TRANSACTION_OP), + transactionOptions); } - - return scopes.startTransaction( - new TransactionContext(name, TransactionNameSource.URL, TRANSACTION_OP), - transactionOptions); + transaction.setData(SpanDataConvention.SENTRY_KIND_KEY, "server"); + return transaction; } } diff --git a/sentry-spring-7/src/test/kotlin/io/sentry/spring7/tracing/SentryTracingFilterTest.kt b/sentry-spring-7/src/test/kotlin/io/sentry/spring7/tracing/SentryTracingFilterTest.kt index fae0f19ebe6..cf98fdc4542 100644 --- a/sentry-spring-7/src/test/kotlin/io/sentry/spring7/tracing/SentryTracingFilterTest.kt +++ b/sentry-spring-7/src/test/kotlin/io/sentry/spring7/tracing/SentryTracingFilterTest.kt @@ -5,6 +5,7 @@ import io.sentry.IScopes import io.sentry.PropagationContext import io.sentry.SentryOptions import io.sentry.SentryTracer +import io.sentry.SpanDataConvention import io.sentry.SpanId import io.sentry.SpanStatus import io.sentry.TraceContext @@ -134,6 +135,10 @@ class SentryTracingFilterTest { assertThat(it.transaction).isEqualTo("POST /product/{id}") assertThat(it.contexts.trace!!.status).isEqualTo(SpanStatus.OK) assertThat(it.contexts.trace!!.operation).isEqualTo("http.server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) }, anyOrNull(), anyOrNull(), @@ -160,6 +165,26 @@ class SentryTracingFilterTest { ) } + @Test + fun `records not found response status`() { + val filter = fixture.getSut(status = 404) + + filter.doFilter(fixture.request, fixture.response, fixture.chain) + + verify(fixture.scopes) + .captureTransaction( + check { + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(404) + }, + anyOrNull(), + anyOrNull(), + anyOrNull(), + ) + } + @Test fun `sets correct span status based on the response status`() { val filter = fixture.getSut(status = 500) @@ -214,7 +239,13 @@ class SentryTracingFilterTest { verify(fixture.scopes) .captureTransaction( - check { assertThat(it.contexts.trace!!.parentSpanId).isEqualTo(parentSpanId) }, + check { + assertThat(it.contexts.trace!!.parentSpanId).isEqualTo(parentSpanId) + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) + }, anyOrNull(), anyOrNull(), anyOrNull(), @@ -429,6 +460,10 @@ class SentryTracingFilterTest { assertThat(it.transaction).isEqualTo("POST /product/{id}") assertThat(it.contexts.trace!!.status).isEqualTo(SpanStatus.OK) assertThat(it.contexts.trace!!.operation).isEqualTo("http.server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) }, anyOrNull(), anyOrNull(), diff --git a/sentry-spring-7/src/test/kotlin/io/sentry/spring7/webflux/SentryWebFluxTracingFilterTest.kt b/sentry-spring-7/src/test/kotlin/io/sentry/spring7/webflux/SentryWebFluxTracingFilterTest.kt index c6c65b560db..a5b31f73c2d 100644 --- a/sentry-spring-7/src/test/kotlin/io/sentry/spring7/webflux/SentryWebFluxTracingFilterTest.kt +++ b/sentry-spring-7/src/test/kotlin/io/sentry/spring7/webflux/SentryWebFluxTracingFilterTest.kt @@ -9,6 +9,7 @@ import io.sentry.ScopeCallback import io.sentry.Sentry import io.sentry.SentryOptions import io.sentry.SentryTracer +import io.sentry.SpanDataConvention import io.sentry.SpanId import io.sentry.SpanStatus import io.sentry.TraceContext @@ -143,6 +144,32 @@ class SentryWebFluxTracingFilterTest { assertThat(it.contexts.trace!!.status).isEqualTo(SpanStatus.OK) assertThat(it.contexts.trace!!.operation).isEqualTo("http.server") assertThat(it.contexts.response!!.statusCode).isEqualTo(200) + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) + }, + anyOrNull(), + anyOrNull(), + anyOrNull(), + ) + } + } + + @Test + fun `records not found response status`() { + val filter = fixture.getSut(status = HttpStatus.NOT_FOUND) + + withMockScopes { + filter.filter(fixture.exchange, fixture.chain).block() + + verify(fixture.scopes) + .captureTransaction( + check { + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(404) }, anyOrNull(), anyOrNull(), @@ -215,7 +242,13 @@ class SentryWebFluxTracingFilterTest { verify(fixture.scopes) .captureTransaction( - check { assertThat(it.contexts.trace!!.parentSpanId).isEqualTo(parentSpanId) }, + check { + assertThat(it.contexts.trace!!.parentSpanId).isEqualTo(parentSpanId) + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) + }, anyOrNull(), anyOrNull(), anyOrNull(), diff --git a/sentry-spring-boot-4/src/integrationTest/kotlin/io/sentry/spring/boot4/integrationtest/PersonIntegrationTest.kt b/sentry-spring-boot-4/src/integrationTest/kotlin/io/sentry/spring/boot4/integrationtest/PersonIntegrationTest.kt index 30543274d5d..afb633e66e8 100644 --- a/sentry-spring-boot-4/src/integrationTest/kotlin/io/sentry/spring/boot4/integrationtest/PersonIntegrationTest.kt +++ b/sentry-spring-boot-4/src/integrationTest/kotlin/io/sentry/spring/boot4/integrationtest/PersonIntegrationTest.kt @@ -2,6 +2,7 @@ package io.sentry.spring.boot4.integrationtest import com.google.common.truth.Truth.assertThat import io.sentry.Sentry +import io.sentry.SpanDataConvention import io.sentry.protocol.FeatureFlag import io.sentry.test.event import io.sentry.test.hasFlag @@ -45,6 +46,10 @@ class PersonIntegrationTest : IntegrationTest() { } == true } .transaction()!! + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) assertThat( transaction.hasOp( "http.server", @@ -83,6 +88,10 @@ class PersonIntegrationTest : IntegrationTest() { val transaction = server.awaitEnvelope { it.transaction()?.transaction == "POST /person/" }.transaction()!! + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) assertThat(transaction.hasSpanWithOp("PersonService.create")).isTrue() assertThat( transaction.hasSpanWithOpAndDescription( diff --git a/sentry-spring-boot-4/src/integrationTestWebflux/kotlin/io/sentry/spring/boot4/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt b/sentry-spring-boot-4/src/integrationTestWebflux/kotlin/io/sentry/spring/boot4/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt index 8151eb4a8a1..15aab17c410 100644 --- a/sentry-spring-boot-4/src/integrationTestWebflux/kotlin/io/sentry/spring/boot4/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt +++ b/sentry-spring-boot-4/src/integrationTestWebflux/kotlin/io/sentry/spring/boot4/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt @@ -2,6 +2,7 @@ package io.sentry.spring.boot4.webfluxintegrationtest import com.google.common.truth.Truth.assertThat import io.sentry.Sentry +import io.sentry.SpanDataConvention import io.sentry.test.event import io.sentry.test.hasFlag import io.sentry.test.hasLogWithAttribute @@ -30,6 +31,10 @@ class PersonWebfluxIntegrationTest : WebfluxIntegrationTest() { val transaction = server.awaitEnvelope { it.transaction()?.transaction == "GET /person/{id}" }.transaction()!! assertThat(transaction.contexts.trace!!.operation).isEqualTo("http.server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(500) val logs = server @@ -55,6 +60,10 @@ class PersonWebfluxIntegrationTest : WebfluxIntegrationTest() { val transaction = server.awaitEnvelope { it.transaction()?.transaction == "POST /person/" }.transaction()!! assertThat(transaction.contexts.trace!!.operation).isEqualTo("http.server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) } @Test diff --git a/sentry-spring-boot-jakarta/src/integrationTest/kotlin/io/sentry/spring/boot/jakarta/integrationtest/PersonIntegrationTest.kt b/sentry-spring-boot-jakarta/src/integrationTest/kotlin/io/sentry/spring/boot/jakarta/integrationtest/PersonIntegrationTest.kt index 3f8ba722099..1728424fbc1 100644 --- a/sentry-spring-boot-jakarta/src/integrationTest/kotlin/io/sentry/spring/boot/jakarta/integrationtest/PersonIntegrationTest.kt +++ b/sentry-spring-boot-jakarta/src/integrationTest/kotlin/io/sentry/spring/boot/jakarta/integrationtest/PersonIntegrationTest.kt @@ -2,6 +2,7 @@ package io.sentry.spring.boot.jakarta.integrationtest import com.google.common.truth.Truth.assertThat import io.sentry.Sentry +import io.sentry.SpanDataConvention import io.sentry.protocol.FeatureFlag import io.sentry.test.event import io.sentry.test.hasFlag @@ -45,6 +46,10 @@ class PersonIntegrationTest : IntegrationTest() { } == true } .transaction()!! + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) assertThat( transaction.hasOp( "http.server", @@ -83,6 +88,10 @@ class PersonIntegrationTest : IntegrationTest() { val transaction = server.awaitEnvelope { it.transaction()?.transaction == "POST /person/" }.transaction()!! + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) assertThat(transaction.hasSpanWithOp("PersonService.create")).isTrue() assertThat( transaction.hasSpanWithOpAndDescription( diff --git a/sentry-spring-boot-jakarta/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/jakarta/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt b/sentry-spring-boot-jakarta/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/jakarta/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt index c72ed553235..662ffc961dc 100644 --- a/sentry-spring-boot-jakarta/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/jakarta/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt +++ b/sentry-spring-boot-jakarta/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/jakarta/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt @@ -2,6 +2,7 @@ package io.sentry.spring.boot.jakarta.webfluxintegrationtest import com.google.common.truth.Truth.assertThat import io.sentry.Sentry +import io.sentry.SpanDataConvention import io.sentry.test.event import io.sentry.test.hasFlag import io.sentry.test.hasLogWithAttribute @@ -30,6 +31,10 @@ class PersonWebfluxIntegrationTest : WebfluxIntegrationTest() { val transaction = server.awaitEnvelope { it.transaction()?.transaction == "GET /person/{id}" }.transaction()!! assertThat(transaction.contexts.trace!!.operation).isEqualTo("http.server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(500) val logs = server @@ -55,6 +60,10 @@ class PersonWebfluxIntegrationTest : WebfluxIntegrationTest() { val transaction = server.awaitEnvelope { it.transaction()?.transaction == "POST /person/" }.transaction()!! assertThat(transaction.contexts.trace!!.operation).isEqualTo("http.server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) } @Test diff --git a/sentry-spring-boot/src/integrationTest/kotlin/io/sentry/spring/boot/integrationtest/PersonIntegrationTest.kt b/sentry-spring-boot/src/integrationTest/kotlin/io/sentry/spring/boot/integrationtest/PersonIntegrationTest.kt index 5a15d818166..045bfa37a96 100644 --- a/sentry-spring-boot/src/integrationTest/kotlin/io/sentry/spring/boot/integrationtest/PersonIntegrationTest.kt +++ b/sentry-spring-boot/src/integrationTest/kotlin/io/sentry/spring/boot/integrationtest/PersonIntegrationTest.kt @@ -2,6 +2,7 @@ package io.sentry.spring.boot.integrationtest import com.google.common.truth.Truth.assertThat import io.sentry.Sentry +import io.sentry.SpanDataConvention import io.sentry.protocol.FeatureFlag import io.sentry.test.event import io.sentry.test.hasFlag @@ -45,6 +46,10 @@ class PersonIntegrationTest : IntegrationTest() { } == true } .transaction()!! + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) assertThat( transaction.hasOp( "http.server", @@ -83,6 +88,10 @@ class PersonIntegrationTest : IntegrationTest() { val transaction = server.awaitEnvelope { it.transaction()?.transaction == "POST /person/" }.transaction()!! + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) assertThat(transaction.hasSpanWithOp("PersonService.create")).isTrue() assertThat( transaction.hasSpanWithOpAndDescription( diff --git a/sentry-spring-boot/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt b/sentry-spring-boot/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt index 379d6a5913d..0210da8ba64 100644 --- a/sentry-spring-boot/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt +++ b/sentry-spring-boot/src/integrationTestWebflux/kotlin/io/sentry/spring/boot/webfluxintegrationtest/PersonWebfluxIntegrationTest.kt @@ -2,6 +2,7 @@ package io.sentry.spring.boot.webfluxintegrationtest import com.google.common.truth.Truth.assertThat import io.sentry.Sentry +import io.sentry.SpanDataConvention import io.sentry.test.event import io.sentry.test.hasFlag import io.sentry.test.hasLogWithAttribute @@ -30,6 +31,10 @@ class PersonWebfluxIntegrationTest : WebfluxIntegrationTest() { val transaction = server.awaitEnvelope { it.transaction()?.transaction == "GET /person/{id}" }.transaction()!! assertThat(transaction.contexts.trace!!.operation).isEqualTo("http.server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(500) val logs = server @@ -55,6 +60,10 @@ class PersonWebfluxIntegrationTest : WebfluxIntegrationTest() { val transaction = server.awaitEnvelope { it.transaction()?.transaction == "POST /person/" }.transaction()!! assertThat(transaction.contexts.trace!!.operation).isEqualTo("http.server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(transaction.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) } @Test diff --git a/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/tracing/SentryTracingFilter.java b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/tracing/SentryTracingFilter.java index 4832e1c21ff..55a0cc1faeb 100644 --- a/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/tracing/SentryTracingFilter.java +++ b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/tracing/SentryTracingFilter.java @@ -9,6 +9,7 @@ import io.sentry.ITransaction; import io.sentry.ScopesAdapter; import io.sentry.SentryTraceHeader; +import io.sentry.SpanDataConvention; import io.sentry.SpanStatus; import io.sentry.TransactionContext; import io.sentry.TransactionOptions; @@ -164,6 +165,7 @@ private void doFilterWithTransaction( if (transactionName != null) { transaction.setName(transactionName, transactionNameSource); transaction.setOperation(TRANSACTION_OP); + transaction.setData(SpanDataConvention.HTTP_STATUS_CODE_KEY, httpResponse.getStatus()); // if exception has been thrown, transaction status is already set to INTERNAL_ERROR, and // httpResponse.getStatus() returns 200. if (transaction.getStatus() == null) { @@ -240,15 +242,20 @@ private ITransaction startTransaction( transactionOptions.setBindToScope(true); transactionOptions.setOrigin(TRACE_ORIGIN); + final @NotNull ITransaction transaction; if (transactionContext != null) { transactionContext.setName(name); transactionContext.setTransactionNameSource(TransactionNameSource.URL); transactionContext.setOperation("http.server"); - return scopes.startTransaction(transactionContext, transactionOptions); + transaction = scopes.startTransaction(transactionContext, transactionOptions); + } else { + transaction = + scopes.startTransaction( + new TransactionContext(name, TransactionNameSource.URL, "http.server"), + transactionOptions); } - - return scopes.startTransaction( - new TransactionContext(name, TransactionNameSource.URL, "http.server"), transactionOptions); + transaction.setData(SpanDataConvention.SENTRY_KIND_KEY, "server"); + return transaction; } } diff --git a/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/webflux/AbstractSentryWebFilter.java b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/webflux/AbstractSentryWebFilter.java index a3edfd54c83..2468b43d20f 100644 --- a/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/webflux/AbstractSentryWebFilter.java +++ b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/webflux/AbstractSentryWebFilter.java @@ -13,6 +13,7 @@ import io.sentry.NoOpScopes; import io.sentry.Sentry; import io.sentry.SentryTraceHeader; +import io.sentry.SpanDataConvention; import io.sentry.SpanStatus; import io.sentry.TransactionContext; import io.sentry.TransactionOptions; @@ -126,6 +127,7 @@ private void finishTransaction(ServerWebExchange exchange, ITransaction transact if (response != null) { final @Nullable HttpStatusCode statusCode = response.getStatusCode(); if (statusCode != null) { + transaction.setData(SpanDataConvention.HTTP_STATUS_CODE_KEY, statusCode.value()); transaction .getContexts() .withResponse( @@ -154,16 +156,20 @@ private void finishTransaction(ServerWebExchange exchange, ITransaction transact transactionOptions.setBindToScope(true); transactionOptions.setOrigin(origin); + final @NotNull ITransaction transaction; if (transactionContext != null) { transactionContext.setName(name); transactionContext.setTransactionNameSource(TransactionNameSource.URL); transactionContext.setOperation(TRANSACTION_OP); - return scopes.startTransaction(transactionContext, transactionOptions); + transaction = scopes.startTransaction(transactionContext, transactionOptions); + } else { + transaction = + scopes.startTransaction( + new TransactionContext(name, TransactionNameSource.URL, TRANSACTION_OP), + transactionOptions); } - - return scopes.startTransaction( - new TransactionContext(name, TransactionNameSource.URL, TRANSACTION_OP), - transactionOptions); + transaction.setData(SpanDataConvention.SENTRY_KIND_KEY, "server"); + return transaction; } } diff --git a/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/tracing/SentryTracingFilterTest.kt b/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/tracing/SentryTracingFilterTest.kt index 61fabb6d478..18d3ae096b6 100644 --- a/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/tracing/SentryTracingFilterTest.kt +++ b/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/tracing/SentryTracingFilterTest.kt @@ -5,6 +5,7 @@ import io.sentry.IScopes import io.sentry.PropagationContext import io.sentry.SentryOptions import io.sentry.SentryTracer +import io.sentry.SpanDataConvention import io.sentry.SpanId import io.sentry.SpanStatus import io.sentry.TraceContext @@ -134,6 +135,10 @@ class SentryTracingFilterTest { assertThat(it.transaction).isEqualTo("POST /product/{id}") assertThat(it.contexts.trace!!.status).isEqualTo(SpanStatus.OK) assertThat(it.contexts.trace!!.operation).isEqualTo("http.server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) }, anyOrNull(), anyOrNull(), @@ -160,6 +165,26 @@ class SentryTracingFilterTest { ) } + @Test + fun `records not found response status`() { + val filter = fixture.getSut(status = 404) + + filter.doFilter(fixture.request, fixture.response, fixture.chain) + + verify(fixture.scopes) + .captureTransaction( + check { + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(404) + }, + anyOrNull(), + anyOrNull(), + anyOrNull(), + ) + } + @Test fun `sets correct span status based on the response status`() { val filter = fixture.getSut(status = 500) @@ -214,7 +239,13 @@ class SentryTracingFilterTest { verify(fixture.scopes) .captureTransaction( - check { assertThat(it.contexts.trace!!.parentSpanId).isEqualTo(parentSpanId) }, + check { + assertThat(it.contexts.trace!!.parentSpanId).isEqualTo(parentSpanId) + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) + }, anyOrNull(), anyOrNull(), anyOrNull(), @@ -429,6 +460,10 @@ class SentryTracingFilterTest { assertThat(it.transaction).isEqualTo("POST /product/{id}") assertThat(it.contexts.trace!!.status).isEqualTo(SpanStatus.OK) assertThat(it.contexts.trace!!.operation).isEqualTo("http.server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) }, anyOrNull(), anyOrNull(), diff --git a/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/webflux/SentryWebFluxTracingFilterTest.kt b/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/webflux/SentryWebFluxTracingFilterTest.kt index 0a01b4cbcc4..9fe7351b1ef 100644 --- a/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/webflux/SentryWebFluxTracingFilterTest.kt +++ b/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/webflux/SentryWebFluxTracingFilterTest.kt @@ -9,6 +9,7 @@ import io.sentry.ScopeCallback import io.sentry.Sentry import io.sentry.SentryOptions import io.sentry.SentryTracer +import io.sentry.SpanDataConvention import io.sentry.SpanId import io.sentry.SpanStatus import io.sentry.TraceContext @@ -143,6 +144,32 @@ class SentryWebFluxTracingFilterTest { assertThat(it.contexts.trace!!.status).isEqualTo(SpanStatus.OK) assertThat(it.contexts.trace!!.operation).isEqualTo("http.server") assertThat(it.contexts.response!!.statusCode).isEqualTo(200) + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) + }, + anyOrNull(), + anyOrNull(), + anyOrNull(), + ) + } + } + + @Test + fun `records not found response status`() { + val filter = fixture.getSut(status = HttpStatus.NOT_FOUND) + + withMockScopes { + filter.filter(fixture.exchange, fixture.chain).block() + + verify(fixture.scopes) + .captureTransaction( + check { + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(404) }, anyOrNull(), anyOrNull(), @@ -215,7 +242,13 @@ class SentryWebFluxTracingFilterTest { verify(fixture.scopes) .captureTransaction( - check { assertThat(it.contexts.trace!!.parentSpanId).isEqualTo(parentSpanId) }, + check { + assertThat(it.contexts.trace!!.parentSpanId).isEqualTo(parentSpanId) + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) + }, anyOrNull(), anyOrNull(), anyOrNull(), diff --git a/sentry-spring/src/main/java/io/sentry/spring/tracing/SentryTracingFilter.java b/sentry-spring/src/main/java/io/sentry/spring/tracing/SentryTracingFilter.java index 02da16feaca..e1056690761 100644 --- a/sentry-spring/src/main/java/io/sentry/spring/tracing/SentryTracingFilter.java +++ b/sentry-spring/src/main/java/io/sentry/spring/tracing/SentryTracingFilter.java @@ -9,6 +9,7 @@ import io.sentry.ITransaction; import io.sentry.ScopesAdapter; import io.sentry.SentryTraceHeader; +import io.sentry.SpanDataConvention; import io.sentry.SpanStatus; import io.sentry.TransactionContext; import io.sentry.TransactionOptions; @@ -163,6 +164,7 @@ private void doFilterWithTransaction( if (transactionName != null) { transaction.setName(transactionName, transactionNameSource); transaction.setOperation(TRANSACTION_OP); + transaction.setData(SpanDataConvention.HTTP_STATUS_CODE_KEY, httpResponse.getStatus()); // if exception has been thrown, transaction status is already set to INTERNAL_ERROR, and // httpResponse.getStatus() returns 200. if (transaction.getStatus() == null) { @@ -239,15 +241,20 @@ private ITransaction startTransaction( transactionOptions.setBindToScope(true); transactionOptions.setOrigin(TRACE_ORIGIN); + final @NotNull ITransaction transaction; if (transactionContext != null) { transactionContext.setName(name); transactionContext.setTransactionNameSource(TransactionNameSource.URL); transactionContext.setOperation("http.server"); - return scopes.startTransaction(transactionContext, transactionOptions); + transaction = scopes.startTransaction(transactionContext, transactionOptions); + } else { + transaction = + scopes.startTransaction( + new TransactionContext(name, TransactionNameSource.URL, "http.server"), + transactionOptions); } - - return scopes.startTransaction( - new TransactionContext(name, TransactionNameSource.URL, "http.server"), transactionOptions); + transaction.setData(SpanDataConvention.SENTRY_KIND_KEY, "server"); + return transaction; } } diff --git a/sentry-spring/src/main/java/io/sentry/spring/webflux/SentryWebFilter.java b/sentry-spring/src/main/java/io/sentry/spring/webflux/SentryWebFilter.java index 031f579d4e4..9f907b206dd 100644 --- a/sentry-spring/src/main/java/io/sentry/spring/webflux/SentryWebFilter.java +++ b/sentry-spring/src/main/java/io/sentry/spring/webflux/SentryWebFilter.java @@ -13,6 +13,7 @@ import io.sentry.NoOpScopes; import io.sentry.Sentry; import io.sentry.SentryTraceHeader; +import io.sentry.SpanDataConvention; import io.sentry.SpanStatus; import io.sentry.TransactionContext; import io.sentry.TransactionOptions; @@ -132,17 +133,21 @@ private boolean shouldTraceRequest( transactionOptions.setBindToScope(true); transactionOptions.setOrigin(TRACE_ORIGIN); + final @NotNull ITransaction transaction; if (transactionContext != null) { transactionContext.setName(name); transactionContext.setTransactionNameSource(TransactionNameSource.URL); transactionContext.setOperation(TRANSACTION_OP); - return scopes.startTransaction(transactionContext, transactionOptions); + transaction = scopes.startTransaction(transactionContext, transactionOptions); + } else { + transaction = + scopes.startTransaction( + new TransactionContext(name, TransactionNameSource.URL, TRANSACTION_OP), + transactionOptions); } - - return scopes.startTransaction( - new TransactionContext(name, TransactionNameSource.URL, TRANSACTION_OP), - transactionOptions); + transaction.setData(SpanDataConvention.SENTRY_KIND_KEY, "server"); + return transaction; } private void finishTransaction(ServerWebExchange exchange, ITransaction transaction) { @@ -155,6 +160,7 @@ private void finishTransaction(ServerWebExchange exchange, ITransaction transact if (response != null) { final @Nullable Integer rawStatusCode = response.getRawStatusCode(); if (rawStatusCode != null) { + transaction.setData(SpanDataConvention.HTTP_STATUS_CODE_KEY, rawStatusCode); transaction .getContexts() .withResponse( diff --git a/sentry-spring/src/test/kotlin/io/sentry/spring/tracing/SentryTracingFilterTest.kt b/sentry-spring/src/test/kotlin/io/sentry/spring/tracing/SentryTracingFilterTest.kt index acfcdb4ebab..5e5f689f73c 100644 --- a/sentry-spring/src/test/kotlin/io/sentry/spring/tracing/SentryTracingFilterTest.kt +++ b/sentry-spring/src/test/kotlin/io/sentry/spring/tracing/SentryTracingFilterTest.kt @@ -5,6 +5,7 @@ import io.sentry.IScopes import io.sentry.PropagationContext import io.sentry.SentryOptions import io.sentry.SentryTracer +import io.sentry.SpanDataConvention import io.sentry.SpanId import io.sentry.SpanStatus import io.sentry.TraceContext @@ -134,6 +135,10 @@ class SentryTracingFilterTest { assertThat(it.transaction).isEqualTo("POST /product/{id}") assertThat(it.contexts.trace!!.status).isEqualTo(SpanStatus.OK) assertThat(it.contexts.trace!!.operation).isEqualTo("http.server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) }, anyOrNull(), anyOrNull(), @@ -160,6 +165,26 @@ class SentryTracingFilterTest { ) } + @Test + fun `records not found response status`() { + val filter = fixture.getSut(status = 404) + + filter.doFilter(fixture.request, fixture.response, fixture.chain) + + verify(fixture.scopes) + .captureTransaction( + check { + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(404) + }, + anyOrNull(), + anyOrNull(), + anyOrNull(), + ) + } + @Test fun `sets correct span status based on the response status`() { val filter = fixture.getSut(status = 500) @@ -214,7 +239,13 @@ class SentryTracingFilterTest { verify(fixture.scopes) .captureTransaction( - check { assertThat(it.contexts.trace!!.parentSpanId).isEqualTo(parentSpanId) }, + check { + assertThat(it.contexts.trace!!.parentSpanId).isEqualTo(parentSpanId) + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) + }, anyOrNull(), anyOrNull(), anyOrNull(), @@ -429,6 +460,10 @@ class SentryTracingFilterTest { assertThat(it.transaction).isEqualTo("POST /product/{id}") assertThat(it.contexts.trace!!.status).isEqualTo(SpanStatus.OK) assertThat(it.contexts.trace!!.operation).isEqualTo("http.server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) }, anyOrNull(), anyOrNull(), diff --git a/sentry-spring/src/test/kotlin/io/sentry/spring/webflux/SentryWebFluxTracingFilterTest.kt b/sentry-spring/src/test/kotlin/io/sentry/spring/webflux/SentryWebFluxTracingFilterTest.kt index 326b5979991..88fe80cab0d 100644 --- a/sentry-spring/src/test/kotlin/io/sentry/spring/webflux/SentryWebFluxTracingFilterTest.kt +++ b/sentry-spring/src/test/kotlin/io/sentry/spring/webflux/SentryWebFluxTracingFilterTest.kt @@ -9,6 +9,7 @@ import io.sentry.ScopeCallback import io.sentry.Sentry import io.sentry.SentryOptions import io.sentry.SentryTracer +import io.sentry.SpanDataConvention import io.sentry.SpanId import io.sentry.SpanStatus import io.sentry.TraceContext @@ -144,6 +145,32 @@ class SentryWebFluxTracingFilterTest { assertThat(it.contexts.trace!!.status).isEqualTo(SpanStatus.OK) assertThat(it.contexts.trace!!.operation).isEqualTo("http.server") assertThat(it.contexts.response!!.statusCode).isEqualTo(200) + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) + }, + anyOrNull(), + anyOrNull(), + anyOrNull(), + ) + } + } + + @Test + fun `records not found response status`() { + val filter = fixture.getSut(status = HttpStatus.NOT_FOUND) + + withMockScopes { + filter.filter(fixture.exchange, fixture.chain).block() + + verify(fixture.scopes) + .captureTransaction( + check { + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(404) }, anyOrNull(), anyOrNull(), @@ -216,7 +243,13 @@ class SentryWebFluxTracingFilterTest { verify(fixture.scopes) .captureTransaction( - check { assertThat(it.contexts.trace!!.parentSpanId).isEqualTo(parentSpanId) }, + check { + assertThat(it.contexts.trace!!.parentSpanId).isEqualTo(parentSpanId) + assertThat(it.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) + .isEqualTo("server") + assertThat(it.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) + .isEqualTo(200) + }, anyOrNull(), anyOrNull(), anyOrNull(), diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api index b3c312169a3..49e5242da7f 100644 --- a/sentry/api/sentry.api +++ b/sentry/api/sentry.api @@ -4360,6 +4360,7 @@ public abstract interface class io/sentry/SpanDataConvention { public static final field MESSAGING_OPERATION_TYPE Ljava/lang/String; public static final field MESSAGING_SYSTEM Ljava/lang/String; public static final field PROFILER_ID Ljava/lang/String; + public static final field SENTRY_KIND_KEY Ljava/lang/String; public static final field THREAD_ID Ljava/lang/String; public static final field THREAD_NAME Ljava/lang/String; } diff --git a/sentry/src/main/java/io/sentry/SpanDataConvention.java b/sentry/src/main/java/io/sentry/SpanDataConvention.java index 4ede74505cb..93760fb8dc4 100644 --- a/sentry/src/main/java/io/sentry/SpanDataConvention.java +++ b/sentry/src/main/java/io/sentry/SpanDataConvention.java @@ -12,6 +12,7 @@ public interface SpanDataConvention { String HTTP_FRAGMENT_KEY = "http.fragment"; String HTTP_METHOD_KEY = "http.request.method"; String HTTP_STATUS_CODE_KEY = "http.response.status_code"; + String SENTRY_KIND_KEY = "sentry.kind"; String HTTP_RESPONSE_CONTENT_LENGTH_KEY = "http.response_content_length"; String BLOCKED_MAIN_THREAD_KEY = "blocked_main_thread"; String CALL_STACK_KEY = "call_stack"; From 54d0dcae0448efa34c7d54a0c772a9e9ecf202af Mon Sep 17 00:00:00 2001 From: Alexander Dinauer Date: Thu, 12 Nov 2026 15:28:30 +0100 Subject: [PATCH 2/3] fix(spring): Omit unreliable HTTP status on escaping exceptions Avoid recording a provisional response status before the container handles an escaping exception. Preserve transaction finishing and error status, and verify omission across all three servlet integrations. Refs #6557 Co-Authored-By: Claude --- .../io/sentry/spring7/tracing/SentryTracingFilter.java | 7 ++++++- .../io/sentry/spring7/tracing/SentryTracingFilterTest.kt | 6 +++++- .../spring/boot4/integrationtest/PersonIntegrationTest.kt | 4 ++-- .../boot/jakarta/integrationtest/PersonIntegrationTest.kt | 4 ++-- .../spring/boot/integrationtest/PersonIntegrationTest.kt | 4 ++-- .../sentry/spring/jakarta/tracing/SentryTracingFilter.java | 7 ++++++- .../spring/jakarta/tracing/SentryTracingFilterTest.kt | 6 +++++- .../java/io/sentry/spring/tracing/SentryTracingFilter.java | 7 ++++++- .../io/sentry/spring/tracing/SentryTracingFilterTest.kt | 6 +++++- 9 files changed, 39 insertions(+), 12 deletions(-) diff --git a/sentry-spring-7/src/main/java/io/sentry/spring7/tracing/SentryTracingFilter.java b/sentry-spring-7/src/main/java/io/sentry/spring7/tracing/SentryTracingFilter.java index 23796f187b3..39e2fc3ec9e 100644 --- a/sentry-spring-7/src/main/java/io/sentry/spring7/tracing/SentryTracingFilter.java +++ b/sentry-spring-7/src/main/java/io/sentry/spring7/tracing/SentryTracingFilter.java @@ -140,8 +140,10 @@ private void doFilterWithTransaction( final @Nullable ITransaction transaction = getOrStartTransaction(httpRequest, transactionContext); + boolean filterChainCompleted = false; try { filterChain.doFilter(httpRequest, httpResponse); + filterChainCompleted = true; } catch (Throwable e) { if (transaction != null) { // exceptions that are not handled by Spring @@ -165,7 +167,10 @@ private void doFilterWithTransaction( if (transactionName != null) { transaction.setName(transactionName, transactionNameSource); transaction.setOperation(TRANSACTION_OP); - transaction.setData(SpanDataConvention.HTTP_STATUS_CODE_KEY, httpResponse.getStatus()); + // An escaping exception may be mapped to an HTTP status later by the container. + if (filterChainCompleted) { + transaction.setData(SpanDataConvention.HTTP_STATUS_CODE_KEY, httpResponse.getStatus()); + } // if exception has been thrown, transaction status is already set to INTERNAL_ERROR, and // httpResponse.getStatus() returns 200. if (transaction.getStatus() == null) { diff --git a/sentry-spring-7/src/test/kotlin/io/sentry/spring7/tracing/SentryTracingFilterTest.kt b/sentry-spring-7/src/test/kotlin/io/sentry/spring7/tracing/SentryTracingFilterTest.kt index cf98fdc4542..7bdb93e786a 100644 --- a/sentry-spring-7/src/test/kotlin/io/sentry/spring7/tracing/SentryTracingFilterTest.kt +++ b/sentry-spring-7/src/test/kotlin/io/sentry/spring7/tracing/SentryTracingFilterTest.kt @@ -276,7 +276,11 @@ class SentryTracingFilterTest { } catch (_: Exception) {} verify(fixture.scopes) .captureTransaction( - check { assertThat(it.status).isEqualTo(SpanStatus.INTERNAL_ERROR) }, + check { + assertThat(it.status).isEqualTo(SpanStatus.INTERNAL_ERROR) + assertThat(it.contexts.trace!!.data) + .doesNotContainKey(SpanDataConvention.HTTP_STATUS_CODE_KEY) + }, anyOrNull(), anyOrNull(), anyOrNull(), diff --git a/sentry-spring-boot-4/src/integrationTest/kotlin/io/sentry/spring/boot4/integrationtest/PersonIntegrationTest.kt b/sentry-spring-boot-4/src/integrationTest/kotlin/io/sentry/spring/boot4/integrationtest/PersonIntegrationTest.kt index afb633e66e8..23b86c38867 100644 --- a/sentry-spring-boot-4/src/integrationTest/kotlin/io/sentry/spring/boot4/integrationtest/PersonIntegrationTest.kt +++ b/sentry-spring-boot-4/src/integrationTest/kotlin/io/sentry/spring/boot4/integrationtest/PersonIntegrationTest.kt @@ -48,8 +48,8 @@ class PersonIntegrationTest : IntegrationTest() { .transaction()!! assertThat(transaction.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) .isEqualTo("server") - assertThat(transaction.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) - .isEqualTo(200) + assertThat(transaction.contexts.trace!!.data) + .doesNotContainKey(SpanDataConvention.HTTP_STATUS_CODE_KEY) assertThat( transaction.hasOp( "http.server", diff --git a/sentry-spring-boot-jakarta/src/integrationTest/kotlin/io/sentry/spring/boot/jakarta/integrationtest/PersonIntegrationTest.kt b/sentry-spring-boot-jakarta/src/integrationTest/kotlin/io/sentry/spring/boot/jakarta/integrationtest/PersonIntegrationTest.kt index 1728424fbc1..97b80afa3cc 100644 --- a/sentry-spring-boot-jakarta/src/integrationTest/kotlin/io/sentry/spring/boot/jakarta/integrationtest/PersonIntegrationTest.kt +++ b/sentry-spring-boot-jakarta/src/integrationTest/kotlin/io/sentry/spring/boot/jakarta/integrationtest/PersonIntegrationTest.kt @@ -48,8 +48,8 @@ class PersonIntegrationTest : IntegrationTest() { .transaction()!! assertThat(transaction.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) .isEqualTo("server") - assertThat(transaction.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) - .isEqualTo(200) + assertThat(transaction.contexts.trace!!.data) + .doesNotContainKey(SpanDataConvention.HTTP_STATUS_CODE_KEY) assertThat( transaction.hasOp( "http.server", diff --git a/sentry-spring-boot/src/integrationTest/kotlin/io/sentry/spring/boot/integrationtest/PersonIntegrationTest.kt b/sentry-spring-boot/src/integrationTest/kotlin/io/sentry/spring/boot/integrationtest/PersonIntegrationTest.kt index 045bfa37a96..43dd6bb5f07 100644 --- a/sentry-spring-boot/src/integrationTest/kotlin/io/sentry/spring/boot/integrationtest/PersonIntegrationTest.kt +++ b/sentry-spring-boot/src/integrationTest/kotlin/io/sentry/spring/boot/integrationtest/PersonIntegrationTest.kt @@ -48,8 +48,8 @@ class PersonIntegrationTest : IntegrationTest() { .transaction()!! assertThat(transaction.contexts.trace!!.data[SpanDataConvention.SENTRY_KIND_KEY]) .isEqualTo("server") - assertThat(transaction.contexts.trace!!.data[SpanDataConvention.HTTP_STATUS_CODE_KEY]) - .isEqualTo(200) + assertThat(transaction.contexts.trace!!.data) + .doesNotContainKey(SpanDataConvention.HTTP_STATUS_CODE_KEY) assertThat( transaction.hasOp( "http.server", diff --git a/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/tracing/SentryTracingFilter.java b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/tracing/SentryTracingFilter.java index 55a0cc1faeb..ddc1c25ec72 100644 --- a/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/tracing/SentryTracingFilter.java +++ b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/tracing/SentryTracingFilter.java @@ -140,8 +140,10 @@ private void doFilterWithTransaction( final @Nullable ITransaction transaction = getOrStartTransaction(httpRequest, transactionContext); + boolean filterChainCompleted = false; try { filterChain.doFilter(httpRequest, httpResponse); + filterChainCompleted = true; } catch (Throwable e) { if (transaction != null) { // exceptions that are not handled by Spring @@ -165,7 +167,10 @@ private void doFilterWithTransaction( if (transactionName != null) { transaction.setName(transactionName, transactionNameSource); transaction.setOperation(TRANSACTION_OP); - transaction.setData(SpanDataConvention.HTTP_STATUS_CODE_KEY, httpResponse.getStatus()); + // An escaping exception may be mapped to an HTTP status later by the container. + if (filterChainCompleted) { + transaction.setData(SpanDataConvention.HTTP_STATUS_CODE_KEY, httpResponse.getStatus()); + } // if exception has been thrown, transaction status is already set to INTERNAL_ERROR, and // httpResponse.getStatus() returns 200. if (transaction.getStatus() == null) { diff --git a/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/tracing/SentryTracingFilterTest.kt b/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/tracing/SentryTracingFilterTest.kt index 18d3ae096b6..376083a41b7 100644 --- a/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/tracing/SentryTracingFilterTest.kt +++ b/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/tracing/SentryTracingFilterTest.kt @@ -276,7 +276,11 @@ class SentryTracingFilterTest { } catch (_: Exception) {} verify(fixture.scopes) .captureTransaction( - check { assertThat(it.status).isEqualTo(SpanStatus.INTERNAL_ERROR) }, + check { + assertThat(it.status).isEqualTo(SpanStatus.INTERNAL_ERROR) + assertThat(it.contexts.trace!!.data) + .doesNotContainKey(SpanDataConvention.HTTP_STATUS_CODE_KEY) + }, anyOrNull(), anyOrNull(), anyOrNull(), diff --git a/sentry-spring/src/main/java/io/sentry/spring/tracing/SentryTracingFilter.java b/sentry-spring/src/main/java/io/sentry/spring/tracing/SentryTracingFilter.java index e1056690761..9a74b27c234 100644 --- a/sentry-spring/src/main/java/io/sentry/spring/tracing/SentryTracingFilter.java +++ b/sentry-spring/src/main/java/io/sentry/spring/tracing/SentryTracingFilter.java @@ -139,8 +139,10 @@ private void doFilterWithTransaction( final @Nullable ITransaction transaction = getOrStartTransaction(httpRequest, transactionContext); + boolean filterChainCompleted = false; try { filterChain.doFilter(httpRequest, httpResponse); + filterChainCompleted = true; } catch (Throwable e) { if (transaction != null) { // exceptions that are not handled by Spring @@ -164,7 +166,10 @@ private void doFilterWithTransaction( if (transactionName != null) { transaction.setName(transactionName, transactionNameSource); transaction.setOperation(TRANSACTION_OP); - transaction.setData(SpanDataConvention.HTTP_STATUS_CODE_KEY, httpResponse.getStatus()); + // An escaping exception may be mapped to an HTTP status later by the container. + if (filterChainCompleted) { + transaction.setData(SpanDataConvention.HTTP_STATUS_CODE_KEY, httpResponse.getStatus()); + } // if exception has been thrown, transaction status is already set to INTERNAL_ERROR, and // httpResponse.getStatus() returns 200. if (transaction.getStatus() == null) { diff --git a/sentry-spring/src/test/kotlin/io/sentry/spring/tracing/SentryTracingFilterTest.kt b/sentry-spring/src/test/kotlin/io/sentry/spring/tracing/SentryTracingFilterTest.kt index 5e5f689f73c..c21100e539b 100644 --- a/sentry-spring/src/test/kotlin/io/sentry/spring/tracing/SentryTracingFilterTest.kt +++ b/sentry-spring/src/test/kotlin/io/sentry/spring/tracing/SentryTracingFilterTest.kt @@ -276,7 +276,11 @@ class SentryTracingFilterTest { } catch (_: Exception) {} verify(fixture.scopes) .captureTransaction( - check { assertThat(it.status).isEqualTo(SpanStatus.INTERNAL_ERROR) }, + check { + assertThat(it.status).isEqualTo(SpanStatus.INTERNAL_ERROR) + assertThat(it.contexts.trace!!.data) + .doesNotContainKey(SpanDataConvention.HTTP_STATUS_CODE_KEY) + }, anyOrNull(), anyOrNull(), anyOrNull(), From 7562d98848d1053b97305fa6414a4be26733dde7 Mon Sep 17 00:00:00 2001 From: Alexander Dinauer Date: Thu, 19 Nov 2026 11:04:00 +0100 Subject: [PATCH 3/3] feat(core): Add Sentry span kind constants Expose the values supported by the sentry.kind convention and use the server constant across Spring and OpenTelemetry instrumentation. This keeps convention keys and values separate while avoiding duplicated literals. Refs #4735 Co-Authored-By: Claude --- .../sentry/opentelemetry/SentrySpanExporter.java | 3 ++- .../spring7/tracing/SentryTracingFilter.java | 3 ++- .../spring7/webflux/AbstractSentryWebFilter.java | 3 ++- .../jakarta/tracing/SentryTracingFilter.java | 3 ++- .../jakarta/webflux/AbstractSentryWebFilter.java | 3 ++- .../spring/tracing/SentryTracingFilter.java | 3 ++- .../io/sentry/spring/webflux/SentryWebFilter.java | 3 ++- sentry/api/sentry.api | 8 ++++++++ .../src/main/java/io/sentry/SentrySpanKind.java | 12 ++++++++++++ .../src/test/java/io/sentry/SentrySpanKindTest.kt | 15 +++++++++++++++ 10 files changed, 49 insertions(+), 7 deletions(-) create mode 100644 sentry/src/main/java/io/sentry/SentrySpanKind.java create mode 100644 sentry/src/test/java/io/sentry/SentrySpanKindTest.kt diff --git a/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SentrySpanExporter.java b/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SentrySpanExporter.java index 571fddc6e83..c442bc3b216 100644 --- a/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SentrySpanExporter.java +++ b/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SentrySpanExporter.java @@ -28,6 +28,7 @@ import io.sentry.SentryInstantDate; import io.sentry.SentryLevel; import io.sentry.SentryLongDate; +import io.sentry.SentrySpanKind; import io.sentry.SpanContext; import io.sentry.SpanDataConvention; import io.sentry.SpanId; @@ -565,7 +566,7 @@ private void setOtelSpanKind(final @NotNull SpanData otelSpan, final @NotNull IS private void setSentrySpanKind( final @NotNull SpanData otelSpan, final @NotNull ISpan sentrySpan) { if (SpanKind.SERVER.equals(otelSpan.getKind())) { - sentrySpan.setData(SpanDataConvention.SENTRY_KIND_KEY, "server"); + sentrySpan.setData(SpanDataConvention.SENTRY_KIND_KEY, SentrySpanKind.SERVER); } } diff --git a/sentry-spring-7/src/main/java/io/sentry/spring7/tracing/SentryTracingFilter.java b/sentry-spring-7/src/main/java/io/sentry/spring7/tracing/SentryTracingFilter.java index 39e2fc3ec9e..8d9904e5bd4 100644 --- a/sentry-spring-7/src/main/java/io/sentry/spring7/tracing/SentryTracingFilter.java +++ b/sentry-spring-7/src/main/java/io/sentry/spring7/tracing/SentryTracingFilter.java @@ -8,6 +8,7 @@ import io.sentry.IScopes; import io.sentry.ITransaction; import io.sentry.ScopesAdapter; +import io.sentry.SentrySpanKind; import io.sentry.SentryTraceHeader; import io.sentry.SpanDataConvention; import io.sentry.SpanStatus; @@ -260,7 +261,7 @@ private ITransaction startTransaction( new TransactionContext(name, TransactionNameSource.URL, "http.server"), transactionOptions); } - transaction.setData(SpanDataConvention.SENTRY_KIND_KEY, "server"); + transaction.setData(SpanDataConvention.SENTRY_KIND_KEY, SentrySpanKind.SERVER); return transaction; } } diff --git a/sentry-spring-7/src/main/java/io/sentry/spring7/webflux/AbstractSentryWebFilter.java b/sentry-spring-7/src/main/java/io/sentry/spring7/webflux/AbstractSentryWebFilter.java index 0301159bb4d..53f2ed2ad54 100644 --- a/sentry-spring-7/src/main/java/io/sentry/spring7/webflux/AbstractSentryWebFilter.java +++ b/sentry-spring-7/src/main/java/io/sentry/spring7/webflux/AbstractSentryWebFilter.java @@ -12,6 +12,7 @@ import io.sentry.ITransaction; import io.sentry.NoOpScopes; import io.sentry.Sentry; +import io.sentry.SentrySpanKind; import io.sentry.SentryTraceHeader; import io.sentry.SpanDataConvention; import io.sentry.SpanStatus; @@ -169,7 +170,7 @@ private void finishTransaction(ServerWebExchange exchange, ITransaction transact new TransactionContext(name, TransactionNameSource.URL, TRANSACTION_OP), transactionOptions); } - transaction.setData(SpanDataConvention.SENTRY_KIND_KEY, "server"); + transaction.setData(SpanDataConvention.SENTRY_KIND_KEY, SentrySpanKind.SERVER); return transaction; } } diff --git a/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/tracing/SentryTracingFilter.java b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/tracing/SentryTracingFilter.java index ddc1c25ec72..9259dce62ba 100644 --- a/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/tracing/SentryTracingFilter.java +++ b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/tracing/SentryTracingFilter.java @@ -8,6 +8,7 @@ import io.sentry.IScopes; import io.sentry.ITransaction; import io.sentry.ScopesAdapter; +import io.sentry.SentrySpanKind; import io.sentry.SentryTraceHeader; import io.sentry.SpanDataConvention; import io.sentry.SpanStatus; @@ -260,7 +261,7 @@ private ITransaction startTransaction( new TransactionContext(name, TransactionNameSource.URL, "http.server"), transactionOptions); } - transaction.setData(SpanDataConvention.SENTRY_KIND_KEY, "server"); + transaction.setData(SpanDataConvention.SENTRY_KIND_KEY, SentrySpanKind.SERVER); return transaction; } } diff --git a/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/webflux/AbstractSentryWebFilter.java b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/webflux/AbstractSentryWebFilter.java index 2468b43d20f..8b8252bac57 100644 --- a/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/webflux/AbstractSentryWebFilter.java +++ b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/webflux/AbstractSentryWebFilter.java @@ -12,6 +12,7 @@ import io.sentry.ITransaction; import io.sentry.NoOpScopes; import io.sentry.Sentry; +import io.sentry.SentrySpanKind; import io.sentry.SentryTraceHeader; import io.sentry.SpanDataConvention; import io.sentry.SpanStatus; @@ -169,7 +170,7 @@ private void finishTransaction(ServerWebExchange exchange, ITransaction transact new TransactionContext(name, TransactionNameSource.URL, TRANSACTION_OP), transactionOptions); } - transaction.setData(SpanDataConvention.SENTRY_KIND_KEY, "server"); + transaction.setData(SpanDataConvention.SENTRY_KIND_KEY, SentrySpanKind.SERVER); return transaction; } } diff --git a/sentry-spring/src/main/java/io/sentry/spring/tracing/SentryTracingFilter.java b/sentry-spring/src/main/java/io/sentry/spring/tracing/SentryTracingFilter.java index 9a74b27c234..6371134cdec 100644 --- a/sentry-spring/src/main/java/io/sentry/spring/tracing/SentryTracingFilter.java +++ b/sentry-spring/src/main/java/io/sentry/spring/tracing/SentryTracingFilter.java @@ -8,6 +8,7 @@ import io.sentry.IScopes; import io.sentry.ITransaction; import io.sentry.ScopesAdapter; +import io.sentry.SentrySpanKind; import io.sentry.SentryTraceHeader; import io.sentry.SpanDataConvention; import io.sentry.SpanStatus; @@ -259,7 +260,7 @@ private ITransaction startTransaction( new TransactionContext(name, TransactionNameSource.URL, "http.server"), transactionOptions); } - transaction.setData(SpanDataConvention.SENTRY_KIND_KEY, "server"); + transaction.setData(SpanDataConvention.SENTRY_KIND_KEY, SentrySpanKind.SERVER); return transaction; } } diff --git a/sentry-spring/src/main/java/io/sentry/spring/webflux/SentryWebFilter.java b/sentry-spring/src/main/java/io/sentry/spring/webflux/SentryWebFilter.java index 9f907b206dd..0743b6bb0ea 100644 --- a/sentry-spring/src/main/java/io/sentry/spring/webflux/SentryWebFilter.java +++ b/sentry-spring/src/main/java/io/sentry/spring/webflux/SentryWebFilter.java @@ -12,6 +12,7 @@ import io.sentry.ITransaction; import io.sentry.NoOpScopes; import io.sentry.Sentry; +import io.sentry.SentrySpanKind; import io.sentry.SentryTraceHeader; import io.sentry.SpanDataConvention; import io.sentry.SpanStatus; @@ -146,7 +147,7 @@ private boolean shouldTraceRequest( new TransactionContext(name, TransactionNameSource.URL, TRANSACTION_OP), transactionOptions); } - transaction.setData(SpanDataConvention.SENTRY_KIND_KEY, "server"); + transaction.setData(SpanDataConvention.SENTRY_KIND_KEY, SentrySpanKind.SERVER); return transaction; } diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api index 49e5242da7f..e1465518e76 100644 --- a/sentry/api/sentry.api +++ b/sentry/api/sentry.api @@ -4043,6 +4043,14 @@ public final class io/sentry/SentryReplayOptions$SentryReplayQuality : java/lang public static fun values ()[Lio/sentry/SentryReplayOptions$SentryReplayQuality; } +public final class io/sentry/SentrySpanKind { + public static final field CLIENT Ljava/lang/String; + public static final field CONSUMER Ljava/lang/String; + public static final field INTERNAL Ljava/lang/String; + public static final field PRODUCER Ljava/lang/String; + public static final field SERVER Ljava/lang/String; +} + public final class io/sentry/SentryStackTraceFactory { public fun (Lio/sentry/SentryOptions;)V public fun getInAppCallStack ()Ljava/util/List; diff --git a/sentry/src/main/java/io/sentry/SentrySpanKind.java b/sentry/src/main/java/io/sentry/SentrySpanKind.java new file mode 100644 index 00000000000..50e20b0328b --- /dev/null +++ b/sentry/src/main/java/io/sentry/SentrySpanKind.java @@ -0,0 +1,12 @@ +package io.sentry; + +/** Values supported by the {@code sentry.kind} span data attribute. */ +public final class SentrySpanKind { + public static final String CLIENT = "client"; + public static final String SERVER = "server"; + public static final String PRODUCER = "producer"; + public static final String CONSUMER = "consumer"; + public static final String INTERNAL = "internal"; + + private SentrySpanKind() {} +} diff --git a/sentry/src/test/java/io/sentry/SentrySpanKindTest.kt b/sentry/src/test/java/io/sentry/SentrySpanKindTest.kt new file mode 100644 index 00000000000..8f09a54c884 --- /dev/null +++ b/sentry/src/test/java/io/sentry/SentrySpanKindTest.kt @@ -0,0 +1,15 @@ +package io.sentry + +import com.google.common.truth.Truth.assertThat +import kotlin.test.Test + +class SentrySpanKindTest { + @Test + fun `values match the sentry kind convention`() { + assertThat(SentrySpanKind.CLIENT).isEqualTo("client") + assertThat(SentrySpanKind.SERVER).isEqualTo("server") + assertThat(SentrySpanKind.PRODUCER).isEqualTo("producer") + assertThat(SentrySpanKind.CONSUMER).isEqualTo("consumer") + assertThat(SentrySpanKind.INTERNAL).isEqualTo("internal") + } +}