RUM-1702: Start session when RUM is initialized

features/dd-sdk-android-rum/src/main/kotlin/com/datadog/android/rum/Rum.kt

@@ -11,6 +11,7 @@ import android.os.Looper
 import com.datadog.android.Datadog
 import com.datadog.android.api.InternalLogger
 import com.datadog.android.api.SdkCore
+import com.datadog.android.api.feature.Feature
 import com.datadog.android.api.feature.FeatureSdkCore
 import com.datadog.android.core.InternalSdkCore
 import com.datadog.android.core.sampling.RateBasedSampler
@@ -30,6 +31,7 @@ object Rum {
      * @param sdkCore SDK instance to register feature in. If not provided, default SDK instance
      * will be used.
      */
+    @Suppress("ReturnCount")
     @JvmOverloads
     @JvmStatic
     fun enable(rumConfiguration: RumConfiguration, sdkCore: SdkCore = Datadog.getInstance()) {
@@ -52,18 +54,35 @@ object Rum {
             return
         }
 
+        if (sdkCore.getFeature(Feature.RUM_FEATURE_NAME) != null) {
+            sdkCore.internalLogger.log(
+                InternalLogger.Level.WARN,
+                InternalLogger.Target.USER,
+                { RUM_FEATURE_ALREADY_ENABLED }
+            )
+            return
+        }
+
         val rumFeature = RumFeature(
-            sdkCore = sdkCore as FeatureSdkCore,
+            sdkCore = sdkCore,
             applicationId = rumConfiguration.applicationId,
             configuration = rumConfiguration.featureConfiguration
         )
 
         sdkCore.registerFeature(rumFeature)
 
+        val rumMonitor = createMonitor(sdkCore, rumFeature)
         GlobalRumMonitor.registerIfAbsent(
-            monitor = createMonitor(sdkCore, rumFeature),
+            monitor = rumMonitor,
             sdkCore
         )
+
+        // TODO RUM-0000 there is a small chance of application crashing between RUM monitor
+        //  registration and the moment SDK init is processed, in this case we will miss this crash
+        //  (it won't activate new session). Ideally we should start session when monitor is created
+        //  and before it is registered, but with current code (internal RUM scopes using the
+        //  `GlobalRumMonitor`) it is impossible to break cycle dependency.
+        rumMonitor.start()
     }
 
     // region private
@@ -104,5 +123,8 @@ object Rum {
         "You're trying to create a RumMonitor instance, " +
             "but the RUM application id was empty. No RUM data will be sent."
 
+    internal const val RUM_FEATURE_ALREADY_ENABLED =
+        "RUM Feature is already enabled in this SDK core, ignoring the call to enable it."
+
     // endregion
 }

features/dd-sdk-android-rum/src/main/kotlin/com/datadog/android/rum/internal/domain/scope/RumApplicationScope.kt

@@ -6,21 +6,15 @@
 
 package com.datadog.android.rum.internal.domain.scope
 
-import android.app.ActivityManager
 import androidx.annotation.WorkerThread
 import com.datadog.android.api.InternalLogger
 import com.datadog.android.api.feature.Feature
 import com.datadog.android.api.storage.DataWriter
 import com.datadog.android.core.InternalSdkCore
 import com.datadog.android.core.internal.net.FirstPartyHostHeaderTypeResolver
-import com.datadog.android.rum.DdRumContentProvider
 import com.datadog.android.rum.RumSessionListener
-import com.datadog.android.rum.internal.AppStartTimeProvider
-import com.datadog.android.rum.internal.DefaultAppStartTimeProvider
 import com.datadog.android.rum.internal.domain.RumContext
-import com.datadog.android.rum.internal.domain.Time
 import com.datadog.android.rum.internal.vitals.VitalMonitor
-import java.util.concurrent.TimeUnit
 
 @Suppress("LongParameterList")
 internal class RumApplicationScope(
@@ -33,8 +27,7 @@ internal class RumApplicationScope(
     private val cpuVitalMonitor: VitalMonitor,
     private val memoryVitalMonitor: VitalMonitor,
     private val frameRateVitalMonitor: VitalMonitor,
-    private val sessionListener: RumSessionListener?,
-    private val appStartTimeProvider: AppStartTimeProvider = DefaultAppStartTimeProvider()
+    private val sessionListener: RumSessionListener?
 ) : RumScope, RumViewChangedListener {
 
     private var rumContext = RumContext(applicationId = applicationId)
@@ -62,7 +55,6 @@ internal class RumApplicationScope(
         }
 
     private var lastActiveViewInfo: RumViewInfo? = null
-    private var isSentAppStartedEvent = false
 
     // region RumScope
 
@@ -87,10 +79,6 @@ internal class RumApplicationScope(
             }
         }
 
-        if (!isSentAppStartedEvent) {
-            sendApplicationStartEvent(event.eventTime, writer)
-        }
-
         delegateToChildren(event, writer)
 
         return this
@@ -166,37 +154,9 @@ internal class RumApplicationScope(
         }
     }
 
-    @WorkerThread
-    private fun sendApplicationStartEvent(eventTime: Time, writer: DataWriter<Any>) {
-        val processImportance = DdRumContentProvider.processImportance
-        val isForegroundProcess = processImportance ==
-                ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND
-        if (isForegroundProcess) {
-            val processStartTimeNs = appStartTimeProvider.appStartTimeNs
-            // processStartTime is the time in nanoseconds since VM start. To get a timestamp, we want
-            // to convert it to milliseconds since epoch provided by System.currentTimeMillis.
-            // To do so, we take the offset of those times in the event time, which should be consistent,
-            // then add that to our processStartTime to get the correct value.
-            val timestampNs = (
-                    TimeUnit.MILLISECONDS.toNanos(eventTime.timestamp) - eventTime.nanoTime
-                    ) + processStartTimeNs
-            val applicationLaunchViewTime = Time(
-                timestamp = TimeUnit.NANOSECONDS.toMillis(timestampNs),
-                nanoTime = processStartTimeNs
-            )
-            val startupTime = eventTime.nanoTime - processStartTimeNs
-            val appStartedEvent =
-                RumRawEvent.ApplicationStarted(applicationLaunchViewTime, startupTime)
-            delegateToChildren(appStartedEvent, writer)
-            isSentAppStartedEvent = true
-        }
-    }
-
     // endregion
 
     companion object {
-        internal const val LAST_ACTIVE_VIEW_GONE_WARNING_MESSAGE = "Attempting to start a new " +
-                "session on the last known view (%s) failed because that view has been disposed. "
         internal const val MULTIPLE_ACTIVE_SESSIONS_ERROR = "Application has multiple active " +
                 "sessions when starting a new session"
     }

features/dd-sdk-android-rum/src/main/kotlin/com/datadog/android/rum/internal/domain/scope/RumRawEvent.kt

@@ -215,4 +215,10 @@ internal sealed class RumRawEvent {
         override val eventTime: Time = Time(),
         val isMetric: Boolean = false
     ) : RumRawEvent()
+
+    internal data class SdkInit(
+        val isAppInForeground: Boolean,
+        val appStartTimeNs: Long,
+        override val eventTime: Time = Time()
+    ) : RumRawEvent()
 }

