add enrollment status metric for cirrus

components/nimbus/src/cirrus.udl

@@ -8,12 +8,26 @@ enum NimbusError {
     "UuidError", "InvalidExperimentFormat",
     "InvalidPath", "InternalError", "NoSuchExperiment", "NoSuchBranch",
     "DatabaseNotReady", "VersionParsingError", "TryFromIntError",
-    "ParseIntError", "TransformParameterError", "CirrusError",
+    "ParseIntError", "TransformParameterError", "CirrusError", "UniFFICallbackError"
+};
+
+callback interface MetricsHandler {
+    void record_enrollment_statuses(sequence<EnrollmentStatusExtraDef> enrollment_status_extras);
+};
+
+dictionary EnrollmentStatusExtraDef {
+    string? branch;
+    string? conflict_slug;
+    string? error_string;
+    string? reason;
+    string? slug;
+    string? status;
+    string? user_id;
 };
 
 interface CirrusClient {
     [Throws=NimbusError]
-    constructor(string app_context, optional sequence<string> coenrolling_feature_ids = []);
+    constructor(string app_context, MetricsHandler metrics_handler, optional sequence<string> coenrolling_feature_ids = []);
 
     // Handles an enrollment request string and returns an enrollment response string.
     [Throws=NimbusError]

components/nimbus/src/error.rs

@@ -66,7 +66,6 @@ pub enum NimbusError {
     #[cfg(not(feature = "stateful"))]
     #[error("Error in Cirrus: {0}")]
     CirrusError(#[from] CirrusClientError),
-    #[cfg(feature = "stateful")]
     #[error("UniFFI callback error: {0}")]
     UniFFICallbackError(#[from] uniffi::UnexpectedUniFFICallbackError),
 }

components/nimbus/src/lib.rs

@@ -13,6 +13,7 @@ mod strings;
 mod targeting;
 
 pub mod error;
+pub mod metrics;
 pub mod schema;
 pub mod versioning;
 
@@ -25,7 +26,6 @@ pub use targeting::NimbusTargetingHelper;
 
 cfg_if::cfg_if! {
     if #[cfg(feature = "stateful")] {
-        pub mod metrics;
 
         pub mod stateful;
 

components/nimbus/src/metrics.rs

@@ -16,6 +16,8 @@ pub struct EnrollmentStatusExtraDef {
     pub reason: Option<String>,
     pub slug: Option<String>,
     pub status: Option<String>,
+    #[cfg(not(feature = "stateful"))]
+    pub user_id: Option<String>,
 }
 
 #[cfg(test)]
@@ -43,6 +45,11 @@ impl EnrollmentStatusExtraDef {
     pub fn status(&self) -> &str {
         self.status.as_ref().unwrap()
     }
+
+    #[cfg(not(feature = "stateful"))]
+    pub fn user_id(&self) -> &str {
+        self.user_id.as_ref().unwrap()
+    }
 }
 
 impl From<ExperimentEnrollment> for EnrollmentStatusExtraDef {
@@ -74,6 +81,8 @@ impl From<ExperimentEnrollment> for EnrollmentStatusExtraDef {
             reason: reason_value,
             slug: Some(enrollment.slug),
             status: Some(enrollment.status.name()),
+            #[cfg(not(feature = "stateful"))]
+            user_id: None,
         }
     }
 }

components/nimbus/src/stateful/nimbus_client.rs

@@ -81,7 +81,7 @@ impl NimbusClient {
         db_path: P,
         config: Option<RemoteSettingsConfig>,
         available_randomization_units: AvailableRandomizationUnits,
-        host_metrics: Box<dyn MetricsHandler>,
+        metrics_handler: Box<dyn MetricsHandler>,
     ) -> Result<Self> {
         let settings_client = Mutex::new(create_client(config)?);
 
@@ -99,7 +99,7 @@ impl NimbusClient {
             coenrolling_feature_ids,
             db: OnceCell::default(),
             event_store: Arc::default(),
-            metrics_handler: Arc::new(host_metrics),
+            metrics_handler: Arc::new(metrics_handler),
         })
     }
 

components/nimbus/src/stateless/cirrus_client.rs

@@ -8,14 +8,15 @@ use crate::{
         EnrollmentsEvolver, ExperimentEnrollment,
     },
     error::CirrusClientError,
+    metrics::{EnrollmentStatusExtraDef, MetricsHandler},
     parse_experiments, AppContext, AvailableRandomizationUnits, Experiment, NimbusError,
     NimbusTargetingHelper, Result, TargetingAttributes,
 };
 use serde_derive::*;
 use serde_json::{Map, Value};
 use std::collections::HashMap;
 use std::fmt;
-use std::sync::Mutex;
+use std::sync::{Arc, Mutex};
 
 /// EnrollmentResponse is a DTO for the response from handling enrollment for a given client.
 ///
@@ -76,20 +77,25 @@ pub struct CirrusMutableState {
     experiments: Vec<Experiment>,
 }
 
-#[derive(Default)]
 pub struct CirrusClient {
     app_context: AppContext,
     coenrolling_feature_ids: Vec<String>,
     state: Mutex<CirrusMutableState>,
+    metrics_handler: Arc<Box<dyn MetricsHandler>>,
 }
 
 impl CirrusClient {
-    pub fn new(app_context: String, coenrolling_feature_ids: Vec<String>) -> Result<Self> {
+    pub fn new(
+        app_context: String,
+        metrics_handler: Box<dyn MetricsHandler>,
+        coenrolling_feature_ids: Vec<String>,
+    ) -> Result<Self> {
         let app_context: AppContext = serde_json::from_str(&app_context)?;
         Ok(Self {
             app_context,
             coenrolling_feature_ids,
             state: Default::default(),
+            metrics_handler: Arc::new(metrics_handler),
         })
     }
 
@@ -151,6 +157,18 @@ impl CirrusClient {
                 prev_enrollments,
             )?;
 
+        self.metrics_handler.record_enrollment_statuses(
+            enrollments
+                .iter()
+                .cloned()
+                .map(|e| {
+                    let mut extra: EnrollmentStatusExtraDef = e.into();
+                    extra.user_id = Some(user_id.clone());
+                    extra
+                })
+                .collect(),
+        );
+
         let enrolled_feature_config_map =
             map_features_by_feature_id(&enrollments, &state.experiments, &coenrolling_ids);
 

components/nimbus/src/tests/helpers.rs

@@ -2,21 +2,20 @@
 * 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::{
-    EnrolledFeatureConfig, EnrolledReason, ExperimentEnrollment, NotEnrolledReason,
-};
 use crate::{
+    enrollment::{EnrolledFeatureConfig, EnrolledReason, ExperimentEnrollment, NotEnrolledReason},
+    metrics::{EnrollmentStatusExtraDef, MetricsHandler},
     AppContext, EnrollmentStatus, Experiment, FeatureConfig, NimbusTargetingHelper,
     TargetingAttributes,
 };
 use serde::Serialize;
 use serde_json::{json, Value};
-use std::collections::HashSet;
+use std::collections::{HashMap, HashSet};
+use std::sync::{Arc, Mutex};
 
 cfg_if::cfg_if! {
     if #[cfg(feature = "stateful")] {
         use crate::stateful::behavior::EventStore;
-        use std::sync::{Arc, Mutex};
     }
 }
 
@@ -48,6 +47,53 @@ impl Default for NimbusTargetingHelper {
     }
 }
 
+/// A Rust implementation of the MetricsHandler trait
+/// Used to test recording of Glean metrics across the FFI within Rust
+///
+/// *NOTE: Use this struct's `new` method when instantiating it to lock the Glean store*
+#[derive(Clone)]
+pub struct TestMetrics {
+    state: Arc<Mutex<HashMap<String, serde_json::Value>>>,
+}
+
+impl TestMetrics {
+    pub fn new() -> Self {
+        TestMetrics {
+            state: Default::default(),
+        }
+    }
+
+    pub fn assert_get_vec_value(&self, key: &str) -> serde_json::Value {
+        self.state.lock().unwrap().get(key).unwrap().clone()
+    }
+}
+
+impl MetricsHandler for TestMetrics {
+    /// In actual implementations of the MetricsHandler trait, this method would record the
+    /// supplied EnrollmentStatusExtraDefs into Glean.
+    ///
+    /// This implementation is explicitly used for testing, and does the following:
+    /// 1. It locks the TestMetrics instance's state
+    /// 2. It looks up the key for `enrollment_status` in the state, extends it if it already
+    ///    exists and inserts it if it does not exist.
+    ///
+    /// This then allows for us to use the `assert_get_vec_value` method above in tests to fetch the
+    /// list of metrics that have been recorded during a given test.
+    fn record_enrollment_statuses(&self, enrollment_status_extras: Vec<EnrollmentStatusExtraDef>) {
+        let key = "enrollment_status".to_string();
+        let mut state = self.state.lock().unwrap();
+        let new = serde_json::to_value(enrollment_status_extras).unwrap();
+        state
+            .entry(key)
+            .and_modify(|v| {
+                v.as_array_mut()
+                    .unwrap()
+                    .extend(new.as_array().unwrap().iter().cloned());
+            })
+            .or_insert(new);
+    }
+}
+
 pub(crate) fn get_test_experiments() -> Vec<Experiment> {
     vec![
         serde_json::from_value(json!({

components/nimbus/src/tests/mod.rs

@@ -14,7 +14,6 @@ mod test_versioning;
 
 #[cfg(feature = "stateful")]
 mod stateful {
-    mod helpers;
     mod test_behavior;
     mod test_enrollment;
     mod test_evaluator;

components/nimbus/src/tests/stateful/client/test_null_client.rs

@@ -6,7 +6,7 @@
 #![allow(unused_imports)]
 
 use crate::error::Result;
-use crate::tests::stateful::helpers::TestMetrics;
+use crate::tests::helpers::TestMetrics;
 
 #[cfg(feature = "rkv-safe-mode")]
 #[test]

components/nimbus/src/tests/stateful/test_nimbus.rs

@@ -13,12 +13,9 @@ use crate::{
         },
         persistence::{Database, StoreId},
     },
-    tests::{
-        helpers::{
-            get_bucketed_rollout, get_ios_rollout_experiment, get_targeted_experiment,
-            to_local_experiments_string,
-        },
-        stateful::helpers::TestMetrics,
+    tests::helpers::{
+        get_bucketed_rollout, get_ios_rollout_experiment, get_targeted_experiment,
+        to_local_experiments_string, TestMetrics,
     },
     AppContext, AvailableRandomizationUnits, Experiment, NimbusClient, TargetingAttributes,
     DB_KEY_APP_VERSION, DB_KEY_UPDATE_DATE,