Update EvaluationEngine initialization interface

Author: Strech

lib/datadog/open_feature/evaluation_engine.rb

@@ -20,8 +20,10 @@ class EvaluationEngine
 
       ALLOWED_TYPES = %i[boolean string number float integer object].freeze
 
-      def initialize(telemetry)
+      def initialize(telemetry, logger: Datadog.logger)
         @telemetry = telemetry
+        @logger = logger
+
         # NOTE: We also could create a no-op evaluator?
         @evaluator = nil
         @configuration = nil
@@ -49,11 +51,17 @@ def fetch_value(flag_key:, expected_type:, evaluation_context: nil)
 
       # TODO: Put the lock to reconfigure deduplicatoin cache too
       def reconfigure!
+        if @configuration.nil?
+          @logger.debug("OpenFeature: Configuration is not received, skip reconfiguration")
+
+          return
+        end
+
         @evaluator = Binding::Evaluator.new(@configuration)
       rescue => e
         error_message = 'OpenFeature: Failed to reconfigure, reverting to the previous configuration'
 
-        Datadog.logger.error("#{error_message}, error #{e.inspect}")
+        @logger.error("#{error_message}, error #{e.inspect}")
         @telemetry.report(e, description: error_message)
       end
     end

spec/datadog/open_feature/evaluator_spec.rb renamed to spec/datadog/open_feature/evaluation_engine_spec.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
-require 'datadog/open_feature/evaluator'
+require 'datadog/open_feature/evaluation_engine'
 
-RSpec.describe Datadog::OpenFeature::Evaluator do
+RSpec.describe Datadog::OpenFeature::EvaluationEngine do
+  let(:evaluator) { described_class.new(telemetry, logger: logger) }
   let(:telemetry) { instance_double(Datadog::Core::Telemetry::Component) }
-  let(:evaluator) { described_class.new(telemetry) }
   let(:logger) { instance_double(Datadog::Core::Logger) }
   let(:ufc) do
     <<~JSON
@@ -40,8 +40,6 @@
     JSON
   end
 
-  before { allow(Datadog).to receive(:logger).and_return(logger) }
-
   describe '#fetch_value' do
     let(:result) { evaluator.fetch_value(flag_key: 'test', expected_type: :string) }
 
@@ -55,10 +53,10 @@
 
     context 'when binding evaluator returns error' do
       before do
-        evaluator.ufc_json = ufc
+        evaluator.configuration = ufc
         evaluator.reconfigure!
 
-        allow_any_instance_of(described_class::Binding::Evaluator).to receive(:get_assignment)
+        allow_any_instance_of(Datadog::OpenFeature::Binding::Evaluator).to receive(:get_assignment)
           .and_return(error)
       end
 
@@ -73,11 +71,11 @@
 
     context 'when binding evaluator raises error' do
       before do
-        evaluator.ufc_json = ufc
+        evaluator.configuration = ufc
         evaluator.reconfigure!
 
         allow(telemetry).to receive(:report)
-        allow_any_instance_of(described_class::Binding::Evaluator).to receive(:get_assignment)
+        allow_any_instance_of(Datadog::OpenFeature::Binding::Evaluator).to receive(:get_assignment)
           .and_raise(error)
       end
 
@@ -92,7 +90,7 @@
 
     context 'when expected type not in the allowed list' do
       before do
-        evaluator.ufc_json = ufc
+        evaluator.configuration = ufc
         evaluator.reconfigure!
       end
 
@@ -107,7 +105,7 @@
 
     context 'when binding evaluator returns resolution details' do
       before do
-        evaluator.ufc_json = ufc
+        evaluator.configuration = ufc
         evaluator.reconfigure!
       end
 
@@ -118,30 +116,40 @@
   end
 
   describe '#reconfigure!' do
+    context 'when configuration is not yet present' do
+      before { allow(logger).to receive(:debug) }
+
+      it 'does nothing and logs the issue' do
+        evaluator.reconfigure!
+
+        expect(logger).to have_received(:debug).with(/OpenFeature: Configuration is not received, skip reconfiguration/)
+      end
+    end
+
     context 'when binding initialization fails with exception' do
       before do
-        evaluator.ufc_json = ufc
+        evaluator.configuration = ufc
         evaluator.reconfigure!
 
-        allow(described_class::Binding::Evaluator).to receive(:new).and_raise(error)
+        allow(Datadog::OpenFeature::Binding::Evaluator).to receive(:new).and_raise(error)
       end
 
       let(:error) { StandardError.new('Ooops') }
 
       it 'reports error to telemetry and logs it' do
         expect(logger).to receive(:error).with(/Ooops/)
         expect(telemetry).to receive(:report)
-          .with(error, description: match(/OpenFeature failed to reconfigure/))
+          .with(error, description: match(/OpenFeature: Failed to reconfigure/))
 
-        evaluator.ufc_json = '{}'
+        evaluator.configuration = '{}'
         expect { evaluator.reconfigure! }.not_to raise_error
       end
 
       it 'persists previouly configured evaluator' do
         allow(logger).to receive(:error)
         allow(telemetry).to receive(:report)
 
-        evaluator.ufc_json = '{}'
+        evaluator.configuration = '{}'
         expect { evaluator.reconfigure! }.not_to change {
           evaluator.fetch_value(flag_key: 'test', expected_type: :string).value
         }.from('hello')
@@ -150,7 +158,7 @@
 
     context 'when binding initialization succeeds' do
       before do
-        evaluator.ufc_json = ufc
+        evaluator.configuration = ufc
         evaluator.reconfigure!
       end
 
@@ -188,7 +196,7 @@
       end
 
       xit 'reconfigures binding evaluator with new flags configuration' do
-        expect { evaluator.ufc_json = new_ufc; evaluator.reconfigure!}
+        expect { evaluator.configuration = new_ufc; evaluator.reconfigure!}
           .to change { evaluator.fetch_value(flag_key: 'test', expected_type: :string).value }
           .from('hello').to('goodbye')
       end