Fix InternalEvaluator compatibility and resolve class conflicts

- Remove unused _configuration parameter from get_assignment method
- Rename ResolutionDetails to EvaluationResult to avoid class conflict with OpenFeature SDK
- Fix variationType output format in flagMetadata (INTEGER→number, BOOLEAN→boolean, etc.)
- Add fallback from targeting_key when id attribute is missing in rule evaluation
- Update all method signatures and test files to match new get_assignment interface
- Fix test data path in test_cases_spec.rb to use local fixtures
- Add flagMetadata validation in tests

Author: sameerank

lib/datadog/open_feature/binding/evaluator.rb

@@ -1,7 +1,7 @@
 module Datadog
   module OpenFeature
     module Binding
-      ResolutionDetails = Struct.new(
+      EvaluationResult = Struct.new(
         :value,
         :reason,
         :variant,
@@ -17,8 +17,8 @@ def initialize(ufc_json)
           @ufc_json = ufc_json
         end
 
-        def get_assignment(_configuration, _flag_key, _evaluation_context, expected_type, _time, _default_value)
-          ResolutionDetails.new(
+        def get_assignment(_flag_key, _evaluation_context, expected_type, _time, _default_value)
+          EvaluationResult.new(
             value: generate(expected_type),
             reason: 'hardcoded',
             variant: 'hardcoded'

lib/datadog/open_feature/binding/internal_evaluator.rb

@@ -24,10 +24,10 @@ def initialize(ufc_json)
           @parsed_config = parse_and_validate_json(ufc_json)
         end
 
-        def get_assignment(_configuration, flag_key, _evaluation_context, expected_type, _time, default_value)
+        def get_assignment(flag_key, _evaluation_context, expected_type, _time, default_value)
           # Return default value if JSON parsing failed during initialization
-          if @parsed_config.is_a?(ResolutionDetails)
-            return ResolutionDetails.new(
+          if @parsed_config.is_a?(EvaluationResult)
+            return EvaluationResult.new(
               value: default_value,
               error_code: @parsed_config.error_code,
               error_message: @parsed_config.error_message
@@ -59,18 +59,18 @@ def get_assignment(_configuration, flag_key, _evaluation_context, expected_type,
             selected_allocation, selected_variation, reason = evaluate_flag_allocations(flag, _evaluation_context, _time)
 
             # Return the actual assignment result
-            ResolutionDetails.new(
+            EvaluationResult.new(
               value: selected_variation.value,
               reason: reason,
               variant: selected_variation.key,
               flag_metadata: {
                 'allocationKey' => selected_allocation.key,
                 'doLog' => selected_allocation.do_log,
-                'variationType' => flag.variation_type
+                'variationType' => convert_variation_type_for_output(flag.variation_type)
               }
             )
           rescue EvaluationError => e
-            # Convert evaluation errors to ResolutionDetails with default value - matches Rust error propagation
+            # Convert evaluation errors to EvaluationResult with default value - matches Rust error propagation
             create_evaluation_error_with_default(e.code, e.message, default_value)
           end
         end
@@ -110,23 +110,23 @@ def parse_and_validate_json(ufc_json)
         end
 
         def create_parse_error(error_code, error_message)
-          ResolutionDetails.new(
+          EvaluationResult.new(
             value: nil,
             error_code: error_code,
             error_message: error_message
           )
         end
 
         def create_evaluation_error(error_code, error_message)
-          ResolutionDetails.new(
+          EvaluationResult.new(
             value: nil,
             error_code: error_code,
             error_message: error_message
           )
         end
 
         def create_evaluation_error_with_default(error_code, error_message, default_value)
-          ResolutionDetails.new(
+          EvaluationResult.new(
             value: default_value,
             error_code: error_code,
             error_message: error_message
@@ -255,11 +255,23 @@ def get_attribute_from_context(attribute_name, evaluation_context)
 
           # If evaluation_context is a hash, look up the attribute
           if evaluation_context.respond_to?(:[])
-            evaluation_context[attribute_name] || evaluation_context[attribute_name.to_sym]
+            attribute_value = evaluation_context[attribute_name] || evaluation_context[attribute_name.to_sym]
+            
+            # Special handling for 'id' attribute: if not present, use targeting_key
+            if attribute_value.nil? && attribute_name == 'id'
+              attribute_value = get_targeting_key(evaluation_context)
+            end
+            
+            attribute_value
           elsif evaluation_context.respond_to?(attribute_name)
             evaluation_context.send(attribute_name)
           else
-            nil
+            # Special handling for 'id' attribute: if not present, use targeting_key
+            if attribute_name == 'id'
+              get_targeting_key(evaluation_context)
+            else
+              nil
+            end
           end
         end
 
@@ -448,6 +460,19 @@ def determine_assignment_reason(allocation)
             AssignmentReason::SPLIT
           end
         end
+
+        def convert_variation_type_for_output(variation_type)
+          # Convert from SCREAMING_SNAKE_CASE to lowercase format for output
+          # This matches the expected test format
+          case variation_type
+          when VariationType::STRING then 'string'
+          when VariationType::INTEGER then 'number'
+          when VariationType::NUMERIC then 'number'
+          when VariationType::BOOLEAN then 'boolean'
+          when VariationType::JSON then 'object'
+          else variation_type # fallback to original value
+          end
+        end
       end
     end
   end

lib/datadog/open_feature/evaluation_engine.rb

@@ -42,7 +42,7 @@ def fetch_value(flag_key:, expected_type:, evaluation_context: nil, default_valu
         # In the example from the OpenFeature there is zero trust to the result of the evaluation
         # do we want to go that way?
 
-        @evaluator.get_assignment(:todo_remove_this, flag_key, evaluation_context, expected_type, Time.now.utc.to_i, default_value)
+        @evaluator.get_assignment(flag_key, evaluation_context, expected_type, Time.now.utc.to_i, default_value)
       rescue => e
         @telemetry.report(e, description: 'OpenFeature: Failed to fetch value for flag')
         ResolutionError.new(code: Ext::PROVIDER_FATAL, message: e.message, reason: Ext::ERROR)

sig/datadog/open_feature/binding/evaluator.rbs

@@ -1,7 +1,7 @@
 module Datadog
   module OpenFeature
     module Binding
-      class ResolutionDetails < ::Struct[untyped]
+      class EvaluationResult < ::Struct[untyped]
         attr_reader value: untyped
 
         attr_reader reason: ::String
@@ -33,8 +33,9 @@ module Datadog
           ::String flag_key,
           untyped evaluation_context,
           ::Symbol expected_type,
-          ::Integer time
-        ) -> ResolutionDetails
+          ::Integer time,
+          untyped default_value
+        ) -> EvaluationResult
 
         private
 

sig/datadog/open_feature/evaluation_engine.rbs

@@ -23,7 +23,7 @@ module Datadog
         flag_key: ::String,
         expected_type: ::Symbol,
         ?evaluation_context: ::OpenFeature::SDK::EvaluationContext
-      ) -> (Binding::ResolutionDetails | ResolutionError)
+      ) -> (Binding::EvaluationResult | ResolutionError)
 
       def reconfigure!: () -> void
     end

spec/datadog/open_feature/binding/allocation_matching_spec.rb

@@ -41,7 +41,7 @@
     let(:evaluator) { Datadog::OpenFeature::Binding::InternalEvaluator.new(flag_config.to_json) }
 
     it 'skips expired allocations and uses active ones' do
-      result = evaluator.get_assignment(nil, "time_test_flag", {}, :string, Time.now, "default")
+      result = evaluator.get_assignment("time_test_flag", {}, :string, Time.now, "default")
 
       expect(result.error_code).to be_nil
       expect(result.value).to eq("treatment_value") # Should use active allocation
@@ -51,7 +51,7 @@
     end
 
     it 'returns assignment reason based on allocation properties' do
-      result = evaluator.get_assignment(nil, "time_test_flag", {}, :string, Time.now, "default")
+      result = evaluator.get_assignment("time_test_flag", {}, :string, Time.now, "default")
 
       expect(result.reason).to eq("STATIC") # Single split with no shards = static
     end
@@ -61,16 +61,16 @@
     let(:evaluator) { Datadog::OpenFeature::Binding::InternalEvaluator.new('{"flags": {}}') }
 
     it 'returns user default on flag lookup errors' do
-      result = evaluator.get_assignment(nil, "missing_flag", {}, :string, Time.now, "user_fallback")
+      result = evaluator.get_assignment("missing_flag", {}, :string, Time.now, "user_fallback")
 
       expect(result.error_code).to eq("FLAG_UNRECOGNIZED_OR_DISABLED") 
       expect(result.value).to eq("user_fallback")
     end
 
     it 'preserves different default types correctly' do
-      string_result = evaluator.get_assignment(nil, "missing", {}, :string, Time.now, "string_default")
-      number_result = evaluator.get_assignment(nil, "missing", {}, :float, Time.now, 3.14)
-      bool_result = evaluator.get_assignment(nil, "missing", {}, :boolean, Time.now, true)
+      string_result = evaluator.get_assignment("missing", {}, :string, Time.now, "string_default")
+      number_result = evaluator.get_assignment("missing", {}, :float, Time.now, 3.14)
+      bool_result = evaluator.get_assignment("missing", {}, :boolean, Time.now, true)
 
       expect(string_result.value).to eq("string_default")
       expect(number_result.value).to eq(3.14) 
@@ -101,7 +101,7 @@
       }
 
       evaluator = Datadog::OpenFeature::Binding::InternalEvaluator.new(config_with_time_bounds.to_json)
-      result = evaluator.get_assignment(nil, "timed_flag", {}, :boolean, Time.now, false)
+      result = evaluator.get_assignment("timed_flag", {}, :boolean, Time.now, false)
 
       expect(result.error_code).to be_nil
       expect(result.reason).to eq("TARGETING_MATCH") # Has time bounds