Merge pull request #24 from lopitz/fix-classcastexceptions

Fixes ClassCastExceptions when hooks are called (address #23)

Author: Justin Abrahms

.github/workflows/pullrequest.yml

@@ -38,4 +38,4 @@ jobs:
           flags: unittests # optional
           name: pr coverage # optional
           fail_ci_if_error: true # optional (default = false)
-          verbose: true # optional (default = false)
+          verbose: true # optional (default = false)

lib/build.gradle

@@ -42,6 +42,12 @@ dependencies {
     api 'org.apache.commons:commons-math3:3.6.1'
 }
 
+java {
+    toolchain {
+        languageVersion.set(JavaLanguageVersion.of(8))
+    }
+}
+
 tasks.named('test') {
     // Use JUnit Platform for unit tests.
     useJUnitPlatform()

lib/src/main/java/dev/openfeature/javasdk/BooleanHook.java

@@ -0,0 +1,9 @@
+package dev.openfeature.javasdk;
+
+public interface BooleanHook extends Hook<Boolean> {
+
+    @Override
+    default boolean supportsFlagValueType(FlagValueType flagValueType) {
+        return FlagValueType.BOOLEAN == flagValueType;
+    }
+}

lib/src/main/java/dev/openfeature/javasdk/FlagEvaluationDetails.java

@@ -11,11 +11,11 @@
  */
 @Data @Builder
 public class FlagEvaluationDetails<T> implements BaseEvaluation<T> {
-    String flagKey;
-    T value;
-    @Nullable String variant;
-    Reason reason;
-    @Nullable String errorCode;
+    private String flagKey;
+    private T value;
+    @Nullable private String variant;
+    private Reason reason;
+    @Nullable private String errorCode;
 
     public static <T> FlagEvaluationDetails<T> from(ProviderEvaluation<T> providerEval, String flagKey) {
         return FlagEvaluationDetails.<T>builder()

lib/src/main/java/dev/openfeature/javasdk/FlagEvaluationOptions.java

@@ -1,15 +1,14 @@
 package dev.openfeature.javasdk;
 
-import com.google.common.collect.ImmutableMap;
-import lombok.Builder;
-import lombok.Data;
-import lombok.Singular;
+import java.util.*;
 
-import java.util.List;
+import lombok.*;
 
-@Data @Builder
+@Value
+@Builder
 public class FlagEvaluationOptions {
-    @Singular private List<Hook> hooks;
+    @Singular
+    List<Hook> hooks;
     @Builder.Default
-    private ImmutableMap<String, Object> hookHints = ImmutableMap.of();
+    Map<String, Object> hookHints = new HashMap<>();
 }

lib/src/main/java/dev/openfeature/javasdk/Hook.java

@@ -1,45 +1,55 @@
 package dev.openfeature.javasdk;
 
-import com.google.common.collect.ImmutableMap;
-
-import java.util.Optional;
+import java.util.*;
 
 /**
  * An extension point which can run around flag resolution. They are intended to be used as a way to add custom logic
  * to the lifecycle of flag evaluation.
+ *
  * @param <T> The type of the flag being evaluated.
  */
 public interface Hook<T> {
     /**
      * Runs before flag is resolved.
-     * @param ctx Information about the particular flag evaluation
+     *
+     * @param ctx   Information about the particular flag evaluation
      * @param hints An immutable mapping of data for users to communicate to the hooks.
      * @return An optional {@link EvaluationContext}. If returned, it will be merged with the EvaluationContext instances from other hooks, the client and API.
      */
-    default Optional<EvaluationContext> before(HookContext<T> ctx, ImmutableMap<String, Object> hints) {
+    default Optional<EvaluationContext> before(HookContext<T> ctx, Map<String, Object> hints) {
         return Optional.empty();
     }
 
     /**
      * Runs after a flag is resolved.
-     * @param ctx Information about the particular flag evaluation
+     *
+     * @param ctx     Information about the particular flag evaluation
      * @param details Information about how the flag was resolved, including any resolved values.
-     * @param hints An immutable mapping of data for users to communicate to the hooks.
+     * @param hints   An immutable mapping of data for users to communicate to the hooks.
      */
-    default void after(HookContext<T> ctx, FlagEvaluationDetails<T> details, ImmutableMap<String, Object> hints) {}
+    default void after(HookContext<T> ctx, FlagEvaluationDetails<T> details, Map<String, Object> hints) {
+    }
 
     /**
      * Run when evaluation encounters an error. This will always run. Errors thrown will be swallowed.
-     * @param ctx Information about the particular flag evaluation
+     *
+     * @param ctx   Information about the particular flag evaluation
      * @param error The exception that was thrown.
      * @param hints An immutable mapping of data for users to communicate to the hooks.
      */
-    default void error(HookContext<T> ctx, Exception error, ImmutableMap<String, Object> hints) {}
+    default void error(HookContext<T> ctx, Exception error, Map<String, Object> hints) {
+    }
 
     /**
      * Run after flag evaluation, including any error processing. This will always run. Errors will be swallowed.
-     * @param ctx Information about the particular flag evaluation
+     *
+     * @param ctx   Information about the particular flag evaluation
      * @param hints An immutable mapping of data for users to communicate to the hooks.
      */
-    default void finallyAfter(HookContext<T> ctx, ImmutableMap<String, Object> hints) {}
+    default void finallyAfter(HookContext<T> ctx, Map<String, Object> hints) {
+    }
+
+    default boolean supportsFlagValueType(FlagValueType flagValueType) {
+        return true;
+    }
 }

lib/src/main/java/dev/openfeature/javasdk/HookSupport.java

@@ -0,0 +1,81 @@
+package dev.openfeature.javasdk;
+
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.Stream;
+
+import com.google.common.collect.Lists;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+@RequiredArgsConstructor
+@SuppressWarnings({"unchecked", "rawtypes"})
+class HookSupport {
+
+    public void errorHooks(FlagValueType flagValueType, HookContext hookCtx, Exception e, List<Hook> hooks, Map<String, Object> hints) {
+        executeHooks(flagValueType, hooks, "error", hook -> hook.error(hookCtx, e, hints));
+    }
+
+    public void afterAllHooks(FlagValueType flagValueType, HookContext hookCtx, List<Hook> hooks, Map<String, Object> hints) {
+        executeHooks(flagValueType, hooks, "finally", hook -> hook.finallyAfter(hookCtx, hints));
+    }
+
+    public void afterHooks(FlagValueType flagValueType, HookContext hookContext, FlagEvaluationDetails details, List<Hook> hooks, Map<String, Object> hints) {
+        executeHooksUnchecked(flagValueType, hooks, hook -> hook.after(hookContext, details, hints));
+    }
+
+    private <T> void executeHooks(
+        FlagValueType flagValueType, List<Hook> hooks,
+        String hookMethod,
+        Consumer<Hook<T>> hookCode
+    ) {
+        hooks
+            .stream()
+            .filter(hook -> hook.supportsFlagValueType(flagValueType))
+            .forEach(hook -> executeChecked(hook, hookCode, hookMethod));
+    }
+
+    private <T> void executeHooksUnchecked(
+        FlagValueType flagValueType, List<Hook> hooks,
+        Consumer<Hook<T>> hookCode
+    ) {
+        hooks
+            .stream()
+            .filter(hook -> hook.supportsFlagValueType(flagValueType))
+            .forEach(hookCode::accept);
+    }
+
+    private <T> void executeChecked(Hook<T> hook, Consumer<Hook<T>> hookCode, String hookMethod) {
+        try {
+            hookCode.accept(hook);
+        } catch (Exception exception) {
+            log.error("Exception when running {} hooks {}", hookMethod, hook.getClass(), exception);
+        }
+    }
+
+    public EvaluationContext beforeHooks(FlagValueType flagValueType, HookContext hookCtx, List<Hook> hooks, Map<String, Object> hints) {
+        Stream<EvaluationContext> result = callBeforeHooks(flagValueType, hookCtx, hooks, hints);
+        return EvaluationContext.merge(hookCtx.getCtx(), collectContexts(result));
+    }
+
+    private Stream<EvaluationContext> callBeforeHooks(FlagValueType flagValueType, HookContext hookCtx, List<Hook> hooks, Map<String, Object> hints) {
+        // These traverse backwards from normal.
+        return Lists
+            .reverse(hooks)
+            .stream()
+            .filter(hook -> hook.supportsFlagValueType(flagValueType))
+            .map(hook -> hook.before(hookCtx, hints))
+            .filter(Objects::nonNull)
+            .filter(Optional::isPresent)
+            .map(Optional::get)
+            .map(EvaluationContext.class::cast);
+    }
+
+    //for whatever reason, an error `error: incompatible types: invalid method reference` is thrown on compilation with javac
+    //when the reduce call is appended directly as stream call chain above. moving it to its own method works however...
+    private EvaluationContext collectContexts(Stream<EvaluationContext> result) {
+        return result
+            .reduce(new EvaluationContext(), EvaluationContext::merge, EvaluationContext::merge);
+    }
+}

lib/src/main/java/dev/openfeature/javasdk/IntegerHook.java

@@ -0,0 +1,9 @@
+package dev.openfeature.javasdk;
+
+public interface IntegerHook extends Hook<Integer> {
+
+    @Override
+    default boolean supportsFlagValueType(FlagValueType flagValueType) {
+        return FlagValueType.INTEGER == flagValueType;
+    }
+}