fix: exp and config partial apply

Author: ayushjain17

clients/haskell/hs-exp-client/src/Client.hs

@@ -54,10 +54,10 @@ foreign import ccall unsafe "expt_get_applicable_variant"
     c_get_applicable_variants :: Ptr ExpClient -> CString -> CString -> CString -> CString -> IO CString
 
 foreign import ccall unsafe "expt_get_satisfied_experiments"
-    c_get_satisfied_experiments :: Ptr ExpClient -> CString -> CString -> IO CString
+    c_get_satisfied_experiments :: Ptr ExpClient -> CString -> CString -> CString -> IO CString
 
 foreign import ccall unsafe "expt_get_filtered_satisfied_experiments"
-    c_get_filtered_satisfied_experiments :: Ptr ExpClient -> CString -> CString -> IO CString
+    c_get_filtered_satisfied_experiments :: Ptr ExpClient -> CString -> CString -> CString -> IO CString
 
 foreign import ccall unsafe "expt_get_running_experiments"
     c_get_running_experiments :: Ptr ExpClient -> IO CString
@@ -116,29 +116,31 @@ getApplicableVariants client dimensions query identifier mbPrefix = do
                     -- Error s     -> Left s
                     -- Success vec -> Right vec
 
-getSatisfiedExperiments :: ForeignPtr ExpClient -> String -> Maybe String -> IO (Either Error Value)
-getSatisfiedExperiments client query mbPrefix = do
+getSatisfiedExperiments :: ForeignPtr ExpClient -> String -> String -> Maybe String -> IO (Either Error Value)
+getSatisfiedExperiments client dimensions query mbPrefix = do
     context     <- newCString query
+    dimensions  <- newCString dimensions
     prefix <- case mbPrefix of
         Just prefix -> newCString prefix
         Nothing     -> return nullPtr
-    experiments <- withForeignPtr client $ \client -> c_get_satisfied_experiments client context prefix
+    experiments <- withForeignPtr client $ \client -> c_get_satisfied_experiments dimensions client context prefix
     _           <- cleanup [context]
     if experiments == nullPtr
         then Left <$> getError
         else do
             fptrExperiments  <- newForeignPtr c_free_string experiments
             Right . toJSON <$> withForeignPtr fptrExperiments peekCString
 
-getFilteredSatisfiedExperiments :: ForeignPtr ExpClient -> Maybe String -> Maybe String -> IO (Either Error Value)
-getFilteredSatisfiedExperiments client mbFilters mbPrefix = do
+getFilteredSatisfiedExperiments :: ForeignPtr ExpClient -> String -> Maybe String -> Maybe String -> IO (Either Error Value)
+getFilteredSatisfiedExperiments client dimensions mbFilters mbPrefix = do
+    dimensions  <- newCString dimensions
     filters <- case mbFilters of
         Just filters' -> newCString filters'
         Nothing       -> return nullPtr
     prefix <- case mbPrefix of
         Just prefix' -> newCString prefix'
         Nothing      -> return nullPtr
-    experiments <- withForeignPtr client $ \client -> c_get_filtered_satisfied_experiments client filters prefix
+    experiments <- withForeignPtr client $ \client -> c_get_filtered_satisfied_experiments dimensions client filters prefix
     _           <- cleanup [filters]
     if experiments == nullPtr
         then Left <$> getError

clients/haskell/hs-exp-client/src/Main.hs

@@ -24,8 +24,8 @@ main = do
         loopNTimes 0 _ = return ()
         loopNTimes n client = do
             runningExperiments   <- getRunningExperiments client
-            satisfiedExperiments <- getSatisfiedExperiments client "{\"os\": \"android\", \"client\": \"1mg\"}" Nothing
-            filteredExperiments  <- getFilteredSatisfiedExperiments client (Just "{\"os\": \"android\"}") (Just "hyperpay")
+            satisfiedExperiments <- getSatisfiedExperiments client "{}" "{\"os\": \"android\", \"client\": \"1mg\"}" Nothing
+            filteredExperiments  <- getFilteredSatisfiedExperiments client "{}" (Just "{\"os\": \"android\"}") (Just "hyperpay")
             variants             <- getApplicableVariants client "{}" "{\"os\": \"android\", \"client\": \"1mg\"}" "1mg-android" Nothing
             print "Running experiments"
             print runningExperiments

crates/experimentation_client/src/interface.rs

@@ -11,7 +11,10 @@ use std::{
     cell::RefCell,
     ffi::{c_int, CString},
 };
