initialization report (#1178)

* initialization report

Signed-off-by: Tomas Chladek <[email protected]>

* Test fix

Signed-off-by: Tomas Chladek <[email protected]>

* Fix startup timing

Signed-off-by: Tomas Chladek <[email protected]>

---------

Signed-off-by: Tomas Chladek <[email protected]>

Author: TomasChladekSL

.run/Format code.run.xml

@@ -18,6 +18,7 @@
     <ExternalSystemDebugServerProcess>true</ExternalSystemDebugServerProcess>
     <ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
     <DebugAllEnabled>false</DebugAllEnabled>
+    <RunAsTest>false</RunAsTest>
     <method v="2" />
   </configuration>
 </component>

app/src/main/java/com/splunk/app/App.kt

@@ -22,7 +22,7 @@ import com.splunk.rum.integration.agent.api.AgentConfiguration
 import com.splunk.rum.integration.agent.api.SplunkRUMAgent
 import com.splunk.rum.integration.interactions.InteractionsModuleConfiguration
 import com.splunk.rum.integration.navigation.NavigationModuleConfiguration
-import com.splunk.rum.integration.sessionreplay.api.sessionReplay
+import com.splunk.rum.integration.sessionreplay.extension.sessionReplay
 import java.net.URL
 
 class App : Application() {

common/otel/src/main/java/com/splunk/sdk/common/otel/logRecord/AndroidLogRecordExporter.kt

@@ -17,6 +17,7 @@
 package com.splunk.sdk.common.otel.logRecord
 
 import com.splunk.sdk.common.otel.OpenTelemetry
+import com.splunk.sdk.common.otel.internal.RumConstants
 import io.opentelemetry.api.common.AttributeKey
 import io.opentelemetry.api.trace.Span
 import io.opentelemetry.api.trace.SpanKind
@@ -37,7 +38,7 @@ internal class AndroidLogRecordExporter : LogRecordExporter {
              val activeSpan = Span.fromContextOrNull(parentContext)
 
             // traceId and spanId should be inside the context already from global OTel instance
-            val spanBuilder = OpenTelemetry.instance!!.sdkTracerProvider.get("SplunkRum")
+            val spanBuilder = OpenTelemetry.instance!!.sdkTracerProvider.get(RumConstants.RUM_TRACER_NAME)
                 .spanBuilder(log.attributes[AttributeKey.stringKey("event.name")] ?: "")
                 .setSpanKind(SpanKind.INTERNAL)
                 .setParent(parentContext)

instrumentation/runtime/startup/src/main/java/com/splunk/rum/startup/ApplicationStartupTimekeeper.kt

@@ -21,6 +21,7 @@ import android.app.Application
 import android.os.Bundle
 import android.os.Handler
 import android.os.Looper
+import android.os.SystemClock
 import com.cisco.android.common.utils.adapters.ActivityLifecycleCallbacksAdapter
 import com.cisco.android.common.utils.extensions.forEachFast
 
@@ -29,6 +30,8 @@ object ApplicationStartupTimekeeper {
     private val handler = Handler(Looper.getMainLooper())
 
     private var firstTimestamp = 0L
+    private var firstElapsed = 0L
+
     private var isColdStartCompleted = false
 
     var isEnabled = true
@@ -37,16 +40,17 @@ object ApplicationStartupTimekeeper {
 
     internal fun onInit() {
         firstTimestamp = System.currentTimeMillis()
+        firstElapsed = SystemClock.elapsedRealtime()
     }
 
     internal fun onCreate(application: Application) {
         handler.twoConsecutivePosts {
             isColdStartCompleted = true
 
             if (isEnabled) {
-                val endTimestamp = System.currentTimeMillis()
-                val duration = endTimestamp - firstTimestamp
-                listeners.forEachFast { it.onColdStarted(firstTimestamp, endTimestamp, duration) }
+                val endElapsed = SystemClock.elapsedRealtime()
+                val duration = endElapsed - firstElapsed
+                listeners.forEachFast { it.onColdStarted(firstTimestamp, firstTimestamp + duration, duration) }
             }
         }
 
@@ -60,16 +64,19 @@ object ApplicationStartupTimekeeper {
         private var resumedActivityCount = 0
 
         private var firstActivityCreateTimestamp = 0L
+        private var firstActivityCreateElapsed = 0L
         private var isWarmStartPending = false
 
         private var firstActivityStartTimestamp = 0L
+        private var firstActivityStartElapsed = 0L
         private var isHotStartPending = false
 
         override fun onActivityPreCreated(activity: Activity, savedInstanceState: Bundle?) {
             createdActivityCount++
 
             if (isColdStartCompleted && createdActivityCount == 1) {
                 firstActivityCreateTimestamp = System.currentTimeMillis()
+                firstActivityCreateElapsed = SystemClock.elapsedRealtime()
                 isWarmStartPending = true
             }
         }
@@ -79,6 +86,7 @@ object ApplicationStartupTimekeeper {
 
             if (isColdStartCompleted && !isWarmStartPending && !isHotStartPending) {
                 firstActivityStartTimestamp = System.currentTimeMillis()
+                firstActivityStartElapsed = SystemClock.elapsedRealtime()
                 isHotStartPending = true
             }
         }
@@ -88,21 +96,21 @@ object ApplicationStartupTimekeeper {
 
             if (resumedActivityCount == 1 && (isHotStartPending || isWarmStartPending))
                 handler.twoConsecutivePosts {
-                    val endTimestamp = System.currentTimeMillis()
+                    val endTimestamp = SystemClock.elapsedRealtime()
 
                     if (isHotStartPending) {
                         if (isEnabled) {
-                            val duration = endTimestamp - firstActivityStartTimestamp
-                            listeners.forEachFast { it.onHotStarted(firstActivityStartTimestamp, endTimestamp, duration) }
+                            val duration = endTimestamp - firstActivityStartElapsed
+                            listeners.forEachFast { it.onHotStarted(firstActivityStartTimestamp, firstActivityStartTimestamp + duration, duration) }
                         }
 
                         isHotStartPending = false
                     }
 
                     if (isWarmStartPending) {
                         if (isEnabled) {
-                            val duration = endTimestamp - firstActivityCreateTimestamp
-                            listeners.forEachFast { it.onWarmStarted(firstActivityCreateTimestamp, endTimestamp, duration) }
+                            val duration = endTimestamp - firstActivityCreateElapsed
+                            listeners.forEachFast { it.onWarmStarted(firstActivityCreateTimestamp, firstActivityCreateTimestamp + duration, duration) }
                         }
 
                         isWarmStartPending = false

integration/agent/api/src/test/java/com/splunk/rum/integration/agent/api/JavaIntegration.java

@@ -20,8 +20,14 @@
 
 import com.splunk.rum.integration.agent.module.ModuleConfiguration;
 
+import org.jetbrains.annotations.NotNull;
+
 import java.net.MalformedURLException;
 import java.net.URL;
+import java.util.ArrayList;
+import java.util.List;
+
+import kotlin.Pair;
 
 public class JavaIntegration extends Application {
 
@@ -45,5 +51,19 @@ public void onCreate() {
     }
 
     private static class CustomModuleConfiguration implements ModuleConfiguration {
+
+        @NotNull
+        @Override
+        public String getName() {
+            return "test";
+        }
+
+        @NotNull
+        @Override
+        public List<Pair<String, String>> getAttributes() {
+            ArrayList<Pair<String, String>> attributes = new ArrayList<>();
+            attributes.add(new Pair<>("enabled", "true"));
+            return attributes;
+        }
     }
 }

integration/agent/internal/src/main/java/com/splunk/rum/integration/agent/internal/AgentIntegration.kt

@@ -17,25 +17,36 @@
 package com.splunk.rum.integration.agent.internal
 
 import android.content.Context
+import android.os.SystemClock
 import com.cisco.android.common.logger.Logger
 import com.cisco.android.common.utils.extensions.forEachFast
 import com.splunk.rum.integration.agent.internal.config.ModuleConfigurationManager
 import com.splunk.rum.integration.agent.internal.session.SessionManager
 import com.splunk.rum.integration.agent.module.ModuleConfiguration
+import com.splunk.rum.integration.agent.module.extension.toSplunkString
+import com.splunk.sdk.common.otel.OpenTelemetry
+import com.splunk.sdk.common.otel.internal.RumConstants
 import com.splunk.sdk.common.storage.AgentStorage
+import java.util.concurrent.TimeUnit
 
 class AgentIntegration private constructor(
     context: Context
 ) {
     private var appName: String? = null
     private var agentVersion: String? = null
 
+    private var startTimestamp = 0L
+    private var startElapsed = 0L
+
     val sessionManager: SessionManager
     val moduleConfigurationManager: ModuleConfigurationManager
     val listeners: MutableSet<Listener> = HashSet()
 
     init {
-        registerModule(MODULE_NAME)
+        startTimestamp = System.currentTimeMillis()
+        startElapsed = SystemClock.elapsedRealtime()
+
+        registerModuleInitializationStart(MODULE_NAME)
 
         val storage = AgentStorage.attach(context)
 
@@ -51,6 +62,11 @@ class AgentIntegration private constructor(
         this.appName = appName
         this.agentVersion = agentVersion
 
+        for (config in moduleConfigurations) {
+            val module = modules[config.name] ?: Module(config.name)
+            modules[config.name] = module.copy(configuration = config)
+        }
+
         moduleConfigurationManager.setup(moduleConfigurations)
 
         return this
@@ -59,6 +75,35 @@ class AgentIntegration private constructor(
     fun install(context: Context) {
         sessionManager.install(context)
         listeners.forEachFast { it.onInstall(context) }
+
+        registerModuleInitializationEnd(MODULE_NAME)
+        reportInitialization()
+    }
+
+    private fun reportInitialization() {
+        val provider = OpenTelemetry.instance?.sdkTracerProvider ?: throw IllegalStateException("unable to report initialization")
+        val modules = modules.values
+
+        val span = provider.get(RumConstants.RUM_TRACER_NAME)
+            .spanBuilder("SplunkRum.initialize")
+            .setStartTimestamp(startTimestamp + SystemClock.elapsedRealtime() - startElapsed, TimeUnit.MILLISECONDS)
+            .startSpan()
+
+        val resources = modules.joinToString(",", "[", "]") { it.configuration?.toSplunkString() ?: "${it.name}.enabled:true" }
+
+        span.setAttribute("config_settings", resources)
+
+        for (module in modules) {
+            if (module.initialization == null)
+                throw IllegalStateException("Module '${module.name}' initialization has not been started")
+
+            if (module.initialization.endElapsed == null)
+                throw IllegalStateException("Module '${module.name}' is not initialized")
+
+            span.addEvent("${module.name}_initialized", module.initialization.run { endElapsed!! - startElapsed }, TimeUnit.MILLISECONDS)
+        }
+
+        span.end()
     }
 
     private inner class SessionManagerListener : SessionManager.SessionListener {
@@ -72,14 +117,26 @@ class AgentIntegration private constructor(
         fun onInstall(context: Context)
     }
 
+    private data class Module(
+        val name: String,
+        val configuration: ModuleConfiguration? = null,
+        val initialization: Initialization? = null
+    ) {
+        data class Initialization(
+            val startTimestamp: Long,
+            val startElapsed: Long,
+            val endElapsed: Long?
+        )
+    }
+
     companion object {
 
         private const val TAG = "AgentIntegration"
 
         private const val MODULE_NAME = "agent"
 
         private var instanceInternal: AgentIntegration? = null
-        private val moduleNames = HashSet<String>()
+        private val modules = HashMap<String, Module>()
 
         val instance: AgentIntegration
             get() = instanceInternal ?: throw IllegalStateException("Instance is not created, call createInstance() first")
@@ -91,8 +148,32 @@ class AgentIntegration private constructor(
             return instanceInternal!!
         }
 
-        fun registerModule(name: String) {
-            moduleNames += name
+        fun registerModuleInitializationStart(name: String) {
+            val module = modules[name] ?: Module(name)
+
+            if (module.initialization != null)
+                throw IllegalStateException()
+
+            modules[name] = module.copy(
+                initialization = Module.Initialization(
+                    startTimestamp = System.currentTimeMillis(),
+                    startElapsed = SystemClock.elapsedRealtime(),
+                    endElapsed = null
+                )
+            )
+        }
+
+        fun registerModuleInitializationEnd(name: String) {
+            val module = modules[name] ?: throw IllegalStateException("Initialization start for module '$name' was not called")
+
+            if (module.initialization == null)
+                throw IllegalStateException("Function registerModuleInitializationStart() for module '$name' was not called")
+
+            modules[name] = module.copy(
+                initialization = module.initialization.copy(
+                    endElapsed = SystemClock.elapsedRealtime()
+                )
+            )
         }
     }
 }

integration/agent/module/src/main/java/com/splunk/rum/integration/agent/module/ModuleConfiguration.kt

@@ -16,4 +16,8 @@
 
 package com.splunk.rum.integration.agent.module
 
-interface ModuleConfiguration
+interface ModuleConfiguration {
+
+    val name: String
+    val attributes: List<Pair<String, String>>
+}

integration/anr/src/main/java/com/splunk/rum/integration/anr/api/ANRModuleConfiguration.kt renamed to integration/agent/module/src/main/java/com/splunk/rum/integration/agent/module/extension/ModuleConfigurationExt.kt

@@ -14,8 +14,10 @@
  * limitations under the License.
  */
 
-package com.splunk.rum.integration.anr.api
+package com.splunk.rum.integration.agent.module.extension
 
 import com.splunk.rum.integration.agent.module.ModuleConfiguration
 
-class ANRModuleConfiguration : ModuleConfiguration
+fun ModuleConfiguration.toSplunkString(): String {
+    return attributes.joinToString(",") { "$name.${it.first}:${it.second}" }
+}

integration/anr/consumer-rules.pro

@@ -1,5 +1,5 @@
--keep public class com.splunk.rum.integration.anr.installer.ANRInstaller
--keep public class com.splunk.rum.integration.anr.configurer.ANRConfigurer
--keepclassmembers class com.splunk.rum.integration.anr.configurer.ANRConfigurer {
+-keep public class com.splunk.rum.integration.anr.ANRInstaller
+-keep public class com.splunk.rum.integration.anr.ANRConfigurer
+-keepclassmembers class com.splunk.rum.integration.anr.ANRConfigurer {
      public static boolean isANRReportingEnabled;
 }

integration/anr/proguard-rules.pro

@@ -1,6 +1,6 @@
--keep public class com.splunk.rum.integration.anr.installer.ANRInstaller
--keep public class com.splunk.rum.integration.anr.configurer.ANRConfigurer
--keepclassmembers class com.splunk.rum.integration.anr.configurer.ANRConfigurer {
+-keep public class com.splunk.rum.integration.anr.ANRInstaller
+-keep public class com.splunk.rum.integration.anr.ANRConfigurer
+-keepclassmembers class com.splunk.rum.integration.anr.ANRConfigurer {
     public static boolean isANRReportingEnabled;
 }
 -repackageclasses 'com.splunk.rum.integration.anr'