Reimplement fix to pass down params when creating span via OTel API (#2595)

bidetofevil · web-flow · commit 3851375f5165 · 2025-10-20T07:55:58.000-07:00
diff --git a/buildSrc/src/main/kotlin/io/embrace/internal/LintConfig.kt b/buildSrc/src/main/kotlin/io/embrace/internal/LintConfig.kt
@@ -10,6 +10,6 @@ fun LibraryExtension.configureLint(project: Project) {
         checkAllWarnings = true
         checkReleaseBuilds = false // run on CI instead, speeds up release builds
         baseline = project.file("lint-baseline.xml")
-        disable.addAll(setOf("GradleDependency", "NewerVersionAvailable"))
+        disable.addAll(setOf("GradleDependency", "NewerVersionAvailable", "AndroidGradlePluginVersion"))
     }
 }
diff --git a/embrace-android-otel/src/main/kotlin/io/embrace/android/embracesdk/internal/otel/impl/EmbTracer.kt b/embrace-android-otel/src/main/kotlin/io/embrace/android/embracesdk/internal/otel/impl/EmbTracer.kt
@@ -41,18 +41,27 @@ class EmbTracer(
             private = false,
             tracer = impl,
             parentCtx = parentCtx,
+            spanKind = spanKind,
+            startTimeMs = startTimestamp,
             objectCreator = objectCreator,
         )
+        var span: Span? = null
 
         spanService.createSpan(spanCreator)?.let { embraceSpan ->
             if (embraceSpan.start()) {
-                return EmbSpan(
+                span = EmbSpan(
                     impl = embraceSpan,
                     clock = clock,
                     objectCreator = objectCreator,
                 )
             }
         }
-        return EmbInvalidSpan(objectCreator)
+        val ref = span
+        return if (ref == null) {
+            EmbInvalidSpan(objectCreator)
+        } else {
+            action(ref)
+            ref
+        }
     }
 }
diff --git a/embrace-android-otel/src/test/kotlin/io/embrace/android/embracesdk/internal/otel/impl/EmbTracerTest.kt b/embrace-android-otel/src/test/kotlin/io/embrace/android/embracesdk/internal/otel/impl/EmbTracerTest.kt
@@ -7,6 +7,7 @@ import io.embrace.android.embracesdk.fakes.FakeTracer
 import io.embrace.android.embracesdk.fakes.fakeObjectCreator
 import io.embrace.android.embracesdk.internal.otel.schema.EmbType
 import io.embrace.opentelemetry.kotlin.ExperimentalApi
+import io.embrace.opentelemetry.kotlin.tracing.model.SpanKind
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertNull
 import org.junit.Before
@@ -36,11 +37,35 @@ internal class EmbTracerTest {
     @Test
     fun `check span generated with default parameters`() {
         tracer.createSpan("foo").end()
+        val now = clock.now()
         val fakeCreatedSpan = spanService.createdSpans.single()
         with(fakeCreatedSpan) {
             assertNull(parent)
             assertEquals("foo", name)
+            assertEquals(SpanKind.INTERNAL, spanKind)
             assertEquals(EmbType.Performance.Default, type)
+            assertEquals(now, spanStartTimeMs)
+        }
+    }
+
+    @Test
+    fun `check span generated with non default parameters`() {
+        val parentCtx = fakeObjectCreator.context.root()
+        tracer.createSpan(
+            "foo",
+            parentContext = parentCtx,
+            spanKind = SpanKind.CLIENT,
+            startTimestamp = 700L
+        ) {
+            setStringAttribute("foo", "bar")
+        }
+        val fakeCreatedSpan = spanService.createdSpans.single()
+        with(fakeCreatedSpan) {
+            assertEquals(parentCtx, parentContext)
+            assertEquals("foo", name)
+            assertEquals(SpanKind.CLIENT, spanKind)
+            assertEquals("bar", attributes["foo"])
+            assertEquals(700L, spanStartTimeMs)
         }
     }
 }
diff --git a/embrace-android-sdk/src/integrationTest/kotlin/io/embrace/android/embracesdk/testcases/ExternalTracerTest.kt b/embrace-android-sdk/src/integrationTest/kotlin/io/embrace/android/embracesdk/testcases/ExternalTracerTest.kt
@@ -19,6 +19,7 @@ import io.embrace.opentelemetry.kotlin.aliases.OtelJavaOpenTelemetry
 import io.embrace.opentelemetry.kotlin.aliases.OtelJavaSpan
 import io.embrace.opentelemetry.kotlin.aliases.OtelJavaSpanContext
 import io.embrace.opentelemetry.kotlin.aliases.OtelJavaSpanData
+import io.embrace.opentelemetry.kotlin.aliases.OtelJavaSpanKind
 import io.embrace.opentelemetry.kotlin.aliases.OtelJavaStatusCode
 import io.embrace.opentelemetry.kotlin.aliases.OtelJavaTracer
 import io.opentelemetry.context.Context
@@ -31,6 +32,7 @@ import org.junit.Before
 import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
