Implement compat layer for baggage

compat/src/jvmAndAndroidMain/kotlin/io/opentelemetry/kotlin/baggage/BaggageAdapter.kt

@@ -0,0 +1,30 @@
+package io.opentelemetry.kotlin.baggage
+
+import io.opentelemetry.kotlin.ExperimentalApi
+import io.opentelemetry.kotlin.aliases.OtelJavaBaggage
+import io.opentelemetry.kotlin.aliases.OtelJavaBaggageEntryMetadata
+
+@OptIn(ExperimentalApi::class)
+internal class BaggageAdapter(internal val impl: OtelJavaBaggage) : Baggage {
+
+    override fun getValue(name: String): String? = impl.getEntryValue(name)
+
+    override fun asMap(): Map<String, BaggageEntry> = impl.asMap().mapValues { (_, v) ->
+        BaggageEntryAdapter(v)
+    }
+
+    override fun set(name: String, value: String): Baggage =
+        BaggageAdapter(impl.toBuilder().put(name, value).build())
+
+    override fun set(name: String, value: String, metadata: BaggageEntryMetadata): Baggage =
+        BaggageAdapter(
+            impl.toBuilder().put(name, value, OtelJavaBaggageEntryMetadata.create(metadata.value)).build()
+        )
+
+    override fun remove(name: String): Baggage =
+        if (impl.getEntryValue(name) == null) {
+            this
+        } else {
+            BaggageAdapter(impl.toBuilder().remove(name).build())
+        }
+}

compat/src/jvmAndAndroidMain/kotlin/io/opentelemetry/kotlin/baggage/BaggageEntryAdapter.kt

@@ -0,0 +1,14 @@
+package io.opentelemetry.kotlin.baggage
+
+import io.opentelemetry.kotlin.ExperimentalApi
+import io.opentelemetry.kotlin.aliases.OtelJavaBaggageEntry
+
+@OptIn(ExperimentalApi::class)
+internal class BaggageEntryAdapter(
+    private val impl: OtelJavaBaggageEntry
+) : BaggageEntry {
+
+    override val value: String get() = impl.value
+
+    override val metadata: BaggageEntryMetadata get() = BaggageEntryMetadataAdapter(impl.metadata)
+}

compat/src/jvmAndAndroidMain/kotlin/io/opentelemetry/kotlin/baggage/BaggageEntryMetadataAdapter.kt

@@ -0,0 +1,12 @@
+package io.opentelemetry.kotlin.baggage
+
+import io.opentelemetry.kotlin.ExperimentalApi
+import io.opentelemetry.kotlin.aliases.OtelJavaBaggageEntryMetadata
+
+@OptIn(ExperimentalApi::class)
+internal class BaggageEntryMetadataAdapter(
+    private val impl: OtelJavaBaggageEntryMetadata
+) : BaggageEntryMetadata {
+
+    override val value: String get() = impl.value
+}

compat/src/jvmTest/kotlin/io/opentelemetry/kotlin/baggage/BaggageAdapterTest.kt

