fix(nimbus): populate config_slug on mobile (#7367)

Author: moibra05

components/nimbus/src/enrollment.rs

@@ -61,7 +61,7 @@ pub enum NotEnrolledReason {
     /// The experiment enrollment is paused.
     EnrollmentsPaused,
     /// The experiment used a feature that was already under experiment.
-    FeatureConflict,
+    FeatureConflict { conflict_slug: Option<String> },
     /// The evaluator bucketing did not choose us.
     NotSelected,
     /// We are not being targeted for this experiment.
@@ -100,7 +100,7 @@ impl Display for NotEnrolledReason {
                 NotEnrolledReason::DifferentAppName => "DifferentAppName",
                 NotEnrolledReason::DifferentChannel => "DifferentChannel",
                 NotEnrolledReason::EnrollmentsPaused => "EnrollmentsPaused",
-                NotEnrolledReason::FeatureConflict => "FeatureConflict",
+                NotEnrolledReason::FeatureConflict { .. } => "FeatureConflict",
                 NotEnrolledReason::NotSelected => "NotSelected",
                 NotEnrolledReason::NotTargeted => "NotTargeted",
                 NotEnrolledReason::ExperimentsOptOut => "ExperimentsOptOut",
@@ -984,10 +984,11 @@ impl<'a> EnrollmentsEvolver<'a> {
 
         for prev_enrollment in prev_enrollments {
             if matches!(
-                prev_enrollment.status,
+                &prev_enrollment.status,
                 EnrollmentStatus::NotEnrolled {
-                    reason: NotEnrolledReason::FeatureConflict
+                    reason: NotEnrolledReason::FeatureConflict { conflict_slug },
                 }
+                if conflict_slug.is_some()
             ) {
                 continue;
             }
@@ -1066,7 +1067,9 @@ impl<'a> EnrollmentsEvolver<'a> {
                     next_enrollments.push(ExperimentEnrollment {
                         slug: slug.clone(),
                         status: EnrollmentStatus::NotEnrolled {
-                            reason: NotEnrolledReason::FeatureConflict,
+                            reason: NotEnrolledReason::FeatureConflict {
+                                conflict_slug: Some(needed_features_in_use[0].slug.clone()),
+                            },
                         },
                     });
 
@@ -1094,10 +1097,11 @@ impl<'a> EnrollmentsEvolver<'a> {
 
             if prev_enrollment.is_none()
                 || matches!(
-                    prev_enrollment.unwrap().status,
+                    &prev_enrollment.unwrap().status,
                     EnrollmentStatus::NotEnrolled {
-                        reason: NotEnrolledReason::FeatureConflict
+                        reason: NotEnrolledReason::FeatureConflict { conflict_slug }
                     }
+                    if conflict_slug.is_some()
                 )
             {
                 let next_enrollment = match self.evolve_enrollment(

components/nimbus/src/metrics.rs

@@ -10,6 +10,7 @@ use crate::enrollment::ExperimentEnrollment;
 use crate::enrollment::PreviousGeckoPrefState;
 pub use crate::metrics::detail::*;
 
+use crate::enrollment::NotEnrolledReason;
 #[derive(Serialize, Deserialize, Clone)]
 #[cfg_attr(test, derive(Debug))]
 pub struct EnrollmentStatusExtraDef {
@@ -31,6 +32,7 @@ impl From<ExperimentEnrollment> for EnrollmentStatusExtraDef {
         let mut branch_value: Option<String> = None;
         let mut reason_value: Option<String> = None;
         let mut error_value: Option<String> = None;
+        let mut conflict_slug_value: Option<String> = None;
         match &enrollment.status {
             EnrollmentStatus::Enrolled { reason, branch, .. } => {
                 branch_value = Some(branch.to_owned());
@@ -42,6 +44,9 @@ impl From<ExperimentEnrollment> for EnrollmentStatusExtraDef {
             }
             EnrollmentStatus::NotEnrolled { reason } => {
                 reason_value = Some(reason.to_string());
+                if let NotEnrolledReason::FeatureConflict { conflict_slug } = reason {
+                    conflict_slug_value = conflict_slug.clone();
+                }
             }
             EnrollmentStatus::WasEnrolled { branch, .. } => branch_value = Some(branch.to_owned()),
             EnrollmentStatus::Error { reason } => {
@@ -50,7 +55,7 @@ impl From<ExperimentEnrollment> for EnrollmentStatusExtraDef {
         }
         EnrollmentStatusExtraDef {
             branch: branch_value,
-            conflict_slug: None,
+            conflict_slug: conflict_slug_value,
             error_string: error_value,
             reason: reason_value,
             slug: Some(enrollment.slug),

components/nimbus/src/stateful/enrollment.rs

@@ -6,7 +6,8 @@ use std::iter;
 
 use crate::enrollment::Participation;
 use crate::enrollment::{
-    EnrollmentChangeEvent, EnrollmentChangeEventType, EnrollmentsEvolver, ExperimentEnrollment,
+    DisqualifiedReason, EnrolledReason, EnrollmentChangeEvent, EnrollmentChangeEventType,
+    EnrollmentsEvolver, ExperimentEnrollment, NotEnrolledReason, PreviousGeckoPrefState,
     map_enrollments,
 };
 use crate::error::{Result, debug, warn};
@@ -295,3 +296,107 @@ pub fn reset_telemetry_identifiers(
     }
     Ok(events)
 }
+
+pub mod v3 {
+    // This module contains legacy enrollment structs that mirror the schema of enrollments stored as they were in the database as of v3. These are used for deserializing pre-migration enrollments during the migration process, and should not be used outside of that context.
+
+    use super::*;
+    use serde::{Deserialize, Serialize};
+
+    #[derive(Deserialize, Serialize, Debug, Clone, Hash, Eq, PartialEq)]
+    pub enum LegacyNotEnrolledReason {
+        DifferentAppName,
+        DifferentChannel,
+        EnrollmentsPaused,
+        FeatureConflict,
+        NotSelected,
+        NotTargeted,
+        OptOut,
+    }
+
+    #[derive(Deserialize, Serialize, Debug, Clone, PartialEq, Eq)]
+    pub struct LegacyExperimentEnrollment {
+        pub slug: String,
+        pub status: LegacyEnrollmentStatus,
+    }
+
+    #[derive(Deserialize, Serialize, Debug, Clone, Hash, Eq, PartialEq)]
+    pub enum LegacyEnrollmentStatus {
+        Enrolled {
+            reason: EnrolledReason,
+            branch: String,
+            #[serde(skip_serializing_if = "Option::is_none")]
+            prev_gecko_pref_states: Option<Vec<PreviousGeckoPrefState>>,
+        },
+        NotEnrolled {
+            reason: LegacyNotEnrolledReason,
+        },
+        Disqualified {
+            reason: DisqualifiedReason,
+            branch: String,
+        },
+        WasEnrolled {
+            branch: String,
+            experiment_ended_at: u64,
+        },
+        Error {
+            reason: String,
+        },
+    }
+
+    impl From<LegacyNotEnrolledReason> for NotEnrolledReason {
+        #[allow(deprecated)]
+        fn from(value: LegacyNotEnrolledReason) -> Self {
+            match value {
+                LegacyNotEnrolledReason::DifferentAppName => NotEnrolledReason::DifferentAppName,
+                LegacyNotEnrolledReason::DifferentChannel => NotEnrolledReason::DifferentChannel,
+                LegacyNotEnrolledReason::EnrollmentsPaused => NotEnrolledReason::EnrollmentsPaused,
+                LegacyNotEnrolledReason::FeatureConflict => NotEnrolledReason::FeatureConflict {
+                    conflict_slug: None,
+                },
+                LegacyNotEnrolledReason::NotSelected => NotEnrolledReason::NotSelected,
+                LegacyNotEnrolledReason::NotTargeted => NotEnrolledReason::NotTargeted,
+                LegacyNotEnrolledReason::OptOut => NotEnrolledReason::OptOut,
+            }
+        }
+    }
+
+    impl From<LegacyEnrollmentStatus> for EnrollmentStatus {
+        fn from(value: LegacyEnrollmentStatus) -> Self {
+            match value {
+                LegacyEnrollmentStatus::Enrolled {
+                    reason,
+                    branch,
+                    prev_gecko_pref_states,
+                } => EnrollmentStatus::Enrolled {
+                    reason,
+                    branch,
+                    prev_gecko_pref_states,
+                },
+                LegacyEnrollmentStatus::NotEnrolled { reason } => EnrollmentStatus::NotEnrolled {
+                    reason: reason.into(),
+                },
+                LegacyEnrollmentStatus::Disqualified { reason, branch } => {
+                    EnrollmentStatus::Disqualified { reason, branch }
+                }
+                LegacyEnrollmentStatus::WasEnrolled {
+                    branch,
+                    experiment_ended_at,
+                } => EnrollmentStatus::WasEnrolled {
+                    branch,
+                    experiment_ended_at,
+                },
+                LegacyEnrollmentStatus::Error { reason } => EnrollmentStatus::Error { reason },
+            }
+        }
+    }
+
+    impl From<LegacyExperimentEnrollment> for ExperimentEnrollment {
+        fn from(value: LegacyExperimentEnrollment) -> Self {
+            ExperimentEnrollment {
+                slug: value.slug,
+                status: value.status.into(),
+            }
+        }
+    }
+}

components/nimbus/src/stateful/persistence.rs

@@ -10,8 +10,10 @@ use std::fs;
 use std::path::Path;
 use std::sync::Arc;
 
+use crate::enrollment::ExperimentEnrollment;
 use crate::error::{ErrorCode, NimbusError, Result, debug, info, warn};
 use crate::metrics::{DatabaseLoadExtraDef, DatabaseMigrationExtraDef, MetricsHandler};
+use crate::stateful::enrollment::v3;
 
 // This uses the lmdb backend for rkv, which is unstable.
 // We use it for now since glean didn't seem to have trouble with it (although
@@ -27,7 +29,7 @@ use crate::metrics::{DatabaseLoadExtraDef, DatabaseMigrationExtraDef, MetricsHan
 pub(crate) const DB_KEY_DB_VERSION: &str = "db_version";
 
 /// The current database version.
-pub(crate) const DB_VERSION: u16 = 3;
+pub(crate) const DB_VERSION: u16 = 4;
 
 pub(crate) const DB_KEY_DB_WAS_CORRUPT: &str = "db-was-corrupt";
 
@@ -554,6 +556,14 @@ impl Database {
             DatabaseMigrationReason::Upgrade,
         )?;
 
+        self.apply_migration(
+            writer,
+            |writer| self.migrate_v3_to_v4(writer),
+            &mut current_version,
+            4,
+            DatabaseMigrationReason::Upgrade,
+        )?;
+
         Ok(())
     }
 
@@ -677,6 +687,23 @@ impl Database {
         Ok(())
     }
 
+    fn migrate_v3_to_v4(&self, writer: &mut Writer) -> Result<()> {
+        info!("Upgrading from version 3 to version 4");
+
+        let enrollment_store = self.get_store(StoreId::Enrollments);
+        let enrollments: Vec<v3::LegacyExperimentEnrollment> =
+            enrollment_store.try_collect_all(writer)?;
+
+        let enrollments: Vec<ExperimentEnrollment> =
+            enrollments.into_iter().map(Into::into).collect();
+
+        for enrollment in enrollments {
+            enrollment_store.put(writer, &enrollment.slug, &enrollment)?;
+        }
+
+        Ok(())
+    }
+
     /// Gets a Store object, which used with the writer returned by
     /// `self.write()` to update the database in a transaction.
     pub fn get_store(&self, store_id: StoreId) -> &SingleStore {