feat: O11Y-601 - Add Android launch time instrumentation (#274)

## Summary

This commit introduces automatic instrumentation for Android application
launch times. It measures and reports two key metrics:
- Time to Initial Display (TTID)
- Time to Full Display (TTFD)

The instrumentation classifies launches as `cold`, `warm`, or `hot` and
records the durations as histogram metrics (`app.launch.duration.ttid`
and `app.launch.duration.ttfd`). These metrics include attributes for
the launch type and the specific activity being launched.

The implementation also includes:
- Adding the dependency `androidx.activity:activity`.
- Updating the Android compile SDK version to 36 (Required for the
dependency added)


<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> Adds Android launch-time metrics (TTID, TTFD), integrates
instrumentation into the SDK, switches metrics export to delta
temporality, and updates compileSdk to 36 with new metric APIs and demo
triggers.
> 
> - **SDK**:
> - **Launch time instrumentation**: Add `LaunchTimeInstrumentation` to
record `app.launch.duration.ttid` and `app.launch.duration.ttfd` with
`launch.type` and `launch.activity` attributes.
> - **Integration**: Wire instrumentation into `InstrumentationManager`
(enabled when metrics are on).
> - **Metrics export**: Use delta temporality via
`AggregationTemporalitySelector.deltaPreferred()` for OTLP and debug
exporters; adjust periodic reader interval to milliseconds.
> - **Dependencies/Config**: Add `androidx.activity:activity`; bump
`compileSdk` to `36`.
> - **E2E demo app**:
> - Add UI buttons to trigger new metric types; update `ViewModel` with
`recordHistogram`, `recordCount`, `recordIncr`, `recordUpDownCounter`
and rename gauge metric to `test-gauge`.
>   - Bump `compileSdk` to `36`.
> 
> <sup>Written by [Cursor
Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit
e5c261d. This will update automatically
on new commits. Configure
[here](https://cursor.com/dashboard?tab=bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

---------

Co-authored-by: Todd Anderson <[email protected]>

Author: agrognetti

e2e/android/app/build.gradle.kts

@@ -7,7 +7,7 @@ plugins {
 
 android {
     namespace = "com.example.androidobservability"
-    compileSdk = 35
+    compileSdk = 36
 
     defaultConfig {
         applicationId = "com.example.androidobservability"

e2e/android/app/src/main/java/com/example/androidobservability/MainActivity.kt

@@ -10,6 +10,7 @@ import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.imePadding
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.verticalScroll
@@ -35,16 +36,21 @@ class MainActivity : ComponentActivity() {
         enableEdgeToEdge()
         setContent {
             AndroidObservabilityTheme {
-                Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding ->
+                Scaffold(
+                    modifier = Modifier
+                        .fillMaxSize()
+                        .imePadding()
+                ) { innerPadding ->
                     var customLogText by remember { mutableStateOf("") }
                     var customSpanText by remember { mutableStateOf("") }
                     var customContextKey by remember { mutableStateOf("") }
 
                     Column(
                         modifier = Modifier
+                            .fillMaxSize()
                             .padding(innerPadding)
-                            .padding(16.dp)
                             .verticalScroll(rememberScrollState())
+                            .padding(16.dp)
                     ) {
                         Text(
                             text = "Hello Telemetry",
@@ -77,6 +83,34 @@ class MainActivity : ComponentActivity() {
                         ) {
                             Text("Trigger Metric")
                         }
+                        Button(
+                            onClick = {
+                                viewModel.triggerHistogramMetric()
+                            }
+                        ) {
+                            Text("Trigger Histogram Metric")
+                        }
+                        Button(
+                            onClick = {
+                                viewModel.triggerCountMetric()
+                            }
+                        ) {
+                            Text("Trigger Count Metric")
+                        }
+                        Button(
+                            onClick = {
+                                viewModel.triggerIncrementalMetric()
+                            }
+                        ) {
+                            Text("Trigger Incremental Metric")
+                        }
+                        Button(
+                            onClick = {
+                                viewModel.triggerUpDownCounterMetric()
+                            }
+                        ) {
+                            Text("Trigger UpDownCounter Metric")
+                        }
                         Button(
                             onClick = {
                                 viewModel.triggerError()

e2e/android/app/src/main/java/com/example/androidobservability/ViewModel.kt

@@ -21,7 +21,23 @@ import java.net.URL
 class ViewModel : ViewModel() {
 
     fun triggerMetric() {
-        LDObserve.recordMetric(Metric("test", 50.0))
+        LDObserve.recordMetric(Metric("test-gauge", 50.0))
+    }
+
+    fun triggerHistogramMetric() {
+        LDObserve.recordHistogram(Metric("test-histogram", 15.0))
+    }
+
+    fun triggerCountMetric() {
+        LDObserve.recordCount(Metric("test-counter", 10.0))
+    }
+
+    fun triggerIncrementalMetric() {
+        LDObserve.recordIncr(Metric("test-incremental-counter", 12.0))
+    }
+
+    fun triggerUpDownCounterMetric() {
+        LDObserve.recordUpDownCounter(Metric("test-up-down-counter", 25.0))
     }
 
     fun triggerError() {

sdk/@launchdarkly/observability-android/lib/build.gradle.kts

@@ -23,6 +23,9 @@ dependencies {
     implementation("com.launchdarkly:launchdarkly-android-client-sdk:5.9.0")
     implementation("com.jakewharton.timber:timber:5.0.1")
 
+    // Android
+    implementation("androidx.activity:activity:1.11.0")
+
     // Coroutines
     implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.10.2")
     implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.10.2")
@@ -69,7 +72,7 @@ tasks.withType<Test> {
 
 android {
     namespace = "com.launchdarkly.observability"
-    compileSdk = 35
+    compileSdk = 36
 
     buildFeatures {
         buildConfig = true

sdk/@launchdarkly/observability-android/lib/src/main/kotlin/com/launchdarkly/observability/client/DebugMetricExporter.kt

@@ -5,18 +5,20 @@ import io.opentelemetry.sdk.common.CompletableResultCode
 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.AggregationTemporalitySelector
 import io.opentelemetry.sdk.metrics.export.MetricExporter
 
 class DebugMetricExporter(private val logger: LDLogger): MetricExporter {
 
     override fun export(metrics: Collection<MetricData?>): CompletableResultCode? {
         for (metric in metrics) {
-            logger.info(metric.toString())
+            logger.info("Metric exported: ${metric.toString()}")
         }
         return CompletableResultCode.ofSuccess()
     }
 
     override fun flush(): CompletableResultCode = CompletableResultCode.ofSuccess()
     override fun shutdown(): CompletableResultCode = CompletableResultCode.ofSuccess()
-    override fun getAggregationTemporality(instrumentType: InstrumentType): AggregationTemporality? = AggregationTemporality.CUMULATIVE
+    override fun getAggregationTemporality(instrumentType: InstrumentType): AggregationTemporality? =
+        AggregationTemporalitySelector.deltaPreferred().getAggregationTemporality(instrumentType)
 }

sdk/@launchdarkly/observability-android/lib/src/main/kotlin/com/launchdarkly/observability/client/InstrumentationManager.kt

@@ -33,6 +33,7 @@ import io.opentelemetry.sdk.logs.SdkLoggerProviderBuilder
 import io.opentelemetry.sdk.logs.export.BatchLogRecordProcessor
 import io.opentelemetry.sdk.logs.export.LogRecordExporter
 import io.opentelemetry.sdk.metrics.SdkMeterProviderBuilder
+import io.opentelemetry.sdk.metrics.export.AggregationTemporalitySelector
 import io.opentelemetry.sdk.metrics.export.MetricExporter
 import io.opentelemetry.sdk.metrics.export.PeriodicMetricReader
 import io.opentelemetry.sdk.resources.Resource
@@ -75,7 +76,7 @@ class InstrumentationManager(
         private const val BATCH_SCHEDULE_DELAY_MS = 1000L
         private const val BATCH_EXPORTER_TIMEOUT_MS = 5000L
         private const val BATCH_MAX_EXPORT_SIZE = 10
-        private const val METRICS_EXPORT_INTERVAL_SECONDS = 10L
+        private const val METRICS_EXPORT_INTERVAL_MS = 10_000L
         private const val FLUSH_TIMEOUT_SECONDS = 5L
     }
 
@@ -93,6 +94,7 @@ class InstrumentationManager(
     private var spanProcessor: BatchSpanProcessor? = null
     private var logProcessor: BatchLogRecordProcessor? = null
     private var metricsReader: PeriodicMetricReader? = null
+    private var launchTimeInstrumentation: LaunchTimeInstrumentation? = null
     private val gaugeCache = ConcurrentHashMap<String, DoubleGauge>()
     private val counterCache = ConcurrentHashMap<String, LongCounter>()
     private val histogramCache = ConcurrentHashMap<String, DoubleHistogram>()
@@ -104,7 +106,7 @@ class InstrumentationManager(
     init {
         val otelRumConfig = createOtelRumConfig()
 
-        otelRUM = OpenTelemetryRum.builder(application, otelRumConfig)
+        val rumBuilder = OpenTelemetryRum.builder(application, otelRumConfig)
             .addLoggerProviderCustomizer { sdkLoggerProviderBuilder, _ ->
                 return@addLoggerProviderCustomizer if (options.disableLogs && options.disableErrorTracking) {
                     sdkLoggerProviderBuilder
@@ -126,7 +128,17 @@ class InstrumentationManager(
                     configureMeterProvider(sdkMeterProviderBuilder)
                 }
             }
-            .build()
+
+        if (!options.disableMetrics) {
+            launchTimeInstrumentation = LaunchTimeInstrumentation(
+                application = application,
+                metricRecorder = this::recordHistogram
+            ).also {
+                rumBuilder.addInstrumentation(it)
+            }
+        }
+
+        otelRUM = rumBuilder.build()
 
         initializeTelemetryInspector()
         loadSamplingConfigAsync()
@@ -211,6 +223,7 @@ class InstrumentationManager(
         return OtlpHttpMetricExporter.builder()
             .setEndpoint(options.otlpEndpoint + METRICS_PATH)
             .setHeaders { options.customHeaders }
+            .setAggregationTemporalitySelector(AggregationTemporalitySelector.deltaPreferred())
             .build()
     }
 
@@ -275,7 +288,7 @@ class InstrumentationManager(
     private fun createPeriodicMetricReader(metricExporter: MetricExporter): PeriodicMetricReader {
         // Configure a periodic reader that pushes metrics every 10 seconds.
         return PeriodicMetricReader.builder(metricExporter)
-            .setInterval(METRICS_EXPORT_INTERVAL_SECONDS, TimeUnit.SECONDS)
+            .setInterval(METRICS_EXPORT_INTERVAL_MS, TimeUnit.MILLISECONDS)
             .build()
     }
 
@@ -332,6 +345,7 @@ class InstrumentationManager(
         val counter = counterCache.getOrPut(metric.name) {
             otelMeter.counterBuilder(metric.name).build()
         }
+        // It increments the value until the metric is exported, then it’s reset.
         counter.add(1, metric.attributes)
     }