Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
32 commits
Select commit Hold shift + click to select a range
dd197b9
collection: Ignore HTTP Status
adinauer Nov 11, 2026
a32bc6e
feat(tracing): [Ignore HTTP Status 1] Add sentry.kind to server instr…
adinauer Nov 11, 2026
54d0dca
fix(spring): Omit unreliable HTTP status on escaping exceptions
adinauer Nov 12, 2026
b80bf59
feat(core): [Ignore HTTP Status 2] Add tracing status configuration
adinauer Nov 11, 2026
5bbc5e6
Merge branch 'feat/ignore404-server-kind' into feat/ignore404-options
adinauer Nov 12, 2026
a018c68
feat(tracing): Filter configured incoming HTTP statuses
adinauer Nov 11, 2026
199172d
chore: Link HTTP status filter changelog entry
adinauer Nov 11, 2026
b9bad2a
feat(tracing): [Ignore HTTP Status 4] Ignore incoming 404s by default
adinauer Nov 11, 2026
becc6d0
changelog
adinauer Nov 11, 2026
7b048a0
fix(spring): Bind integer HTTP status codes from YAML
adinauer Nov 16, 2026
8eb7843
Merge branch 'feat/ignore404-options' into feat/ignore404-filter
adinauer Nov 17, 2026
0a7d341
Merge branch 'feat/ignore404-filter' into feat/ignore404-default
adinauer Nov 17, 2026
2a02d6d
Format code
getsentry-bot Nov 17, 2026
cf2f6fc
feat(tracing): Align ignored status defaults with spec
adinauer Nov 17, 2026
3ad504c
fix(core): Make trace ignore statuses thread-safe
adinauer Nov 19, 2026
7562d98
feat(core): Add Sentry span kind constants
adinauer Nov 19, 2026
6e6beba
Merge branch 'feat/ignore404-server-kind' into feat/ignore404-options
adinauer Nov 19, 2026
316b324
Merge branch 'feat/ignore404-options' into feat/ignore404-filter
adinauer Nov 19, 2026
19c9599
ref(tracing): Use span kind constant for filtering
adinauer Nov 19, 2026
4b97e4d
Merge branch 'feat/ignore404-filter' into feat/ignore404-default
adinauer Nov 19, 2026
d72b66f
ref(core): Share ignored transaction accounting
adinauer Nov 19, 2026
5b57ecb
Merge branch 'feat/ignore404-filter' into feat/ignore404-default
adinauer Nov 19, 2026
4a173f2
ref(core): Simplify HTTP status conversion
adinauer Nov 19, 2026
10243cf
Merge branch 'feat/ignore404-filter' into feat/ignore404-default
adinauer Nov 19, 2026
737909a
feat(tracing): [Ignore HTTP Status 1] Add sentry.kind to server instr…
adinauer Nov 19, 2026
e7fdb28
feat(core): [Ignore HTTP Status 2] Add traceIgnoreStatusCodes configu…
adinauer Nov 19, 2026
fbf86b6
feat(tracing): [Ignore HTTP Status 3] Filter configured incoming HTTP…
adinauer Nov 19, 2026
0e12b0b
feat(tracing): [Ignore HTTP Status 4] Use spec status defaults (#6567)
adinauer Nov 19, 2026
2b572d4
Merge branch '9.x.x' into feat/ignore404-collection
adinauer Nov 19, 2026
90a5ac4
Format code
getsentry-bot Nov 19, 2026
97d463a
docs(changelog): Document ignored status defaults
adinauer Nov 19, 2026
e61179f
Format code
getsentry-bot Nov 19, 2026
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
75 changes: 75 additions & 0 deletions CHANGELOG.md
Original file line number Diff line number Diff line change
Expand Up @@ -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))
Expand All @@ -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))

Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -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;
Expand All @@ -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;
Expand Down Expand Up @@ -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);
Expand Down Expand Up @@ -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);
Expand Down Expand Up @@ -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);
Expand Down
Original file line number Diff line number Diff line change
@@ -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://[email protected]/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<SentryTransaction> {
val transaction = argumentCaptor<SentryTransaction>()
verify(client, atLeastOnce())
.captureTransaction(
transaction.capture(),
anyOrNull(),
anyOrNull(),
anyOrNull(),
anyOrNull(),
)
return transaction.allValues
}
}
Original file line number Diff line number Diff line change
Expand Up @@ -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;
Expand Down Expand Up @@ -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
Expand All @@ -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) {
Expand Down Expand Up @@ -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;
}
}
Loading