refactor: simplify provider initialization with explicit blocking control

Replace event-based flow control in set_provider_and_wait with direct
blocking initialization following Go/Java SDK patterns.

- Add wait_for_init parameter to set_provider_internal
- Remove timeout and event handler cleanup from set_provider_and_wait
- Extract init_provider helper for unified initialization logic
- Preserve event emission in both sync and async paths
- Remove unused private methods

Reduces complexity by 118 lines while maintaining 100% test coverage.

Author: sameerank

lib/open_feature/sdk/configuration.rb

@@ -52,68 +52,19 @@ def clear_all_handlers
 
       def set_provider(provider, domain: nil)
         @provider_mutex.synchronize do
-          set_provider_internal(provider, domain:)
+          set_provider_internal(provider, domain: domain, wait_for_init: false)
         end
       end
 
-      def set_provider_and_wait(provider, domain: nil, timeout: 30)
-        completion_queue = Queue.new
-
-        ready_handler = lambda do |event_details|
-          if event_details[:provider] == provider
-            completion_queue << {status: :ready}
-          end
-        end
-
-        error_handler = lambda do |event_details|
-          if event_details[:provider] == provider
-            completion_queue << {
-              status: :error,
-              message: event_details[:message] || "an unspecified error occurred",
-              error_code: event_details[:error_code]
-            }
-          end
-        end
-
-        add_handler(ProviderEvent::PROVIDER_READY, ready_handler)
-        add_handler(ProviderEvent::PROVIDER_ERROR, error_handler)
-
-        # Lock only while mutating shared state
+      def set_provider_and_wait(provider, domain: nil)
         @provider_mutex.synchronize do
-          set_provider_internal(provider, domain:)
-        end
-
-        begin
-          # Wait for initialization to complete, outside the main provider mutex
-          Timeout.timeout(timeout) do
-            result = completion_queue.pop
-
-            if result[:status] == :error
-              error_code = result[:error_code] || Provider::ErrorCode::PROVIDER_FATAL
-              message = result[:message]
-              raise ProviderInitializationError.new(
-                "Provider #{provider.class.name} initialization failed: #{message}",
-                provider:,
-                error_code:,
-                original_error: nil  # Exceptions not included in events
-              )
-            end
-          end
-        rescue Timeout::Error => e
-          raise ProviderInitializationError.new(
-            "Provider #{provider.class.name} initialization timed out after #{timeout} seconds",
-            provider:,
-            original_error: e
-          )
-        ensure
-          remove_handler(ProviderEvent::PROVIDER_READY, ready_handler)
-          remove_handler(ProviderEvent::PROVIDER_ERROR, error_handler)
+          set_provider_internal(provider, domain: domain, wait_for_init: true)
         end
       end
 
       private
 
-      def set_provider_internal(provider, domain: nil)
+      def set_provider_internal(provider, domain:, wait_for_init:)
         old_provider = @providers[domain]
 
         begin
@@ -136,23 +87,41 @@ def set_provider_internal(provider, domain: nil)
         # Capture evaluation context to prevent race condition
         context_for_init = @evaluation_context
 
-        Thread.new do
-          if provider.respond_to?(:init)
-            init_method = provider.method(:init)
-            if init_method.parameters.empty?
-              provider.init
-            else
-              provider.init(context_for_init)
-            end
+        if wait_for_init
+          init_provider(provider, context_for_init, raise_on_error: true)
+        else
+          Thread.new do
+            init_provider(provider, context_for_init, raise_on_error: false)
           end
+        end
+      end
 
-          unless provider.is_a?(Provider::EventHandler)
-            dispatch_provider_event(provider, ProviderEvent::PROVIDER_READY)
+      def init_provider(provider, context, raise_on_error: false)
+        if provider.respond_to?(:init)
+          init_method = provider.method(:init)
+          if init_method.parameters.empty?
+            provider.init
+          else
+            provider.init(context)
           end
