EXP-5700: Change from global rollout opt-out to experiments and rollouts separately (#6888)

- Adding db migration from v2 to v3 due to the flag change
- Removing the old set_global_rollout function
- Adding set_experiment and set_rollout functions
- Export four new functions via UDL
	- get_rollouts_user_participation
	- set_rollouts_user_participation
	- get_experiments_user_participation
	- set_experiments_user_participation

Marked `set_global_user_participation` and `get_global_user_participation` as deprecated

Author: gruberb

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "nimbus-sdk"
-version = "0.10.0"
+version = "0.10.1"
 authors = ["The Glean Team <glean-team@mozilla.com>", "The Sync Team <sync-team@mozilla.com>"]
 edition = "2021"
 description = "A rapid experiment library"

components/nimbus/Cargo.toml

@@ -141,11 +141,31 @@ open class Nimbus(
 
     private val nimbusClient: NimbusClientInterface
 
+    override var experimentParticipation: Boolean
+        get() = nimbusClient.getExperimentParticipation()
+        set(active) {
+            dbScope.launch {
+                nimbusClient.setExperimentParticipation(active)
+                applyPendingExperimentsOnThisThread()
+            }
+        }
+
+    override var rolloutParticipation: Boolean
+        get() = nimbusClient.getRolloutParticipation()
+        set(active) {
+            dbScope.launch {
+                nimbusClient.setRolloutParticipation(active)
+                applyPendingExperimentsOnThisThread()
+            }
+        }
+
+    @Deprecated("Use experimentParticipation and rolloutParticipation instead")
     override var globalUserParticipation: Boolean
         get() = nimbusClient.getGlobalUserParticipation()
         set(active) {
             dbScope.launch {
-                setGlobalUserParticipationOnThisThread(active)
+                setExperimentParticipationOnThisThread(active)
+                setRolloutParticipationOnThisThread(active)
             }
         }
 
@@ -400,13 +420,37 @@ open class Nimbus(
 
     @WorkerThread
     @VisibleForTesting(otherwise = VisibleForTesting.PRIVATE)
-    internal fun setGlobalUserParticipationOnThisThread(active: Boolean) = withCatchAll("setGlobalUserParticipation") {
-        val enrolmentChanges = nimbusClient.setGlobalUserParticipation(active)
-        if (enrolmentChanges.isNotEmpty()) {
-            recordExperimentTelemetryEvents(enrolmentChanges)
-            postEnrolmentCalculation()
+    internal fun setExperimentParticipationOnThisThread(active: Boolean) =
+        withCatchAll("setExperimentParticipation") {
+            val enrolmentChanges = nimbusClient.setExperimentParticipation(active)
+            if (enrolmentChanges.isNotEmpty()) {
+                recordExperimentTelemetryEvents(enrolmentChanges)
+                postEnrolmentCalculation()
+            }
+        }
+
+    @WorkerThread
+    @VisibleForTesting(otherwise = VisibleForTesting.PRIVATE)
+    internal fun setRolloutParticipationOnThisThread(active: Boolean) =
+        withCatchAll("setRolloutParticipation") {
+            val enrolmentChanges = nimbusClient.setRolloutParticipation(active)
+            if (enrolmentChanges.isNotEmpty()) {
+                recordExperimentTelemetryEvents(enrolmentChanges)
+                postEnrolmentCalculation()
+            }
+        }
+
+    @Deprecated("Use setExperimentParticipationOnThisThread and setRolloutParticipationOnThisThread instead")
+    @WorkerThread
+    @VisibleForTesting(otherwise = VisibleForTesting.PRIVATE)
+    internal fun setGlobalUserParticipationOnThisThread(active: Boolean) =
+        withCatchAll("setGlobalUserParticipation") {
+            val enrolmentChanges = nimbusClient.setGlobalUserParticipation(active)
+            if (enrolmentChanges.isNotEmpty()) {
+                recordExperimentTelemetryEvents(enrolmentChanges)
+                postEnrolmentCalculation()
+            }
         }
-    }
 
     override fun optOut(experimentId: String) {
         dbScope.launch {

components/nimbus/android/src/main/java/org/mozilla/experiments/nimbus/Nimbus.kt

@@ -198,11 +198,28 @@ interface NimbusInterface : FeaturesInterface, NimbusMessagingInterface, NimbusE
      */
     fun resetTelemetryIdentifiers() = Unit
 
-    /**
-     * Control the opt out for all experiments at once. This is likely a user action.
-     */
+    @Deprecated("Use experimentParticipation and rolloutParticipation instead")
     var globalUserParticipation: Boolean
-        get() = false
+        get() = experimentParticipation && rolloutParticipation
+        set(value) {
+            experimentParticipation = value
+            rolloutParticipation = value
+        }
+
+    /**
+    * Control the opt out for experiments. This is likely a user action.
+    * When set to false, the user will be opted out of all experiments but not rollouts.
+    */
+    var experimentParticipation: Boolean
+        get() = true
+        set(_) = Unit
+
+    /**
+    * Control the opt out for rollouts. This is likely a user action.
+    * When set to false, the user will be opted out of all rollouts but not experiments.
+    */
+    var rolloutParticipation: Boolean
+        get() = true
         set(_) = Unit
 
     override val events: NimbusEventStore

components/nimbus/android/src/main/java/org/mozilla/experiments/nimbus/NimbusInterface.kt

@@ -450,8 +450,8 @@ class NimbusTests {
             NimbusEvents.disqualification.testGetValue(),
         )
 
-        // Opt out of all experiments
-        nimbus.setGlobalUserParticipationOnThisThread(false)
+        // Opt out of experiments but keep rollouts
+        nimbus.setExperimentParticipationOnThisThread(false)
 
         // Use the Glean test API to check that the valid event is present
         assertNotNull("Event must have a value", NimbusEvents.disqualification.testGetValue())

components/nimbus/android/src/test/java/org/mozilla/experiments/nimbus/NimbusTests.kt

@@ -75,6 +75,21 @@ impl Display for NotEnrolledReason {
     }
 }
 
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Participation {
+    pub in_experiments: bool,
+    pub in_rollouts: bool,
+}
+
+impl Default for Participation {
+    fn default() -> Self {
+        Self {
+            in_experiments: true,
+            in_rollouts: true,
+        }
+    }
+}
+
 // These are types we use internally for managing disqualifications.
 
 // ⚠️ Attention : Changes to this type should be accompanied by a new test  ⚠️
@@ -583,7 +598,7 @@ impl<'a> EnrollmentsEvolver<'a> {
 
     pub(crate) fn evolve_enrollments<E>(
         &mut self,
-        is_user_participating: bool,
+        participation: Participation,
         prev_experiments: &[E],
         next_experiments: &[Experiment],
         prev_enrollments: &[ExperimentEnrollment],
@@ -604,7 +619,7 @@ impl<'a> EnrollmentsEvolver<'a> {
         let next_rollouts = filter_experiments(next_experiments, ExperimentMetadata::is_rollout);
 
         let (next_ro_enrollments, ro_events) = self.evolve_enrollment_recipes(
-            is_user_participating,
+            participation.in_rollouts,
             &prev_rollouts,
             &next_rollouts,
             &ro_enrollments,
@@ -628,7 +643,7 @@ impl<'a> EnrollmentsEvolver<'a> {
             .collect();
 
         let (next_exp_enrollments, exp_events) = self.evolve_enrollment_recipes(
-            is_user_participating,
+            participation.in_experiments,
             &prev_experiments,
             &next_experiments,
             &prev_enrollments,

components/nimbus/src/enrollment.rs

@@ -239,10 +239,29 @@ interface NimbusClient {
     [Throws=NimbusError]
     sequence<AvailableExperiment> get_available_experiments();
 
-    /// Getter and setter for user's participation in all experiments.
+    /// Getter and setter for user's participation in experiments only.
     /// Possible values are:
-    /// * `true`: the user will not enroll in new experiments, and opt out of all existing ones.
-    /// * `false`: experiments proceed as usual.
+    /// * `true`: the user will enroll in experiments as usual.
+    /// * `false`: the user will not enroll in new experiments, and opt out of all existing ones.
+    [Throws=NimbusError]
+    boolean get_experiment_participation();
+
+    [Throws=NimbusError]
+    sequence<EnrollmentChangeEvent> set_experiment_participation(boolean opt_in);
+
+    /// Getter and setter for user's participation in rollouts.
+    /// Possible values are:
+    /// * `true`: the user will enroll in rollouts as usual.
+    /// * `false`: the user will not enroll in new rollouts, and opt out of all existing ones.
+    [Throws=NimbusError]
+    boolean get_rollout_participation();
+
+    [Throws=NimbusError]
+    sequence<EnrollmentChangeEvent> set_rollout_participation(boolean opt_in);
+
+    /// DEPRECATED: Use set_experiment_participation and set_rollout_participation instead.
+    /// Getter and setter for global user participation (applies to both experiments and rollouts).
+    /// For simplicity, the getter returns the experiment participation value.
     [Throws=NimbusError]
     boolean get_global_user_participation();
 
@@ -258,7 +277,7 @@ interface NimbusClient {
     /// Toggles the enablement of the fetch. If `false`, then calling `fetch_experiments`
     /// returns immediately, having not done any fetching from remote settings.
     /// This is only useful for QA, and should not be used in production: use
-    /// `set_global_user_participation` instead.
+    /// `set_experiment_participation` or `set_rollout_participation` instead.
     [Throws=NimbusError]
     void set_fetch_enabled(boolean flag);
 

components/nimbus/src/nimbus.udl

@@ -1,6 +1,11 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+use crate::enrollment::Participation;
+use crate::stateful::persistence::{
+    DB_KEY_EXPERIMENT_PARTICIPATION, DB_KEY_ROLLOUT_PARTICIPATION,
+    DEFAULT_EXPERIMENT_PARTICIPATION, DEFAULT_ROLLOUT_PARTICIPATION,
+};
 use crate::{
     enrollment::{
         map_enrollments, EnrollmentChangeEvent, EnrollmentChangeEventType, EnrollmentsEvolver,
@@ -14,9 +19,6 @@ use crate::{
     EnrolledExperiment, EnrollmentStatus, Experiment,
 };
 
-const DB_KEY_GLOBAL_USER_PARTICIPATION: &str = "user-opt-in";
-const DEFAULT_GLOBAL_USER_PARTICIPATION: bool = true;
-
 impl EnrollmentsEvolver<'_> {
     /// Convenient wrapper around `evolve_enrollments` that fetches the current state of experiments,
     /// enrollments and user participation from the database.
@@ -26,15 +28,22 @@ impl EnrollmentsEvolver<'_> {
         writer: &mut Writer,
         next_experiments: &[Experiment],
     ) -> Result<Vec<EnrollmentChangeEvent>> {
-        // Get the state from the db.
-        let is_user_participating = get_global_user_participation(db, writer)?;
+        // Get separate participation states from the db
+        let is_participating_in_experiments = get_experiment_participation(db, writer)?;
+        let is_participating_in_rollouts = get_rollout_participation(db, writer)?;
+
+        let participation = Participation {
+            in_experiments: is_participating_in_experiments,
+            in_rollouts: is_participating_in_rollouts,
+        };
+
         let experiments_store = db.get_store(StoreId::Experiments);
         let enrollments_store = db.get_store(StoreId::Enrollments);
         let prev_experiments: Vec<Experiment> = experiments_store.collect_all(writer)?;
         let prev_enrollments: Vec<ExperimentEnrollment> = enrollments_store.collect_all(writer)?;
         // Calculate the changes.
         let (next_enrollments, enrollments_change_events) = self.evolve_enrollments(
-            is_user_participating,
+            participation,
             &prev_experiments,
             next_experiments,
             &prev_enrollments,
@@ -171,26 +180,41 @@ pub fn unenroll_for_pref(
     Ok(events)
 }
 
-pub fn get_global_user_participation<'r>(
+pub fn get_experiment_participation<'r>(
     db: &Database,
     reader: &'r impl Readable<'r>,
 ) -> Result<bool> {
     let store = db.get_store(StoreId::Meta);
-    let opted_in = store.get::<bool, _>(reader, DB_KEY_GLOBAL_USER_PARTICIPATION)?;
+    let opted_in = store.get::<bool, _>(reader, DB_KEY_EXPERIMENT_PARTICIPATION)?;
+    if let Some(opted_in) = opted_in {
+        Ok(opted_in)
+    } else {
+        Ok(DEFAULT_EXPERIMENT_PARTICIPATION)
+    }
+}
+
+pub fn get_rollout_participation<'r>(db: &Database, reader: &'r impl Readable<'r>) -> Result<bool> {
+    let store = db.get_store(StoreId::Meta);
+    let opted_in = store.get::<bool, _>(reader, DB_KEY_ROLLOUT_PARTICIPATION)?;
     if let Some(opted_in) = opted_in {
         Ok(opted_in)
     } else {
-        Ok(DEFAULT_GLOBAL_USER_PARTICIPATION)
+        Ok(DEFAULT_ROLLOUT_PARTICIPATION)
     }
 }
 
-pub fn set_global_user_participation(
+pub fn set_experiment_participation(
     db: &Database,
     writer: &mut Writer,
     opt_in: bool,
 ) -> Result<()> {
     let store = db.get_store(StoreId::Meta);
-    store.put(writer, DB_KEY_GLOBAL_USER_PARTICIPATION, &opt_in)
+    store.put(writer, DB_KEY_EXPERIMENT_PARTICIPATION, &opt_in)
+}
+
+pub fn set_rollout_participation(db: &Database, writer: &mut Writer, opt_in: bool) -> Result<()> {
+    let store = db.get_store(StoreId::Meta);
+    store.put(writer, DB_KEY_ROLLOUT_PARTICIPATION, &opt_in)
 }
 
 /// Reset unique identifiers in response to application-level telemetry reset.