Technical Analytics: Milestone 2 - Add Ability To Log Feature Flags

domain/src/main/java/org/oppia/android/domain/oppialogger/LoggingIdentifierController.kt

@@ -17,6 +17,7 @@ import javax.inject.Inject
 import javax.inject.Singleton
 
 private const val SESSION_ID_DATA_PROVIDER_ID = "LoggingIdentifierController.session_id"
+private const val APP_SESSION_ID_DATA_PROVIDER_ID = "LoggingIdentifierController.app_session_id"
 private const val INSTALLATION_ID_DATA_PROVIDER_ID = "LoggingIdentifierController.installation_id"
 
 /** Controller that handles logging identifiers related operations. */
@@ -34,14 +35,22 @@ class LoggingIdentifierController @Inject constructor(
   private val installationRandomSeed = baseRandom.nextLong()
   private val sessionRandomSeed = baseRandom.nextLong()
   private val learnerRandomSeed = baseRandom.nextLong()
+  private val appSessionRandomSeed = baseRandom.nextLong()
   private val installationIdRandom by lazy { Random(installationRandomSeed) }
   private val sessionIdRandom by lazy { Random(sessionRandomSeed) }
   private val learnerIdRandom by lazy { Random(learnerRandomSeed) }
+  private val appSessionIdRandom by lazy { Random(appSessionRandomSeed) }
 
   private val sessionId by lazy { MutableStateFlow(computeSessionId()) }
+  private val appSessionId by lazy { MutableStateFlow(computeAppSessionId()) }
   private val sessionIdDataProvider by lazy {
     dataProviders.run { sessionId.convertToAutomaticDataProvider(SESSION_ID_DATA_PROVIDER_ID) }
   }
+  private val appSessionIdDataProvider by lazy {
+    dataProviders.run {
+      appSessionId.convertToAutomaticDataProvider(APP_SESSION_ID_DATA_PROVIDER_ID)
+    }
+  }
   private val installationIdStore by lazy {
     persistentCacheStoreFactory.create(
       cacheName = "device_context_database", DeviceContextDatabase.getDefaultInstance()
@@ -101,6 +110,14 @@ class LoggingIdentifierController @Inject constructor(
    */
   fun getSessionId(): DataProvider<String> = sessionIdDataProvider
 
+  /**
+   * Returns an in-memory data provider pointing to a class variable of [appSessionId].
+   *
+   * This ID is unique to each app session. A session starts when the app is opened and ends when
+   * the app is destroyed by the Android system.
+   */
+  fun getAppSessionId(): DataProvider<String> = appSessionIdDataProvider
+
   /**
    * Returns the [StateFlow] backing the current session ID indicated by [getSessionId].
    *
@@ -110,6 +127,15 @@ class LoggingIdentifierController @Inject constructor(
    */
   fun getSessionIdFlow(): StateFlow<String> = sessionId
 
+  /**
+   * Returns the [StateFlow] backing the current app session ID indicated by [getAppSessionId].
+   *
+   * Where the [DataProvider] returned by [getAppSessionId] can be composed by domain controllers or
+   * observed by the UI layer, the [StateFlow] returned by this method can be observed in background
+   * contexts.
+   */
+  fun getAppSessionIdFlow(): StateFlow<String> = appSessionId
+
   /**
    * Regenerates [sessionId] and notifies the data provider.
    *
@@ -123,6 +149,8 @@ class LoggingIdentifierController @Inject constructor(
 
   private fun computeSessionId(): String = sessionIdRandom.randomUuid().toString()
 
+  private fun computeAppSessionId(): String = appSessionIdRandom.randomUuid().toString()
+
   private fun computeInstallationId(): String {
     return machineLocale.run {
       MessageDigest.getInstance("SHA-1")

domain/src/main/java/org/oppia/android/domain/oppialogger/analytics/ApplicationLifecycleObserver.kt

@@ -38,6 +38,7 @@ class ApplicationLifecycleObserver @Inject constructor(
   private val profileManagementController: ProfileManagementController,
   private val oppiaLogger: OppiaLogger,
   private val performanceMetricsLogger: PerformanceMetricsLogger,
+  private val featureFlagsLogger: FeatureFlagsLogger,
   private val performanceMetricsController: PerformanceMetricsController,
   private val cpuPerformanceSnapshotter: CpuPerformanceSnapshotter,
   @LearnerAnalyticsInactivityLimitMillis private val inactivityLimitMillis: Long,
@@ -84,6 +85,7 @@ class ApplicationLifecycleObserver @Inject constructor(
     ProcessLifecycleOwner.get().lifecycle.addObserver(this)
     application.registerActivityLifecycleCallbacks(this)
     logApplicationStartupMetrics()
+    logAllFeatureFlags()
     cpuPerformanceSnapshotter.initialiseSnapshotter()
   }
 
@@ -172,6 +174,22 @@ class ApplicationLifecycleObserver @Inject constructor(
     }
   }
 
+  private fun logAllFeatureFlags() {
+    CoroutineScope(backgroundDispatcher).launch {
+      // TODO(#5341): Replace appSessionId generation to the modified Twitter snowflake algorithm.
+      val appSessionId = loggingIdentifierController.getAppSessionIdFlow().value
+      featureFlagsLogger.logAllFeatureFlags(appSessionId)
+    }.invokeOnCompletion { failure ->
+      if (failure != null) {
+        oppiaLogger.e(
+          "ActivityLifecycleObserver",
+          "Encountered error while logging feature flags.",
+          failure
+        )
+      }
+    }
+  }
+
   private fun logAppInForegroundTime() {
     CoroutineScope(backgroundDispatcher).launch {
       val sessionId = loggingIdentifierController.getSessionIdFlow().value

domain/src/main/java/org/oppia/android/domain/oppialogger/analytics/BUILD.bazel

@@ -121,6 +121,7 @@ kt_android_library(
     deps = [
         ":application_lifecycle_listener",
         ":cpu_performance_snapshotter",
+        ":feature_flags_logger",
         ":learner_analytics_inactivity_limit_millis",
         ":performance_metrics_controller",
         "//domain/src/main/java/org/oppia/android/domain/oppialogger:logging_identifier_controller",
@@ -191,6 +192,20 @@ kt_android_library(
     visibility = ["//:oppia_api_visibility"],
 )
 
+kt_android_library(
+    name = "feature_flags_logger",
+    srcs = [
+        "FeatureFlagsLogger.kt",
+    ],
+    visibility = ["//:oppia_api_visibility"],
+    deps = [
+        "//:dagger",
+        "//domain/src/main/java/org/oppia/android/domain/oppialogger:oppia_logger",
+        "//domain/src/main/java/org/oppia/android/domain/oppialogger/analytics:controller",
+        "//third_party:javax_inject_javax_inject",
+    ],
+)
+
 kt_android_library(
     name = "data_controller",
     srcs = [

domain/src/main/java/org/oppia/android/domain/oppialogger/analytics/FeatureFlagsLogger.kt

@@ -0,0 +1,142 @@
+package org.oppia.android.domain.oppialogger.analytics
+
+import org.oppia.android.app.model.EventLog
+import org.oppia.android.app.model.EventLog.FeatureFlagItemContext
+import org.oppia.android.app.model.EventLog.FeatureFlagListContext
+import org.oppia.android.util.platformparameter.APP_AND_OS_DEPRECATION
+import org.oppia.android.util.platformparameter.DOWNLOADS_SUPPORT
+import org.oppia.android.util.platformparameter.EDIT_ACCOUNTS_OPTIONS_UI
+import org.oppia.android.util.platformparameter.ENABLE_NPS_SURVEY
+import org.oppia.android.util.platformparameter.ENABLE_ONBOARDING_FLOW_V2
+import org.oppia.android.util.platformparameter.ENABLE_PERFORMANCE_METRICS_COLLECTION
+import org.oppia.android.util.platformparameter.EXTRA_TOPIC_TABS_UI
+import org.oppia.android.util.platformparameter.EnableAppAndOsDeprecation
+import org.oppia.android.util.platformparameter.EnableDownloadsSupport
+import org.oppia.android.util.platformparameter.EnableEditAccountsOptionsUi
+import org.oppia.android.util.platformparameter.EnableExtraTopicTabsUi
+import org.oppia.android.util.platformparameter.EnableFastLanguageSwitchingInLesson
+import org.oppia.android.util.platformparameter.EnableInteractionConfigChangeStateRetention
+import org.oppia.android.util.platformparameter.EnableLearnerStudyAnalytics
+import org.oppia.android.util.platformparameter.EnableLoggingLearnerStudyIds
+import org.oppia.android.util.platformparameter.EnableNpsSurvey
+import org.oppia.android.util.platformparameter.EnableOnboardingFlowV2
+import org.oppia.android.util.platformparameter.EnablePerformanceMetricsCollection
+import org.oppia.android.util.platformparameter.EnableSpotlightUi
+import org.oppia.android.util.platformparameter.FAST_LANGUAGE_SWITCHING_IN_LESSON
+import org.oppia.android.util.platformparameter.INTERACTION_CONFIG_CHANGE_STATE_RETENTION
+import org.oppia.android.util.platformparameter.LEARNER_STUDY_ANALYTICS
+import org.oppia.android.util.platformparameter.LOGGING_LEARNER_STUDY_IDS
+import org.oppia.android.util.platformparameter.PlatformParameterValue
+import org.oppia.android.util.platformparameter.SPOTLIGHT_UI
+import javax.inject.Inject
+import javax.inject.Singleton
+
+/**
+ * Convenience logger for feature flags.
+ *
+ * This logger is meant to be used for feature flag-related logging on every app launch. It is
+ * primarily used within the ApplicationLifecycleObserver to log the status of feature flags in a
+ * given app session.
+ */
+@Singleton
+class FeatureFlagsLogger @Inject constructor(
+  private val analyticsController: AnalyticsController,
+  @EnableDownloadsSupport
+  private val enableDownloadsSupport: PlatformParameterValue<Boolean>,
+  @EnableExtraTopicTabsUi
+  private val enableExtraTopicTabsUi: PlatformParameterValue<Boolean>,
+  @EnableLearnerStudyAnalytics
+  private val enableLearnerStudyAnalytics: PlatformParameterValue<Boolean>,
+  @EnableFastLanguageSwitchingInLesson
+  private val enableFastLanguageSwitchingInLesson: PlatformParameterValue<Boolean>,
+  @EnableLoggingLearnerStudyIds
+  private val enableLoggingLearnerStudyIds: PlatformParameterValue<Boolean>,
+  @EnableEditAccountsOptionsUi
+  private val enableEditAccountsOptionsUi: PlatformParameterValue<Boolean>,
+  @EnablePerformanceMetricsCollection
+  private val enablePerformanceMetricsCollection: PlatformParameterValue<Boolean>,
+  @EnableSpotlightUi
+  private val enableSpotlightUi: PlatformParameterValue<Boolean>,
+  @EnableInteractionConfigChangeStateRetention
+  private val enableInteractionConfigChangeStateRetention: PlatformParameterValue<Boolean>,
+  @EnableAppAndOsDeprecation
+  private val enableAppAndOsDeprecation: PlatformParameterValue<Boolean>,
+  @EnableNpsSurvey
+  private val enableNpsSurvey: PlatformParameterValue<Boolean>,
+  @EnableOnboardingFlowV2
+  private val enableOnboardingFlowV2: PlatformParameterValue<Boolean>
+) {
+  /**
+   * A variable containing a list of all the feature flags in the app.
+   *
+   * @return a list of key-value pairs of [String] and [PlatformParameterValue]
+   */
+  private var featureFlagItemMap: Map<String, PlatformParameterValue<Boolean>> = mapOf(
+    DOWNLOADS_SUPPORT to enableDownloadsSupport,
+    EXTRA_TOPIC_TABS_UI to enableExtraTopicTabsUi,
+    LEARNER_STUDY_ANALYTICS to enableLearnerStudyAnalytics,
+    FAST_LANGUAGE_SWITCHING_IN_LESSON to enableFastLanguageSwitchingInLesson,
+    LOGGING_LEARNER_STUDY_IDS to enableLoggingLearnerStudyIds,
+    EDIT_ACCOUNTS_OPTIONS_UI to enableEditAccountsOptionsUi,
+    ENABLE_PERFORMANCE_METRICS_COLLECTION to enablePerformanceMetricsCollection,
+    SPOTLIGHT_UI to enableSpotlightUi,
+    INTERACTION_CONFIG_CHANGE_STATE_RETENTION to enableInteractionConfigChangeStateRetention,
+    APP_AND_OS_DEPRECATION to enableAppAndOsDeprecation,
+    ENABLE_NPS_SURVEY to enableNpsSurvey,
+    ENABLE_ONBOARDING_FLOW_V2 to enableOnboardingFlowV2
+  )
+
+  /**
+   * This method can be used to override the featureFlagItemMap and sets its value to the given map.
+   *
+   * @param featureFlagItemMap denotes the map of feature flag names to their corresponding
+   * [PlatformParameterValue]s
+   */
+  fun setFeatureFlagItemMap(featureFlagItemMap: Map<String, PlatformParameterValue<Boolean>>) {
+    this.featureFlagItemMap = featureFlagItemMap
+  }
+
+  /**
+   * This method logs the name, enabled status and sync status of all feature flags to Firebase.
+   *
+   * @param appSessionId denotes the id of the current appInForeground session
+   */
+  fun logAllFeatureFlags(appSessionId: String) {
+    val featureFlagItemList = mutableListOf<FeatureFlagItemContext>()
+    for (flag in featureFlagItemMap) {
+      featureFlagItemList.add(
+        createFeatureFlagItemContext(flag)
+      )
+    }
+
+    // TODO(#5341): Set the UUID value for this context
+    val featureFlagContext = FeatureFlagListContext.newBuilder()
+      .setAppSessionId(appSessionId)
+      .addAllFeatureFlags(featureFlagItemList)
+      .build()
+
+    analyticsController.logLowPriorityEvent(
+      EventLog.Context.newBuilder()
+        .setFeatureFlagListContext(featureFlagContext)
+        .build(),
+      profileId = null
+    )
+  }
+
+  /**
+   * Creates an [EventLog] context for the feature flags to be logged.
+   *
+   * @param flagDetails denotes the key-value pair of the feature flag name and its corresponding
+   * [PlatformParameterValue]
+   * @return an [EventLog.Context] for the feature flags to be logged
+   */
+  private fun createFeatureFlagItemContext(
+    flagDetails: Map.Entry<String, PlatformParameterValue<Boolean>>,
+  ): FeatureFlagItemContext {
+    return FeatureFlagItemContext.newBuilder()
+      .setFlagName(flagDetails.key)
+      .setFlagEnabledState(flagDetails.value.value)
+      .setFlagSyncStatus(flagDetails.value.syncStatus)
+      .build()
+  }
+}

domain/src/test/java/org/oppia/android/domain/oppialogger/LoggingIdentifierControllerTest.kt

@@ -309,6 +309,58 @@ class LoggingIdentifierControllerTest {
     assertThat(sessionIdFlow.value).isEqualTo("59aea8d4-af4b-3249-b889-dfeba06d0495")
   }
 
+  @Test
+  fun testGetAppSessionId_initialState_returnsRandomId() {
+    val appSessionIdProvider = loggingIdentifierController.getAppSessionId()
+
+    val appSessionId = monitorFactory.waitForNextSuccessfulResult(appSessionIdProvider)
+    assertThat(appSessionId).isEqualTo("2a11efe0-70f8-3a40-8d94-4fc3a2bd4f14")
+  }
+
+  @Test
+  fun testGetAppSessionId_secondCall_returnsSameRandomId() {
+    monitorFactory.ensureDataProviderExecutes(loggingIdentifierController.getAppSessionId())
+
+    val sessionIdProvider = loggingIdentifierController.getAppSessionId()
+
+    // The second call should return the same ID (since the ID doesn't automatically change).
+    val appSessionId = monitorFactory.waitForNextSuccessfulResult(sessionIdProvider)
+    assertThat(appSessionId).isEqualTo("2a11efe0-70f8-3a40-8d94-4fc3a2bd4f14")
+  }
+
+  @Test
+  fun testGetAppSessionIdFlow_initialState_returnsFlowWithRandomId() {
+    val appSessionIdFlow = loggingIdentifierController.getAppSessionIdFlow()
+
+    val appSessionId = appSessionIdFlow.waitForLatestValue()
+    assertThat(appSessionId).isEqualTo("2a11efe0-70f8-3a40-8d94-4fc3a2bd4f14")
+  }
+
+  @Test
+  fun testGetAppSessionIdFlow_secondCall_returnsFlowWithSameRandomId() {
+    loggingIdentifierController.getSessionIdFlow().waitForLatestValue()
+
+    val appSessionIdFlow = loggingIdentifierController.getAppSessionIdFlow()
+
+    // The second call should return the same ID (since the ID doesn't automatically change).
+    val appSessionId = appSessionIdFlow.waitForLatestValue()
+    assertThat(appSessionId).isEqualTo("2a11efe0-70f8-3a40-8d94-4fc3a2bd4f14")
+  }
+
+  @Test
+  fun testGetAppSessionId_onSecondAppOpen_returnsDifferentRandomId() {
+    monitorFactory.ensureDataProviderExecutes(loggingIdentifierController.getAppSessionId())
+
+    // Simulate a second app open.
+    TestLoggingIdentifierModule.applicationIdSeed = SECOND_APP_OPEN_APPLICATION_ID
+    setUpNewTestApplicationComponent()
+
+    // The app session ID should be different on the second app open.
+    val appSessionIdProvider = loggingIdentifierController.getAppSessionId()
+    val appSessionId = monitorFactory.waitForNextSuccessfulResult(appSessionIdProvider)
+    assertThat(appSessionId).isEqualTo("c9d50545-33dc-3231-a1db-6a2672498c74")
+  }
+
   private fun <T : MessageLite> writeFileCache(cacheName: String, value: T) {
     getCacheFile(cacheName).writeBytes(value.toByteArray())
   }