-        rescue => e
-          dispatch_provider_event(provider, ProviderEvent::PROVIDER_ERROR,
+        end
+
+        unless provider.is_a?(Provider::EventHandler)
+          dispatch_provider_event(provider, ProviderEvent::PROVIDER_READY)
+        end
+      rescue => e
+        dispatch_provider_event(provider, ProviderEvent::PROVIDER_ERROR,
+          error_code: Provider::ErrorCode::PROVIDER_FATAL,
+          message: e.message)
+
+        if raise_on_error
+          # Re-raise as ProviderInitializationError for synchronous callers
+          raise ProviderInitializationError.new(
+            "Provider #{provider.class.name} initialization failed: #{e.message}",
+            provider:,
             error_code: Provider::ErrorCode::PROVIDER_FATAL,
-            message: e.message)
+            original_error: e
+          )
         end
       end
 
@@ -174,14 +143,6 @@ def provider_state(provider)
 
       private
 
-      def handler_count(event_type)
-        @event_emitter.handler_count(event_type)
-      end
-
-      def total_handler_count
-        ProviderEvent::ALL_EVENTS.sum { |event_type| handler_count(event_type) }
-      end
-
       class ProviderEventDispatcher
         def initialize(config)
           @config = config

spec/open_feature/sdk/configuration_async_spec.rb

@@ -33,11 +33,9 @@ def create_event_aware_provider(init_time: 0.1, &on_init)
       include OpenFeature::SDK::Provider::EventHandler
 
       define_method :init do |_evaluation_context|
-        Thread.new do
-          sleep(init_time)
-          on_init&.call
-          emit_event(OpenFeature::SDK::ProviderEvent::PROVIDER_READY)
-        end
+        sleep(init_time)
+        on_init&.call
+        emit_event(OpenFeature::SDK::ProviderEvent::PROVIDER_READY)
       end
 
       def shutdown
@@ -59,12 +57,8 @@ def create_failing_provider(error_message = "Init failed")
       include OpenFeature::SDK::Provider::EventHandler
 
       define_method :init do |_evaluation_context|
-        Thread.new do
-          sleep(0.05)
-          emit_event(OpenFeature::SDK::ProviderEvent::PROVIDER_ERROR,
-            error_code: OpenFeature::SDK::Provider::ErrorCode::PROVIDER_FATAL,
-            message: error_message)
-        end
+        sleep(0.05) # Simulate some initialization time
+        raise StandardError, error_message
       end
 
       def shutdown
@@ -159,15 +153,15 @@ def shutdown
         provider = create_slow_provider(init_time: 0.1) { initialized = true }
 
         expect(initialized).to be false
-        configuration.set_provider_and_wait(provider, timeout: 1)
+        configuration.set_provider_and_wait(provider)
         expect(initialized).to be true
       end
 
       it "returns only after PROVIDER_READY event" do
         provider = create_event_aware_provider(init_time: 0.1)
 
         start_time = Time.now
-        configuration.set_provider_and_wait(provider, timeout: 1)
+        configuration.set_provider_and_wait(provider)
         elapsed = Time.now - start_time
 
         expect(elapsed).to be >= 0.1 # Should wait at least as long as init time
@@ -179,56 +173,11 @@ def shutdown
         provider = create_failing_provider("Custom error")
 
         expect do
-          configuration.set_provider_and_wait(provider, timeout: 1)
+          configuration.set_provider_and_wait(provider)
         end.to raise_error(OpenFeature::SDK::ProviderInitializationError) do |error|
           expect(error.message).to include("Custom error")
         end
       end
