Use Binding::ResolutionDetails everywhere

Strech · Strech · commit b1a978fff669 · 2025-11-07T16:05:13.000+01:00
diff --git a/lib/datadog/open_feature/evaluation_engine.rb b/lib/datadog/open_feature/evaluation_engine.rb
@@ -37,6 +37,7 @@ def fetch_value(flag_key:, expected_type:, evaluation_context: nil)
         # do we want to go that way?
 
         @evaluator.get_assignment(flag_key, evaluation_context, expected_type, Time.now.utc.to_i)
+        # TODO: insert reporting here
       rescue => e
         @telemetry.report(e, description: 'OpenFeature: Failed to fetch value for flag')
 
diff --git a/lib/datadog/open_feature/exposures/models/event.rb b/lib/datadog/open_feature/exposures/models/event.rb
@@ -17,41 +17,15 @@ class Event
             FalseClass
           ].freeze
 
-          # NOTE: The result is a Hash-like structure like this
-          #
-          # {
-          #     "flag": "boolean-one-of-matches",
-          #     "variationType": "INTEGER",
-          #     "defaultValue": 0,
-          #     "targetingKey": "haley",
-          #     "attributes": {
-          #       "not_matches_flag": "False"
-          #     },
-          #     "result": {
-          #       "value": 4,
-          #       "variant": "4",
-          #       "flagMetadata": {
-          #         "allocationKey": "4-for-not-matches",
-          #         "variationType": "number",
-          #         "doLog": true
-          #       }
-          #     }
-          # }
           class << self
-            def build(result, context:)
+            def build(result, flag_key:, context:)
               payload = {
                 timestamp: current_timestamp_ms,
-                allocation: {
-                  key: result.dig('result', 'flagMetadata', 'allocationKey').to_s
-                },
-                flag: {
-                  key: result['flag'].to_s
-                },
-                variant: {
-                  key: result.dig('result', 'variant').to_s
-                },
+                allocation: {key: result.allocation_key},
+                flag: {key: flag_key},
+                variant: {key: result.variant},
                 subject: {
-                  id: result['targetingKey'].to_s,
+                  id: context.targeting_key,
                   attributes: extract_attributes(context)
                 }
               }
diff --git a/lib/datadog/open_feature/exposures/reporter.rb b/lib/datadog/open_feature/exposures/reporter.rb
@@ -14,10 +14,10 @@ def initialize(worker, telemetry:, logger: Datadog.logger)
           @deduplicator = Deduplicator.new
         end
 
-        def report(result, context:)
-          return false unless result.dig('result', 'flagMetadata', 'doLog')
+        def report(result, flag_key:, context:)
+          return false unless result.do_log
 
-          event = Models::Event.build(result, context: context)
+          event = Models::Event.build(result, flag_key: flag_key, context: context)
           return false if @deduplicator.duplicate?(event)
 
           @worker.enqueue(event)
diff --git a/sig/datadog/open_feature/evaluation_engine.rbs b/sig/datadog/open_feature/evaluation_engine.rbs
@@ -3,7 +3,7 @@ module Datadog
     class EvaluationEngine
       ALLOWED_TYPES: ::Array[::Symbol]
 
-      attr_writer configuration: ::String?
+      attr_accessor configuration: ::String?
 
       attr_reader reporter: Exposures::Reporter
 
@@ -12,8 +12,8 @@ module Datadog
       def fetch_value: (
         flag_key: ::String,
         expected_type: ::Symbol,
-        ?evaluation_context: ::OpenFeature::SDK::EvaluationContext
-      ) -> ::Hash[::Symbol, untyped]
+        ?evaluation_context: ::OpenFeature::SDK::EvaluationContext?
+      ) -> Binding::ResolutionDetails
 
       def reconfigure!: () -> void
     end
diff --git a/sig/datadog/open_feature/exposures/deduplicator.rbs b/sig/datadog/open_feature/exposures/deduplicator.rbs
@@ -6,12 +6,10 @@ module Datadog
 
         def initialize: (?limit: ::Integer) -> void
 
