Merge pull request #2647 from DataDog/aleksandr-gringauz/RUM-9958/align-datadog-init-with-ios-for-benchmarks

aleksandr-gringauz · web-flow · commit 9515e48bdaf2 · 2025-05-14T15:17:37.000+02:00
RUM-9958: Align datadog initialization with ios for benchmark app
diff --git a/sample/benchmark/src/main/java/com/datadog/benchmark/sample/BenchmarkApplication.kt b/sample/benchmark/src/main/java/com/datadog/benchmark/sample/BenchmarkApplication.kt
@@ -7,20 +7,13 @@
 package com.datadog.benchmark.sample
 
 import android.app.Application
-import androidx.annotation.Keep
-import com.datadog.android.api.SdkCore
 import com.datadog.benchmark.sample.di.app.BenchmarkAppComponent
 import com.datadog.benchmark.sample.di.app.DaggerBenchmarkAppComponent
-import javax.inject.Inject
 
 internal class BenchmarkApplication : Application() {
 
     internal lateinit var benchmarkAppComponent: BenchmarkAppComponent
 
-    @Inject
-    @Keep
-    internal lateinit var sdkCore: SdkCore
-
     override fun onCreate() {
         super.onCreate()
 
diff --git a/sample/benchmark/src/main/java/com/datadog/benchmark/sample/DatadogFeaturesInitializer.kt b/sample/benchmark/src/main/java/com/datadog/benchmark/sample/DatadogFeaturesInitializer.kt
@@ -23,24 +23,30 @@ import com.datadog.android.trace.TraceConfiguration
 import com.datadog.benchmark.sample.config.BenchmarkConfig
 import com.datadog.benchmark.sample.config.SyntheticsRun
 import com.datadog.benchmark.sample.config.SyntheticsScenario
+import com.datadog.benchmark.sample.di.activity.BenchmarkActivityScope
 import com.datadog.benchmark.sample.navigation.BenchmarkNavigationPredicate
 import com.datadog.sample.benchmark.BuildConfig
 import com.datadog.sample.benchmark.R
+import dagger.Lazy
 import javax.inject.Inject
-import javax.inject.Singleton
 
 /**
  * The general recommendation is to initialize all the components at the Application.onCreate
  * to have all the observability as early as possible. However in the Benchmark app we know what features
  * we need only in [MainActivity.onCreate], it depends on the [SyntheticsScenario] which is derived from intent extras.
  */
-@Singleton
+@BenchmarkActivityScope
 @Suppress("TooManyFunctions")
 internal class DatadogFeaturesInitializer @Inject constructor(
-    private val sdkCore: SdkCore
+    private val sdkCore: Lazy<SdkCore>
 ) {
     private var isInitialized = false
+
     fun initialize(config: BenchmarkConfig) {
+        if (config.run == SyntheticsRun.Baseline) {
+            return
+        }
+
         if (isInitialized) {
             return
         }
@@ -76,7 +82,7 @@ internal class DatadogFeaturesInitializer @Inject constructor(
             .addExtensionSupport(ComposeExtensionSupport())
             .build()
 
-        SessionReplay.enable(sessionReplayConfig, sdkCore)
+        SessionReplay.enable(sessionReplayConfig, sdkCore.get())
     }
 
     private fun needToEnableLogs(config: BenchmarkConfig): Boolean {
@@ -85,13 +91,14 @@ internal class DatadogFeaturesInitializer @Inject constructor(
 
     private fun enableLogs() {
         val logsConfig = LogsConfiguration.Builder().build()
-        Logs.enable(logsConfig, sdkCore)
+        Logs.enable(logsConfig, sdkCore.get())
     }
 
     private fun needToEnableRum(config: BenchmarkConfig): Boolean {
-        return when (isInstrumentedRun(config)) {
-            true -> isSessionReplayScenario(config) || isRumScenario(config)
-            false -> isSessionReplayScenario(config)
+        return if (isInstrumentedRun(config)) {
+            isSessionReplayScenario(config) || isRumScenario(config)
+        } else {
+            false
         }
     }
 
@@ -138,7 +145,7 @@ internal class DatadogFeaturesInitializer @Inject constructor(
 
     private fun enableRum(config: BenchmarkConfig) {
         val rumConfig = createRumConfiguration(config)
-        Rum.enable(rumConfig, sdkCore = sdkCore)
+        Rum.enable(rumConfig, sdkCore = sdkCore.get())
     }
 
     private fun isSessionReplayScenario(config: BenchmarkConfig) = when (config.scenario) {
@@ -186,7 +193,7 @@ internal class DatadogFeaturesInitializer @Inject constructor(
     private fun enableTracing() {
         val tracesConfig = TraceConfiguration.Builder().build()
 
-        Trace.enable(tracesConfig, sdkCore)
+        Trace.enable(tracesConfig, sdkCore.get())
     }
 
     private fun isInstrumentedRun(config: BenchmarkConfig) = config.run == SyntheticsRun.Instrumented
diff --git a/sample/benchmark/src/main/java/com/datadog/benchmark/sample/di/activity/BenchmarkActivityComponent.kt b/sample/benchmark/src/main/java/com/datadog/benchmark/sample/di/activity/BenchmarkActivityComponent.kt
@@ -8,8 +8,7 @@
 
 package com.datadog.benchmark.sample.di.activity
 
-import com.datadog.android.api.SdkCore
-import com.datadog.benchmark.sample.DatadogFeaturesInitializer
+import android.content.Context
 import com.datadog.benchmark.sample.MainActivity
 import com.datadog.benchmark.sample.config.BenchmarkConfig
 import com.datadog.benchmark.sample.di.common.DispatchersModule
@@ -27,8 +26,7 @@ import javax.inject.Scope
 internal annotation class BenchmarkActivityScope
 
 internal interface BenchmarkActivityComponentDependencies {
-    val sdkCore: SdkCore
-    val datadogFeaturesInitializer: DatadogFeaturesInitializer
+    val context: Context
 }
 
 @Component(
diff --git a/sample/benchmark/src/main/java/com/datadog/benchmark/sample/di/activity/DatadogActivityModule.kt b/sample/benchmark/src/main/java/com/datadog/benchmark/sample/di/activity/DatadogActivityModule.kt
@@ -6,15 +6,27 @@
 
 package com.datadog.benchmark.sample.di.activity
 
+import android.annotation.SuppressLint
+import android.content.Context
+import android.util.Log
+import com.datadog.android.Datadog
 import com.datadog.android.api.SdkCore
+import com.datadog.android.core.configuration.BackPressureMitigation
+import com.datadog.android.core.configuration.BackPressureStrategy
+import com.datadog.android.core.configuration.BatchSize
+import com.datadog.android.core.configuration.Configuration
+import com.datadog.android.core.configuration.UploadFrequency
 import com.datadog.android.log.Logger
+import com.datadog.android.privacy.TrackingConsent
 import com.datadog.android.rum.GlobalRumMonitor
 import com.datadog.android.rum.RumMonitor
 import com.datadog.benchmark.DatadogBaseMeter
 import com.datadog.benchmark.DatadogExporterConfiguration
 import com.datadog.benchmark.DatadogSdkMeter
 import com.datadog.benchmark.DatadogVitalsMeter
+import com.datadog.benchmark.sample.MainActivity
 import com.datadog.benchmark.sample.config.BenchmarkConfig
+import com.datadog.benchmark.sample.config.SyntheticsRun
 import com.datadog.benchmark.sample.config.SyntheticsScenario
 import com.datadog.sample.benchmark.BuildConfig
 import dagger.Module
@@ -23,6 +35,29 @@ import dagger.Provides
 @Module
 internal interface DatadogActivityModule {
     companion object {
+        /**
+         * The general recommendation is to initialize Datadog SDK at the Application.onCreate
+         * to have all the observability as early as possible. However in the Benchmark app we know what kind of run we
+         * have [SyntheticsRun.Instrumented] or [SyntheticsRun.Baseline] only in [MainActivity.onCreate].
+         * It is derived from intent extras.
+         */
+        @Provides
+        @BenchmarkActivityScope
+        fun provideSdkCore(
+            context: Context,
+            config: BenchmarkConfig
+        ): SdkCore {
+            check(config.run != SyntheticsRun.Baseline) {
+                "Datadog must not be initialized in baseline run"
+            }
+
+            return Datadog.initialize(
+                context,
+                createDatadogConfiguration(),
+                TrackingConsent.GRANTED
+            )!!
+        }
+
         @Provides
         @BenchmarkActivityScope
         fun provideDatadogMeter(config: BenchmarkConfig): DatadogBaseMeter {
@@ -59,5 +94,29 @@ internal interface DatadogActivityModule {
     }
 }
 
+@SuppressLint("LogNotTimber")
+private fun createDatadogConfiguration(): Configuration {
+    val configBuilder = Configuration.Builder(
+        clientToken = BuildConfig.BENCHMARK_CLIENT_TOKEN,
+        env = BuildConfig.BUILD_TYPE
+    )
+        .setBatchSize(BatchSize.SMALL)
+        .setUploadFrequency(UploadFrequency.FREQUENT)
+
+    configBuilder.setBackpressureStrategy(
+        BackPressureStrategy(
+            CAPACITY_BACK_PRESSURE_STRATEGY,
+            { Log.w("BackPressure", "Threshold reached") },
+            { Log.e("BackPressure", "Item dropped: $it") },
+            BackPressureMitigation.IGNORE_NEWEST
+        )
+    )
+
+    return configBuilder.build()
+}
+
+// the same as the default one
+private const val CAPACITY_BACK_PRESSURE_STRATEGY = 1024
+
 private const val METER_INTERVAL_IN_SECONDS = 10L
 private const val BENCHMARK_APPLICATION_NAME = "Benchmark Application"
diff --git a/sample/benchmark/src/main/java/com/datadog/benchmark/sample/di/app/BenchmarkAppComponent.kt b/sample/benchmark/src/main/java/com/datadog/benchmark/sample/di/app/BenchmarkAppComponent.kt
@@ -14,8 +14,7 @@ import javax.inject.Singleton
 
 @Component(
     modules = [
-        AppModule::class,
-        DatadogModule::class
+        AppModule::class
     ]
 )
 @Singleton
diff --git a/sample/benchmark/src/main/java/com/datadog/benchmark/sample/di/app/DatadogModule.kt b/sample/benchmark/src/main/java/com/datadog/benchmark/sample/di/app/DatadogModule.kt
diff --git a/sample/benchmark/src/test/java/com/datadog/benchmark/sample/config/DatadogFeaturesInitializerTest.kt b/sample/benchmark/src/test/java/com/datadog/benchmark/sample/config/DatadogFeaturesInitializerTest.kt
@@ -21,6 +21,8 @@ import org.mockito.Mockito
 import org.mockito.junit.jupiter.MockitoExtension
 import org.mockito.junit.jupiter.MockitoSettings
 import org.mockito.kotlin.any
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.verifyNoInteractions
 import org.mockito.quality.Strictness
 
 @Extensions(
@@ -48,7 +50,7 @@ class DatadogFeaturesInitializerTest {
     }
 
     @Test
-    fun `M skip session replay and enable rum W run is baseline and scenario is sr`() {
+    fun `M enable nothing W run is baseline and scenario is sr`() {
         // Given
         val config = BenchmarkConfig(
             run = SyntheticsRun.Baseline,
@@ -58,7 +60,7 @@ class DatadogFeaturesInitializerTest {
         mockAllAndCheck(config) {
             // Then
             sessionReplay.verifyNoInteractions()
-            rum.verifyRumEnabled()
+            rum.verifyNoInteractions()
             logs.verifyNoInteractions()
         }
     }
@@ -101,7 +103,7 @@ class DatadogFeaturesInitializerTest {
                 Mockito.mockStatic(Logs::class.java).use { logsStatic ->
                     // When
                     DatadogFeaturesInitializer(
-                        sdkCore = mockSdkCore
+                        sdkCore = { mockSdkCore }
                     ).initialize(config)
 
                     // Then

Original file line number	Diff line number	Diff line change
`@@ -14,8 +14,7 @@ import javax.inject.Singleton`
`14`	`14`
`15`	`15`	`@Component(`
`16`	`16`	`modules = [`
`17`		`- AppModule::class,`
`18`		`- DatadogModule::class`
	`17`	`+ AppModule::class`
`19`	`18`	`]`
`20`	`19`	`)`
`21`	`20`	`@Singleton`