Remove zero duration span from slow rendering instrumentation. (#1729)

* remove zero duration span from slow rendering instrumentation.

* update changelog

# Conflicts:
#	CHANGELOG.md

Author: breedx-splk

CHANGELOG.md

@@ -3,9 +3,11 @@
 ## Unreleased
 
 ### ⚠️⚠️ Breaking changes
-
+ 
+- Slow rendering instrumentation no longer generates zero-duration spans, only events.
+  ([#1729](https://github.com/open-telemetry/opentelemetry-android/pull/1729))
 - Remove deprecated sdk ready listeners. Users should use the otel ready listeners instead.
-  ([#1731](https://github.com/open-telemetry/opentelemetry-android/pull/1731)) 
+  ([#1731](https://github.com/open-telemetry/opentelemetry-android/pull/1731))
 
 ## Version 1.3.0 (2026-04-22)
 

instrumentation/slowrendering/README.md

@@ -41,31 +41,6 @@ Generated when rendering takes more than 700ms within a polling period.
   * `app.jank.period` - the polling period duration in seconds during which the frames were detected
   * `app.jank.threshold` - the threshold in seconds above which a frame is considered frozen (e.g. `0.7`)
 
-### Deprecated: Zero-Duration Spans
-
-> **Deprecated.** Zero-duration spans are no longer emitted by default. They can be re-enabled
-> via `enableDeprecatedZeroDurationSpan()` for backwards compatibility, but this is discouraged.
-> Use the `app.jank` events above instead.
-
-When enabled via `enableDeprecatedZeroDurationSpan()`, the instrumentation additionally produces
-spans with an instrumentation scope of `io.opentelemetry.slow-rendering`.
-
-#### Slow Renders (Span)
-
-* Type: Span (zero duration)
-* Name: `slowRenders`
-* Attributes:
-  * `count` - the number of slow renders
-  * `activity.name` - the name of the activity for which the slow render was detected
-
-#### Frozen Renders (Span)
-
-* Type: Span (zero duration)
-* Name: `frozenRenders`
-* Attributes:
-  * `count` - the number of frozen renders
-  * `activity.name` - the name of the activity for which the frozen render was detected
-
 ## Installation
 
 This instrumentation comes with the [android agent](../../android-agent) out of the box, so

instrumentation/slowrendering/api/slowrendering.api

@@ -1,6 +1,5 @@
 public final class io/opentelemetry/android/instrumentation/slowrendering/SlowRenderingInstrumentation : io/opentelemetry/android/instrumentation/AndroidInstrumentation {
 	public fun <init> ()V
-	public final fun enableDeprecatedZeroDurationSpan ()Lio/opentelemetry/android/instrumentation/slowrendering/SlowRenderingInstrumentation;
 	public final fun enableVerboseDebugLogging ()Lio/opentelemetry/android/instrumentation/slowrendering/SlowRenderingInstrumentation;
 	public fun getName ()Ljava/lang/String;
 	public fun install (Landroid/content/Context;Lio/opentelemetry/android/OpenTelemetryRum;)V

instrumentation/slowrendering/src/main/java/io/opentelemetry/android/instrumentation/slowrendering/SlowRenderingInstrumentation.kt

@@ -15,12 +15,14 @@ import io.opentelemetry.android.common.RumConstants
 import io.opentelemetry.android.instrumentation.AndroidInstrumentation
 import java.time.Duration
 
+internal const val SLOW_THRESHOLD_MS = 16
+internal const val FROZEN_THRESHOLD_MS = 700
+
 /**
  * Entrypoint for installing the slow rendering detection instrumentation.
  */
 @AutoService(AndroidInstrumentation::class)
 class SlowRenderingInstrumentation : AndroidInstrumentation {
-    internal var useDeprecatedSpan: Boolean = false
     internal var debugVerbose: Boolean = false
     internal var slowRenderingDetectionPollInterval: Duration = Duration.ofSeconds(1)
 
@@ -57,15 +59,6 @@ class SlowRenderingInstrumentation : AndroidInstrumentation {
         return this
     }
 
-    /**
-     * Reports jank by using a zero-duration span.
-     */
-    @Deprecated("Use the default event to report jank")
-    fun enableDeprecatedZeroDurationSpan(): SlowRenderingInstrumentation {
-        useDeprecatedSpan = true
-        return this
-    }
-
     override fun install(context: Context, openTelemetryRum: OpenTelemetryRum) {
         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N) {
             Log.w(
@@ -86,11 +79,6 @@ class SlowRenderingInstrumentation : AndroidInstrumentation {
         var jankReporter: JankReporter = EventJankReporter(logger, SLOW_THRESHOLD_MS / 1000.0, debugVerbose)
         jankReporter = jankReporter.combine(EventJankReporter(logger, FROZEN_THRESHOLD_MS / 1000.0, debugVerbose))
 
-        if (useDeprecatedSpan) {
-            val tracer = openTelemetryRum.openTelemetry.getTracer("io.opentelemetry.slow-rendering")
-            jankReporter = jankReporter.combine(SpanBasedJankReporter(tracer))
-        }
-
         detector = SlowRenderListener(jankReporter, slowRenderingDetectionPollInterval)
 
         (context as? Application)?.registerActivityLifecycleCallbacks(detector)

instrumentation/slowrendering/src/main/java/io/opentelemetry/android/instrumentation/slowrendering/SpanBasedJankReporter.kt

@@ -20,13 +20,10 @@ import io.mockk.junit4.MockKRule
 import io.mockk.mockk
 import io.mockk.slot
 import io.mockk.verify
-import io.opentelemetry.api.common.AttributeKey
-import io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions
+import io.opentelemetry.api.logs.Logger
 import io.opentelemetry.sdk.testing.junit4.OpenTelemetryRule
-import io.opentelemetry.sdk.trace.data.SpanData
 import kotlinx.coroutines.Runnable
 import org.assertj.core.api.Assertions.assertThat
-import org.assertj.core.api.ThrowingConsumer
 import org.junit.Before
 import org.junit.Rule
 import org.junit.Test
@@ -134,8 +131,7 @@ class SlowRenderListenerTest {
 
     @Test
     fun removeWithMetrics() {
-        val tracer = otelTesting.openTelemetry.getTracer("testTracer")
-        jankReporter = SpanBasedJankReporter(tracer)
+        jankReporter = createEventReporter()
         val testInstance =
             SlowRenderListener(
                 jankReporter,
@@ -160,8 +156,7 @@ class SlowRenderListenerTest {
 
         testInstance.onActivityPaused(activity)
 
-        val spans = otelTesting.spans
-        assertSpanContent(spans)
+        assertLogContent(periodSeconds = 0.0)
     }
 
     @Test
@@ -180,8 +175,7 @@ class SlowRenderListenerTest {
             null
         }
 
-        val tracer = otelTesting.openTelemetry.getTracer("testTracer")
-        jankReporter = SpanBasedJankReporter(tracer)
+        jankReporter = createEventReporter()
         val testInstance =
             SlowRenderListener(
                 jankReporter,
@@ -206,8 +200,7 @@ class SlowRenderListenerTest {
 
         testInstance.start()
 
-        val spans = otelTesting.spans
-        assertSpanContent(spans)
+        assertLogContent(periodSeconds = 1.0)
     }
 
     @Test
@@ -235,36 +228,25 @@ class SlowRenderListenerTest {
             )
         }
 
-    companion object {
-        private val COUNT_KEY: AttributeKey<Long> = AttributeKey.longKey("count")
-
-        private fun assertSpanContent(spans: MutableList<SpanData?>) {
-            assertThat<SpanData>(spans)
-                .hasSize(2)
-                .satisfiesExactly(
-                    ThrowingConsumer { span ->
-                        OpenTelemetryAssertions
-                            .assertThat(span)
-                            .hasName("slowRenders")
-                            .endsAt(span!!.startEpochNanos)
-                            .hasAttribute(COUNT_KEY, 3L)
-                            .hasAttribute(
-                                AttributeKey.stringKey("activity.name"),
-                                "io.otel/Komponent",
-                            )
-                    },
-                    ThrowingConsumer { span ->
-                        OpenTelemetryAssertions
-                            .assertThat(span)
-                            .hasName("frozenRenders")
-                            .endsAt(span!!.startEpochNanos)
-                            .hasAttribute(COUNT_KEY, 1L)
-                            .hasAttribute(
-                                AttributeKey.stringKey("activity.name"),
-                                "io.otel/Komponent",
-                            )
-                    },
-                )
-        }
+    private fun createEventReporter(): JankReporter {
+        val eventLogger: Logger = otelTesting.openTelemetry.logsBridge.get("JANK!")
+        return EventJankReporter(eventLogger, SLOW_THRESHOLD_MS / 1000.0)
+            .combine(EventJankReporter(eventLogger, FROZEN_THRESHOLD_MS / 1000.0))
+    }
+
+    private fun assertLogContent(periodSeconds: Double) {
+        assertThat(otelTesting.logRecords).hasSize(2)
+
+        val slowLog = otelTesting.logRecords[0]
+        assertThat(slowLog.eventName).isEqualTo("app.jank")
+        assertThat(slowLog.attributes.get(FRAME_COUNT)).isEqualTo(4)
+        assertThat(slowLog.attributes.get(PERIOD)).isEqualTo(periodSeconds)
+        assertThat(slowLog.attributes.get(THRESHOLD)).isEqualTo(0.016)
+
+        val frozenLog = otelTesting.logRecords[1]
+        assertThat(frozenLog.eventName).isEqualTo("app.jank")
+        assertThat(frozenLog.attributes.get(FRAME_COUNT)).isEqualTo(1)
+        assertThat(frozenLog.attributes.get(PERIOD)).isEqualTo(periodSeconds)
+        assertThat(frozenLog.attributes.get(THRESHOLD)).isEqualTo(0.7)
     }
 }

instrumentation/slowrendering/src/test/java/io/opentelemetry/android/instrumentation/slowrendering/SlowRenderListenerTest.kt

@@ -96,7 +96,6 @@ class SlowRenderingInstrumentationTest {
     @Test
     fun `Installing instrumentation on devices with API level equal or higher than 24`() {
         val capturedListener = slot<SlowRenderListener>()
-        every { openTelemetry.getTracer(any()) }.returns(mockk())
         every { application.registerActivityLifecycleCallbacks(any()) } just Runs
         val openTelemetryRum = mockk<OpenTelemetryRum>()
         every { openTelemetryRum.openTelemetry } returns openTelemetry
@@ -106,21 +105,4 @@ class SlowRenderingInstrumentationTest {
 
         verify { application.registerActivityLifecycleCallbacks(capture(capturedListener)) }
     }
-
-    @Config(sdk = [24, 25])
-    @Test
-    fun `can use legacy span`() {
-        val capturedListener = slot<SlowRenderListener>()
-        every { openTelemetry.getTracer(any()) }.returns(mockk())
-        every { application.registerActivityLifecycleCallbacks(any()) } just Runs
-        val openTelemetryRum = mockk<OpenTelemetryRum>()
-        every { openTelemetryRum.openTelemetry } returns openTelemetry
-        every { openTelemetryRum.sessionProvider } returns mockk()
-        every { openTelemetryRum.clock } returns Clock.getDefault()
-        @Suppress("DEPRECATION")
-        slowRenderingInstrumentation.enableDeprecatedZeroDurationSpan().install(application, openTelemetryRum)
-
-        verify { openTelemetry.getTracer("io.opentelemetry.slow-rendering") }
-        verify { application.registerActivityLifecycleCallbacks(capture(capturedListener)) }
-    }
 }