+import java.util.concurrent.TimeUnit
 
 @RunWith(AndroidJUnit4::class)
 internal class ExternalTracerTest {
@@ -171,6 +173,57 @@ internal class ExternalTracerTest {
         )
     }
 
+    @Test
+    fun `otel span builder parameters propagated correctly`() {
+        var startTimeMs: Long? = null
+        var endTimeMs: Long? = null
+
+        testRule.runTest(
+            preSdkStartAction = {
+                setupExporter()
+            },
+            testCaseAction = {
+                initializeTracer()
+                recordSession {
+                    val pastTs = clock.now() - 100L
+                    startTimeMs = pastTs
+                    val spanBuilder = embTracer.spanBuilder("external-span").apply {
+                        setStartTimestamp(pastTs, TimeUnit.MILLISECONDS)
+                        setSpanKind(OtelJavaSpanKind.CLIENT)
+                        setAttribute("builder-attribute", "dope")
+                    }
+
+                    val span = spanBuilder.startSpan()
+                    endTimeMs = clock.tick()
+                    span.end()
+                }
+            },
+            assertAction = {
+                val sessionMessage = getSingleSessionEnvelope()
+                val spans = checkNotNull(sessionMessage.data.spans)
+                val recordedSpans = spans.associateBy { it.name }
+                val parent = checkNotNull(recordedSpans["external-span"])
+                assertEmbraceSpanData(
+                    span = parent,
+                    expectedStartTimeMs = checkNotNull(startTimeMs),
+                    expectedEndTimeMs = checkNotNull(endTimeMs),
+                    expectedParentId = OtelIds.invalidSpanId,
+                    expectedCustomAttributes = mapOf("builder-attribute" to "dope")
+                )
+
+                assertTrue("Timed out waiting for the span to be exported", spanExporter.awaitSpanExport(2))
+                val exportedSpan: OtelJavaSpanData = spanExporter.exportedSpans.single { it.name == "external-span" }
+                assertEquals(OtelJavaSpanKind.CLIENT, exportedSpan.kind)
+                assertEquals(parent.toEmbracePayload(), exportedSpan.toEmbraceSpanData())
+                with(exportedSpan.instrumentationScopeInfo) {
+                    assertEquals("external-tracer", name)
+                    assertEquals("1.0.0", version)
+                    assertNull(schemaUrl)
+                }
+            }
+        )
+    }
+
     @Test
     fun `span with explicit parent`() {
         testRule.runTest(
diff --git a/embrace-test-fakes/src/main/kotlin/io/embrace/android/embracesdk/fakes/FakeEmbraceSdkSpan.kt b/embrace-test-fakes/src/main/kotlin/io/embrace/android/embracesdk/fakes/FakeEmbraceSdkSpan.kt
@@ -32,6 +32,7 @@ import io.embrace.opentelemetry.kotlin.ExperimentalApi
 import io.embrace.opentelemetry.kotlin.aliases.OtelJavaContext
 import io.embrace.opentelemetry.kotlin.aliases.OtelJavaSpan
 import io.embrace.opentelemetry.kotlin.aliases.OtelJavaSpanContext
+import io.embrace.opentelemetry.kotlin.aliases.OtelJavaSpanKind
 import io.embrace.opentelemetry.kotlin.context.Context
 import io.embrace.opentelemetry.kotlin.context.toOtelJavaContext
 import io.embrace.opentelemetry.kotlin.context.toOtelJavaContextKey
@@ -52,10 +53,11 @@ class FakeEmbraceSdkSpan(
     val private: Boolean = internal,
     override val autoTerminationMode: AutoTerminationMode = AutoTerminationMode.NONE,
     private val fakeClock: FakeClock = FakeClock(),
+    override var spanKind: SpanKind = SpanKind.INTERNAL,
+    var spanStartTimeMs: Long? = null
 ) : EmbraceSdkSpan {
-
     private var sdkSpan: OtelJavaSpan? = null
-    var spanStartTimeMs: Long? = null
+
     var spanEndTimeMs: Long? = null
     override var status: StatusData = StatusData.Unset
     var errorCode: ErrorCode? = null
@@ -82,10 +84,11 @@ class FakeEmbraceSdkSpan(
 
     override fun start(startTimeMs: Long?): Boolean {
         if (!started()) {
-            val timestampMs = startTimeMs ?: fakeClock.now()
+            val timestampMs = startTimeMs ?: spanStartTimeMs ?: fakeClock.now()
             sdkSpan = FakeSpanBuilder(name)
                 .setStartTimestamp(timestampMs, TimeUnit.MILLISECONDS)
                 .setParent(parentContext.toOtelJavaContext())
+                .setSpanKind(spanKind.toOtelJavaSpanKind())
                 .startSpan()
             spanStartTimeMs = timestampMs
         }
@@ -199,8 +202,6 @@ class FakeEmbraceSdkSpan(
 
     override fun name(): String = name
 
-    override val spanKind: SpanKind = SpanKind.INTERNAL
-
     override fun events(): List<SpanEvent> {
         throw UnsupportedOperationException()
     }
@@ -216,6 +217,14 @@ class FakeEmbraceSdkSpan(
 
     private fun started(): Boolean = sdkSpan != null
 
+    private fun SpanKind.toOtelJavaSpanKind(): OtelJavaSpanKind = when (this) {
+        SpanKind.INTERNAL -> OtelJavaSpanKind.INTERNAL
+        SpanKind.CLIENT -> OtelJavaSpanKind.CLIENT
+        SpanKind.SERVER -> OtelJavaSpanKind.SERVER
+        SpanKind.PRODUCER -> OtelJavaSpanKind.PRODUCER
+        SpanKind.CONSUMER -> OtelJavaSpanKind.CONSUMER
+    }
+
     companion object {
         fun notStarted(): FakeEmbraceSdkSpan = FakeEmbraceSdkSpan(name = "not-started")
 
diff --git a/embrace-test-fakes/src/main/kotlin/io/embrace/android/embracesdk/fakes/FakeSpanService.kt b/embrace-test-fakes/src/main/kotlin/io/embrace/android/embracesdk/fakes/FakeSpanService.kt
@@ -12,6 +12,7 @@ import io.embrace.android.embracesdk.spans.ErrorCode
 import io.embrace.opentelemetry.kotlin.ExperimentalApi
 import io.embrace.opentelemetry.kotlin.context.toOtelJavaContext
 import io.embrace.opentelemetry.kotlin.context.toOtelKotlinContext
+import io.embrace.opentelemetry.kotlin.tracing.model.SpanKind
 
 @OptIn(ExperimentalApi::class)
 class FakeSpanService : SpanService {
@@ -44,7 +45,7 @@ class FakeSpanService : SpanService {
     }
 
     override fun createSpan(
-        otelSpanStartArgs: OtelSpanStartArgs
+        otelSpanStartArgs: OtelSpanStartArgs,
     ): EmbraceSdkSpan {
         return FakeEmbraceSdkSpan(
             name = otelSpanStartArgs.initialSpanName,
@@ -53,6 +54,8 @@ class FakeSpanService : SpanService {
             internal = otelSpanStartArgs.internal,
             private = otelSpanStartArgs.embraceAttributes.contains(PrivateSpan),
             autoTerminationMode = otelSpanStartArgs.autoTerminationMode,
+            spanKind = otelSpanStartArgs.spanKind ?: SpanKind.INTERNAL,
+            spanStartTimeMs = otelSpanStartArgs.startTimeMs
         ).apply {
             createdSpans.add(this)
         }
diff --git a/gradle.properties b/gradle.properties
@@ -5,7 +5,7 @@ org.gradle.caching=true
 org.gradle.configuration-cache=true
 org.gradle.configuration-cache.problems=fail
 org.gradle.configuration-cache.parallel=true
-version=7.9.1
+version=7.9.2
 android.useAndroidX=true
 android.experimental.enableArtProfiles=true
 android.defaults.buildfeatures.buildconfig=false

Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,6 @@ fun LibraryExtension.configureLint(project: Project) {`
`10`	`10`	`checkAllWarnings = true`
`11`	`11`	`checkReleaseBuilds = false // run on CI instead, speeds up release builds`
`12`	`12`	`baseline = project.file("lint-baseline.xml")`
`13`		`- disable.addAll(setOf("GradleDependency", "NewerVersionAvailable"))`
	`13`	`+ disable.addAll(setOf("GradleDependency", "NewerVersionAvailable", "AndroidGradlePluginVersion"))`
`14`	`14`	`}`
`15`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -41,18 +41,27 @@ class EmbTracer(`
`41`	`41`	`private = false,`
`42`	`42`	`tracer = impl,`
`43`	`43`	`parentCtx = parentCtx,`
	`44`	`+ spanKind = spanKind,`
	`45`	`+ startTimeMs = startTimestamp,`
`44`	`46`	`objectCreator = objectCreator,`
`45`	`47`	`)`
	`48`	`+ var span: Span? = null`
`46`	`49`
`47`	`50`	`spanService.createSpan(spanCreator)?.let { embraceSpan ->`
`48`	`51`	`if (embraceSpan.start()) {`
`49`		`- return EmbSpan(`
	`52`	`+ span = EmbSpan(`
`50`	`53`	`impl = embraceSpan,`
`51`	`54`	`clock = clock,`
`52`	`55`	`objectCreator = objectCreator,`
`53`	`56`	`)`
`54`	`57`	`}`
`55`	`58`	`}`
`56`		`- return EmbInvalidSpan(objectCreator)`
	`59`	`+ val ref = span`
	`60`	`+ return if (ref == null) {`
	`61`	`+ EmbInvalidSpan(objectCreator)`
	`62`	`+ } else {`
	`63`	`+ action(ref)`
	`64`	`+ ref`
	`65`	`+ }`
`57`	`66`	`}`
`58`	`67`	`}`