Merge branch 'main' into fix/processor-transaction

.github/workflows/build.yml

@@ -66,31 +66,3 @@ jobs:
         uses: codecov/codecov-action@v1
         with:
           name: sentry-java
-
-  release:
-    ## Only run on a release branch
-    if: github.event_name == 'push' && contains(github.ref, 'refs/heads/release')
-    needs: [build]
-    name: Release
-    runs-on: ubuntu-latest
-    steps:
-      - name: Download packages
-        uses: actions/download-artifact@v2
-        with:
-          name: artifacts
-          path: ./*/build/distributions/*.zip
-
-      - uses: actions/setup-node@v1
-
-      - name: Install Zeus
-        run: |
-          yarn global add @zeus-ci/cli
-          echo "::add-path::$(yarn global bin)"
-      - name: Upload to Zeus
-        env:
-          ZEUS_API_TOKEN: ${{ secrets.ZEUS_TOKEN }}
-          ZEUS_HOOK_BASE: ${{ secrets.ZEUS_HOOK_BASE }}
-        run: |
-          zeus job update -b $GITHUB_RUN_ID -j $GITHUB_RUN_NUMBER -r $GITHUB_SHA
-          zeus upload -b $GITHUB_RUN_ID -j $GITHUB_RUN_NUMBER -t "application/zip+maven" *.zip
-          zeus job update --status=passed -b $GITHUB_RUN_ID -j $GITHUB_RUN_NUMBER -r $GITHUB_SHA

CHANGELOG.md

@@ -6,10 +6,12 @@
 * 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)
 * Fix: Run event processors and enrich transactions with contexts (#1430)
+* Bump: sentry-native to 0.4.9 (#1431)
 
 # 4.4.0-alpha.2
 

sentry-android-ndk/src/main/jni/sentry.c

@@ -398,5 +398,5 @@ Java_io_sentry_android_ndk_NativeModuleListLoader_nativeLoadModuleList(JNIEnv *e
 
 JNIEXPORT void JNICALL
 Java_io_sentry_android_ndk_SentryNdk_shutdown(JNIEnv *env, jclass cls) {
-    sentry_shutdown();
+    sentry_close();
 }

sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml

@@ -21,8 +21,6 @@
         android:label="@string/app_name"
         android:roundIcon="@mipmap/ic_launcher_round"
         android:theme="@style/AppTheme"
-        android:allowNativeHeapPointerTagging="false"
-        android:extractNativeLibs="true"
         tools:ignore="GoogleAppIndexingWarning, UnusedAttribute">
 
         <activity android:name=".MainActivity">

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();

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<ITransport>()
@@ -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

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<RuntimeException> { 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")

sentry-test-support/api/sentry-test-support.api

@@ -1,5 +1,6 @@
 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;
 }
 
 public final class io/sentry/test/ReflectionKt {

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")
+        }
     }
 }

sentry/api/sentry.api

@@ -128,7 +128,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
@@ -166,7 +166,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
@@ -219,7 +219,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
@@ -369,7 +369,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
@@ -1872,6 +1872,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 <init> (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;