feat: performance boost

Signed-off-by: Simon Schrottner <[email protected]>

Author: aepfli

src/main/java/dev/openfeature/sdk/HookContext.java

@@ -18,7 +18,10 @@ public interface HookContext<T> {
      * @param defaultValue     Fallback value
      * @param <T>              type that the flag is evaluating against
      * @return resulting context for hook
+     *
+     * @deprecated this should not be instantiated outside the SDK anymore
      */
+    @Deprecated
     static <T> HookContext<T> from(
             String key,
             FlagValueType type,

src/main/java/dev/openfeature/sdk/HookContextWithoutData.java

@@ -1,27 +1,63 @@
 package dev.openfeature.sdk;
 
+import lombok.AccessLevel;
 import lombok.Builder;
+import lombok.Data;
+import lombok.Getter;
 import lombok.NonNull;
+import lombok.Setter;
 import lombok.Value;
 import lombok.With;
+import lombok.experimental.NonFinal;
 
 /**
  * A data class to hold immutable context that {@link Hook} instances use.
  *
  * @param <T> the type for the flag being evaluated
  */
-@Value
+@Data
 @Builder
 @With
+@Setter(AccessLevel.PRIVATE)
 class HookContextWithoutData<T> implements HookContext<T> {
     @NonNull String flagKey;
 
     @NonNull FlagValueType type;
 
     @NonNull T defaultValue;
 
+    @Setter(AccessLevel.PACKAGE)
     @NonNull EvaluationContext ctx;
 
     ClientMetadata clientMetadata;
     Metadata providerMetadata;
+
+    /**
+     * Builds a {@link HookContextWithoutData} instances from request data.
+     *
+     * @param key              feature flag key
+     * @param type             flag value type
+     * @param clientMetadata   info on which client is calling
+     * @param providerMetadata info on the provider
+     * @param ctx              Evaluation Context for the request
+     * @param defaultValue     Fallback value
+     * @param <T>              type that the flag is evaluating against
+     * @return resulting context for hook
+     */
+    static <T> HookContextWithoutData<T> from(
+            String key,
+            FlagValueType type,
+            ClientMetadata clientMetadata,
+            Metadata providerMetadata,
+            EvaluationContext ctx,
+            T defaultValue) {
+        return HookContextWithoutData.<T>builder()
+                .flagKey(key)
+                .type(type)
+                .clientMetadata(clientMetadata)
+                .providerMetadata(providerMetadata)
+                .ctx(ImmutableContext.EMPTY)
+                .defaultValue(defaultValue)
+                .build();
+    }
 }

src/main/java/dev/openfeature/sdk/ImmutableContext.java

@@ -20,6 +20,8 @@
 @SuppressWarnings("PMD.BeanMembersShouldSerialize")
 public final class ImmutableContext implements EvaluationContext {
 
+    public static final ImmutableContext EMPTY = new ImmutableContext();
+
     @Delegate(excludes = DelegateExclusions.class)
     private final ImmutableStructure structure;
 

src/main/java/dev/openfeature/sdk/OpenFeatureClient.java

@@ -166,22 +166,23 @@ private <T> FlagEvaluationDetails<T> evaluateFlag(
         FlagEvaluationDetails<T> details = null;
         List<Hook> mergedHooks;
         List<Pair<Hook, HookData>> hookDataPairs = null;
-        HookContext<T> hookContext = null;
+        HookContextWithoutData<T> hookContext = null;
 
         try {
             final var stateManager = openfeatureApi.getFeatureProviderStateManager(this.domain);
             // provider must be accessed once to maintain a consistent reference
             final var provider = stateManager.getProvider();
             final var state = stateManager.getState();
-            hookContext = HookContext.from(
-                    key, type, this.getMetadata(), provider.getMetadata(), mergeEvaluationContext(ctx), defaultValue);
+            hookContext = HookContextWithoutData.from(
+                    key, type, this.getMetadata(), provider.getMetadata(), null, defaultValue);
+
+            hookContext.setCtx(mergeEvaluationContext(ctx));
+
             mergedHooks = ObjectUtils.merge(
                     provider.getProviderHooks(), flagOptions.getHooks(), clientHooks, openfeatureApi.getMutableHooks());
             hookDataPairs = hookSupport.getHookDataPairs(mergedHooks, type);
             var mergedCtx = hookSupport.beforeHooks(type, hookContext, hookDataPairs, hints);
-
-            hookContext =
-                    HookContext.from(key, type, this.getMetadata(), provider.getMetadata(), mergedCtx, defaultValue);
+            hookContext.setCtx(mergedCtx);
 
             // "short circuit" if the provider is in NOT_READY or FATAL state
             if (ProviderState.NOT_READY.equals(state)) {

src/test/java/dev/openfeature/sdk/HookContextTest.java

@@ -35,13 +35,7 @@ void shouldCreateHookContextWithHookData() {
         HookData hookData = HookData.create();
         hookData.set("test", "value");
 
-        HookContext<String> context = HookContext.<String>builder()
-                .flagKey("test-flag")
-                .type(FlagValueType.STRING)
-                .defaultValue("default")
-                .ctx(new ImmutableContext())
-                .hookData(hookData)
-                .build();
+        HookContext<String> context = HookContextWithData.of(null, hookData);
 
         assertNotNull(context.getHookData());
         assertEquals("value", context.getHookData().get("test"));