features/dd-sdk-android-rum/src/main/kotlin/com/datadog/android/rum/internal/domain/scope/RumSessionScope.kt

@@ -13,6 +13,7 @@ import com.datadog.android.core.InternalSdkCore
 import com.datadog.android.core.internal.net.FirstPartyHostHeaderTypeResolver
 import com.datadog.android.rum.RumSessionListener
 import com.datadog.android.rum.internal.domain.RumContext
+import com.datadog.android.rum.internal.domain.Time
 import com.datadog.android.rum.internal.storage.NoOpDataWriter
 import com.datadog.android.rum.internal.vitals.VitalMonitor
 import com.datadog.android.rum.utils.percent
@@ -33,7 +34,7 @@ internal class RumSessionScope(
     cpuVitalMonitor: VitalMonitor,
     memoryVitalMonitor: VitalMonitor,
     frameRateVitalMonitor: VitalMonitor,
-    internal val sessionListener: RumSessionListener?,
+    private val sessionListener: RumSessionListener?,
     applicationDisplayed: Boolean,
     private val sessionInactivityNanos: Long = DEFAULT_SESSION_INACTIVITY_NS,
     private val sessionMaxDurationNanos: Long = DEFAULT_SESSION_MAX_DURATION_NS
@@ -118,7 +119,20 @@ internal class RumSessionScope(
 
         val actualWriter = if (sessionState == State.TRACKED) writer else noOpWriter
 
-        childScope = childScope?.handleEvent(event, actualWriter)
+        val downStreamEvent = if (event is RumRawEvent.SdkInit) {
+            if (event.isAppInForeground) {
+                createApplicationStartEvent(event)
+            } else {
+                // stop here, we initialized the session, no need to go down
+                null
+            }
+        } else {
+            event
+        }
+
+        if (downStreamEvent != null) {
+            childScope = childScope?.handleEvent(downStreamEvent, actualWriter)
+        }
 
         return if (isSessionComplete()) {
             null
@@ -165,9 +179,10 @@ internal class RumSessionScope(
 
         val isInteraction = (event is RumRawEvent.StartView) || (event is RumRawEvent.StartAction)
         val isBackgroundEvent = event.javaClass in RumViewManagerScope.validBackgroundEventTypes
-        val isApplicationStartEvent = event is RumRawEvent.ApplicationStarted
+        val isSdkInitInForeground = event is RumRawEvent.SdkInit && event.isAppInForeground
+        val isSdkInitInBackground = event is RumRawEvent.SdkInit && !event.isAppInForeground
 
-        if (isInteraction || isApplicationStartEvent) {
+        if (isInteraction || isSdkInitInForeground) {
             if (isNewSession || isExpired || isTimedOut) {
                 val reason = if (isNewSession) {
                     StartReason.USER_APP_LAUNCH
@@ -180,7 +195,7 @@ internal class RumSessionScope(
             }
             lastUserInteractionNs.set(nanoTime)
         } else if (isExpired) {
-            if (backgroundTrackingEnabled && isBackgroundEvent) {
+            if (backgroundTrackingEnabled && (isBackgroundEvent || isSdkInitInBackground)) {
                 renewSession(nanoTime, StartReason.INACTIVITY_TIMEOUT)
                 lastUserInteractionNs.set(nanoTime)
             } else {
@@ -213,6 +228,26 @@ internal class RumSessionScope(
         )
     }
 
+    private fun createApplicationStartEvent(
+        sdkInitEvent: RumRawEvent.SdkInit
+    ): RumRawEvent.ApplicationStarted {
+        val processStartTimeNs = sdkInitEvent.appStartTimeNs
+        val eventTime = sdkInitEvent.eventTime
+        // processStartTime is the time in nanoseconds since VM start. To get a timestamp, we want
+        // to convert it to milliseconds since epoch provided by System.currentTimeMillis.
+        // To do so, we take the offset of those times in the event time, which should be consistent,
+        // then add that to our processStartTime to get the correct value.
+        val timestampNs = (
+                TimeUnit.MILLISECONDS.toNanos(eventTime.timestamp) - eventTime.nanoTime
+                ) + processStartTimeNs
+        val applicationLaunchViewTime = Time(
+            timestamp = TimeUnit.NANOSECONDS.toMillis(timestampNs),
+            nanoTime = processStartTimeNs
+        )
+        val startupTime = sdkInitEvent.eventTime.nanoTime - processStartTimeNs
+        return RumRawEvent.ApplicationStarted(applicationLaunchViewTime, startupTime)
+    }
+
     // endregion
 
     companion object {

features/dd-sdk-android-rum/src/main/kotlin/com/datadog/android/rum/internal/domain/scope/RumViewManagerScope.kt

@@ -280,7 +280,7 @@ internal class RumViewManagerScope(
         internal const val MESSAGE_MISSING_VIEW =
             "A RUM event was detected, but no view is active. " +
                     "To track views automatically, try calling the " +
-                    "Configuration.Builder.useViewTrackingStrategy() method.\n" +
+                    "RumConfiguration.Builder.useViewTrackingStrategy() method.\n" +
                     "You can also track views manually using the RumMonitor.startView() and " +
                     "RumMonitor.stopView() methods."
     }

features/dd-sdk-android-rum/src/main/kotlin/com/datadog/android/rum/internal/monitor/AdvancedRumMonitor.kt

@@ -22,6 +22,8 @@ internal interface AdvancedRumMonitor : RumMonitor, AdvancedNetworkRumMonitor {
 
     fun resetSession()
 
+    fun start()
+
     fun sendWebViewEvent()
 
     fun addLongTask(durationNs: Long, target: String)

features/dd-sdk-android-rum/src/main/kotlin/com/datadog/android/rum/internal/monitor/DatadogRumMonitor.kt

@@ -6,6 +6,7 @@
 
 package com.datadog.android.rum.internal.monitor
 
+import android.app.ActivityManager
 import android.os.Handler
 import com.datadog.android.api.InternalLogger
 import com.datadog.android.api.feature.Feature
@@ -14,6 +15,7 @@ import com.datadog.android.core.InternalSdkCore
 import com.datadog.android.core.internal.net.FirstPartyHostHeaderTypeResolver
 import com.datadog.android.core.internal.utils.loggableStackTrace
 import com.datadog.android.core.internal.utils.submitSafe
+import com.datadog.android.rum.DdRumContentProvider
 import com.datadog.android.rum.RumActionType
 import com.datadog.android.rum.RumAttributes
 import com.datadog.android.rum.RumErrorSource
@@ -23,7 +25,9 @@ import com.datadog.android.rum.RumResourceKind
 import com.datadog.android.rum.RumResourceMethod
 import com.datadog.android.rum.RumSessionListener
 import com.datadog.android.rum._RumInternalProxy
+import com.datadog.android.rum.internal.AppStartTimeProvider
 import com.datadog.android.rum.internal.CombinedRumSessionListener
+import com.datadog.android.rum.internal.DefaultAppStartTimeProvider
 import com.datadog.android.rum.internal.RumErrorSourceType
 import com.datadog.android.rum.internal.RumFeature
 import com.datadog.android.rum.internal.debug.RumDebugListener
@@ -66,6 +70,7 @@ internal class DatadogRumMonitor(
     memoryVitalMonitor: VitalMonitor,
     frameRateVitalMonitor: VitalMonitor,
     sessionListener: RumSessionListener,
+    private val appStartTimeProvider: AppStartTimeProvider = DefaultAppStartTimeProvider(),
     private val executorService: ExecutorService = Executors.newSingleThreadExecutor()
 ) : RumMonitor, AdvancedRumMonitor {
 
@@ -397,6 +402,16 @@ internal class DatadogRumMonitor(
         )
     }
 
+    override fun start() {
+        val processImportance = DdRumContentProvider.processImportance
+        val isAppInForeground = processImportance ==
+                ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND
+        val processStartTimeNs = appStartTimeProvider.appStartTimeNs
+        handleEvent(
+            RumRawEvent.SdkInit(isAppInForeground, processStartTimeNs)
+        )
+    }
+
     override fun waitForResourceTiming(key: String) {
         handleEvent(
             RumRawEvent.WaitForResourceTiming(key)

features/dd-sdk-android-rum/src/test/kotlin/com/datadog/android/rum/RumTest.kt

@@ -8,6 +8,7 @@ package com.datadog.android.rum
 
 import android.os.Looper
 import com.datadog.android.api.InternalLogger
+import com.datadog.android.api.feature.Feature
 import com.datadog.android.api.feature.FeatureSdkCore
 import com.datadog.android.core.InternalSdkCore
 import com.datadog.android.core.sampling.RateBasedSampler
@@ -197,6 +198,27 @@ internal class RumTest {
         check(GlobalRumMonitor.get(mockSdkCore) is NoOpRumMonitor)
     }
 
+    @Test
+    fun `𝕄 register nothing 𝕎 build() { RUM feature already registered }`(
+        @Forgery fakeRumConfiguration: RumConfiguration
+    ) {
+        // Given
+        val mockInternalLogger = mock<InternalLogger>()
+        whenever(mockSdkCore.internalLogger) doReturn mockInternalLogger
+        whenever(mockSdkCore.getFeature(Feature.RUM_FEATURE_NAME)) doReturn mock()
+
+        // When
+        Rum.enable(fakeRumConfiguration, mockSdkCore)
+
+        // Then
+        mockInternalLogger.verifyLog(
+            InternalLogger.Level.WARN,
+            InternalLogger.Target.USER,
+            Rum.RUM_FEATURE_ALREADY_ENABLED
+        )
+        verify(mockSdkCore, never()).registerFeature(any())
+    }
+
     companion object {
         private val mainLooper = MainLooperTestConfiguration()