refactor(resolver): use instance-based FlagEvaluator for in-process resolvers

Replace global thread-local state with per-instance FlagEvaluator for both
InProcessResolver and FileResolver, eliminating global state issues and
enabling multiple independent resolver instances with different configurations.

- Update InProcessResolver to use Arc<tokio::sync::RwLock<FlagEvaluator>>
- Update FileResolver to use Arc<tokio::sync::RwLock<FlagEvaluator>>
- Each resolver instance creates its own FlagEvaluator with Permissive mode
- Remove unused get_flag_and_metadata() and empty_flag() from common.rs
- Use async RwLock for Send-safe access across await points
- Remove calls to thread-local update_flag_state_with_mode()
- Simplify evaluation by using evaluator instance methods directly

This fixes issues where multiple resolver instances could interfere with
each other via global state, and aligns the Rust implementation with
Python's instance-based architecture.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: aepfli

crates/flagd/src/resolver/in_process/resolver/common.rs

@@ -1,25 +1,11 @@
 use flagd_evaluator::evaluation::{
     ErrorCode as EvaluatorErrorCode, EvaluationResult, ResolutionReason as EvaluatorReason,
 };
-use flagd_evaluator::model::FeatureFlag;
 use open_feature::{
     EvaluationContext, EvaluationError, EvaluationErrorCode, EvaluationReason, FlagMetadata,
     FlagMetadataValue, StructValue, Value,
 };
 use serde_json::Value as JsonValue;
-use std::collections::HashMap;
-
-/// Helper to create an empty FeatureFlag for a given key when one doesn't exist
-pub fn empty_flag(key: &str) -> FeatureFlag {
-    FeatureFlag {
-        key: Some(key.to_string()),
-        state: "DISABLED".to_string(),
-        default_variant: None,
-        variants: Default::default(),
-        targeting: None,
-        metadata: Default::default(),
-    }
-}
 
 /// Convert EvaluationContextFieldValue to JsonValue recursively
 fn context_field_to_json(value: &open_feature::EvaluationContextFieldValue) -> JsonValue {
@@ -170,20 +156,3 @@ pub fn json_to_metadata_value(v: &JsonValue) -> Option<FlagMetadataValue> {
     }
 }
 
-/// Get flag and metadata from evaluator storage
-pub fn get_flag_and_metadata(
-    flag_key: &str,
-) -> (FeatureFlag, HashMap<String, serde_json::Value>) {
-    let state = flagd_evaluator::storage::get_flag_state();
-    let flag = state
-        .as_ref()
-        .and_then(|s| s.flags.get(flag_key))
-        .cloned()
-        .unwrap_or_else(|| empty_flag(flag_key));
-    let metadata = state
-        .as_ref()
-        .map(|s| &s.flag_set_metadata)
-        .cloned()
-        .unwrap_or_default();
-    (flag, metadata)
-}

crates/flagd/src/resolver/in_process/resolver/file.rs

