Create Reporter for exposures reporting

(AI generated)

Author: Strech

lib/datadog/open_feature/component.rb

@@ -2,6 +2,7 @@
 
 require_relative 'evaluation_engine'
 require_relative 'exposures'
+require_relative 'transport/http'
 
 module Datadog
   module OpenFeature
@@ -31,11 +32,18 @@ def initialize(settings, agent_settings, logger:, telemetry:)
         @logger = logger
         @telemetry = telemetry
 
-        @engine = EvaluationEngine.new(telemetry, logger: logger)
+        transport = Transport::HTTP.exposures(agent_settings: agent_settings, logger: logger)
+        @worker = Exposures::Worker.new(transport: transport, logger: logger)
+        @reporter = Exposures::Reporter.new(worker: @worker, logger: logger)
+        @engine = EvaluationEngine.new(@reporter, telemetry: telemetry, logger: logger)
       end
 
       def shutdown!
-        # no-op
+        @reporter&.clear
+        return unless defined?(@worker) && @worker
+
+        @worker.flush
+        @worker.stop(true)
       end
     end
   end

lib/datadog/open_feature/evaluation_engine.rb

@@ -8,12 +8,14 @@ module OpenFeature
     # This class performs the evaluation of the feature flag
     class EvaluationEngine
       attr_accessor :configuration
+      attr_reader :reporter
 
       ResolutionError = Struct.new(:reason, :code, :message, keyword_init: true)
 
       ALLOWED_TYPES = %i[boolean string number float integer object].freeze
 
-      def initialize(telemetry, logger: Datadog.logger)
+      def initialize(reporter, telemetry:, logger: Datadog.logger)
+        @reporter = reporter
         @telemetry = telemetry
         @logger = logger
 

lib/datadog/open_feature/exposures.rb

@@ -12,3 +12,4 @@ module Exposures
 require_relative 'exposures/batch'
 require_relative 'exposures/buffer'
 require_relative 'exposures/worker'
+require_relative 'exposures/reporter'

sig/datadog/open_feature/evaluation_engine.rbs

@@ -15,7 +15,9 @@ module Datadog
 
       attr_writer configuration: ::String
 
