From 407f7096913b135159493248191b9ce6c284a52a Mon Sep 17 00:00:00 2001 From: Maciej Walkowiak Date: Fri, 23 Apr 2021 15:01:31 +0200 Subject: [PATCH] Fix: set status and associate events with transactions (#1426) --- CHANGELOG.md | 1 + .../tracing/SentryTransactionAdvice.java | 9 +- .../spring/SentrySpringIntegrationTest.kt | 88 ++++++++++++++++++- .../tracing/SentryTransactionAdviceTest.kt | 14 +++ .../api/sentry-test-support.api | 1 + .../main/kotlin/io/sentry/test/assertions.kt | 27 +++++- sentry/api/sentry.api | 14 ++- sentry/src/main/java/io/sentry/Hub.java | 27 ++++-- .../src/main/java/io/sentry/HubAdapter.java | 7 +- sentry/src/main/java/io/sentry/IHub.java | 8 +- sentry/src/main/java/io/sentry/NoOpHub.java | 4 +- sentry/src/main/java/io/sentry/Span.java | 2 +- sentry/src/main/java/io/sentry/util/Pair.java | 23 +++++ sentry/src/test/java/io/sentry/HubTest.kt | 11 +-- sentry/src/test/java/io/sentry/NoOpHubTest.kt | 2 +- .../test/java/io/sentry/SentryTracerTest.kt | 4 +- sentry/src/test/java/io/sentry/SpanTest.kt | 4 +- 17 files changed, 211 insertions(+), 35 deletions(-) create mode 100644 sentry/src/main/java/io/sentry/util/Pair.java diff --git a/CHANGELOG.md b/CHANGELOG.md index 99bcf8e632..2f9ba83102 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,7 @@ * Fix: set correct transaction status for unhandled exceptions in SentryTracingFilter (#1406) * Fix: handle network errors in SentrySpanClientHttpRequestInterceptor (#1407) * Fix: set scope on transaction (#1409) +* Fix: set status and associate events with transactions (#1426) * Fix: Do not set free memory and is low memory fields when it's a NDK hard crash (#1399) * Fix: Apply user from the scope to transaction (#1424) * Fix: Pass maxBreadcrumbs config. to sentry-native (#1425) diff --git a/sentry-spring/src/main/java/io/sentry/spring/tracing/SentryTransactionAdvice.java b/sentry-spring/src/main/java/io/sentry/spring/tracing/SentryTransactionAdvice.java index 12f8317953..4c33fcc2ef 100644 --- a/sentry-spring/src/main/java/io/sentry/spring/tracing/SentryTransactionAdvice.java +++ b/sentry-spring/src/main/java/io/sentry/spring/tracing/SentryTransactionAdvice.java @@ -3,6 +3,7 @@ import com.jakewharton.nopen.annotation.Open; import io.sentry.IHub; import io.sentry.ITransaction; +import io.sentry.SpanStatus; import io.sentry.util.Objects; import java.lang.reflect.Method; import org.aopalliance.intercept.MethodInterceptor; @@ -59,7 +60,13 @@ public Object invoke(final @NotNull MethodInvocation invocation) throws Throwabl hub.pushScope(); final ITransaction transaction = hub.startTransaction(name, operation, true); try { - return invocation.proceed(); + final Object result = invocation.proceed(); + transaction.setStatus(SpanStatus.OK); + return result; + } catch (Exception e) { + transaction.setStatus(SpanStatus.INTERNAL_ERROR); + transaction.setThrowable(e); + throw e; } finally { transaction.finish(); hub.popScope(); diff --git a/sentry-spring/src/test/kotlin/io/sentry/spring/SentrySpringIntegrationTest.kt b/sentry-spring/src/test/kotlin/io/sentry/spring/SentrySpringIntegrationTest.kt index dab57a1155..b259752f50 100644 --- a/sentry-spring/src/test/kotlin/io/sentry/spring/SentrySpringIntegrationTest.kt +++ b/sentry-spring/src/test/kotlin/io/sentry/spring/SentrySpringIntegrationTest.kt @@ -7,11 +7,17 @@ import com.nhaarman.mockitokotlin2.reset import com.nhaarman.mockitokotlin2.verify import com.nhaarman.mockitokotlin2.verifyZeroInteractions import com.nhaarman.mockitokotlin2.whenever +import io.sentry.IHub import io.sentry.ITransportFactory import io.sentry.Sentry +import io.sentry.SentryOptions +import io.sentry.SpanStatus +import io.sentry.spring.tracing.SentryTracingConfiguration +import io.sentry.spring.tracing.SentryTransaction import io.sentry.test.checkEvent +import io.sentry.test.checkTransaction import io.sentry.transport.ITransport -import java.lang.RuntimeException +import java.lang.Exception import java.time.Duration import org.assertj.core.api.Assertions.assertThat import org.awaitility.kotlin.await @@ -25,6 +31,7 @@ import org.springframework.boot.test.web.client.TestRestTemplate import org.springframework.boot.web.server.LocalServerPort import org.springframework.context.annotation.Bean import org.springframework.context.annotation.Configuration +import org.springframework.context.annotation.Import import org.springframework.http.HttpEntity import org.springframework.http.HttpHeaders import org.springframework.http.HttpMethod @@ -37,6 +44,7 @@ import org.springframework.security.core.userdetails.UserDetailsService import org.springframework.security.crypto.factory.PasswordEncoderFactories import org.springframework.security.crypto.password.PasswordEncoder import org.springframework.security.provisioning.InMemoryUserDetailsManager +import org.springframework.stereotype.Service import org.springframework.test.context.junit4.SpringRunner import org.springframework.web.bind.annotation.ControllerAdvice import org.springframework.web.bind.annotation.ExceptionHandler @@ -53,6 +61,12 @@ class SentrySpringIntegrationTest { @Autowired lateinit var transport: ITransport + @Autowired + lateinit var someService: SomeService + + @Autowired + lateinit var hub: IHub + @LocalServerPort lateinit var port: Integer @@ -137,10 +151,51 @@ class SentrySpringIntegrationTest { verifyZeroInteractions(transport) } } + + @Test + fun `calling a method annotated with @SentryTransaction creates transaction`() { + someService.aMethod() + await.untilAsserted { + verify(transport).send(checkTransaction { + assertThat(it.status).isEqualTo(SpanStatus.OK) + }, anyOrNull()) + } + } + + @Test + fun `calling a method annotated with @SentryTransaction throwing exception associates Sentry event with transaction`() { + try { + someService.aMethodThrowing() + } catch (e: Exception) { + hub.captureException(e) + } + await.untilAsserted { + verify(transport).send(checkEvent { + assertThat(it.contexts.trace).isNotNull + assertThat(it.contexts.trace!!.operation).isEqualTo("bean") + }, anyOrNull()) + } + } + + @Test + fun `calling a method annotated with @SentryTransaction, where an inner span is created within transaction, throwing exception associates Sentry event with inner span`() { + try { + someService.aMethodWithInnerSpanThrowing() + } catch (e: Exception) { + hub.captureException(e) + } + await.untilAsserted { + verify(transport).send(checkEvent { + assertThat(it.contexts.trace).isNotNull + assertThat(it.contexts.trace!!.operation).isEqualTo("child-op") + }, anyOrNull()) + } + } } @SpringBootApplication @EnableSentry(dsn = "http://key@localhost/proj", sendDefaultPii = true) +@Import(SentryTracingConfiguration::class) open class App { private val transport = mock() @@ -157,6 +212,37 @@ open class App { @Bean open fun sentrySpringRequestListener() = SentrySpringRequestListener() + + @Bean + open fun tracesSamplerCallback() = SentryOptions.TracesSamplerCallback { + 1.0 + } +} + +@Service +open class SomeService { + + @SentryTransaction(operation = "bean") + open fun aMethod() { Thread.sleep(100) } + + @SentryTransaction(operation = "bean") + open fun aMethodThrowing() { + throw RuntimeException("oops") + } + + @SentryTransaction(operation = "bean") + open fun aMethodWithInnerSpanThrowing() { + val span = Sentry.getSpan()!!.startChild("child-op") + try { + throw RuntimeException("oops") + } catch (e: Exception) { + span.status = SpanStatus.INTERNAL_ERROR + span.throwable = e + throw e + } finally { + span.finish() + } + } } @RestController diff --git a/sentry-spring/src/test/kotlin/io/sentry/spring/tracing/SentryTransactionAdviceTest.kt b/sentry-spring/src/test/kotlin/io/sentry/spring/tracing/SentryTransactionAdviceTest.kt index 36cd00667b..58459e720c 100644 --- a/sentry-spring/src/test/kotlin/io/sentry/spring/tracing/SentryTransactionAdviceTest.kt +++ b/sentry-spring/src/test/kotlin/io/sentry/spring/tracing/SentryTransactionAdviceTest.kt @@ -12,10 +12,12 @@ import io.sentry.IHub import io.sentry.Scope import io.sentry.ScopeCallback import io.sentry.SentryOptions +import io.sentry.SpanStatus import io.sentry.TransactionContext import kotlin.test.BeforeTest import kotlin.test.Test import org.assertj.core.api.Assertions.assertThat +import org.junit.jupiter.api.assertThrows import org.junit.runner.RunWith import org.springframework.beans.factory.annotation.Autowired import org.springframework.context.annotation.Bean @@ -53,6 +55,15 @@ class SentryTransactionAdviceTest { verify(hub).captureTransaction(check { assertThat(it.transaction).isEqualTo("customName") assertThat(it.contexts.trace!!.operation).isEqualTo("bean") + assertThat(it.status).isEqualTo(SpanStatus.OK) + }) + } + + @Test + fun `when method annotated with @SentryTransaction throws exception, sets error status on transaction`() { + assertThrows { sampleService.methodThrowingException() } + verify(hub).captureTransaction(check { + assertThat(it.status).isEqualTo(SpanStatus.INTERNAL_ERROR) }) } @@ -133,6 +144,9 @@ class SentryTransactionAdviceTest { @SentryTransaction(operation = "op") open fun methodWithoutTransactionNameSet() = Unit + + @SentryTransaction(operation = "op") + open fun methodThrowingException(): Nothing = throw RuntimeException() } @SentryTransaction(operation = "op") diff --git a/sentry-test-support/api/sentry-test-support.api b/sentry-test-support/api/sentry-test-support.api index 45dc6c51f3..d554df7884 100644 --- a/sentry-test-support/api/sentry-test-support.api +++ b/sentry-test-support/api/sentry-test-support.api @@ -1,4 +1,5 @@ public final class io/sentry/test/AssertionsKt { public static final fun checkEvent (Lkotlin/jvm/functions/Function1;)Lio/sentry/SentryEnvelope; + public static final fun checkTransaction (Lkotlin/jvm/functions/Function1;)Lio/sentry/SentryEnvelope; } diff --git a/sentry-test-support/src/main/kotlin/io/sentry/test/assertions.kt b/sentry-test-support/src/main/kotlin/io/sentry/test/assertions.kt index 74abce7be6..7930943164 100644 --- a/sentry-test-support/src/main/kotlin/io/sentry/test/assertions.kt +++ b/sentry-test-support/src/main/kotlin/io/sentry/test/assertions.kt @@ -1,20 +1,39 @@ package io.sentry.test - import com.nhaarman.mockitokotlin2.check import io.sentry.GsonSerializer import io.sentry.SentryEnvelope import io.sentry.SentryEvent import io.sentry.SentryOptions +import io.sentry.protocol.SentryTransaction +import java.lang.AssertionError /** * Verifies is [SentryEnvelope] contains first event matching a predicate. */ -inline fun checkEvent(noinline predicate: (SentryEvent) -> Unit): SentryEnvelope { +fun checkEvent(predicate: (SentryEvent) -> Unit): SentryEnvelope { + val options = SentryOptions().apply { + setSerializer(GsonSerializer(SentryOptions())) + } + return check { + val event: SentryEvent? = it.items.first().getEvent(options.serializer) + if (event != null) { + predicate(event) + } else { + throw AssertionError("event is null") + } + } +} + +fun checkTransaction(predicate: (SentryTransaction) -> Unit): SentryEnvelope { val options = SentryOptions().apply { setSerializer(GsonSerializer(SentryOptions())) } return check { - val event = it.items.first().getEvent(options.serializer)!! - predicate(event) + val transaction = it.items.first().getTransaction(options.serializer) + if (transaction != null) { + predicate(transaction) + } else { + throw AssertionError("transaction is null") + } } } diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api index 51a9789db7..23c91ca244 100644 --- a/sentry/api/sentry.api +++ b/sentry/api/sentry.api @@ -127,7 +127,7 @@ public final class io/sentry/Hub : io/sentry/IHub { public fun setExtra (Ljava/lang/String;Ljava/lang/String;)V public fun setFingerprint (Ljava/util/List;)V public fun setLevel (Lio/sentry/SentryLevel;)V - public fun setSpanContext (Ljava/lang/Throwable;Lio/sentry/ISpan;)V + public fun setSpanContext (Ljava/lang/Throwable;Lio/sentry/ISpan;Ljava/lang/String;)V public fun setTag (Ljava/lang/String;Ljava/lang/String;)V public fun setTransaction (Ljava/lang/String;)V public fun setUser (Lio/sentry/protocol/User;)V @@ -165,7 +165,7 @@ public final class io/sentry/HubAdapter : io/sentry/IHub { public fun setExtra (Ljava/lang/String;Ljava/lang/String;)V public fun setFingerprint (Ljava/util/List;)V public fun setLevel (Lio/sentry/SentryLevel;)V - public fun setSpanContext (Ljava/lang/Throwable;Lio/sentry/ISpan;)V + public fun setSpanContext (Ljava/lang/Throwable;Lio/sentry/ISpan;Ljava/lang/String;)V public fun setTag (Ljava/lang/String;Ljava/lang/String;)V public fun setTransaction (Ljava/lang/String;)V public fun setUser (Lio/sentry/protocol/User;)V @@ -218,7 +218,7 @@ public abstract interface class io/sentry/IHub { public abstract fun setExtra (Ljava/lang/String;Ljava/lang/String;)V public abstract fun setFingerprint (Ljava/util/List;)V public abstract fun setLevel (Lio/sentry/SentryLevel;)V - public abstract fun setSpanContext (Ljava/lang/Throwable;Lio/sentry/ISpan;)V + public abstract fun setSpanContext (Ljava/lang/Throwable;Lio/sentry/ISpan;Ljava/lang/String;)V public abstract fun setTag (Ljava/lang/String;Ljava/lang/String;)V public abstract fun setTransaction (Ljava/lang/String;)V public abstract fun setUser (Lio/sentry/protocol/User;)V @@ -368,7 +368,7 @@ public final class io/sentry/NoOpHub : io/sentry/IHub { public fun setExtra (Ljava/lang/String;Ljava/lang/String;)V public fun setFingerprint (Ljava/util/List;)V public fun setLevel (Lio/sentry/SentryLevel;)V - public fun setSpanContext (Ljava/lang/Throwable;Lio/sentry/ISpan;)V + public fun setSpanContext (Ljava/lang/Throwable;Lio/sentry/ISpan;Ljava/lang/String;)V public fun setTag (Ljava/lang/String;Ljava/lang/String;)V public fun setTransaction (Ljava/lang/String;)V public fun setUser (Lio/sentry/protocol/User;)V @@ -1871,6 +1871,12 @@ public final class io/sentry/util/Objects { public static fun requireNonNull (Ljava/lang/Object;Ljava/lang/String;)Ljava/lang/Object; } +public final class io/sentry/util/Pair { + public fun (Ljava/lang/Object;Ljava/lang/Object;)V + public fun getFirst ()Ljava/lang/Object; + public fun getSecond ()Ljava/lang/Object; +} + public final class io/sentry/util/StringUtils { public static fun capitalize (Ljava/lang/String;)Ljava/lang/String; public static fun getStringAfterDot (Ljava/lang/String;)Ljava/lang/String; diff --git a/sentry/src/main/java/io/sentry/Hub.java b/sentry/src/main/java/io/sentry/Hub.java index dbb8b10061..a0cfa4b4b0 100644 --- a/sentry/src/main/java/io/sentry/Hub.java +++ b/sentry/src/main/java/io/sentry/Hub.java @@ -7,6 +7,7 @@ import io.sentry.protocol.SentryTransaction; import io.sentry.protocol.User; import io.sentry.util.Objects; +import io.sentry.util.Pair; import java.io.Closeable; import java.util.Collections; import java.util.List; @@ -22,7 +23,7 @@ public final class Hub implements IHub { private volatile boolean isEnabled; private final @NotNull Stack stack; private final @NotNull TracesSampler tracesSampler; - private final @NotNull Map throwableToSpan = + private final @NotNull Map> throwableToSpan = Collections.synchronizedMap(new WeakHashMap<>()); public Hub(final @NotNull SentryOptions options) { @@ -174,10 +175,13 @@ public SentryId captureEnvelope( private void assignTraceContext(final @NotNull SentryEvent event) { if (event.getThrowable() != null) { - final ISpan span = throwableToSpan.get(event.getThrowable()); - if (span != null) { + final Pair pair = throwableToSpan.get(event.getThrowable()); + if (pair != null) { if (event.getContexts().getTrace() == null) { - event.getContexts().setTrace(span.getSpanContext()); + event.getContexts().setTrace(pair.getFirst().getSpanContext()); + } + if (event.getTransaction() == null) { + event.setTransaction(pair.getSecond()); } } } @@ -632,18 +636,25 @@ public void flush(long timeoutMillis) { @Override @ApiStatus.Internal - public void setSpanContext(final @NotNull Throwable throwable, final @NotNull ISpan span) { + public void setSpanContext( + final @NotNull Throwable throwable, + final @NotNull ISpan span, + final @NotNull String transactionName) { Objects.requireNonNull(throwable, "throwable is required"); Objects.requireNonNull(span, "span is required"); - this.throwableToSpan.put(throwable, span); + Objects.requireNonNull(transactionName, "transactionName is required"); + // the most inner span should be assigned to a throwable + if (!throwableToSpan.containsKey(throwable)) { + throwableToSpan.put(throwable, new Pair<>(span, transactionName)); + } } @Nullable SpanContext getSpanContext(final @NotNull Throwable throwable) { Objects.requireNonNull(throwable, "throwable is required"); - final ISpan span = this.throwableToSpan.get(throwable); + final Pair span = this.throwableToSpan.get(throwable); if (span != null) { - return span.getSpanContext(); + return span.getFirst().getSpanContext(); } return null; } diff --git a/sentry/src/main/java/io/sentry/HubAdapter.java b/sentry/src/main/java/io/sentry/HubAdapter.java index 4c6813b2cb..d8e617f6fb 100644 --- a/sentry/src/main/java/io/sentry/HubAdapter.java +++ b/sentry/src/main/java/io/sentry/HubAdapter.java @@ -178,8 +178,11 @@ public IHub clone() { } @Override - public void setSpanContext(final @NotNull Throwable t, final @NotNull ISpan sc) { - Sentry.getCurrentHub().setSpanContext(t, sc); + public void setSpanContext( + final @NotNull Throwable throwable, + final @NotNull ISpan span, + final @NotNull String transactionName) { + Sentry.getCurrentHub().setSpanContext(throwable, span, transactionName); } @Override diff --git a/sentry/src/main/java/io/sentry/IHub.java b/sentry/src/main/java/io/sentry/IHub.java index feac998178..4c9f3b5a1f 100644 --- a/sentry/src/main/java/io/sentry/IHub.java +++ b/sentry/src/main/java/io/sentry/IHub.java @@ -402,14 +402,16 @@ ITransaction startTransaction( SentryTraceHeader traceHeaders(); /** - * Associates {@link ISpan} with the {@link Throwable}. Used to determine in which trace the - * exception has been thrown in framework integrations. + * Associates {@link ISpan} and the transaction name with the {@link Throwable}. Used to determine + * in which trace the exception has been thrown in framework integrations. * * @param throwable the throwable * @param span the span context + * @param transactionName the transaction name */ @ApiStatus.Internal - void setSpanContext(@NotNull Throwable throwable, @NotNull ISpan span); + void setSpanContext( + @NotNull Throwable throwable, @NotNull ISpan span, @NotNull String transactionName); /** * Gets the current active transaction or span. diff --git a/sentry/src/main/java/io/sentry/NoOpHub.java b/sentry/src/main/java/io/sentry/NoOpHub.java index d422a48dc9..c051b8f39a 100644 --- a/sentry/src/main/java/io/sentry/NoOpHub.java +++ b/sentry/src/main/java/io/sentry/NoOpHub.java @@ -140,7 +140,9 @@ public SentryId captureTransaction( @Override public void setSpanContext( - final @NotNull Throwable throwable, final @NotNull ISpan spanContext) {} + final @NotNull Throwable throwable, + final @NotNull ISpan spanContext, + final @NotNull String transactionName) {} @Override public @Nullable ISpan getSpan() { diff --git a/sentry/src/main/java/io/sentry/Span.java b/sentry/src/main/java/io/sentry/Span.java index 62d5dafb8c..18f1a202f9 100644 --- a/sentry/src/main/java/io/sentry/Span.java +++ b/sentry/src/main/java/io/sentry/Span.java @@ -94,7 +94,7 @@ public void finish(@Nullable SpanStatus status) { this.context.setStatus(status); timestamp = DateUtils.getCurrentDateTime(); if (throwable != null) { - hub.setSpanContext(throwable, this); + hub.setSpanContext(throwable, this, this.transaction.getName()); } } diff --git a/sentry/src/main/java/io/sentry/util/Pair.java b/sentry/src/main/java/io/sentry/util/Pair.java new file mode 100644 index 0000000000..fbb4d0ed50 --- /dev/null +++ b/sentry/src/main/java/io/sentry/util/Pair.java @@ -0,0 +1,23 @@ +package io.sentry.util; + +import org.jetbrains.annotations.ApiStatus; +import org.jetbrains.annotations.Nullable; + +@ApiStatus.Internal +public final class Pair { + private final @Nullable A first; + private final @Nullable B second; + + public Pair(final @Nullable A first, final @Nullable B second) { + this.first = first; + this.second = second; + } + + public @Nullable A getFirst() { + return first; + } + + public @Nullable B getSecond() { + return second; + } +} diff --git a/sentry/src/test/java/io/sentry/HubTest.kt b/sentry/src/test/java/io/sentry/HubTest.kt index 0ce968bf1d..08b413f437 100644 --- a/sentry/src/test/java/io/sentry/HubTest.kt +++ b/sentry/src/test/java/io/sentry/HubTest.kt @@ -314,7 +314,7 @@ class HubTest { val exception = RuntimeException() val span = mock() whenever(span.spanContext).thenReturn(SpanContext("op")) - sut.setSpanContext(exception, span) + sut.setSpanContext(exception, span, "tx-name") val event = SentryEvent(exception) @@ -330,7 +330,7 @@ class HubTest { val exception = RuntimeException() val span = mock() whenever(span.spanContext).thenReturn(SpanContext("op")) - sut.setSpanContext(exception, span) + sut.setSpanContext(exception, span, "tx-name") val event = SentryEvent(exception) val originalSpanContext = SpanContext("op") @@ -435,11 +435,12 @@ class HubTest { val throwable = Throwable() val span = mock() whenever(span.spanContext).thenReturn(SpanContext("op")) - sut.setSpanContext(throwable, span) + sut.setSpanContext(throwable, span, "tx-name") sut.captureException(throwable) verify(mockClient).captureEvent(check { assertEquals(span.spanContext, it.contexts.trace) + assertEquals("tx-name", it.transaction) }, any(), anyOrNull()) } @@ -448,7 +449,7 @@ class HubTest { val (sut, mockClient) = getEnabledHub() val span = mock() whenever(span.spanContext).thenReturn(SpanContext("op")) - sut.setSpanContext(Throwable(), span) + sut.setSpanContext(Throwable(), span, "tx-name") sut.captureException(Throwable()) verify(mockClient).captureEvent(check { @@ -1170,7 +1171,7 @@ class HubTest { val span = transaction.startChild("op") val exception = RuntimeException() - hub.setSpanContext(exception, span) + hub.setSpanContext(exception, span, "tx-name") hub.captureEvent(SentryEvent(exception)) verify(mockClient).captureEvent(check { diff --git a/sentry/src/test/java/io/sentry/NoOpHubTest.kt b/sentry/src/test/java/io/sentry/NoOpHubTest.kt index 8b34e00d76..f82a082652 100644 --- a/sentry/src/test/java/io/sentry/NoOpHubTest.kt +++ b/sentry/src/test/java/io/sentry/NoOpHubTest.kt @@ -85,5 +85,5 @@ class NoOpHubTest { } @Test - fun `setSpanContext doesnt throw`() = sut.setSpanContext(RuntimeException(), mock()) + fun `setSpanContext doesnt throw`() = sut.setSpanContext(RuntimeException(), mock(), "") } diff --git a/sentry/src/test/java/io/sentry/SentryTracerTest.kt b/sentry/src/test/java/io/sentry/SentryTracerTest.kt index 2d9d8e46bf..56a6f70b2d 100644 --- a/sentry/src/test/java/io/sentry/SentryTracerTest.kt +++ b/sentry/src/test/java/io/sentry/SentryTracerTest.kt @@ -122,7 +122,7 @@ class SentryTracerTest { val ex = RuntimeException() tracer.throwable = ex tracer.finish() - verify(fixture.hub).setSpanContext(ex, tracer.root) + verify(fixture.hub).setSpanContext(ex, tracer.root, "name") } @Test @@ -284,7 +284,7 @@ class SentryTracerTest { transaction.finish(SpanStatus.UNKNOWN_ERROR) // call only once - verify(fixture.hub).setSpanContext(ex, transaction.root) + verify(fixture.hub).setSpanContext(ex, transaction.root, "name") verify(fixture.hub).captureTransaction(check { assertEquals(transaction.root.spanContext, it.contexts.trace) }) diff --git a/sentry/src/test/java/io/sentry/SpanTest.kt b/sentry/src/test/java/io/sentry/SpanTest.kt index d121ba36d3..48acef1b98 100644 --- a/sentry/src/test/java/io/sentry/SpanTest.kt +++ b/sentry/src/test/java/io/sentry/SpanTest.kt @@ -123,7 +123,7 @@ class SpanTest { span.throwable = ex span.finish() - verify(fixture.hub).setSpanContext(ex, span) + verify(fixture.hub).setSpanContext(ex, span, "name") } @Test @@ -138,7 +138,7 @@ class SpanTest { span.finish(SpanStatus.UNKNOWN_ERROR) // call only once - verify(fixture.hub).setSpanContext(any(), any()) + verify(fixture.hub).setSpanContext(any(), any(), any()) assertEquals(SpanStatus.OK, span.status) assertEquals(timestamp, span.timestamp) }