Add capabilities to track jetpack compose composition/rendering time

CHANGELOG.md

@@ -5,6 +5,7 @@
 ### Features
 
 - Improve versatility of exception resolver component for Spring with more flexible API for consumers. ([#2577](https://github.com/getsentry/sentry-java/pull/2577))
+- Add capabilities to track Jetpack Compose composition/rendering time ([#2507](https://github.com/getsentry/sentry-java/pull/2507))
 
 ### Fixes
 

sentry-android-core/src/main/java/io/sentry/android/core/ActivityLifecycleIntegration.java

@@ -182,7 +182,10 @@ private void startTracing(final @NotNull Activity activity) {
       final Boolean coldStart = AppStartState.getInstance().isColdStart();
 
       final TransactionOptions transactionOptions = new TransactionOptions();
-
+      if (options.isEnableActivityLifecycleTracingAutoFinish()) {
+        transactionOptions.setIdleTimeout(options.getIdleTimeout());
+        transactionOptions.setTrimEnd(true);
+      }
       transactionOptions.setWaitForChildren(true);
       transactionOptions.setTransactionFinishedCallback(
           (finishingTransaction) -> {
@@ -392,21 +395,11 @@ public synchronized void onActivityResumed(final @NotNull Activity activity) {
       mainHandler.post(() -> onFirstFrameDrawn(ttidSpan));
     }
     addBreadcrumb(activity, "resumed");
-
-    // fallback call for API < 29 compatibility, otherwise it happens on onActivityPostResumed
-    if (!isAllActivityCallbacksAvailable && options != null) {
-      stopTracing(activity, options.isEnableActivityLifecycleTracingAutoFinish());
-    }
   }
 
   @Override
-  public synchronized void onActivityPostResumed(final @NotNull Activity activity) {
-    // only executed if API >= 29 otherwise it happens on onActivityResumed
-    if (isAllActivityCallbacksAvailable && options != null) {
-      // this should be called only when onResume has been executed already, which means
-      // the UI is responsive at this moment.
-      stopTracing(activity, options.isEnableActivityLifecycleTracingAutoFinish());
-    }
+  public void onActivityPostResumed(@NonNull Activity activity) {
+    // empty override, required to avoid a api-level breaking super.onActivityPostResumed() calls
   }
 
   @Override

sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt

@@ -16,6 +16,7 @@ import io.sentry.FullyDisplayedReporter
 import io.sentry.Hub
 import io.sentry.ISentryExecutorService
 import io.sentry.Scope
+import io.sentry.Sentry
 import io.sentry.SentryDate
 import io.sentry.SentryLevel
 import io.sentry.SentryNanotimeDate
@@ -71,9 +72,23 @@ class ActivityLifecycleIntegrationTest {
         lateinit var transaction: SentryTracer
         val buildInfo = mock<BuildInfoProvider>()
 
-        fun getSut(apiVersion: Int = 29, importance: Int = RunningAppProcessInfo.IMPORTANCE_FOREGROUND): ActivityLifecycleIntegration {
+        fun getSut(
+            apiVersion: Int = 29,
+            importance: Int = RunningAppProcessInfo.IMPORTANCE_FOREGROUND,
+            initializer: Sentry.OptionsConfiguration<SentryAndroidOptions>? = null
+        ): ActivityLifecycleIntegration {
+            initializer?.configure(options)
+
             whenever(hub.options).thenReturn(options)
-            transaction = SentryTracer(context, hub, true, transactionFinishedCallback)
+
+            // TODO: we should let the ActivityLifecycleIntegration create the proper transaction here
+            val transactionOptions = TransactionOptions().apply {
+                isWaitForChildren = true
+                if (options.isEnableActivityLifecycleTracingAutoFinish) {
+                    idleTimeout = options.idleTimeout
+                }
+            }
+            transaction = SentryTracer(context, hub, transactionOptions, transactionFinishedCallback)
             whenever(hub.startTransaction(any(), any<TransactionOptions>())).thenReturn(transaction)
             whenever(buildInfo.sdkInfoVersion).thenReturn(apiVersion)
 
@@ -417,18 +432,32 @@ class ActivityLifecycleIntegrationTest {
     }
 
     @Test
-    fun `When tracing auto finish is enabled and ttid and ttfd spans are finished, it stops the transaction on onActivityPostResumed`() {
-        val sut = fixture.getSut()
-        fixture.options.tracesSampleRate = 1.0
-        fixture.options.isEnableTimeToFullDisplayTracing = true
-        sut.register(fixture.hub, fixture.options)
-
+    fun `When tracing auto finish is enabled and ttid and ttfd spans are finished, it schedules the transaction finish`() {
         val activity = mock<Activity>()
+        val sut = fixture.getSut(initializer = {
+            it.tracesSampleRate = 1.0
+            it.isEnableTimeToFullDisplayTracing = true
+            it.idleTimeout = 200
+        })
+        sut.register(fixture.hub, fixture.options)
         sut.onActivityCreated(activity, fixture.bundle)
+
         sut.ttidSpanMap.values.first().finish()
         sut.ttfdSpan?.finish()
-        sut.onActivityPostResumed(activity)
 
+        // then transaction should not be immediatelly finished
+        verify(fixture.hub, never())
+            .captureTransaction(
+                anyOrNull(),
+                anyOrNull(),
+                anyOrNull(),
+                anyOrNull()
+            )
+
+        // but when idle timeout has passed
+        Thread.sleep(400)
+
+        // then the transaction should be finished
         verify(fixture.hub).captureTransaction(
             check {
                 assertEquals(SpanStatus.OK, it.status)
@@ -485,16 +514,16 @@ class ActivityLifecycleIntegrationTest {
 
     @Test
     fun `When tracing auto finish is disabled, do not finish transaction`() {
-        val sut = fixture.getSut()
-        fixture.options.tracesSampleRate = 1.0
-        fixture.options.isEnableActivityLifecycleTracingAutoFinish = false
+        val sut = fixture.getSut(initializer = {
+            it.tracesSampleRate = 1.0
+            it.isEnableActivityLifecycleTracingAutoFinish = false
+        })
         sut.register(fixture.hub, fixture.options)
-
         val activity = mock<Activity>()
         sut.onActivityCreated(activity, fixture.bundle)
         sut.onActivityPostResumed(activity)
 
-        verify(fixture.hub, never()).captureTransaction(any(), anyOrNull<TraceContext>(), anyOrNull(), anyOrNull())
+        verify(fixture.hub, never()).captureTransaction(any(), anyOrNull(), anyOrNull(), anyOrNull())
     }
 
     @Test
@@ -668,37 +697,37 @@ class ActivityLifecycleIntegrationTest {
         sut.onActivityCreated(activity, mock())
         sut.onActivityResumed(activity)
 
-        verify(fixture.hub, never()).captureTransaction(any(), any<TraceContext>(), anyOrNull(), anyOrNull())
+        verify(fixture.hub, never()).captureTransaction(any(), any(), anyOrNull(), anyOrNull())
     }
 
     @Test
-    fun `start transaction on created if API less than 29`() {
+    fun `do not stop transaction on resumed if API less than 29 and ttid and ttfd are finished`() {
         val sut = fixture.getSut(14)
         fixture.options.tracesSampleRate = 1.0
+        fixture.options.isEnableTimeToFullDisplayTracing = true
         sut.register(fixture.hub, fixture.options)
 
-        setAppStartTime()
-
         val activity = mock<Activity>()
         sut.onActivityCreated(activity, mock())
+        sut.ttidSpanMap.values.first().finish()
+        sut.ttfdSpan?.finish()
+        sut.onActivityResumed(activity)
 
-        verify(fixture.hub).startTransaction(any(), any<TransactionOptions>())
+        verify(fixture.hub, never()).captureTransaction(any(), any(), anyOrNull(), anyOrNull())
     }
 
     @Test
-    fun `stop transaction on resumed if API 29 less than 29 and ttid and ttfd are finished`() {
+    fun `start transaction on created if API less than 29`() {
         val sut = fixture.getSut(14)
         fixture.options.tracesSampleRate = 1.0
-        fixture.options.isEnableTimeToFullDisplayTracing = true
         sut.register(fixture.hub, fixture.options)
 
+        setAppStartTime()
+
         val activity = mock<Activity>()
         sut.onActivityCreated(activity, mock())
-        sut.ttidSpanMap.values.first().finish()
-        sut.ttfdSpan?.finish()
-        sut.onActivityResumed(activity)
 
-        verify(fixture.hub).captureTransaction(any(), anyOrNull<TraceContext>(), anyOrNull(), anyOrNull())
+        verify(fixture.hub).startTransaction(any(), any<TransactionOptions>())
     }
 
     @Test

sentry-compose/api/android/sentry-compose.api

@@ -6,6 +6,10 @@ public final class io/sentry/compose/BuildConfig {
 	public fun <init> ()V
 }
 
+public final class io/sentry/compose/SentryComposeTracingKt {
+	public static final fun SentryTraced (Ljava/lang/String;Landroidx/compose/ui/Modifier;ZLkotlin/jvm/functions/Function3;Landroidx/compose/runtime/Composer;II)V
+}
+
 public final class io/sentry/compose/SentryNavigationIntegrationKt {
 	public static final fun withSentryObservableEffect (Landroidx/navigation/NavHostController;ZZLandroidx/compose/runtime/Composer;II)Landroidx/navigation/NavHostController;
 }

sentry-compose/src/androidMain/kotlin/io/sentry/compose/SentryComposeTracing.kt

@@ -0,0 +1,98 @@
+package io.sentry.compose
+
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.BoxScope
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.Immutable
+import androidx.compose.runtime.compositionLocalOf
+import androidx.compose.runtime.remember
+import androidx.compose.ui.ExperimentalComposeUiApi
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.drawWithContent
+import androidx.compose.ui.platform.testTag
+import io.sentry.ISpan
+import io.sentry.Sentry
+import io.sentry.SpanOptions
+
+private const val OP_PARENT_COMPOSITION = "ui.compose.composition"
+private const val OP_COMPOSE = "ui.compose"
+
+private const val OP_PARENT_RENDER = "ui.compose.rendering"
+private const val OP_RENDER = "ui.render"
+
+@Immutable
+private class ImmutableHolder<T>(var item: T)
+
+private fun getRootSpan(): ISpan? {
+    var rootSpan: ISpan? = null
+    Sentry.configureScope {
+        rootSpan = it.transaction
+    }
+    return rootSpan
+}
+
+private val localSentryCompositionParentSpan = compositionLocalOf {
+    ImmutableHolder(
+        getRootSpan()
+            ?.startChild(
+                OP_PARENT_COMPOSITION,
+                "Jetpack Compose Initial Composition",
+                SpanOptions().apply {
+                    isTrimStart = true
+                    isTrimEnd = true
+                    isIdle = true
+                }
+            )
+    )
+}
+
+private val localSentryRenderingParentSpan = compositionLocalOf {
+    ImmutableHolder(
+        getRootSpan()
+            ?.startChild(
+                OP_PARENT_RENDER,
+                "Jetpack Compose Initial Render",
+                SpanOptions().apply {
+                    isTrimStart = true
+                    isTrimEnd = true
+                    isIdle = true
+                }
+            )
+    )
+}
+
+@ExperimentalComposeUiApi
+@Composable
+public fun SentryTraced(
+    tag: String,
+    modifier: Modifier = Modifier,
+    enableUserInteractionTracing: Boolean = true,
+    content: @Composable BoxScope.() -> Unit
+) {
+    val parentCompositionSpan = localSentryCompositionParentSpan.current
+    val parentRenderingSpan = localSentryRenderingParentSpan.current
+    val compositionSpan = parentCompositionSpan.item?.startChild(OP_COMPOSE, tag)
+    val firstRendered = remember { ImmutableHolder(false) }
+
+    val baseModifier = if (enableUserInteractionTracing) modifier.testTag(tag) else modifier
+
+    Box(
+        modifier = baseModifier
+            .drawWithContent {
+                val renderSpan = if (!firstRendered.item) {
+                    parentRenderingSpan.item?.startChild(
+                        OP_RENDER,
+                        tag
+                    )
+                } else {
+                    null
+                }
+                drawContent()
+                firstRendered.item = true
+                renderSpan?.finish()
+            }
+    ) {
+        content()
+    }
+    compositionSpan?.finish()
+}