fix(flagd): address code review feedback for WASM resolver

- Load WASM from classpath instead of hardcoded path
- Use static SecureRandom for efficiency
- Fix JSON exception handling to not terminate stateWatcher thread
- Implement shutdown() method properly
- Change generic Exception to GeneralError
- Fix ImmutableMetadataDeserializer to preserve value types
- Move OBJECT_MAPPER config to static block
- Make stateWatcher a class field for proper shutdown
- Remove dead code (getFlagMetadata, FLAGD_SELECTOR_KEY)
- Extract serializers/deserializers to jackson package

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

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

Author: aepfli

providers/flagd/WASM_HOST_IMPORTS.md

@@ -76,6 +76,9 @@ private static HostFunction createGetCurrentTimeUnixSeconds() {
 
 **Implementation:**
 ```java
+// Static SecureRandom instance for efficiency (reused across calls)
+private static final SecureRandom SECURE_RANDOM = new SecureRandom();
+
 private static HostFunction createGetRandomValues() {
     return new HostFunction(
             "__wbindgen_placeholder__",
@@ -93,7 +96,7 @@ private static HostFunction createGetRandomValues() {
                 // The WASM code expects a 32-byte buffer at bufferPtr
                 // Fill it with cryptographically secure random bytes
                 byte[] randomBytes = new byte[32];
-                new java.security.SecureRandom().nextBytes(randomBytes);
+                SECURE_RANDOM.nextBytes(randomBytes);
 
                 Memory memory = instance.memory();
                 memory.write(bufferPtr, randomBytes);

providers/flagd/flagd_evaluator.wasm

@@ -12,8 +12,8 @@
 import com.dylibso.chicory.wasm.types.FunctionType;
 import com.dylibso.chicory.wasm.types.ValType;
 import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
+import java.io.InputStream;
+import java.security.SecureRandom;
 import java.util.List;
 import java.util.function.Function;
 
@@ -29,11 +29,16 @@ public final class FlagdWasmRuntime {
 
     private static final WasmModule WASM_MODULE;
     private static final Function<Instance, Machine> MACHINE_FUNCTION;
+    private static final SecureRandom SECURE_RANDOM = new SecureRandom();
 
     static {
         byte[] wasmBytes;
-        try {
-            wasmBytes = Files.readAllBytes(Path.of("flagd_evaluator.wasm"));
+        try (InputStream wasmStream =
+                FlagdWasmRuntime.class.getResourceAsStream("/flagd_evaluator.wasm")) {
+            if (wasmStream == null) {
+                throw new IOException("WASM resource 'flagd_evaluator.wasm' not found in classpath");
+            }
+            wasmBytes = wasmStream.readAllBytes();
         } catch (IOException e) {
             throw new RuntimeException("Failed to load flagd_evaluator.wasm", e);
         }
@@ -148,7 +153,7 @@ private static HostFunction createGetRandomValues() {
                     // The WASM code expects a 32-byte buffer at bufferPtr
                     // Fill it with cryptographically secure random bytes
                     byte[] randomBytes = new byte[32];
-                    new java.security.SecureRandom().nextBytes(randomBytes);
+                    SECURE_RANDOM.nextBytes(randomBytes);
 
                     Memory memory = instance.memory();
                     memory.write(bufferPtr, randomBytes);

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

@@ -11,21 +11,16 @@
 import com.dylibso.chicory.runtime.Memory;
 import com.dylibso.chicory.wasm.types.FunctionType;
 import com.dylibso.chicory.wasm.types.ValType;
-import com.fasterxml.jackson.core.JsonGenerator;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.JavaType;
-import com.fasterxml.jackson.databind.JsonDeserializer;
-import com.fasterxml.jackson.databind.JsonMappingException;
-import com.fasterxml.jackson.databind.JsonSerializer;
 import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.SerializerProvider;
 import com.fasterxml.jackson.databind.module.SimpleModule;
 import com.google.protobuf.Struct;
 import dev.openfeature.contrib.providers.flagd.FlagdOptions;
 import dev.openfeature.contrib.providers.flagd.resolver.Resolver;
 import dev.openfeature.contrib.providers.flagd.resolver.common.FlagdProviderEvent;
-import dev.openfeature.contrib.providers.flagd.resolver.process.model.FeatureFlag;
-import dev.openfeature.contrib.providers.flagd.resolver.process.storage.StorageQueryResult;
+import dev.openfeature.contrib.providers.flagd.resolver.process.jackson.ImmutableMetadataDeserializer;
+import dev.openfeature.contrib.providers.flagd.resolver.process.jackson.LayeredEvalContextSerializer;
 import dev.openfeature.contrib.providers.flagd.resolver.process.storage.connector.QueuePayload;
 import dev.openfeature.contrib.providers.flagd.resolver.process.storage.connector.QueueSource;
 import dev.openfeature.contrib.providers.flagd.resolver.process.storage.connector.file.FileQueueSource;
@@ -38,8 +33,7 @@
 import dev.openfeature.sdk.ProviderEvent;
 import dev.openfeature.sdk.Structure;
 import dev.openfeature.sdk.Value;
-import java.io.IOException;
-import java.util.List;
+import dev.openfeature.sdk.exceptions.GeneralError;
 import java.util.Map;
 import java.util.function.Consumer;
 import lombok.extern.slf4j.Slf4j;
@@ -54,9 +48,8 @@ public class InProcessWasmResolver implements Resolver {
 
     private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
 
-    {
-
-        // Register this module with your ObjectMapper
+    static {
+        // Register custom serializers/deserializers with the ObjectMapper
         SimpleModule module = new SimpleModule();
         module.addDeserializer(ImmutableMetadata.class, new ImmutableMetadataDeserializer());
         module.addSerializer(LayeredEvaluationContext.class, new LayeredEvalContextSerializer());
@@ -66,6 +59,7 @@ public class InProcessWasmResolver implements Resolver {
     private final Consumer<FlagdProviderEvent> onConnectionEvent;
     private final String scope;
     private final QueueSource connector;
+    private Thread stateWatcher;
     private final ExportFunction validationMode;
     private ExportFunction updateStore;
     private ExportFunction alloc;
@@ -109,14 +103,13 @@ public InProcessWasmResolver(FlagdOptions options, Consumer<FlagdProviderEvent>
     public void init() throws Exception {
 
         connector.init();
-        final Thread stateWatcher = new Thread(() -> {
-            try {
-                var streamPayloads = connector.getStreamQueue();
-                while (true) {
+        this.stateWatcher = new Thread(() -> {
+            var streamPayloads = connector.getStreamQueue();
+            while (!Thread.currentThread().isInterrupted()) {
+                try {
                     final QueuePayload payload = streamPayloads.take();
                     switch (payload.getType()) {
                         case DATA:
-                            List<String> changedFlagsKeys;
                             var data = payload.getFlagData().getBytes();
                             long dataPtr = alloc.apply(data.length)[0];
                             memory.write((int) dataPtr, data);
@@ -146,26 +139,30 @@ public void init() throws Exception {
                         default:
                             log.warn(String.format("Payload with unknown type: %s", payload.getType()));
                     }
+                } catch (InterruptedException e) {
+                    log.debug("Storage state watcher interrupted", e);
+                    Thread.currentThread().interrupt();
+                    break;
+                } catch (JsonProcessingException e) {
+                    log.error("Error processing flag data, skipping update", e);
                 }
-            } catch (InterruptedException e) {
-                log.warn("Storage state watcher interrupted", e);
-                Thread.currentThread().interrupt();
-            } catch (JsonMappingException e) {
-                throw new RuntimeException(e);
-            } catch (JsonProcessingException e) {
-                throw new RuntimeException(e);
             }
         });
-        stateWatcher.setDaemon(true);
-        stateWatcher.start();
+        this.stateWatcher.setDaemon(true);
+        this.stateWatcher.start();
     }
 
     /**
      * Shutdown in-process resolver.
      *
      * @throws InterruptedException if stream can't be closed within deadline.
      */
-    public void shutdown() throws InterruptedException {}
+    public void shutdown() throws InterruptedException {
+        if (stateWatcher != null) {
+            stateWatcher.interrupt();
+        }
+        connector.shutdown();
+    }
 
     /**
      * Resolve a boolean flag.
@@ -253,62 +250,16 @@ private <T> ProviderEvaluation<T> resolve(Class<T> type, String key, EvaluationC
             ProviderEvaluation<T> providerEvaluation = OBJECT_MAPPER.readValue(result, javaType);
 
             return providerEvaluation;
+        } catch (JsonProcessingException e) {
+            throw new GeneralError("Error deserializing WASM evaluation result", e);
         } catch (Exception e) {
-            throw new RuntimeException(e);
+            throw new GeneralError("Error during WASM evaluation", e);
         } finally {
             dealloc.apply(flagPtr, flagBytes.length);
             dealloc.apply(ctxPtr, ctxBytes.length);
         }
     }
 
-    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());
-        }
-
-        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");
-    }
-
     private Structure parseSyncContext(Struct syncContext) {
         if (syncContext != null) {
             try {
@@ -319,36 +270,4 @@ private Structure parseSyncContext(Struct syncContext) {
         }
         return new ImmutableStructure();
     }
-
-    // Implement a custom deserializer for ImmutableMetadata
-    public class ImmutableMetadataDeserializer extends JsonDeserializer<ImmutableMetadata> {
-        @Override
-        public ImmutableMetadata deserialize(
-                com.fasterxml.jackson.core.JsonParser p, com.fasterxml.jackson.databind.DeserializationContext ctxt)
-                throws IOException {
-            // Deserialize into a Map or DTO, then use the builder
-            Map<String, Object> map = p.readValueAs(Map.class);
-            ImmutableMetadata.ImmutableMetadataBuilder builder = ImmutableMetadata.builder();
-            for (Map.Entry<String, Object> entry : map.entrySet()) {
-                builder.addString(entry.getKey(), entry.getValue().toString());
-            }
-            return builder.build();
-        }
-    }
-
-    public class LayeredEvalContextSerializer extends JsonSerializer<LayeredEvaluationContext> {
-        @Override
-        public void serialize(LayeredEvaluationContext ctx, JsonGenerator gen, SerializerProvider serializers)
-                throws IOException {
-            gen.writeStartObject();
-
-            // Use the keySet and getValue to stream the entries
-            for (String key : ctx.keySet()) {
-                Object value = ctx.getValue(key);
-                gen.writeObjectField(key, value);
-            }
-
-            gen.writeEndObject();
-        }
-    }
 }

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

@@ -0,0 +1,53 @@
+package dev.openfeature.contrib.providers.flagd.resolver.process.jackson;
+
+import com.fasterxml.jackson.databind.JsonDeserializer;
+import dev.openfeature.sdk.ImmutableMetadata;
+import java.io.IOException;
+import java.util.Map;
+
+/**
+ * Custom deserializer for ImmutableMetadata that preserves value types.
+ *
+ * <p>This deserializer properly handles different value types (Boolean, String, Integer, Long,
+ * Double, Float) instead of converting everything to strings.
+ */
+public class ImmutableMetadataDeserializer extends JsonDeserializer<ImmutableMetadata> {
+
+    @Override
+    public ImmutableMetadata deserialize(
+            com.fasterxml.jackson.core.JsonParser p, com.fasterxml.jackson.databind.DeserializationContext ctxt)
+            throws IOException {
+        @SuppressWarnings("unchecked")
+        Map<String, Object> map = p.readValueAs(Map.class);
+        ImmutableMetadata.ImmutableMetadataBuilder builder = ImmutableMetadata.builder();
+        for (Map.Entry<String, Object> entry : map.entrySet()) {
+            addEntryToMetadataBuilder(builder, entry.getKey(), entry.getValue());
+        }
+        return builder.build();
+    }
+
+    private static void addEntryToMetadataBuilder(
+            ImmutableMetadata.ImmutableMetadataBuilder metadataBuilder, String key, Object value) {
+        if (value instanceof Number) {
+            if (value instanceof Long) {
+                metadataBuilder.addLong(key, (Long) value);
+            } else if (value instanceof Double) {
+                metadataBuilder.addDouble(key, (Double) value);
+            } else if (value instanceof Integer) {
+                metadataBuilder.addInteger(key, (Integer) value);
+            } else if (value instanceof Float) {
+                metadataBuilder.addFloat(key, (Float) value);
+            } else {
+                // Fallback for other Number types
+                metadataBuilder.addDouble(key, ((Number) value).doubleValue());
+            }
+        } else if (value instanceof Boolean) {
+            metadataBuilder.addBoolean(key, (Boolean) value);
+        } else if (value instanceof String) {
+            metadataBuilder.addString(key, (String) value);
+        } else if (value != null) {
+            // Fallback to string for unknown types
+            metadataBuilder.addString(key, value.toString());
+        }
+    }
+}

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

@@ -0,0 +1,30 @@
+package dev.openfeature.contrib.providers.flagd.resolver.process.jackson;
+
+import com.fasterxml.jackson.core.JsonGenerator;
+import com.fasterxml.jackson.databind.JsonSerializer;
+import com.fasterxml.jackson.databind.SerializerProvider;
+import dev.openfeature.sdk.LayeredEvaluationContext;
+import java.io.IOException;
+
+/**
+ * Custom serializer for LayeredEvaluationContext.
+ *
+ * <p>This serializer iterates through the context's keys and writes each key-value pair
+ * to the JSON output.
+ */
+public class LayeredEvalContextSerializer extends JsonSerializer<LayeredEvaluationContext> {
+
+    @Override
+    public void serialize(LayeredEvaluationContext ctx, JsonGenerator gen, SerializerProvider serializers)
+            throws IOException {
+        gen.writeStartObject();
+
+        // Use the keySet and getValue to stream the entries
+        for (String key : ctx.keySet()) {
+            Object value = ctx.getValue(key);
+            gen.writeObjectField(key, value);
+        }
+
+        gen.writeEndObject();
+    }
+}

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

@@ -17,7 +17,6 @@
 import dev.openfeature.flagd.grpc.sync.Sync.SyncFlagsResponse;
 import dev.openfeature.sdk.Awaitable;
 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-import io.grpc.Metadata;
 import io.grpc.Status;
 import io.grpc.StatusRuntimeException;
 import io.grpc.stub.StreamObserver;
@@ -38,9 +37,6 @@
 public class SyncStreamQueueSource implements QueueSource {
     private static final int QUEUE_SIZE = 5;
 
-    private static final Metadata.Key<String> FLAGD_SELECTOR_KEY =
-            Metadata.Key.of("Flagd-Selector", Metadata.ASCII_STRING_MARSHALLER);
-
     private final AtomicBoolean shutdown = new AtomicBoolean(false);
     private final AtomicBoolean shouldThrottle = new AtomicBoolean(false);
     private final int streamDeadline;