-      def initialize: (Core::Telemetry::Component telemetry, ?logger: Core::Logger) -> void
+      attr_reader reporter: Exposures::Reporter
+
+      def initialize: (Exposures::Reporter reporter, telemetry: Core::Telemetry::Component, ?logger: Core::Logger) -> void
 
       def fetch_value: (
         flag_key: ::String,

sig/datadog/open_feature/exposures/reporter.rbs

@@ -0,0 +1,42 @@
+module Datadog
+  module OpenFeature
+    module Exposures
+      class Reporter
+        DEFAULT_CACHE_LIMIT: ::Integer
+
+        def initialize: (
+          worker: Worker,
+          ?cache: Datadog::AppSec::APISecurity::LRUCache,
+          ?logger: Core::Logger,
+          ?time_provider: untyped
+        ) -> void
+
+        def report: (result: ::Hash[untyped, untyped], ?context: untyped) -> bool
+
+        def clear: () -> void
+
+        private
+
+        def duplicate?: (String, ::Integer) -> bool
+
+        def normalize: (untyped, untyped) -> ::Hash[Symbol, untyped]?
+
+        def build_event: (::Hash[Symbol, untyped]) -> Event
+
+        def extract_subject_id: (::Hash[untyped, untyped], untyped) -> (String | nil)
+
+        def extract_attributes: (::Hash[untyped, untyped], untyped) -> (::Hash[untyped, untyped] | nil)
+
+        def context_value: (untyped, Symbol) -> untyped
+
+        def ensure_hash: (untyped) -> ::Hash[untyped, untyped]
+
+        def cache_key: (untyped, untyped) -> (String | nil)
+
+        def digest: (untyped, untyped) -> ::Integer
+      end
+    end
+  end
+end
+
+

sig/datadog/open_feature/exposures/worker.rbs

@@ -13,9 +13,9 @@ module Datadog
         def initialize: (
           transport: Transport::Exposures::Transport,
           logger: Core::Logger,
-          flush_interval_seconds: ::Integer,
-          buffer_limit: ::Integer,
-          context_builder: (^() -> ::Hash[::Symbol, untyped])?
+          ?flush_interval_seconds: ::Integer,
+          ?buffer_limit: ::Integer,
+          ?context_builder: (^() -> ::Hash[::Symbol, untyped])
         ) -> void
 
         def start: () -> void

sig/datadog/open_feature/transport/http.rbs

@@ -4,8 +4,8 @@ module Datadog
       module HTTP
         def self?.exposures: (
           agent_settings: ::Datadog::Core::Configuration::AgentSettings,
-          logger: ::Datadog::Core::Logger?,
-          headers: ::Hash[::Symbol, untyped]?
+          ?logger: ::Datadog::Core::Logger?,
+          ?headers: ::Hash[::Symbol, untyped]?
         ) ?{ (::Datadog::Core::Transport::HTTP::Builder) -> void } -> ::Datadog::OpenFeature::Transport::Exposures::Transport
       end
     end

spec/datadog/open_feature/component_spec.rb

@@ -6,12 +6,26 @@
 RSpec.describe Datadog::OpenFeature::Component do
   before do
     allow(logger).to receive(:warn)
+    allow(logger).to receive(:debug)
+    allow(Datadog::OpenFeature::Transport::HTTP).to receive(:exposures).and_return(transport)
+    allow(Datadog::OpenFeature::Exposures::Worker).to receive(:new).and_return(worker)
+    allow(Datadog::OpenFeature::Exposures::Reporter).to receive(:new).and_return(reporter)
   end
 
   let(:telemetry) { instance_double(Datadog::Core::Telemetry::Component) }
   let(:settings) { Datadog::Core::Configuration::Settings.new }
   let(:agent_settings) { instance_double(Datadog::Core::Configuration::AgentSettings) }
   let(:logger) { instance_double(Logger) }
+  let(:transport) { instance_double(Datadog::OpenFeature::Transport::Exposures::Transport) }
+  let(:worker) do
+    instance_double(
+      Datadog::OpenFeature::Exposures::Worker,
+      enqueue: true,
+      flush: nil,
+      stop: nil
+    )
+  end
+  let(:reporter) { instance_double(Datadog::OpenFeature::Exposures::Reporter, clear: nil) }
 
   describe '.build' do
     subject(:component) do
@@ -29,6 +43,7 @@
         it 'returns configured component instance' do
           expect(component).to be_a(described_class)
           expect(component.engine).to be_a(Datadog::OpenFeature::EvaluationEngine)
+          expect(Datadog::OpenFeature::Exposures::Reporter).to have_received(:new)
         end
       end
 
@@ -70,4 +85,21 @@
       it { expect(component).to be_nil }
     end
   end
+
+  describe '#shutdown!' do
+    subject(:component) { described_class.new(settings, agent_settings, logger: logger, telemetry: telemetry) }
+
+    before do
+      settings.open_feature.enabled = true
+      settings.remote.enabled = true
+    end
+
+    it 'flushes reporter cache and stops worker' do
+      expect(reporter).to receive(:clear)
+      expect(worker).to receive(:flush)
+      expect(worker).to receive(:stop).with(true)
+
+      component.shutdown!
+    end
+  end
 end

spec/datadog/open_feature/evaluation_engine_spec.rb

@@ -4,7 +4,8 @@
 require 'datadog/open_feature/evaluation_engine'
 
 RSpec.describe Datadog::OpenFeature::EvaluationEngine do
-  let(:evaluator) { described_class.new(telemetry, logger: logger) }
+  let(:engine) { described_class.new(reporter, telemetry: telemetry, logger: logger) }
+  let(:reporter) { instance_double(Datadog::OpenFeature::Exposures::Reporter) }
   let(:telemetry) { instance_double(Datadog::Core::Telemetry::Component) }
   let(:logger) { instance_double(Datadog::Core::Logger) }
   let(:ufc) do
@@ -41,7 +42,7 @@
   end
 
   describe '#fetch_value' do
-    let(:result) { evaluator.fetch_value(flag_key: 'test', expected_type: :string) }
+    let(:result) { engine.fetch_value(flag_key: 'test', expected_type: :string) }
 
     context 'when binding evaluator is not ready' do
       it 'returns evaluation error' do
@@ -53,8 +54,8 @@
 
     context 'when binding evaluator returns error' do
       before do
-        evaluator.configuration = ufc
-        evaluator.reconfigure!
+        engine.configuration = ufc
+        engine.reconfigure!
 
         allow_any_instance_of(Datadog::OpenFeature::Binding::Evaluator).to receive(:get_assignment)
           .and_return(error)
@@ -71,8 +72,8 @@
 
     context 'when binding evaluator raises error' do
       before do
-        evaluator.configuration = ufc
-        evaluator.reconfigure!
+        engine.configuration = ufc
+        engine.reconfigure!
 
         allow(telemetry).to receive(:report)
         allow_any_instance_of(Datadog::OpenFeature::Binding::Evaluator).to receive(:get_assignment)
@@ -90,11 +91,11 @@
 
     context 'when expected type not in the allowed list' do
       before do
-        evaluator.configuration = ufc
-        evaluator.reconfigure!
+        engine.configuration = ufc
+        engine.reconfigure!
       end
 
-      let(:result) { evaluator.fetch_value(flag_key: 'test', expected_type: :whatever) }
+      let(:result) { engine.fetch_value(flag_key: 'test', expected_type: :whatever) }
 
       it 'returns evaluation error' do
         expect(result.reason).to eq('ERROR')
@@ -105,11 +106,11 @@
 
     context 'when binding evaluator returns resolution details' do
       before do
-        evaluator.configuration = ufc
-        evaluator.reconfigure!
+        engine.configuration = ufc
+        engine.reconfigure!
       end
 
-      let(:result) { evaluator.fetch_value(flag_key: 'test', expected_type: :string) }
+      let(:result) { engine.fetch_value(flag_key: 'test', expected_type: :string) }
 
       it { expect(result.value).to eq('hello') }
     end
@@ -120,14 +121,14 @@
       it 'does nothing and logs the issue' do
         expect(logger).to receive(:debug).with(/OpenFeature: Configuration is not received, skip reconfiguration/)
 
-        evaluator.reconfigure!
+        engine.reconfigure!
       end
     end
 
     context 'when binding initialization fails with exception' do
       before do
-        evaluator.configuration = ufc
-        evaluator.reconfigure!
+        engine.configuration = ufc
+        engine.reconfigure!
 
         allow(Datadog::OpenFeature::Binding::Evaluator).to receive(:new).and_raise(error)
       end
@@ -139,25 +140,25 @@
         expect(telemetry).to receive(:report)
           .with(error, description: match(/OpenFeature: Failed to reconfigure/))
 
-        evaluator.configuration = '{}'
-        expect { evaluator.reconfigure! }.not_to raise_error
+        engine.configuration = '{}'
+        expect { engine.reconfigure! }.not_to raise_error
       end
 
       it 'persists previouly configured evaluator' do
         allow(logger).to receive(:error)
         allow(telemetry).to receive(:report)
 
-        evaluator.configuration = '{}'
-        expect { evaluator.reconfigure! }.not_to change {
-          evaluator.fetch_value(flag_key: 'test', expected_type: :string).value
+        engine.configuration = '{}'
+        expect { engine.reconfigure! }.not_to change {
+          engine.fetch_value(flag_key: 'test', expected_type: :string).value
         }.from('hello')
       end
     end
 
     context 'when binding initialization succeeds' do
       before do
-        evaluator.configuration = ufc
-        evaluator.reconfigure!
+        engine.configuration = ufc
+        engine.reconfigure!
       end
 
       let(:new_ufc) do
@@ -194,8 +195,8 @@
       end
 
       xit 'reconfigures binding evaluator with new flags configuration' do
-        expect { evaluator.configuration = new_ufc; evaluator.reconfigure!}
-          .to change { evaluator.fetch_value(flag_key: 'test', expected_type: :string).value }
+        expect { engine.configuration = new_ufc; engine.reconfigure!}
+          .to change { engine.fetch_value(flag_key: 'test', expected_type: :string).value }
           .from('hello').to('goodbye')
       end
     end