feat: Update in-process resolver to support flag metadata #1102 (#1122)

Signed-off-by: christian.lutnik <[email protected]>
Co-authored-by: Todd Baert <[email protected]>

Author: chrfwow

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

@@ -10,6 +10,7 @@
 import dev.openfeature.contrib.providers.flagd.resolver.process.model.FeatureFlag;
 import dev.openfeature.contrib.providers.flagd.resolver.process.storage.FlagStore;
 import dev.openfeature.contrib.providers.flagd.resolver.process.storage.Storage;
+import dev.openfeature.contrib.providers.flagd.resolver.process.storage.StorageQueryResult;
 import dev.openfeature.contrib.providers.flagd.resolver.process.storage.StorageState;
 import dev.openfeature.contrib.providers.flagd.resolver.process.storage.StorageStateChange;
 import dev.openfeature.contrib.providers.flagd.resolver.process.storage.connector.Connector;
@@ -25,6 +26,7 @@
 import dev.openfeature.sdk.Value;
 import dev.openfeature.sdk.exceptions.ParseError;
 import dev.openfeature.sdk.exceptions.TypeMismatchError;
+import java.util.Map;
 import java.util.function.Consumer;
 import java.util.function.Supplier;
 import lombok.extern.slf4j.Slf4j;
@@ -40,8 +42,8 @@ public class InProcessResolver implements Resolver {
     private final Consumer<ConnectionEvent> onConnectionEvent;
     private final Operator operator;
     private final long deadline;
-    private final ImmutableMetadata metadata;
     private final Supplier<Boolean> connectedSupplier;
+    private final String scope;
 
     /**
      * Resolves flag values using
@@ -63,11 +65,7 @@ public InProcessResolver(
         this.onConnectionEvent = onConnectionEvent;
         this.operator = new Operator();
         this.connectedSupplier = connectedSupplier;
-        this.metadata = options.getSelector() == null
-                ? null
-                : ImmutableMetadata.builder()
-                        .addString("scope", options.getSelector())
-                        .build();
+        this.scope = options.getSelector();
     }
 
     /**
@@ -167,13 +165,15 @@ static Connector getConnector(final FlagdOptions options, Consumer<ConnectionEve
     }
 
     private <T> ProviderEvaluation<T> resolve(Class<T> type, String key, EvaluationContext ctx) {
-        final FeatureFlag flag = flagStore.getFlag(key);
+        final StorageQueryResult storageQueryResult = flagStore.getFlag(key);
+        final FeatureFlag flag = storageQueryResult.getFeatureFlag();
 
         // missing flag
         if (flag == null) {
             return ProviderEvaluation.<T>builder()
                     .errorMessage("flag: " + key + " not found")
                     .errorCode(ErrorCode.FLAG_NOT_FOUND)
+                    .flagMetadata(getFlagMetadata(storageQueryResult))
                     .build();
         }
 
@@ -182,6 +182,7 @@ private <T> ProviderEvaluation<T> resolve(Class<T> type, String key, EvaluationC
             return ProviderEvaluation.<T>builder()
                     .errorMessage("flag: " + key + " is disabled")
                     .errorCode(ErrorCode.FLAG_NOT_FOUND)
+                    .flagMetadata(getFlagMetadata(storageQueryResult))
                     .build();
         }
 
@@ -228,13 +229,59 @@ private <T> ProviderEvaluation<T> resolve(Class<T> type, String key, EvaluationC
             throw new TypeMismatchError(message);
         }
 
-        final ProviderEvaluation.ProviderEvaluationBuilder<T> evaluationBuilder = ProviderEvaluation.<T>builder()
+        return ProviderEvaluation.<T>builder()
                 .value((T) value)
                 .variant(resolvedVariant)
-                .reason(reason);
+                .reason(reason)
+                .flagMetadata(getFlagMetadata(storageQueryResult))
+                .build();
+    }
+
+    private ImmutableMetadata getFlagMetadata(StorageQueryResult storageQueryResult) {
+        ImmutableMetadata.ImmutableMetadataBuilder metadataBuilder = ImmutableMetadata.builder();
+        for (Map.Entry<String, Object> entry :
+                storageQueryResult.getFlagSetMetadata().entrySet()) {
+            addEntryToMetadataBuilder(metadataBuilder, entry.getKey(), entry.getValue());
+        }
 
-        return this.metadata == null
-                ? evaluationBuilder.build()
-                : evaluationBuilder.flagMetadata(this.metadata).build();
+        if (scope != null) {
+            metadataBuilder.addString("scope", scope);
+        }
+
+        FeatureFlag flag = storageQueryResult.getFeatureFlag();
+        if (flag != null) {
+            for (Map.Entry<String, Object> entry : flag.getMetadata().entrySet()) {
+                addEntryToMetadataBuilder(metadataBuilder, entry.getKey(), entry.getValue());
+            }
+        }
+
+        return metadataBuilder.build();
+    }
+
+    private void addEntryToMetadataBuilder(
+            ImmutableMetadata.ImmutableMetadataBuilder metadataBuilder, String key, Object value) {
+        if (value instanceof Number) {
+            if (value instanceof Long) {
+                metadataBuilder.addLong(key, (Long) value);
+                return;
+            } else if (value instanceof Double) {
+                metadataBuilder.addDouble(key, (Double) value);
+                return;
+            } else if (value instanceof Integer) {
+                metadataBuilder.addInteger(key, (Integer) value);
+                return;
+            } else if (value instanceof Float) {
+                metadataBuilder.addFloat(key, (Float) value);
+                return;
+            }
+        } else if (value instanceof Boolean) {
+            metadataBuilder.addBoolean(key, (Boolean) value);
+            return;
+        } else if (value instanceof String) {
+            metadataBuilder.addString(key, (String) value);
+            return;
+        }
+        throw new IllegalArgumentException(
+                "The type of the Metadata entry with key " + key + " and value " + value + " is not supported");
     }
 }

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

@@ -5,6 +5,7 @@
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import java.util.HashMap;
 import java.util.Map;
 import lombok.EqualsAndHashCode;
 import lombok.Getter;
@@ -23,18 +24,34 @@ public class FeatureFlag {
     private final String defaultVariant;
     private final Map<String, Object> variants;
     private final String targeting;
+    private final Map<String, Object> metadata;
 
     /** Construct a flagd feature flag. */
     @JsonCreator
     public FeatureFlag(
             @JsonProperty("state") String state,
             @JsonProperty("defaultVariant") String defaultVariant,
             @JsonProperty("variants") Map<String, Object> variants,
-            @JsonProperty("targeting") @JsonDeserialize(using = StringSerializer.class) String targeting) {
+            @JsonProperty("targeting") @JsonDeserialize(using = StringSerializer.class) String targeting,
+            @JsonProperty("metadata") Map<String, Object> metadata) {
         this.state = state;
         this.defaultVariant = defaultVariant;
         this.variants = variants;
         this.targeting = targeting;
+        if (metadata == null) {
+            this.metadata = new HashMap<>();
+        } else {
+            this.metadata = metadata;
+        }
+    }
+
+    /** Construct a flagd feature flag. */
+    public FeatureFlag(String state, String defaultVariant, Map<String, Object> variants, String targeting) {
+        this.state = state;
+        this.defaultVariant = defaultVariant;
+        this.variants = variants;
+        this.targeting = targeting;
+        this.metadata = new HashMap<>();
     }
 
     /** Get targeting rule of the flag. */

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

@@ -1,7 +1,9 @@
 package dev.openfeature.contrib.providers.flagd.resolver.process.model;
 
 import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.core.TreeNode;
+import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.networknt.schema.JsonSchema;
 import com.networknt.schema.JsonSchemaFactory;
@@ -24,6 +26,7 @@
         justification = "Feature flag comes as a Json configuration, hence they must be exposed")
 public class FlagParser {
     private static final String FLAG_KEY = "flags";
+    private static final String METADATA_KEY = "metadata";
     private static final String EVALUATOR_KEY = "$evaluators";
     private static final String REPLACER_FORMAT = "\"\\$ref\":(\\s)*\"%s\"";
     private static final ObjectMapper MAPPER = new ObjectMapper();
@@ -50,8 +53,7 @@ private FlagParser() {}
     }
 
     /** Parse {@link String} for feature flags. */