@@ -4,12 +4,9 @@ use crate::resolver::in_process::storage::connector::{Connector, QueuePayloadTyp
 use crate::{CacheService, CacheSettings};
 use anyhow::Result;
 use async_trait::async_trait;
-use flagd_evaluator::evaluation::{
-    evaluate_bool_flag, evaluate_float_flag, evaluate_flag, evaluate_int_flag,
-    evaluate_string_flag, EvaluationResult,
-};
+use flagd_evaluator::evaluation::EvaluationResult;
 use flagd_evaluator::model::ParsingResult;
-use flagd_evaluator::storage::{update_flag_state, ValidationMode};
+use flagd_evaluator::storage::ValidationMode;
 use open_feature::provider::{FeatureProvider, ProviderMetadata, ResolutionDetails};
 use open_feature::{EvaluationContext, EvaluationError, Value};
 use serde_json::Value as JsonValue;
@@ -20,24 +17,22 @@ use tracing::debug;
 pub struct FileResolver {
     /// Connector for watching file changes
     connector: Arc<FileConnector>,
+    /// Instance-based flag evaluator with its own state and validation mode
+    evaluator: Arc<tokio::sync::RwLock<flagd_evaluator::FlagEvaluator>>,
     metadata: ProviderMetadata,
     cache: Option<Arc<CacheService<Value>>>,
 }
 
 impl FileResolver {
     pub async fn new(source_path: String, cache_settings: Option<CacheSettings>) -> Result<Self> {
-        // Set validation mode to permissive to match other providers
-        // NOTE: This sets a thread-local global state. If multiple resolver instances
-        // are created in the same thread with different validation requirements, this
-        // could cause issues. Currently both InProcessResolver and FileResolver use
-        // Permissive mode, so this is not a problem in practice. A future improvement
-        // would be to make validation mode configurable per CacheSettings and pass it
-        // to evaluator functions, or for flagd-evaluator to support per-instance config.
-        flagd_evaluator::storage::set_validation_mode(ValidationMode::Permissive);
-
         let connector = Arc::new(FileConnector::new(source_path));
         let cache = cache_settings.map(|settings| Arc::new(CacheService::new(settings)));
 
+        // Create evaluator instance with permissive validation mode
+        let evaluator = Arc::new(tokio::sync::RwLock::new(
+            flagd_evaluator::FlagEvaluator::new(ValidationMode::Permissive)
+        ));
+
         // Initialize the connector to start watching the file
         connector.init().await?;
 
@@ -53,7 +48,8 @@ impl FileResolver {
                         debug!("Received initial flag configuration from file");
                         match ParsingResult::parse(&payload.flag_data) {
                             Ok(_) => {
-                                if let Err(e) = update_flag_state(&payload.flag_data) {
+                                let mut eval = evaluator.write().await;
+                                if let Err(e) = eval.update_state(&payload.flag_data) {
                                     return Err(anyhow::anyhow!("Failed to update flag state: {}", e));
                                 }
                             }
@@ -78,6 +74,7 @@ impl FileResolver {
         // Spawn task to handle subsequent config updates
         let stream_clone = stream.clone();
         let cache_clone = cache.clone();
+        let evaluator_clone = evaluator.clone();
         tokio::spawn(async move {
             let mut receiver_opt = stream_clone.lock().await;
             if let Some(receiver) = receiver_opt.as_mut() {
@@ -88,14 +85,16 @@ impl FileResolver {
                         // Parse and update state in evaluator
                         match ParsingResult::parse(&payload.flag_data) {
                             Ok(_) => {
-                                if let Err(e) = update_flag_state(&payload.flag_data) {
+                                let mut eval = evaluator_clone.write().await;
+                                if let Err(e) = eval.update_state(&payload.flag_data) {
                                     tracing::error!("Failed to update flag state: {}", e);
                                 } else {
                                     // Clear cache when flags update
                                     if let Some(cache) = &cache_clone {
                                         cache.purge().await;
                                     }
                                 }
+                                drop(eval); // Explicitly drop lock before continuing
                             }
                             Err(e) => {
                                 tracing::error!("Failed to parse flag configuration: {}", e);
@@ -108,6 +107,7 @@ impl FileResolver {
 
         Ok(Self {
             connector,
+            evaluator,
             metadata: ProviderMetadata::new("flagd"),
             cache,
         })
@@ -131,7 +131,7 @@ impl FileResolver {
         &self,
         flag_key: &str,
         context: &EvaluationContext,
-        evaluator_fn: impl Fn(&serde_json::Map<String, JsonValue>) -> EvaluationResult,
+        evaluator_fn: impl Fn(&flagd_evaluator::FlagEvaluator, &JsonValue) -> EvaluationResult,
         value_extractor: impl Fn(&JsonValue) -> Option<T>,
         cache_value_fn: impl Fn(T) -> Value,
     ) -> Result<ResolutionDetails<T>, EvaluationError>
@@ -156,12 +156,11 @@ impl FileResolver {
 
         // Build context for evaluator
         let ctx_json = common::build_context_json(context);
-        let ctx_map = ctx_json.as_object().unwrap_or_else(|| {
-            panic!("build_context_json should always return an object")
-        });
 
-        // Call evaluator (no clone needed)
-        let result = evaluator_fn(ctx_map);
+        // Get read lock on evaluator and call evaluation function
+        let eval = self.evaluator.read().await;
+        let result = evaluator_fn(&*eval, &ctx_json);
+        drop(eval); // Release lock before awaiting
 
         // Convert result to details
         let details = common::result_to_details(&result, value_extractor)?;
@@ -191,10 +190,7 @@ impl FeatureProvider for FileResolver {
         self.resolve_value(
             flag_key,
             context,
-            |ctx| {
-                let (flag, metadata) = common::get_flag_and_metadata(flag_key);
-                evaluate_bool_flag(&flag, &JsonValue::Object(ctx.clone()), &metadata)
-            },
+            |eval, ctx| eval.evaluate_bool(flag_key, ctx),
             |v| v.as_bool(),
             Value::Bool,
         )
@@ -209,10 +205,7 @@ impl FeatureProvider for FileResolver {
         self.resolve_value(
             flag_key,
             context,
-            |ctx| {
-                let (flag, metadata) = common::get_flag_and_metadata(flag_key);
-                evaluate_string_flag(&flag, &JsonValue::Object(ctx.clone()), &metadata)
-            },
+            |eval, ctx| eval.evaluate_string(flag_key, ctx),
             |v| v.as_str().map(String::from),
             Value::String,
         )
@@ -227,10 +220,7 @@ impl FeatureProvider for FileResolver {
         self.resolve_value(
             flag_key,
             context,
-            |ctx| {
-                let (flag, metadata) = common::get_flag_and_metadata(flag_key);
-                evaluate_int_flag(&flag, &JsonValue::Object(ctx.clone()), &metadata)
-            },
+            |eval, ctx| eval.evaluate_int(flag_key, ctx),
             |v| v.as_i64(),
             Value::Int,
         )
@@ -245,10 +235,7 @@ impl FeatureProvider for FileResolver {
         self.resolve_value(
             flag_key,
             context,
-            |ctx| {
-                let (flag, metadata) = common::get_flag_and_metadata(flag_key);
-                evaluate_float_flag(&flag, &JsonValue::Object(ctx.clone()), &metadata)
-            },
+            |eval, ctx| eval.evaluate_float(flag_key, ctx),
             |v| v.as_f64(),
             Value::Float,
         )
@@ -263,10 +250,7 @@ impl FeatureProvider for FileResolver {
         self.resolve_value(
             flag_key,
             context,
-            |ctx| {
-                let (flag, metadata) = common::get_flag_and_metadata(flag_key);
-                evaluate_flag(&flag, &JsonValue::Object(ctx.clone()), &metadata)
-            },
+            |eval, ctx| eval.evaluate_flag(flag_key, ctx),
             |v| {
                 v.as_object().map(|obj| {
                     let fields = obj