Compatibility checks

agent-sdk/build.gradle.kts

@@ -34,6 +34,7 @@ dependencies {
     implementation(libs.androidx.annotations)
     implementation(libs.androidx.core)
     implementation(libs.dsl.json)
+    testImplementation(project(":internal-tools:otel-test-common"))
     testImplementation(libs.wireMock)
     testImplementation(libs.opentelemetry.testing)
     testImplementation(libs.robolectric)

agent-sdk/metadata/agent-sdk.api

@@ -173,10 +173,10 @@ public final class co/elastic/otel/android/exporters/configuration/ExporterConfi
 }
 
 public final class co/elastic/otel/android/extensions/ElasticOtelAgentExtensionsKt {
-	public static final fun log (Lco/elastic/otel/android/api/ElasticOtelAgent;Ljava/lang/String;Lio/opentelemetry/api/logs/Severity;Ljava/lang/String;Lio/opentelemetry/api/common/Attributes;Lio/opentelemetry/context/Context;Ljava/time/Instant;Ljava/time/Instant;)V
-	public static synthetic fun log$default (Lco/elastic/otel/android/api/ElasticOtelAgent;Ljava/lang/String;Lio/opentelemetry/api/logs/Severity;Ljava/lang/String;Lio/opentelemetry/api/common/Attributes;Lio/opentelemetry/context/Context;Ljava/time/Instant;Ljava/time/Instant;ILjava/lang/Object;)V
-	public static final fun span (Lco/elastic/otel/android/api/ElasticOtelAgent;Ljava/lang/String;Lio/opentelemetry/api/common/Attributes;Lio/opentelemetry/api/trace/SpanKind;Lio/opentelemetry/context/Context;ZLkotlin/jvm/functions/Function1;)V
-	public static synthetic fun span$default (Lco/elastic/otel/android/api/ElasticOtelAgent;Ljava/lang/String;Lio/opentelemetry/api/common/Attributes;Lio/opentelemetry/api/trace/SpanKind;Lio/opentelemetry/context/Context;ZLkotlin/jvm/functions/Function1;ILjava/lang/Object;)V
+	public static final fun log (Lco/elastic/otel/android/api/ElasticOtelAgent;Ljava/lang/String;Lio/opentelemetry/api/logs/Severity;Ljava/lang/String;Lio/opentelemetry/api/common/Attributes;Lio/opentelemetry/context/Context;Ljava/time/Instant;Ljava/time/Instant;Ljava/lang/String;)V
+	public static synthetic fun log$default (Lco/elastic/otel/android/api/ElasticOtelAgent;Ljava/lang/String;Lio/opentelemetry/api/logs/Severity;Ljava/lang/String;Lio/opentelemetry/api/common/Attributes;Lio/opentelemetry/context/Context;Ljava/time/Instant;Ljava/time/Instant;Ljava/lang/String;ILjava/lang/Object;)V
+	public static final fun span (Lco/elastic/otel/android/api/ElasticOtelAgent;Ljava/lang/String;Lio/opentelemetry/api/common/Attributes;Lio/opentelemetry/api/trace/SpanKind;Lio/opentelemetry/context/Context;ZLjava/lang/String;Lkotlin/jvm/functions/Function1;)V
+	public static synthetic fun span$default (Lco/elastic/otel/android/api/ElasticOtelAgent;Ljava/lang/String;Lio/opentelemetry/api/common/Attributes;Lio/opentelemetry/api/trace/SpanKind;Lio/opentelemetry/context/Context;ZLjava/lang/String;Lkotlin/jvm/functions/Function1;ILjava/lang/Object;)V
 }
 
 public abstract interface class co/elastic/otel/android/features/session/Session {

agent-sdk/src/main/java/co/elastic/otel/android/extensions/ElasticOtelAgentExtensions.kt

@@ -28,18 +28,31 @@ import io.opentelemetry.context.Context
 import io.opentelemetry.context.Scope
 import java.time.Instant
 
-private const val SCOPE_NAME = "co.elastic.otel.android.extensions"
+private const val DEFAULT_SCOPE_NAME = "co.elastic.otel.android.extensions"
 
+/**
+ * Convenience method to send OpenTelemetry's [Log Records](https://opentelemetry.io/docs/concepts/signals/logs/).
+ *
+ * @param body The log body/text.
+ * @param severity The log's severity. Defaults to OpenTelemetry SDK's default.
+ * @param severityText The log's severity text. Defaults to OpenTelemetry SDK's default.
+ * @param attributes The log's attributes. Defaults to OpenTelemetry SDK's default.
+ * @param context The log's context. Defaults to OpenTelemetry SDK's default.
+ * @param observedTimestamp The log's observed timestamp. Defaults to OpenTelemetry SDK's default.
+ * @param timestamp The log's timestamp. Defaults to OpenTelemetry SDK's default.
+ * @param scopeName The log's instrumentation scope name. Defaults to [DEFAULT_SCOPE_NAME].
+ */
 fun ElasticOtelAgent.log(
     body: String,
     severity: Severity? = null,
     severityText: String? = null,
     attributes: Attributes? = null,
     context: Context? = null,
     observedTimestamp: Instant? = null,
-    timestamp: Instant? = null
+    timestamp: Instant? = null,
+    scopeName: String = DEFAULT_SCOPE_NAME
 ) {
-    val logger = getOpenTelemetry().logsBridge.get(SCOPE_NAME).logRecordBuilder()
+    val logger = getOpenTelemetry().logsBridge.get(scopeName).logRecordBuilder()
         .setBody(body)
     severity?.let { logger.setSeverity(it) }
     severityText?.let { logger.setSeverityText(it) }
@@ -50,15 +63,27 @@ fun ElasticOtelAgent.log(
     logger.emit()
 }
 
+/**
+ * Convenience method to send OpenTelemetry's [Spans](https://opentelemetry.io/docs/concepts/signals/traces/#spans).
+ *
+ * @param name The span name.
+ * @param attributes The span's attributes. Defaults to OpenTelemetry SDK's default.
+ * @param kind The span's kind. Defaults to OpenTelemetry SDK's default.
+ * @param parentContext The span's parent context. Defaults to OpenTelemetry SDK's default.
+ * @param makeCurrent Whether the span will be automatically set as the "current one" within the thread it's created in, until its body's finished. Defaults to TRUE.
+ * @param scopeName The span's instrumentation scope name. Defaults to [DEFAULT_SCOPE_NAME].
+ * @param body The span's body. The span will start right before executing its body and will end right after its body's finished or an uncaught exception happens.
+ */
 fun ElasticOtelAgent.span(
     name: String,
     attributes: Attributes? = null,
     kind: SpanKind? = null,
     parentContext: Context? = null,
     makeCurrent: Boolean = true,
+    scopeName: String = DEFAULT_SCOPE_NAME,
     body: (Span) -> Unit
 ) {
-    val builder = getOpenTelemetry().getTracer(SCOPE_NAME).spanBuilder(name)
+    val builder = getOpenTelemetry().getTracer(scopeName).spanBuilder(name)
     attributes?.let { builder.setAllAttributes(it) }
     kind?.let { builder.setSpanKind(it) }
     parentContext?.let { builder.setParent(it) }
@@ -67,9 +92,9 @@ fun ElasticOtelAgent.span(
     val scope: Scope? = if (makeCurrent) span.makeCurrent() else null
     try {
         body(span)
-    } catch (e: Throwable) {
+    } catch (t: Throwable) {
         span.setStatus(StatusCode.ERROR)
-        span.recordException(e)
+        throw t
     } finally {
         scope?.close()
         span.end()

agent-sdk/src/main/java/co/elastic/otel/android/internal/features/conditionaldrop/ConditionalDropLogRecordExporter.kt

@@ -21,19 +21,18 @@ package co.elastic.otel.android.internal.features.conditionaldrop
 import io.opentelemetry.sdk.common.CompletableResultCode
 import io.opentelemetry.sdk.logs.data.LogRecordData
 import io.opentelemetry.sdk.logs.export.LogRecordExporter
-import java.util.function.Predicate
 
 /**
  * This class is internal and is hence not for public use. Its APIs are unstable and can change at
  * any time.
  */
 internal class ConditionalDropLogRecordExporter(
     private val delegate: LogRecordExporter,
-    private val drop: Predicate<SignalType>
+    private val drop: (SignalType) -> Boolean
 ) : LogRecordExporter {
 
     override fun export(logs: MutableCollection<LogRecordData>): CompletableResultCode {
-        if (drop.test(SignalType.LOG)) {
+        if (drop(SignalType.LOG)) {
             return CompletableResultCode.ofSuccess()
         }
         return delegate.export(logs)

agent-sdk/src/main/java/co/elastic/otel/android/internal/features/conditionaldrop/ConditionalDropManager.kt

@@ -21,16 +21,19 @@ package co.elastic.otel.android.internal.features.conditionaldrop
 import io.opentelemetry.sdk.logs.export.LogRecordExporter
 import io.opentelemetry.sdk.metrics.export.MetricExporter
 import io.opentelemetry.sdk.trace.export.SpanExporter
-import java.util.function.Predicate
 
 /**
  * This class is internal and is hence not for public use. Its APIs are unstable and can change at
  * any time.
  */
-internal class ConditionalDropManager(private var dropCondition: Predicate<SignalType>? = null) {
+internal class ConditionalDropManager(private var dropCondition: ((SignalType) -> Boolean)? = null) {
 
-    fun dropWhen(condition: Predicate<SignalType>) {
-        dropCondition = dropCondition?.or(condition) ?: condition
+    fun dropWhen(condition: (SignalType) -> Boolean) {
+        dropCondition = dropCondition?.let {
+            { type ->
+                it(type) || condition(type)
+            }
+        } ?: condition
     }
 
     fun createConditionalDropSpanExporter(delegate: SpanExporter): SpanExporter {

agent-sdk/src/main/java/co/elastic/otel/android/internal/features/conditionaldrop/ConditionalDropMetricExporter.kt

@@ -23,23 +23,22 @@ import io.opentelemetry.sdk.metrics.InstrumentType
 import io.opentelemetry.sdk.metrics.data.AggregationTemporality
 import io.opentelemetry.sdk.metrics.data.MetricData
 import io.opentelemetry.sdk.metrics.export.MetricExporter
-import java.util.function.Predicate
 
 /**
  * This class is internal and is hence not for public use. Its APIs are unstable and can change at
  * any time.
  */
 internal class ConditionalDropMetricExporter(
     private val delegate: MetricExporter,
-    private val drop: Predicate<SignalType>
+    private val drop: (SignalType) -> Boolean
 ) : MetricExporter {
 
     override fun getAggregationTemporality(instrumentType: InstrumentType): AggregationTemporality {
         return delegate.getAggregationTemporality(instrumentType)
     }
 
     override fun export(metrics: MutableCollection<MetricData>): CompletableResultCode {
-        if (drop.test(SignalType.METRIC)) {
+        if (drop(SignalType.METRIC)) {
             return CompletableResultCode.ofSuccess()
         }
         return delegate.export(metrics)

agent-sdk/src/main/java/co/elastic/otel/android/internal/features/conditionaldrop/ConditionalDropSpanExporter.kt

@@ -21,19 +21,18 @@ package co.elastic.otel.android.internal.features.conditionaldrop
 import io.opentelemetry.sdk.common.CompletableResultCode
 import io.opentelemetry.sdk.trace.data.SpanData
 import io.opentelemetry.sdk.trace.export.SpanExporter
-import java.util.function.Predicate
 
 /**
  * This class is internal and is hence not for public use. Its APIs are unstable and can change at
  * any time.
  */
 internal class ConditionalDropSpanExporter(
     private val delegate: SpanExporter,
-    private val drop: Predicate<SignalType>
+    private val drop: (SignalType) -> Boolean
 ) : SpanExporter {
 
     override fun export(spans: MutableCollection<SpanData>): CompletableResultCode {
-        if (drop.test(SignalType.SPAN)) {
+        if (drop(SignalType.SPAN)) {
             return CompletableResultCode.ofSuccess()
         }
         return delegate.export(spans)

agent-sdk/src/main/java/co/elastic/otel/android/internal/time/ntp/UdpClient.kt

@@ -25,7 +25,9 @@ import java.net.InetAddress
 import java.net.SocketException
 import java.net.SocketTimeoutException
 import java.net.UnknownHostException
-import java.time.Duration
+import kotlin.time.Duration
+import kotlin.time.Duration.Companion.seconds
+import kotlin.time.DurationUnit
 
 /**
  * This class is internal and is hence not for public use. Its APIs are unstable and can change at
@@ -40,13 +42,13 @@ internal class UdpClient internal constructor(
     private var address: InetAddress? = null
 
     @Throws(UnknownHostException::class, SocketTimeoutException::class, SocketException::class)
-    fun send(bytes: ByteArray, timeout: Duration = Duration.ofSeconds(5)): ByteArray =
+    fun send(bytes: ByteArray, timeout: Duration = 5.seconds): ByteArray =
         synchronized(this) {
             if (address == null) {
                 address = InetAddress.getByName(host)
             }
 
-            socket.soTimeout = timeout.toMillis().toInt()
+            socket.soTimeout = timeout.toInt(DurationUnit.MILLISECONDS)
 
             val packet = DatagramPacket(bytes, bytes.size, address, port)
             socket.send(packet)

agent-sdk/src/test/java/co/elastic/otel/android/functional/ElasticApmAgentTest.kt

@@ -26,9 +26,8 @@ import co.elastic.otel.android.interceptor.Interceptor
 import co.elastic.otel.android.internal.api.ManagedElasticOtelAgent
 import co.elastic.otel.android.internal.features.centralconfig.CentralConfigurationConnectivity
 import co.elastic.otel.android.internal.features.diskbuffering.DiskBufferingConfiguration
-import co.elastic.otel.android.processors.ProcessorFactory
-import co.elastic.otel.android.test.common.ElasticAttributes.getLogRecordDefaultAttributes
-import co.elastic.otel.android.test.common.ElasticAttributes.getSpanDefaultAttributes
+import co.elastic.otel.android.test.exporter.InMemoryExporterProvider
+import co.elastic.otel.android.test.processor.SimpleProcessorFactory
 import co.elastic.otel.android.testutils.DummySntpClient
 import co.elastic.otel.android.testutils.WireMockRule
 import io.mockk.Runs
@@ -40,26 +39,9 @@ import io.opentelemetry.api.OpenTelemetry
 import io.opentelemetry.api.common.AttributeKey
 import io.opentelemetry.api.common.Attributes
 import io.opentelemetry.sdk.common.CompletableResultCode
-import io.opentelemetry.sdk.logs.LogRecordProcessor
-import io.opentelemetry.sdk.logs.data.LogRecordData
-import io.opentelemetry.sdk.logs.export.LogRecordExporter
-import io.opentelemetry.sdk.logs.export.SimpleLogRecordProcessor
-import io.opentelemetry.sdk.metrics.data.MetricData
-import io.opentelemetry.sdk.metrics.export.MetricExporter
-import io.opentelemetry.sdk.metrics.export.MetricReader
-import io.opentelemetry.sdk.metrics.export.PeriodicMetricReader
 import io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat
-import io.opentelemetry.sdk.testing.exporter.InMemoryLogRecordExporter
-import io.opentelemetry.sdk.testing.exporter.InMemoryMetricExporter
-import io.opentelemetry.sdk.testing.exporter.InMemorySpanExporter
-import io.opentelemetry.sdk.trace.SpanProcessor
-import io.opentelemetry.sdk.trace.data.SpanData
-import io.opentelemetry.sdk.trace.export.SimpleSpanProcessor
-import io.opentelemetry.sdk.trace.export.SpanExporter
-import java.io.File
 import java.time.Duration
 import java.util.concurrent.TimeUnit
-import java.util.concurrent.atomic.AtomicReference
 import org.awaitility.core.ConditionTimeoutException
 import org.awaitility.kotlin.await
 import org.junit.After
@@ -78,11 +60,6 @@ class ElasticApmAgentTest {
     private val inMemoryExporters = InMemoryExporterProvider()
     private val inMemoryExportersInterceptor = Interceptor<ExporterProvider> { inMemoryExporters }
 
-    companion object {
-        private val SPAN_DEFAULT_ATTRIBUTES = getSpanDefaultAttributes()
-        private val LOG_DEFAULT_ATTRIBUTES = getLogRecordDefaultAttributes()
-    }
-
     @get:Rule
     val wireMockRule = WireMockRule()
 
@@ -746,10 +723,6 @@ class ElasticApmAgentTest {
             }
     }
 
-    private fun verifySessionId(attributes: Attributes, value: String) {
-        assertThat(attributes.get(AttributeKey.stringKey("session.id"))).isEqualTo(value)
-    }
-
     private fun sendSpan(name: String = "span-name", attributes: Attributes = Attributes.empty()) {
         agent.getOpenTelemetry().getTracer("TestTracer")
             .spanBuilder(name)
@@ -768,28 +741,7 @@ class ElasticApmAgentTest {
             .counterBuilder("counter")
             .build()
             .add(1)
-        simpleProcessorFactory.flush()
-    }
-
-    private fun awaitAndTrackTimeMillis(condition: () -> Boolean): Long {
-        val waitStart = System.nanoTime()
-        await.until(condition)
-        val waitTimeMillis = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - waitStart)
-        return waitTimeMillis
-    }
-
-    private fun awaitForCacheFileCreation(dirNames: List<String>) {
-        val signalsDir = File(RuntimeEnvironment.getApplication().cacheDir, "opentelemetry/signals")
-        val dirs = dirNames.map { File(signalsDir, it) }
-        await.until {
-            var dirsNotEmpty = 0
-            dirs.forEach {
-                if (it.list().isNotEmpty()) {
-                    dirsNotEmpty++
-                }
-            }
-            dirsNotEmpty == dirs.size
-        }
+        simpleProcessorFactory.flushMetrics().join(1, TimeUnit.SECONDS)
     }
 
     private fun awaitForOpenGates(maxSecondsToWait: Int = 1) {
@@ -806,71 +758,4 @@ class ElasticApmAgentTest {
             throw e
         }
     }
-
-    private interface FlushableProcessorFactory : ProcessorFactory {
-        fun flush()
-    }
-
-    private class SimpleProcessorFactory : FlushableProcessorFactory {
-        private lateinit var metricReader: PeriodicMetricReader
-
-        override fun createSpanProcessor(exporter: SpanExporter?): SpanProcessor? {
-            return SimpleSpanProcessor.create(exporter)
-        }
-
-        override fun createLogRecordProcessor(exporter: LogRecordExporter?): LogRecordProcessor? {
-            return SimpleLogRecordProcessor.create(exporter)
-        }
-
-        override fun createMetricReader(exporter: MetricExporter?): MetricReader {
-            metricReader = PeriodicMetricReader.create(exporter)
-            return metricReader
-        }
-
-        override fun flush() {
-            metricReader.forceFlush()
-        }
-    }
-
-    private class InMemoryExporterProvider : ExporterProvider {
-        private var spanExporter = AtomicReference(InMemorySpanExporter.create())
-        private var logRecordExporter = AtomicReference(InMemoryLogRecordExporter.create())
-        private var metricExporter = AtomicReference(InMemoryMetricExporter.create())
-
-        fun reset() {
-            spanExporter.set(InMemorySpanExporter.create())
-            logRecordExporter.set(InMemoryLogRecordExporter.create())
-            metricExporter.set(InMemoryMetricExporter.create())
-        }
-
-        fun resetExporters() {
-            spanExporter.get().reset()
-            logRecordExporter.get().reset()
-            metricExporter.get().reset()
-        }
-
-        fun getFinishedSpans(): List<SpanData> {
-            return spanExporter.get().finishedSpanItems
-        }
-
-        fun getFinishedLogRecords(): List<LogRecordData> {
-            return logRecordExporter.get().finishedLogRecordItems
-        }
-
-        fun getFinishedMetrics(): List<MetricData> {
-            return metricExporter.get().finishedMetricItems
-        }
-
-        override fun getSpanExporter(): SpanExporter? {
-            return spanExporter.get()
-        }
-
-        override fun getLogRecordExporter(): LogRecordExporter? {
-            return logRecordExporter.get()
-        }
-
-        override fun getMetricExporter(): MetricExporter? {
-            return metricExporter.get()
-        }
-    }
 }