-    public static Map<String, FeatureFlag> parseString(final String configuration, boolean throwIfInvalid)
-            throws IOException {
+    public static ParsingResult parseString(final String configuration, boolean throwIfInvalid) throws IOException {
         if (SCHEMA_VALIDATOR != null) {
             try (JsonParser parser = MAPPER.createParser(configuration)) {
                 Set<ValidationMessage> validationMessages = SCHEMA_VALIDATOR.validate(parser.readValueAsTree());
@@ -69,10 +71,12 @@ public static Map<String, FeatureFlag> parseString(final String configuration, b
         final String transposedConfiguration = transposeEvaluators(configuration);
 
         final Map<String, FeatureFlag> flagMap = new HashMap<>();
-
+        final Map<String, Object> flagSetMetadata;
         try (JsonParser parser = MAPPER.createParser(transposedConfiguration)) {
             final TreeNode treeNode = parser.readValueAsTree();
             final TreeNode flagNode = treeNode.get(FLAG_KEY);
+            final TreeNode metadataNode = treeNode.get(METADATA_KEY);
+            flagSetMetadata = parseMetadata(metadataNode);
 
             if (flagNode == null) {
                 throw new IllegalArgumentException("No flag configurations found in the payload");
@@ -85,7 +89,16 @@ public static Map<String, FeatureFlag> parseString(final String configuration, b
             }
         }
 
-        return flagMap;
+        return new ParsingResult(flagMap, flagSetMetadata);
+    }
+
+    private static Map<String, Object> parseMetadata(TreeNode metadataNode) throws JsonProcessingException {
+        if (metadataNode == null) {
+            return new HashMap<>();
+        }
+
+        TypeReference<Map<String, Object>> typeRef = new TypeReference<Map<String, Object>>() {};
+        return MAPPER.treeToValue(metadataNode, typeRef);
     }
 
     private static String transposeEvaluators(final String configuration) throws IOException {

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

@@ -0,0 +1,22 @@
+package dev.openfeature.contrib.providers.flagd.resolver.process.model;
+
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import java.util.Map;
+import lombok.Getter;
+
+/**
+ * The result of the parsing of a json string containing feature flag definitions.
+ */
+@Getter
+@SuppressFBWarnings(
+        value = {"EI_EXPOSE_REP"},
+        justification = "Feature flag comes as a Json configuration, hence they must be exposed")
+public class ParsingResult {
+    private final Map<String, FeatureFlag> flags;
+    private final Map<String, Object> flagSetMetadata;
+
+    public ParsingResult(Map<String, FeatureFlag> flags, Map<String, Object> flagSetMetadata) {
+        this.flags = flags;
+        this.flagSetMetadata = flagSetMetadata;
+    }
+}

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

@@ -4,6 +4,7 @@
 
 import dev.openfeature.contrib.providers.flagd.resolver.process.model.FeatureFlag;
 import dev.openfeature.contrib.providers.flagd.resolver.process.model.FlagParser;
+import dev.openfeature.contrib.providers.flagd.resolver.process.model.ParsingResult;
 import dev.openfeature.contrib.providers.flagd.resolver.process.storage.connector.Connector;
 import dev.openfeature.contrib.providers.flagd.resolver.process.storage.connector.QueuePayload;
 import dev.openfeature.flagd.grpc.sync.Sync.GetMetadataResponse;
@@ -35,6 +36,7 @@ public class FlagStore implements Storage {
     private final AtomicBoolean shutdown = new AtomicBoolean(false);
     private final BlockingQueue<StorageStateChange> stateBlockingQueue = new LinkedBlockingQueue<>(1);
     private final Map<String, FeatureFlag> flags = new HashMap<>();
+    private final Map<String, Object> flagSetMetadata = new HashMap<>();
 
     private final Connector connector;
     private final boolean throwIfInvalid;
@@ -49,6 +51,7 @@ public FlagStore(final Connector connector, final boolean throwIfInvalid) {
     }
 
     /** Initialize storage layer. */
+    @Override
     public void init() throws Exception {
         connector.init();
         Thread streamer = new Thread(() -> {
@@ -68,6 +71,7 @@ public void init() throws Exception {
      *
      * @throws InterruptedException if stream can't be closed within deadline.
      */
+    @Override
     public void shutdown() throws InterruptedException {
         if (shutdown.getAndSet(true)) {
             return;
@@ -76,17 +80,23 @@ public void shutdown() throws InterruptedException {
         connector.shutdown();
     }
 
-    /** Retrieve flag for the given key. */
-    public FeatureFlag getFlag(final String key) {
+    /** Retrieve flag for the given key and the flag set metadata. */
+    @Override
+    public StorageQueryResult getFlag(final String key) {
         readLock.lock();
+        FeatureFlag flag;
+        Map<String, Object> metadata;
         try {
-            return flags.get(key);
+            flag = flags.get(key);
+            metadata = new HashMap<>(flagSetMetadata);
         } finally {
             readLock.unlock();
         }
+        return new StorageQueryResult(flag, metadata);
     }
 
     /** Retrieve blocking queue to check storage status. */
+    @Override
     public BlockingQueue<StorageStateChange> getStateQueue() {
         return stateBlockingQueue;
     }
@@ -100,14 +110,18 @@ private void streamerListener(final Connector connector) throws InterruptedExcep
                 case DATA:
                     try {
                         List<String> changedFlagsKeys;
-                        Map<String, FeatureFlag> flagMap =
-                                FlagParser.parseString(payload.getFlagData(), throwIfInvalid);
+                        ParsingResult parsingResult = FlagParser.parseString(payload.getFlagData(), throwIfInvalid);
+                        Map<String, FeatureFlag> flagMap = parsingResult.getFlags();
+                        Map<String, Object> flagSetMetadataMap = parsingResult.getFlagSetMetadata();
+
                         Structure metadata = parseSyncMetadata(payload.getMetadataResponse());
                         writeLock.lock();
                         try {
                             changedFlagsKeys = getChangedFlagsKeys(flagMap);
                             flags.clear();
                             flags.putAll(flagMap);
+                            flagSetMetadata.clear();
+                            flagSetMetadata.putAll(flagSetMetadataMap);
                         } finally {
                             writeLock.unlock();
                         }

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

@@ -1,6 +1,5 @@
 package dev.openfeature.contrib.providers.flagd.resolver.process.storage;
 
-import dev.openfeature.contrib.providers.flagd.resolver.process.model.FeatureFlag;
 import java.util.concurrent.BlockingQueue;
 
 /** Storage abstraction for resolver. */
@@ -9,7 +8,7 @@ public interface Storage {
 
     void shutdown() throws InterruptedException;
 
-    FeatureFlag getFlag(final String key);
+    StorageQueryResult getFlag(final String key);
 
     BlockingQueue<StorageStateChange> getStateQueue();
 }

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

@@ -0,0 +1,24 @@
+package dev.openfeature.contrib.providers.flagd.resolver.process.storage;
+
+import dev.openfeature.contrib.providers.flagd.resolver.process.model.FeatureFlag;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import java.util.Map;
+import lombok.Getter;
+
+/**
+ * To be returned by the storage when a flag is queried. Contains the flag (iff a flag associated with the given key
+ * exists, null otherwise) and flag set metadata
+ */
+@Getter
+@SuppressFBWarnings(
+        value = {"EI_EXPOSE_REP"},
+        justification = "The storage provides access to both feature flags and flag set metadata")
+public class StorageQueryResult {
+    private final FeatureFlag featureFlag;
+    private final Map<String, Object> flagSetMetadata;
+
+    public StorageQueryResult(FeatureFlag featureFlag, Map<String, Object> flagSetMetadata) {
+        this.featureFlag = featureFlag;
+        this.flagSetMetadata = flagSetMetadata;
+    }
+}