@@ -0,0 +1,108 @@
+package io.opentelemetry.kotlin.baggage
+
+import io.opentelemetry.kotlin.ExperimentalApi
+import io.opentelemetry.kotlin.aliases.OtelJavaBaggage
+import io.opentelemetry.kotlin.aliases.OtelJavaBaggageEntryMetadata
+import org.junit.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNull
+import kotlin.test.assertSame
+import kotlin.test.assertTrue
+
+@OptIn(ExperimentalApi::class)
+internal class BaggageAdapterTest {
+
+    @Test
+    fun `getValue returns value for present key`() {
+        val baggage = BaggageAdapter(otelJavaBaggage("key" to "value"))
+        assertEquals("value", baggage.getValue("key"))
+    }
+
+    @Test
+    fun `getValue returns null for absent key`() {
+        val baggage = BaggageAdapter(otelJavaBaggage())
+        assertNull(baggage.getValue("missing"))
+    }
+
+    @Test
+    fun `asMap wraps entries as BaggageEntryAdapter`() {
+        val baggage = BaggageAdapter(otelJavaBaggage("k" to "v"))
+        val map = baggage.asMap()
+        assertEquals(1, map.size)
+        val entry = map["k"]
+        assertTrue(entry is BaggageEntryAdapter)
+        assertEquals("v", entry.value)
+    }
+
+    @Test
+    fun `set without metadata adds entry`() {
+        val original = BaggageAdapter(otelJavaBaggage())
+        val updated = original.set("foo", "bar")
+        assertEquals("bar", updated.getValue("foo"))
+        assertNull(original.getValue("foo"))
+    }
+
+    @Test
+    fun `set with metadata preserves metadata`() {
+        val meta = object : BaggageEntryMetadata {
+            override val value = "myMeta"
+        }
+        val updated = BaggageAdapter(otelJavaBaggage()).set("foo", "bar", meta)
+        assertEquals("bar", updated.getValue("foo"))
+        val entry = checkNotNull(updated.asMap()["foo"])
+        assertEquals("myMeta", entry.metadata.value)
+    }
+
+    @Test
+    fun `set replaces existing value`() {
+        val original = BaggageAdapter(otelJavaBaggage("key" to "old"))
+        val updated = original.set("key", "new")
+        assertEquals("new", updated.getValue("key"))
+    }
+
+    @Test
+    fun `remove deletes existing entry`() {
+        val original = BaggageAdapter(otelJavaBaggage("key" to "val"))
+        val updated = original.remove("key")
+        assertNull(updated.getValue("key"))
+    }
+
+    @Test
+    fun `remove absent key returns same instance`() {
+        val original = BaggageAdapter(otelJavaBaggage("key" to "val"))
+        val result = original.remove("missing")
+        assertSame(original, result)
+    }
+
+    @Test
+    fun `BaggageEntryAdapter delegates value`() {
+        val map = otelJavaBaggage("k" to "v").asMap()
+        val javaEntry = checkNotNull(map["k"])
+        val entry = BaggageEntryAdapter(javaEntry)
+        assertEquals("v", entry.value)
+    }
+
+    @Test
+    fun `BaggageEntryAdapter wraps metadata as BaggageEntryMetadataAdapter`() {
+        val javaEntry = OtelJavaBaggage.builder()
+            .put("k", "v", OtelJavaBaggageEntryMetadata.create("meta"))
+            .build()
+            .asMap()["k"]
+        val entry = BaggageEntryAdapter(checkNotNull(javaEntry))
+        assertTrue(entry.metadata is BaggageEntryMetadataAdapter)
+        assertEquals("meta", entry.metadata.value)
+    }
+
+    @Test
+    fun `BaggageEntryMetadataAdapter delegates value`() {
+        val javaMeta = OtelJavaBaggageEntryMetadata.create("someValue")
+        val meta = BaggageEntryMetadataAdapter(javaMeta)
+        assertEquals("someValue", meta.value)
+    }
+
+    private fun otelJavaBaggage(vararg entries: Pair<String, String>): OtelJavaBaggage {
+        val builder = OtelJavaBaggage.builder()
+        entries.forEach { (k, v) -> builder.put(k, v) }
+        return builder.build()
+    }
+}

java-typealiases/src/jvmAndAndroidMain/kotlin/io/opentelemetry/kotlin/aliases/Aliases.kt

@@ -3,6 +3,9 @@
 package io.opentelemetry.kotlin.aliases
 
 import io.opentelemetry.api.OpenTelemetry
+import io.opentelemetry.api.baggage.Baggage
+import io.opentelemetry.api.baggage.BaggageEntry
+import io.opentelemetry.api.baggage.BaggageEntryMetadata
 import io.opentelemetry.api.common.AttributeKey
 import io.opentelemetry.api.common.Attributes
 import io.opentelemetry.api.common.AttributesBuilder
@@ -61,6 +64,9 @@ import io.opentelemetry.sdk.trace.samplers.Sampler
 import io.opentelemetry.sdk.trace.samplers.SamplingDecision
 import io.opentelemetry.sdk.trace.samplers.SamplingResult
 
+typealias OtelJavaBaggage = Baggage
+typealias OtelJavaBaggageEntry = BaggageEntry
+typealias OtelJavaBaggageEntryMetadata = BaggageEntryMetadata
 typealias OtelJavaAttributes = Attributes
 typealias OtelJavaAttributeKey<T> = AttributeKey<T>
 typealias OtelJavaSpan = Span