-use superposition_types::DimensionInfo;
+use superposition_types::{
+    logic::{evaluate_local_cohorts, evaluate_local_cohorts_skip_unresolved},
+    DimensionInfo,
+};
 use tokio::{runtime::Runtime, task};
 
 thread_local! {
@@ -216,6 +219,7 @@ pub extern "C" fn expt_get_applicable_variant(
 #[no_mangle]
 pub extern "C" fn expt_get_satisfied_experiments(
     client: *mut Arc<Client>,
+    c_dimensions: *const c_char,
     c_context: *const c_char,
     filter_prefix: *const c_char,
 ) -> *mut c_char {
@@ -227,6 +231,16 @@ pub extern "C" fn expt_get_satisfied_experiments(
         return std::ptr::null_mut()
     );
 
+    let dimensions = unwrap_safe!(
+        cstring_to_rstring(c_dimensions),
+        return std::ptr::null_mut()
+    );
+
+    let dimensions = unwrap_safe!(
+        serde_json::from_str::<HashMap<String, DimensionInfo>>(dimensions.as_str()),
+        return std::ptr::null_mut()
+    );
+
     let prefix_list = if filter_prefix.is_null() {
         None
     } else {
@@ -238,6 +252,11 @@ pub extern "C" fn expt_get_satisfied_experiments(
         Some(prefix_list)
     };
 
+    let context = Value::Object(evaluate_local_cohorts(
+        &dimensions,
+        &context.as_object().cloned().unwrap_or_default(),
+    ));
+
     let local = task::LocalSet::new();
     local.block_on(&Runtime::new().unwrap(), async move {
         unsafe {
@@ -258,6 +277,7 @@ pub extern "C" fn expt_get_satisfied_experiments(
 #[no_mangle]
 pub extern "C" fn expt_get_filtered_satisfied_experiments(
     client: *mut Arc<Client>,
+    c_dimensions: *const c_char,
     c_context: *const c_char,
     filter_prefix: *const c_char,
 ) -> *mut c_char {
@@ -268,6 +288,17 @@ pub extern "C" fn expt_get_filtered_satisfied_experiments(
         serde_json::from_str::<Value>(context.as_str()),
         return std::ptr::null_mut()
     );
+
+    let dimensions = unwrap_safe!(
+        cstring_to_rstring(c_dimensions),
+        return std::ptr::null_mut()
+    );
+
+    let dimensions = unwrap_safe!(
+        serde_json::from_str::<HashMap<String, DimensionInfo>>(dimensions.as_str()),
+        return std::ptr::null_mut()
+    );
+
     let prefix_list = if filter_prefix.is_null() {
         None
     } else {
@@ -280,6 +311,12 @@ pub extern "C" fn expt_get_filtered_satisfied_experiments(
 
         Some(prefix_list).filter(|list| !list.is_empty())
     };
+
+    let context = Value::Object(evaluate_local_cohorts_skip_unresolved(
+        &dimensions,
+        &context.as_object().cloned().unwrap_or_default(),
+    ));
+
     let local = task::LocalSet::new();
     local.block_on(&Runtime::new().unwrap(), async move {
         unsafe {

crates/superposition_core/src/experiment.rs

@@ -230,7 +230,7 @@ pub fn get_satisfied_experiments(
                             &Value::Object(context.clone()),
                         ) == Ok(Value::Bool(true))
                 } else {
-                    superposition_types::partial_apply(&exp.context, context)
+                    superposition_types::apply(&exp.context, context)
                 }
             }
         })
@@ -247,6 +247,50 @@ pub fn get_satisfied_experiments(
     Ok(running_experiments)
 }
 
+pub fn get_filtered_satisfied_experiments(
+    experiments: &Experiments,
+    context: &Map<String, Value>,
+    filter_prefixes: Option<Vec<String>>,
+) -> Result<Experiments, String> {
+    let running_experiments = experiments
+        .iter()
+        .filter_map(|exp| {
+            if exp.context.is_empty() {
+                Some(exp.clone())
+            } else {
+                cfg_if::cfg_if! {
+                    if #[cfg(feature = "jsonlogic")] {
+                        match jsonlogic::partial_apply(
+                            &Value::Object(exp.context.clone().into()),
+                            context,
+                        ) {
+                            Ok(jsonlogic::PartialApplyOutcome::Resolved(Value::Bool(
+                                true,
+                            )))
+                            | Ok(jsonlogic::PartialApplyOutcome::Ambiguous) => {
+                                Some(exp.clone())
+                            }
+                            _ => None,
+                        }
+                    } else {
+                        superposition_types::partial_apply(&exp.context, &context)
+                            .then(|| exp.clone())
+                    }
+                }
+            }
+        })
+        .collect();
+
+    if let Some(prefix_list) = filter_prefixes {
+        return Ok(filter_experiments_by_prefix(
+            running_experiments,
+            prefix_list,
+        ));
+    }
+
+    Ok(running_experiments)
+}
+
 fn filter_experiments_by_prefix(
     experiments: Experiments,
     filter_prefixes: Vec<String>,

crates/superposition_types/src/config.rs

@@ -16,7 +16,7 @@ use uniffi::deps::anyhow;
 
 use crate::{
     database::models::cac::{DependencyGraph, DimensionType},
-    logic::evaluate_local_cohorts,
+    logic::evaluate_local_cohorts_skip_unresolved,
     overridden::filter_config_keys_by_prefix,
     Cac, Contextual, Exp, ExtendedMap,
 };
@@ -360,7 +360,8 @@ pub struct Config {
 
 impl Config {
     pub fn filter_by_dimensions(&self, dimension_data: &Map<String, Value>) -> Self {
-        let modified_context = evaluate_local_cohorts(&self.dimensions, dimension_data);
+        let modified_context =
+            evaluate_local_cohorts_skip_unresolved(&self.dimensions, dimension_data);
 
         let filtered_context =
             Context::filter_by_eval(self.contexts.clone(), &modified_context);

crates/superposition_types/src/logic.rs

@@ -141,16 +141,10 @@ fn evaluate_local_cohorts_dependency(
     }
 }
 
-/// Evaluates all local cohort dimensions based on the provided query data and dimension definitions
-/// First all local cohorts which are computable from the query data are evaluated, then any remaining local cohorts are set to "otherwise"
-/// Computation starts from such a point, such that dependencies can be resolved in a depth-first manner
-///
-/// Values of regular and remote cohort dimensions in query_data are retained as is.
-/// Returned value, might have a different value for local cohort dimensions based on its based on dimensions,
-/// if the value provided for the local cohort was incorrect in the query data.
-pub fn evaluate_local_cohorts(
+fn _evaluate_local_cohorts(
     dimensions: &HashMap<String, DimensionInfo>,
     query_data: &Map<String, Value>,
+    skip_unresolved: bool,
 ) -> Map<String, Value> {
     if dimensions.is_empty() {
         return query_data.clone();
@@ -175,6 +169,10 @@ pub fn evaluate_local_cohorts(
         }
     }
 
+    if skip_unresolved {
+        return modified_context;
+    }
+
     // For any local cohort dimension not yet set, set it to "otherwise"
     for dimension_key in dimensions.keys() {
         if let Some(dimension_info) = dimensions.get(dimension_key) {
@@ -192,6 +190,28 @@ pub fn evaluate_local_cohorts(
     modified_context
 }
 
+/// Evaluates all local cohort dimensions based on the provided query data and dimension definitions
+/// First all local cohorts which are computable from the query data are evaluated, then any remaining local cohorts are set to "otherwise"
+/// Computation starts from such a point, such that dependencies can be resolved in a depth-first manner
+///
+/// Values of regular and remote cohort dimensions in query_data are retained as is.
+/// Returned value, might have a different value for local cohort dimensions based on its based on dimensions,
+/// if the value provided for the local cohort was incorrect in the query data.
+pub fn evaluate_local_cohorts(
+    dimensions: &HashMap<String, DimensionInfo>,
+    query_data: &Map<String, Value>,
+) -> Map<String, Value> {
+    _evaluate_local_cohorts(dimensions, query_data, false)
+}
+
+/// Same as evaluate_local_cohorts but does not set unresolved local cohorts to "otherwise"
+pub fn evaluate_local_cohorts_skip_unresolved(
+    dimensions: &HashMap<String, DimensionInfo>,
+    query_data: &Map<String, Value>,
+) -> Map<String, Value> {
+    _evaluate_local_cohorts(dimensions, query_data, true)
+}
+
 /// Identifies starting dimensions for evaluation based on query data and dimension definitions
 /// For each tree in the dependency graph, picks the node closest to root from query_data for each branch of the tree.
 /// If nothing is found and a local cohort is encountered, picks that local cohort as start point from that branch.

headers/libexperimentation_client.h

@@ -26,10 +26,12 @@ char *expt_get_applicable_variant(struct Arc_Client *client,
                                   const char *filter_prefix);
 
 char *expt_get_satisfied_experiments(struct Arc_Client *client,
+                                     const char *c_dimensions,
                                      const char *c_context,
                                      const char *filter_prefix);
 
 char *expt_get_filtered_satisfied_experiments(struct Arc_Client *client,
+                                              const char *c_dimensions,
                                               const char *c_context,
                                               const char *filter_prefix);