-        def duplicate?: (Models::Event) -> bool
+        def duplicate?: (Models::Event event) -> bool
 
         private
 
-        def key: (::String, ::String) -> ::String
-
         def digest: (::String, ::String) -> ::Integer
       end
     end
diff --git a/sig/datadog/open_feature/exposures/reporter.rbs b/sig/datadog/open_feature/exposures/reporter.rbs
@@ -2,23 +2,13 @@ module Datadog
   module OpenFeature
     module Exposures
       class Reporter
-        def initialize: (Worker, ?logger: Core::Logger, telemetry: Core::Telemetry::Component) -> void
+        def initialize: (Worker worker, telemetry: Core::Telemetry::Component, ?logger: Core::Logger) -> void
 
-        def report: (::Hash[untyped, untyped], context: untyped) -> bool
-
-        def flush: () -> void
-
-        private
-
-        def normalize: (untyped, untyped) -> ::Hash[Symbol, untyped]?
-
-        def build_exposure: (::Hash[Symbol, untyped]) -> ::Hash[Symbol, untyped]
-
-        def extract_targeting_key: (untyped) -> (String | nil)
-
-        def extract_attributes: (::Hash[untyped, untyped], untyped) -> (::Hash[untyped, untyped] | nil)
-
-        def ensure_hash: (untyped) -> ::Hash[untyped, untyped]
+        def report: (
+          Binding::ResolutionDetails result,
+          flag_key: ::String,
+          context: ::OpenFeature::SDK::EvaluationContext
+        ) -> bool
       end
     end
   end
diff --git a/sig/datadog/open_feature/models/event.rbs b/sig/datadog/open_feature/models/event.rbs
@@ -7,7 +7,11 @@ module Datadog
 
           TARGETING_KEY_FIELD: ::String
 
-          def self.build: (::Hash[untyped, untyped], context: untyped) -> Event?
+          def self.build: (
+            Binding::ResolutionDetails result,
+            flag_key: ::String,
+            context: ::OpenFeature::SDK::EvaluationContext
+          ) -> Event
 
           def initialize: (::Hash[Symbol, untyped]) -> void
 
@@ -21,11 +25,9 @@ module Datadog
 
           def to_h: () -> ::Hash[Symbol, untyped]
 
-        def self.current_timestamp_ms: () -> ::Integer
+          def self.current_timestamp_ms: () -> ::Integer
 
-        def self.extract_attributes: (untyped) -> ::Hash[untyped, untyped]
-
-        def self.context_targeting_key: (untyped) -> (::String | nil)
+          def self.extract_attributes: (::OpenFeature::SDK::EvaluationContext) -> ::Hash[::String, untyped]
         end
       end
     end
diff --git a/spec/datadog/open_feature/exposures/models/event_spec.rb b/spec/datadog/open_feature/exposures/models/event_spec.rb
@@ -8,30 +8,24 @@
     before { allow(Datadog::Core::Utils::Time).to receive(:now).and_return(now) }
 
     let(:now) { Time.utc(2025, 1, 1, 0, 0, 0) }
-    let(:event) { described_class.build(result, context: context) }
+    let(:event) { described_class.build(result, flag_key: 'feature_flag', context: context) }
     let(:result) do
