feat: Make the Evaluator customizable

providers/flagd/src/main/java/dev/openfeature/contrib/providers/flagd/FlagdOptions.java

@@ -5,6 +5,7 @@
 import static dev.openfeature.contrib.providers.flagd.Config.fromValueProvider;
 
 import dev.openfeature.contrib.providers.flagd.resolver.process.storage.connector.QueueSource;
+import dev.openfeature.contrib.tools.flagd.api.Evaluator;
 import dev.openfeature.sdk.EvaluationContext;
 import dev.openfeature.sdk.ImmutableContext;
 import dev.openfeature.sdk.Structure;
@@ -13,6 +14,7 @@
 import io.opentelemetry.api.OpenTelemetry;
 import java.util.List;
 import java.util.function.Function;
+import jdk.jfr.Experimental;
 import lombok.Builder;
 import lombok.Getter;
 import org.apache.commons.lang3.StringUtils;
@@ -141,7 +143,9 @@ public class FlagdOptions {
      *
      * <p>Only applicable for in-process resolver mode.
      *
-     * @see <a href="https://github.com/open-feature/java-sdk-contrib/tree/main/providers/flagd#selector-filtering-in-process-mode-only">Selector filtering documentation</a>
+     * @see <a
+     *         href="https://github.com/open-feature/java-sdk-contrib/tree/main/providers/flagd#selector-filtering-in-process-mode-only">Selector
+     *         filtering documentation</a>
      **/
     @Builder.Default
     private String selector = fallBackToEnvOrDefault(Config.SOURCE_SELECTOR_ENV_VAR_NAME, null);
@@ -232,6 +236,14 @@ public class FlagdOptions {
     private boolean reinitializeOnError = Boolean.parseBoolean(
             fallBackToEnvOrDefault(Config.REINITIALIZE_ON_ERROR_ENV_VAR_NAME, Config.DEFAULT_REINITIALIZE_ON_ERROR));
 
+    /**
+     * The evaluator to use for flag evaluations. Defaults to {@code new FlagdCore()}. Only applicable in the in-process
+     * mode
+     */
+    @Builder.Default
+    @Experimental
+    private Evaluator evaluator = null;
+
     /**
      * Builder overwrite in order to customize the "build" method.
      *

providers/flagd/src/main/java/dev/openfeature/contrib/providers/flagd/resolver/process/InProcessResolver.java

@@ -49,13 +49,20 @@ public class InProcessResolver implements Resolver {
      */
     public InProcessResolver(
             FlagdOptions options, TriConsumer<ProviderEvent, ProviderEventDetails, Structure> onConnectionEvent) {
+        Evaluator evaluator = options.getEvaluator();
+        if (evaluator == null) {
+            evaluator = new FlagdCore();
+        }
         this.queueSource = getQueueSource(options);
-        Evaluator flagdCore = new FlagdCore();
-        this.evaluator = flagdCore;
-        this.flagStore = new FlagStore(queueSource, flagdCore);
+        this.evaluator = evaluator;
+        this.flagStore = new FlagStore(queueSource, evaluator);
         this.onConnectionEvent = onConnectionEvent;
     }
 
+    Evaluator getEvaluator() {
+        return evaluator;
+    }
+
     /**
      * Initialize in-process resolver.
      */

providers/flagd/src/test/java/dev/openfeature/contrib/providers/flagd/resolver/process/InProcessResolverTest.java

@@ -19,6 +19,7 @@
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
 
 import dev.openfeature.contrib.providers.flagd.Config;
 import dev.openfeature.contrib.providers.flagd.FlagdOptions;
@@ -27,6 +28,8 @@
 import dev.openfeature.contrib.providers.flagd.resolver.process.storage.StorageStateChange;
 import dev.openfeature.contrib.providers.flagd.resolver.process.storage.connector.file.FileQueueSource;
 import dev.openfeature.contrib.providers.flagd.resolver.process.storage.connector.sync.SyncStreamQueueSource;
+import dev.openfeature.contrib.tools.flagd.api.Evaluator;
+import dev.openfeature.contrib.tools.flagd.core.FlagdCore;
 import dev.openfeature.contrib.tools.flagd.core.model.FeatureFlag;
 import dev.openfeature.sdk.ErrorCode;
 import dev.openfeature.sdk.ImmutableContext;
@@ -57,6 +60,7 @@
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
 
 class InProcessResolverTest {
     private final List<InProcessResolver> resolversToShutdown = new ArrayList<>();
@@ -551,6 +555,27 @@ void testStateWatcherThreadIsCleanedUpDuringShutdown() throws Exception {
         // background threads can affect the count, making such assertions flaky in CI.
     }
 
+    @Test
+    void usesSuppliedEvaluator() {
+        var evaluator = Mockito.mock(Evaluator.class);
+        var key = "key";
+        var ctx = new ImmutableContext(key);
+        when(evaluator.resolveBooleanValue(key, false, ctx)).thenReturn(Mockito.mock(ProviderEvaluation.class));
+        var resolver = new InProcessResolver(
+                FlagdOptions.builder().evaluator(evaluator).build(), (event, details, metadata) -> {});
+
+        resolver.booleanEvaluation(key, false, ctx);
+        Mockito.verify(evaluator).resolveBooleanValue(key, false, ctx);
+        assertThat(resolver.getEvaluator()).isEqualTo(evaluator);
+    }
+
+    @Test
+    void usesFlagdCoreEvaluatorWhenNotSupplied() {
+        var resolver = new InProcessResolver(FlagdOptions.builder().build(), (event, details, metadata) -> {});
+
+        assertThat(resolver.getEvaluator()).isInstanceOf(FlagdCore.class);
+    }
+
     private long currentDaemonThreadCount() {
         return Thread.getAllStackTraces().keySet().stream()
                 .filter(Thread::isDaemon)