fix sticky, add log functionality (#34)

Author: vahidlazio

confidence-resolver/protos/confidence/flags/resolver/v1/wasm_api.proto

@@ -37,6 +37,10 @@ message MaterializationInfo {
  map<string, string> rule_to_variant = 2;
 }
 
+message LogMessage {
+ string message = 1;
+}
+
 message ResolveWithStickyResponse {
  oneof resolve_result {
  Success success = 1;

confidence-resolver/src/lib.rs

@@ -6,11 +6,11 @@
     // clippy::integer_arithmetic
 ))]
 
-use core::marker::PhantomData;
-use std::collections::{HashMap, HashSet};
-
 use bitvec::prelude as bv;
+use core::marker::PhantomData;
 use fastmurmur3::murmur3_x64_128;
+use std::collections::{HashMap, HashSet};
+use std::fmt::format;
 
 use bytes::Bytes;
 
@@ -227,6 +227,10 @@ pub trait Host {
         Alphanumeric.sample_string(&mut rand::rng(), len)
     }
 
+    fn log(_: &str) {
+        // noop
+    }
+
     #[cfg(not(feature = "std"))]
     fn current_time() -> Timestamp;
     #[cfg(feature = "std")]
@@ -512,7 +516,9 @@ impl<'a, H: Host> AccountResolver<'a, H> {
 
         let mut resolve_results = Vec::with_capacity(flags_to_resolve.len());
 
-        for flag in flags_to_resolve {
+        let mut has_missing_materializations = false;
+
+        for flag in flags_to_resolve.clone() {
             let resolve_result = self.resolve_flag(flag, request.materialization_context.clone());
             match resolve_result {
                 Ok(resolve_result) => resolve_results.push(resolve_result),
@@ -526,22 +532,26 @@ impl<'a, H: Host> AccountResolver<'a, H> {
                                     vec![],
                                 ))
                             } else {
-                                let deps = self.collect_missing_materializations(&flag);
-                                match deps {
-                                    Ok(deps) => Ok(
-                                        ResolveWithStickyResponse::with_missing_materializations(
-                                            deps,
-                                        ),
-                                    ),
-                                    Err(err) => Err(err),
-                                }
+                                has_missing_materializations = true;
+                                break;
                             }
                         }
                     };
                 }
             }
         }
 
+        if has_missing_materializations {
+            let result = self.collect_missing_materializations(flags_to_resolve);
+            if let Ok(missing) = result {
+                return Ok(ResolveWithStickyResponse::with_missing_materializations(
+                    missing,
+                ));
+            } else {
+                return Err("Could not collect missing materializations".to_string());
+            }
+        }
+
         let resolved_values: Vec<ResolvedValue> = resolve_results
             .iter()
             .map(|r| r.resolved_value.clone())
@@ -726,6 +736,27 @@ impl<'a, H: Host> AccountResolver<'a, H> {
     }
 
     pub fn collect_missing_materializations(
+        &'a self,
+        flags: Vec<&'a Flag>,
+    ) -> Result<Vec<resolve_with_sticky_response::MissingMaterializationItem>, String> {
+        let mut missing_materializations: Vec<
+            resolve_with_sticky_response::MissingMaterializationItem,
+        > = Vec::new();
+        for flag in flags {
+            let result = self.collect_missing_materializations_for_flag(flag);
+            if let Ok(items) = result {
+                missing_materializations.extend(items);
+            } else {
+                return Err(format!(
+                    "Could not collect missing materializations for flag {}",
+                    flag.name
+                ));
+            }
+        }
+        Ok(missing_materializations)
+    }
+
+    fn collect_missing_materializations_for_flag(
         &'a self,
         flag: &'a Flag,
     ) -> Result<Vec<resolve_with_sticky_response::MissingMaterializationItem>, String> {
@@ -767,7 +798,6 @@ impl<'a, H: Host> AccountResolver<'a, H> {
                 }
             }
         }
-
         Ok(missing_materializations)
     }
 

wasm/rust-guest/src/lib.rs

@@ -10,7 +10,7 @@ use prost::Message;
 static ALLOC: wee_alloc::WeeAlloc = wee_alloc::WeeAlloc::INIT;
 
 use confidence_resolver::proto::confidence::flags::resolver::v1::{
-    ResolveWithStickyRequest, WriteFlagLogsRequest,
+    LogMessage, ResolveWithStickyRequest, WriteFlagLogsRequest,
 };
 use confidence_resolver::resolve_logger::ResolveLogger;
 use rand::distr::Alphanumeric;
@@ -124,6 +124,17 @@ fn converted_client(client: &Client) -> crate::proto::Client {
 struct WasmHost;
 
 impl Host for WasmHost {
+    fn random_alphanumeric(len: usize) -> String {
+        RNG.with_borrow_mut(|rng| Alphanumeric.sample_string(rng, len))
+    }
+
+    fn log(message: &str) {
+        log_message(LogMessage {
+            message: message.to_string(),
+        })
+        .unwrap();
+    }
+
     fn current_time() -> Timestamp {
         current_time(Void {}).unwrap()
     }
@@ -160,10 +171,6 @@ impl Host for WasmHost {
     fn decrypt_resolve_token(token_data: &[u8], _encryption_key: &[u8]) -> Result<Vec<u8>, String> {
         Ok(token_data.to_vec())
     }
-
-    fn random_alphanumeric(len: usize) -> String {
-        RNG.with_borrow_mut(|rng| Alphanumeric.sample_string(rng, len))
-    }
 }
 
 /// Safely gets an owned handle to the current resolver state.
@@ -215,5 +222,6 @@ wasm_msg_guest! {
 
 // Declare the add function as a host function
 wasm_msg_host! {
+    fn log_message(message: LogMessage) -> WasmResult<Void>;
     fn current_time(request: Void) -> WasmResult<Timestamp>;
 }