-
-      it "raises ProviderInitializationError on timeout" do
-        provider = create_slow_provider(init_time: 2.0) # 2 seconds
-
-        expect do
-          configuration.set_provider_and_wait(provider, timeout: 0.5)
-        end.to raise_error(OpenFeature::SDK::ProviderInitializationError) do |error|
-          expect(error.message).to include("timed out after 0.5 seconds")
-        end
-      end
-    end
-
-    context "event handler cleanup" do
-      it "removes event handlers after completion" do
-        provider = create_slow_provider(init_time: 0.05)
-
-        # Get initial handler count
-        initial_ready_count = configuration.send(:handler_count, OpenFeature::SDK::ProviderEvent::PROVIDER_READY)
-        initial_error_count = configuration.send(:handler_count, OpenFeature::SDK::ProviderEvent::PROVIDER_ERROR)
-
-        configuration.set_provider_and_wait(provider, timeout: 1)
-
-        # Handler counts should be back to initial
-        final_ready_count = configuration.send(:handler_count, OpenFeature::SDK::ProviderEvent::PROVIDER_READY)
-        final_error_count = configuration.send(:handler_count, OpenFeature::SDK::ProviderEvent::PROVIDER_ERROR)
-
-        expect(final_ready_count).to eq(initial_ready_count)
-        expect(final_error_count).to eq(initial_error_count)
-      end
-
-      it "removes event handlers even on error" do
-        provider = create_failing_provider
-
-        # Get initial handler count
-        initial_count = configuration.send(:total_handler_count)
-
-        expect do
-          configuration.set_provider_and_wait(provider, timeout: 1)
-        end.to raise_error(OpenFeature::SDK::ProviderInitializationError)
-
-        # Handler count should be back to initial
-        final_count = configuration.send(:total_handler_count)
-
-        expect(final_count).to eq(initial_count)
-      end
     end
   end
 
@@ -261,7 +210,7 @@ def shutdown
       provider = OpenFeature::SDK::Provider::NoOpProvider.new
 
       expect do
-        configuration.set_provider_and_wait(provider, timeout: 1)
+        configuration.set_provider_and_wait(provider)
       end.not_to raise_error
 
       expect(configuration.provider).to eq(provider)

spec/open_feature/sdk/configuration_spec.rb

@@ -74,10 +74,10 @@
         expect(configuration.provider).to be(provider)
       end
 
-      it "supports custom timeout" do
+      it "initializes the provider synchronously" do
         expect(provider).to receive(:init).once
 
-        configuration.set_provider_and_wait(provider, timeout: 60)
+        configuration.set_provider_and_wait(provider)
 
         expect(configuration.provider).to be(provider)
       end
@@ -119,7 +119,7 @@
           expect(error.message).to include("Provider initialization failed")
           expect(error.message).to include(error_message)
           expect(error.provider).to be(provider)
-          expect(error.original_error).to be_nil # Provider init errors come through events, so no original exception
+          expect(error.original_error).to be_a(StandardError) # Synchronous init preserves original exception
           expect(error.error_code).to eq(OpenFeature::SDK::Provider::ErrorCode::PROVIDER_FATAL)
         end
       end
@@ -135,37 +135,6 @@
       end
     end
 
-    context "when provider init times out" do
-      let(:provider) { OpenFeature::SDK::Provider::InMemoryProvider.new }
-
-      before do
-        allow(provider).to receive(:init) do
-          sleep 2 # Simulate slow initialization
-        end
-      end
-
-      it "raises ProviderInitializationError after timeout" do
-        expect do
-          configuration.set_provider_and_wait(provider, timeout: 0.1)
-        end.to raise_error(OpenFeature::SDK::ProviderInitializationError) do |error|
-          expect(error.message).to include("Provider initialization timed out after 0.1 seconds")
-          expect(error.provider).to be(provider)
-          expect(error.original_error).to be_a(Timeout::Error)
-          expect(error.error_code).to eq(OpenFeature::SDK::Provider::ErrorCode::PROVIDER_FATAL)
-        end
-      end
-
-      it "leaves the failed provider in place when init times out" do
-        configuration.provider
-
-        expect do
-          configuration.set_provider_and_wait(provider, timeout: 0.1)
-        end.to raise_error(OpenFeature::SDK::ProviderInitializationError)
-
-        expect(configuration.provider).to be(provider)
-      end
-    end
-
     context "when shutting down the old provider fails" do
       let(:old_provider) { OpenFeature::SDK::Provider::InMemoryProvider.new }
       let(:new_provider) { OpenFeature::SDK::Provider::InMemoryProvider.new }