-      {
-        'flag' => 'feature_flag',
-        'variationType' => 'INTEGER',
-        'defaultValue' => 0,
-        'targetingKey' => 'john-doe',
-        'attributes' => {
-          'not_matches_flag' => 'False'
+      Datadog::OpenFeature::Binding::ResolutionDetails.new(
+        value: 4,
+        allocation_key: '4-for-john-doe',
+        variant: '4',
+        flag_metadata: {
+          'allocationKey' => '4-for-john-doe',
+          'variationType' => 'number',
+          'doLog' => true
         },
-        'result' => {
-          'value' => 4,
-          'variant' => '4',
-          'flagMetadata' => {
-            'allocationKey' => '4-for-john-doe',
-            'variationType' => 'number',
-            'doLog' => true
-          }
-        }
-      }
+        do_log: true
+      )
     end
     let(:context) do
       instance_double(
         'OpenFeature::SDK::EvaluationContext',
+        targeting_key: 'john-doe',
         fields: {
           'targeting_key' => 'john-doe',
           'age' => 21,
@@ -82,7 +76,7 @@
     context 'when context does not contain extra fields' do
       let(:context) do
         instance_double(
-          'OpenFeature::SDK::EvaluationContext', fields: {'targeting_key' => 'john-doe'}
+          'OpenFeature::SDK::EvaluationContext', targeting_key: 'john-doe', fields: {'targeting_key' => 'john-doe'}
         )
       end
       let(:expected) do
diff --git a/spec/datadog/open_feature/exposures/reporter_spec.rb b/spec/datadog/open_feature/exposures/reporter_spec.rb
@@ -15,23 +15,21 @@
   let(:deduplicator) { instance_double(Datadog::OpenFeature::Exposures::Deduplicator) }
   let(:context) do
     instance_double(
-      'OpenFeature::SDK::EvaluationContext', fields: {'targeting_key' => 'john-doe'}
+      'OpenFeature::SDK::EvaluationContext', targeting_key: 'john-doe', fields: {'targeting_key' => 'john-doe'}
     )
   end
   let(:result) do
-    {
-      'flag' => 'feature_flag',
-      'targetingKey' => 'john-doe',
-      'result' => {
-        'value' => 4,
-        'variant' => '4',
-        'flagMetadata' => {
-          'allocationKey' => '4-for-john-doe',
-          'variationType' => 'number',
-          'doLog' => true
-        }
-      }
-    }
+    Datadog::OpenFeature::Binding::ResolutionDetails.new(
+      value: 4,
+      allocation_key: '4-for-john-doe',
+      variant: '4',
+      flag_metadata: {
+        'allocationKey' => '4-for-john-doe',
+        'variationType' => 'number',
+        'doLog' => true
+      },
+      do_log: true
+    )
   end
 
   describe '#report' do
@@ -40,7 +38,7 @@
 
       it 'enqueues event' do
         expect(worker).to receive(:enqueue).and_return(true)
-        expect(reporter.report(result, context: context)).to be(true)
+        expect(reporter.report(result, flag_key: 'feature_flag', context: context)).to be(true)
       end
     end
 
@@ -49,7 +47,7 @@
 
       it 'does not enqueue event again' do
         expect(worker).not_to receive(:enqueue)
-        expect(reporter.report(result, context: context)).to be(false)
+        expect(reporter.report(result, flag_key: 'feature_flag', context: context)).to be(false)
       end
     end
 
@@ -61,7 +59,7 @@
 
       it 'returns false and logs debug message' do
         expect_lazy_log(logger, :debug, /OpenFeature: Reporter failed to enqueue exposure: StandardError: boom/)
-        expect(reporter.report(result, context: context)).to be(false)
+        expect(reporter.report(result, flag_key: 'feature_flag', context: context)).to be(false)
       end
     end
 
@@ -86,7 +84,7 @@
         expect(deduplicator).not_to receive(:duplicate?)
         expect(worker).not_to receive(:enqueue)
 
-        expect(reporter.report(result, context: context)).to be(false)
+        expect(reporter.report(result, flag_key: 'feature_flag', context: context)).to be(false)
       end
     end
   end
diff --git a/vendor/rbs/openfeature-sdk/0/openfeature-sdk.rbs b/vendor/rbs/openfeature-sdk/0/openfeature-sdk.rbs
@@ -1,6 +1,9 @@
 module OpenFeature
   module SDK
     class EvaluationContext
+      def targeting_key: () -> ::String?
+
+      def fields: () -> ::Hash[::String, untyped]
     end
 
     module Provider
@@ -14,7 +17,7 @@ module OpenFeature
         def self.new: (
           ?value: value_t,
           ?variant: untyped,
-          ?flag_metadata: untyped,
+          ?flag_metadata: ::Hash[untyped, untyped]?,
           ?error_code: ErrorCode::t,
           ?error_message: ::String,
           ?reason: Reason::t
