splitclient-rb 7.3.3.pre.rc15-java → 7.3.4.pre.rc1-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fbe80dcceedb5a8c8314d21e237433db8ab31cf7
-  data.tar.gz: dda1b35792fa23504ec78977786ec8c6a4310d0c
+  metadata.gz: 6b87c29efc94839289ddc4bc83b2909854ba3a9b
+  data.tar.gz: 7163fc08290ace163cb8e7815060673d0a68a1f7
 SHA512:
-  metadata.gz: ac6008e523ce1d692ff49ca33b6a9ccaab0940e539627b2a0fa42b9e1a744599872369fb8f5b8e6d0124d7bdbb7f42c877daf3774d88bd4a731b66c14a3d0f36
-  data.tar.gz: 9a581b2b1919fb562c7e2802d0031c35055cf2fbfbf7603812cc5a4a832fe463ba0118b2eb9b09804b9054ede1e1d8f4ffda9884900154fcd4a8e92345f1403f
+  metadata.gz: b160683bc39ed4adb87223be199bbfbcdffef63ae383e4f9d72156d7a5fabcf862eec3ff4735cee6366d260a1df4711f682f1dd58e197f46d9373292c2843dbf
+  data.tar.gz: a8c9b5e4a447687ae1c2706c158376b2ac7da5c756eb40e8a9c485f7ba296fbf72c6894b310bd3a5fd02ca4145d175316a10d58d1b9a09aff65eedd46f0d43fc

data/.rubocop.yml

@@ -10,6 +10,7 @@ Metrics/MethodLength:
   Max: 20
   Exclude:
     - lib/splitclient-rb/telemetry/memory/memory_synchronizer.rb
+    - lib/splitclient-rb/engine/sync_manager.rb
 
 Metrics/ClassLength:
   Max: 150
@@ -17,9 +18,10 @@ Metrics/ClassLength:
     - lib/splitclient-rb/telemetry/memory/memory_synchronizer.rb
 
 Metrics/CyclomaticComplexity:
-  Max: 8
+  Max: 11
 
 Metrics/ParameterLists:
+  Max: 8
   Exclude:
     - lib/splitclient-rb/engine/sync_manager.rb
 
@@ -32,6 +34,7 @@ Metrics/LineLength:
     - spec/engine/auth_api_client_spec.rb
     - spec/telemetry/synchronizer_spec.rb
     - spec/splitclient/split_config_spec.rb
+    - spec/engine/push_manager_spec.rb
 
 Style/BracesAroundHashParameters:
   Exclude:
@@ -65,3 +68,4 @@ AllCops:
     - spec/telemetry/synchronizer_spec.rb
     - lib/splitclient-rb/engine/synchronizer.rb
     - tmp/**/*
+    - lib/splitclient-rb/sse/event_source/client.rb

data/CHANGES.txt

@@ -1,5 +1,15 @@
 CHANGES
 
+7.3.3 (Jan 28, 2021)
+- Fixed edge cases where the sdk lost streaming connection.
+- Updated default auth service url to https://auth.split.io/api/v2/auth
+- Updated dependencies:
+  - faraday to  >= 0.8, < 2.0
+  - net-http-persistent to >= 2.9, < 5.0
+  - redis to >= 4.0.0, < 5.0
+  - socketry to >= 0.4, < 1.0
+  - thread_safe to ~> 0.3
+
 7.3.2 (Dec 10, 2021)
 - Updated the readiness flow to be more consistent with the other sdks and improve the readiness time.
 - Updated the name of telemety key latencies in Redis.

data/lib/splitclient-rb/constants.rb

@@ -12,4 +12,5 @@ class SplitIoClient::Constants
   PUSH_SUBSYSTEM_DOWN = 'PUSH_SUBSYSTEM_DOWN'
   PUSH_SUBSYSTEM_READY = 'PUSH_SUBSYSTEM_READY'
   PUSH_SUBSYSTEM_OFF = 'PUSH_SUBSYSTEM_OFF'
+  PUSH_FORCED_STOP = 'PUSH_FORCED_STOP'
 end

data/lib/splitclient-rb/engine/push_manager.rb

@@ -34,8 +34,6 @@ module SplitIoClient
       end
 
       def stop_sse
-        @config.logger.error('## STOP SSE')
-        @sse_handler.process_disconnect if @sse_handler.sse_client.nil?
         @sse_handler.stop
         SplitIoClient::Helpers::ThreadHelper.stop(:schedule_next_token_refresh, @config)
       end
@@ -48,12 +46,9 @@ module SplitIoClient
             @config.logger.debug("schedule_next_token_refresh refresh in #{time} seconds.") if @config.debug_enabled
             sleep(time)
             @config.logger.debug('schedule_next_token_refresh starting ...') if @config.debug_enabled
-            @config.logger.error('## SCHEDULE NEXT TOKEN')
-
             @sse_handler.stop
             start_sse
           rescue StandardError => e
-            @config.logger.error("## SCHEDULE EXCEPTION #{e.inspect}")
             @config.logger.debug("schedule_next_token_refresh error: #{e.inspect}") if @config.debug_enabled
           end
         end

data/lib/splitclient-rb/engine/sync_manager.rb

@@ -6,35 +6,23 @@ module SplitIoClient
       SYNC_MODE_STREAMING = 0
       SYNC_MODE_POLLING = 1
 
-      def initialize(
-        repositories,
-        api_key,
-        config,
-        synchronizer,
-        telemetry_runtime_producer,
-        telemetry_synchronizer,
-        status_manager
-      )
-        @synchronizer = synchronizer
-        notification_manager_keeper = SSE::NotificationManagerKeeper.new(config, telemetry_runtime_producer) do |manager|
-          manager.on_action { |action| process_action(action) }
-        end
-        @sse_handler = SSE::SSEHandler.new(
-          { config: config, api_key: api_key },
-          @synchronizer,
-          repositories,
-          notification_manager_keeper,
-          telemetry_runtime_producer
-        ) do |handler|
-          handler.on_action { |action| process_action(action) }
-        end
-
-        @push_manager = PushManager.new(config, @sse_handler, api_key, telemetry_runtime_producer)
-        @sse_connected = Concurrent::AtomicBoolean.new(false)
+      def initialize(config,
+                     synchronizer,
+                     telemetry_runtime_producer,
+                     telemetry_synchronizer,
+                     status_manager,
+                     sse_handler,
+                     push_manager,
+                     status_queue)
         @config = config
+        @synchronizer = synchronizer
         @telemetry_runtime_producer = telemetry_runtime_producer
         @telemetry_synchronizer = telemetry_synchronizer
         @status_manager = status_manager
+        @sse_handler = sse_handler
+        @push_manager = push_manager
+        @status_queue = status_queue
+        @sse_connected = Concurrent::AtomicBoolean.new(false)
       end
 
       def start
@@ -55,6 +43,7 @@ module SplitIoClient
 
           if @config.streaming_enabled
             @config.logger.debug('Starting Straming mode ...')
+            start_push_status_monitor
             connected = @push_manager.start_sse
           end
 
@@ -66,28 +55,6 @@ module SplitIoClient
         end
       end
 
-      def process_action(action)
-        @config.logger.error("process_action #{action}")
-        case action
-        when Constants::PUSH_CONNECTED
-          process_connected
-        when Constants::PUSH_RETRYABLE_ERROR
-          process_disconnect(true)
-        when Constants::PUSH_NONRETRYABLE_ERROR
-          process_disconnect(false)
-        when Constants::PUSH_SUBSYSTEM_DOWN
-          process_subsystem_down
-        when Constants::PUSH_SUBSYSTEM_READY
-          process_subsystem_ready
-        when Constants::PUSH_SUBSYSTEM_OFF
-          process_push_shutdown
-        else
-          @config.logger.debug('Incorrect action type.')
-        end
-      rescue StandardError => e
-        @config.logger.error("process_action error: #{e.inspect}")
-      end
-
       def process_subsystem_ready
         @synchronizer.stop_periodic_fetch
         @synchronizer.sync_all
@@ -125,6 +92,19 @@ module SplitIoClient
         @config.logger.error("process_connected error: #{e.inspect}")
       end
 
+      def process_forced_stop
+        unless @sse_connected.value
+          @config.logger.debug('Streaming already disconnected.')
+          return
+        end
+
+        @sse_connected.make_false
+        @synchronizer.start_periodic_fetch
+        record_telemetry(Telemetry::Domain::Constants::SYNC_MODE, SYNC_MODE_POLLING)
+      rescue StandardError => e
+        @config.logger.error("process_connected error: #{e.inspect}")
+      end
+
       def process_disconnect(reconnect)
         unless @sse_connected.value
           @config.logger.debug('Streaming already disconnected.')
@@ -148,6 +128,40 @@ module SplitIoClient
       def record_telemetry(type, data)
         @telemetry_runtime_producer.record_streaming_event(type, data)
       end
+
+      def start_push_status_monitor
+        @config.threads[:push_status_handler] = Thread.new do
+          @config.logger.debug('Starting push status handler ...') if @config.debug_enabled
+          incoming_push_status_handler
+        end
+      end
+
+      def incoming_push_status_handler
+        while (status = @status_queue.pop)
+          @config.logger.debug("Push status handler dequeue #{status}") if @config.debug_enabled
+
+          case status
+          when Constants::PUSH_CONNECTED
+            process_connected
+          when Constants::PUSH_RETRYABLE_ERROR
+            process_disconnect(true)
+          when Constants::PUSH_FORCED_STOP
+            process_forced_stop
+          when Constants::PUSH_NONRETRYABLE_ERROR
+            process_disconnect(false)
+          when Constants::PUSH_SUBSYSTEM_DOWN
+            process_subsystem_down
+          when Constants::PUSH_SUBSYSTEM_READY
+            process_subsystem_ready
+          when Constants::PUSH_SUBSYSTEM_OFF
+            process_push_shutdown
+          else
+            @config.logger.debug('Incorrect push status type.')
+          end
+        end
+      rescue StandardError => e
+        @config.logger.error("Push status handler error: #{e.inspect}")
+      end
     end
   end
 end

data/lib/splitclient-rb/helpers/thread_helper.rb

@@ -8,11 +8,9 @@ module SplitIoClient
 
         unless thread.nil?
           config.logger.debug("Stopping #{thread_sym} thread...") if config.debug_enabled
-          # sleep(0.1) while thread.status == 'run'
           Thread.kill(thread)
         end
       rescue StandardError => e
-        puts e.inspect
         config.logger.error(e.inspect)
       end
 

data/lib/splitclient-rb/split_factory.rb

@@ -33,15 +33,10 @@ module SplitIoClient
       register_factory
 
       build_telemetry_components
+      build_repositories
+      build_impressions_components
+      build_telemetry_synchronizer
 
-      @splits_repository = SplitsRepository.new(@config)
-      @segments_repository = SegmentsRepository.new(@config)
-      @impressions_repository = ImpressionsRepository.new(@config)
-      @events_repository = EventsRepository.new(@config, @api_key, @runtime_producer)
-      @impression_counter = SplitIoClient::Engine::Common::ImpressionCounter.new
-      @impressions_manager = SplitIoClient::Engine::Common::ImpressionManager.new(@config, @impressions_repository, @impression_counter, @runtime_producer)
-      @telemetry_api = SplitIoClient::Api::TelemetryApi.new(@config, @api_key, @runtime_producer)
-      @telemetry_synchronizer = Telemetry::Synchronizer.new(@config, @telemetry_consumers, @init_producer, repositories, @telemetry_api)
       @status_manager = Engine::StatusManager.new(@config)
 
       start!
@@ -59,18 +54,12 @@ module SplitIoClient
         return
       end
       
-      split_fetcher = SplitFetcher.new(@splits_repository, @api_key, config, @runtime_producer)
-      segment_fetcher = SegmentFetcher.new(@segments_repository, @api_key, config, @runtime_producer)
-      params = {
-        split_fetcher: split_fetcher,
-        segment_fetcher: segment_fetcher,
-        imp_counter: @impression_counter,
-        telemetry_runtime_producer: @runtime_producer,
-        telemetry_synchronizer: @telemetry_synchronizer
-      }
+      build_fetchers
+      build_synchronizer
+      build_streaming_components
+      build_sync_manager
 
-      synchronizer = SplitIoClient::Engine::Synchronizer.new(repositories, @api_key, @config, params)
-      SplitIoClient::Engine::SyncManager.new(repositories, @api_key, @config, synchronizer, @runtime_producer, @telemetry_synchronizer, @status_manager).start
+      @sync_manager.start
     end
 
     def stop!
@@ -166,6 +155,56 @@ module SplitIoClient
       @runtime_producer = Telemetry::RuntimeProducer.new(@config)
 
       @telemetry_consumers = { init: @init_consumer, evaluation: @evaluation_consumer, runtime: @runtime_consumer }
-    end    
+    end
+
+    def build_fetchers
+      @split_fetcher = SplitFetcher.new(@splits_repository, @api_key, @config, @runtime_producer)
+      @segment_fetcher = SegmentFetcher.new(@segments_repository, @api_key, @config, @runtime_producer)
+    end
+
+    def build_synchronizer
+      params = {
+        split_fetcher: @split_fetcher,
+        segment_fetcher: @segment_fetcher,
+        imp_counter: @impression_counter,
+        telemetry_runtime_producer: @runtime_producer,
+        telemetry_synchronizer: @telemetry_synchronizer
+      }
+
+      @synchronizer = Engine::Synchronizer.new(repositories, @api_key, @config, params)
+    end
+
+    def build_streaming_components
+      @push_status_queue = Queue.new
+      splits_worker = SSE::Workers::SplitsWorker.new(@synchronizer, @config, @splits_repository)
+      segments_worker = SSE::Workers::SegmentsWorker.new(@synchronizer, @config, @segments_repository)
+      notification_manager_keeper = SSE::NotificationManagerKeeper.new(@config, @runtime_producer, @push_status_queue)
+      notification_processor = SSE::NotificationProcessor.new(@config, splits_worker, segments_worker)
+      event_parser = SSE::EventSource::EventParser.new(config)      
+      sse_client = SSE::EventSource::Client.new(@config, @api_key, @runtime_producer, event_parser, notification_manager_keeper, notification_processor, @push_status_queue)
+      @sse_handler = SSE::SSEHandler.new(@config, splits_worker, segments_worker, sse_client)
+      @push_manager = Engine::PushManager.new(@config, @sse_handler, @api_key, @runtime_producer)
+    end
+
+    def build_sync_manager
+      @sync_manager = Engine::SyncManager.new(@config, @synchronizer, @runtime_producer, @telemetry_synchronizer, @status_manager, @sse_handler, @push_manager, @push_status_queue)
+    end
+
+    def build_repositories
+      @splits_repository = SplitsRepository.new(@config)
+      @segments_repository = SegmentsRepository.new(@config)
+      @impressions_repository = ImpressionsRepository.new(@config)
+      @events_repository = EventsRepository.new(@config, @api_key, @runtime_producer)
+    end
+
+    def build_telemetry_synchronizer
+      telemetry_api = Api::TelemetryApi.new(@config, @api_key, @runtime_producer)
+      @telemetry_synchronizer = Telemetry::Synchronizer.new(@config, @telemetry_consumers, @init_producer, repositories, telemetry_api)
+    end
+
+    def build_impressions_components
+      @impression_counter = Engine::Common::ImpressionCounter.new
+      @impressions_manager = Engine::Common::ImpressionManager.new(@config, @impressions_repository, @impression_counter, @runtime_producer)
+    end
   end
 end

data/lib/splitclient-rb/sse/event_source/client.rb

@@ -13,29 +13,28 @@ module SplitIoClient
         KEEP_ALIVE_RESPONSE = "c\r\n:keepalive\n\n\r\n".freeze
         ERROR_EVENT_TYPE = 'error'.freeze
 
-        def initialize(config, api_key, telemetry_runtime_producer, read_timeout: DEFAULT_READ_TIMEOUT)
+        def initialize(config,
+                       api_key,
+                       telemetry_runtime_producer,
+                       event_parser,
+                       notification_manager_keeper,
+                       notification_processor,
+                       status_queue,
+                       read_timeout: DEFAULT_READ_TIMEOUT)
           @config = config
+          @api_key = api_key
+          @telemetry_runtime_producer = telemetry_runtime_producer
+          @event_parser = event_parser
+          @notification_manager_keeper = notification_manager_keeper
+          @notification_processor = notification_processor
+          @status_queue = status_queue
           @read_timeout = read_timeout
           @connected = Concurrent::AtomicBoolean.new(false)
           @first_event = Concurrent::AtomicBoolean.new(true)
           @socket = nil
-          @event_parser = SSE::EventSource::EventParser.new(config)
-          @on = { event: ->(_) {}, action: ->(_) {} }
-          @api_key = api_key
-          @telemetry_runtime_producer = telemetry_runtime_producer
-
-          yield self if block_given?
-        end
-
-        def on_event(&action)
-          @on[:event] = action
         end
 
-        def on_action(&action)
-          @on[:action] = action
-        end
-
-        def close
+        def close(status = nil)
           unless connected?
             @config.logger.error('SSEClient already disconected.') if @config.debug_enabled
             return
@@ -43,7 +42,7 @@ module SplitIoClient
 
           @connected.make_false
           @socket&.close
-          @config.logger.error('## CLOSE SSE')
+          push_status(status)
         rescue StandardError => e
           @config.logger.error("SSEClient close Error: #{e.inspect}")
         end
@@ -75,12 +74,10 @@ module SplitIoClient
 
         def connect_thread(latch)
           @config.threads[:connect_stream] = Thread.new do
-            @config.logger.error('## CONNECT THREAD')
             @config.logger.info('Starting connect_stream thread ...') if @config.debug_enabled
-            action = connect_stream(latch)
-            dispatch_action(action)
+            new_status = connect_stream(latch)
+            push_status(new_status)
             @config.logger.info('connect_stream thread finished.') if @config.debug_enabled
-            @config.logger.error('#### DISCONNECTED')
           end
         end
 
@@ -96,15 +93,17 @@ module SplitIoClient
               raise 'eof exception' if partial_data == :eof
             rescue Errno::EBADF, IOError => e
               @config.logger.error(e.inspect)
-              return Constants::PUSH_NONRETRYABLE_ERROR
+              return nil
             rescue StandardError => e
+              return nil if ENV['SPLITCLIENT_ENV'] == 'test'
+
               @config.logger.error("Error reading partial data: #{e.inspect}") if @config.debug_enabled
               return Constants::PUSH_RETRYABLE_ERROR
             end
 
             process_data(partial_data)
           end
-          Constants::PUSH_NONRETRYABLE_ERROR
+          nil
         end
 
         def socket_write(latch)
@@ -132,7 +131,7 @@ module SplitIoClient
           if response_code == OK_CODE && !error_event
             @connected.make_true
             @telemetry_runtime_producer.record_streaming_event(Telemetry::Domain::Constants::SSE_CONNECTION_ESTABLISHED, nil)
-            dispatch_action(Constants::PUSH_CONNECTED)
+            push_status(Constants::PUSH_CONNECTED)
           end
 
           latch.count_down
@@ -188,15 +187,18 @@ module SplitIoClient
         end
 
         def dispatch_event(event)
-          @config.logger.debug("Dispatching event: #{event.event_type}, #{event.channel}") if @config.debug_enabled
-          @on[:event].call(event)
+          if event.occupancy?
+            @notification_manager_keeper.handle_incoming_occupancy_event(event)
+          else
+            @notification_processor.process(event)
+          end
         end
 
-        def dispatch_action(action)
-          @config.threads[:dispatch_action] = Thread.new do
-            @config.logger.debug("Dispatching action: #{action}") if @config.debug_enabled
-            @on[:action].call(action)
-          end
+        def push_status(status)
+          return if status.nil?
+          
+          @config.logger.debug("Pushing new sse status: #{status}")
+          @status_queue.push(status)
         end
       end
     end

data/lib/splitclient-rb/sse/notification_manager_keeper.rb

@@ -9,15 +9,13 @@ module SplitIoClient
       ENABLED = 1
       PAUSED = 2
 
-      def initialize(config, telemetry_runtime_producer)
+      def initialize(config, telemetry_runtime_producer, status_queue)
         @config = config
+        @telemetry_runtime_producer = telemetry_runtime_producer
+        @status_queue = status_queue
         @publisher_available = Concurrent::AtomicBoolean.new(true)
         @publishers_pri = Concurrent::AtomicFixnum.new
         @publishers_sec = Concurrent::AtomicFixnum.new
-        @on = { action: ->(_) {} }
-        @telemetry_runtime_producer = telemetry_runtime_producer
-
-        yield self if block_given?
       end
 
       def handle_incoming_occupancy_event(event)
@@ -27,27 +25,22 @@ module SplitIoClient
           process_event_occupancy(event.channel, event.data['metrics']['publishers'])
         end
       rescue StandardError => e
-        p e
         @config.logger.error(e)
       end
 
-      def on_action(&action)
-        @on[:action] = action
-      end
-
       private
 
       def process_event_control(type)
         case type
         when 'STREAMING_PAUSED'
           @telemetry_runtime_producer.record_streaming_event(Telemetry::Domain::Constants::STREAMING_STATUS, PAUSED)
-          dispatch_action(Constants::PUSH_SUBSYSTEM_DOWN)
+          push_status(Constants::PUSH_SUBSYSTEM_DOWN)
         when 'STREAMING_RESUMED'
           @telemetry_runtime_producer.record_streaming_event(Telemetry::Domain::Constants::STREAMING_STATUS, ENABLED)
-          dispatch_action(Constants::PUSH_SUBSYSTEM_READY) if @publisher_available.value
+          push_status(Constants::PUSH_SUBSYSTEM_READY) if @publisher_available.value
         when 'STREAMING_DISABLED'
           @telemetry_runtime_producer.record_streaming_event(Telemetry::Domain::Constants::STREAMING_STATUS, DISABLED)
-          dispatch_action(Constants::PUSH_SUBSYSTEM_OFF)
+          push_status(Constants::PUSH_SUBSYSTEM_OFF)
         else
           @config.logger.error("Incorrect event type: #{incoming_notification}")
         end
@@ -60,10 +53,10 @@ module SplitIoClient
 
         if !are_publishers_available? && @publisher_available.value
           @publisher_available.make_false
-          dispatch_action(Constants::PUSH_SUBSYSTEM_DOWN)
+          push_status(Constants::PUSH_SUBSYSTEM_DOWN)
         elsif are_publishers_available? && !@publisher_available.value
           @publisher_available.make_true
-          dispatch_action(Constants::PUSH_SUBSYSTEM_READY)
+          push_status(Constants::PUSH_SUBSYSTEM_READY)
         end
       end
 
@@ -81,9 +74,9 @@ module SplitIoClient
         @publishers_pri.value.positive? || @publishers_sec.value.positive?
       end
 
-      def dispatch_action(action)
-        @config.logger.debug("Dispatching action: #{action}")
-        @on[:action].call(action)
+      def push_status(status)
+        @config.logger.debug("Pushing occupancy status: #{status}")
+        @status_queue.push(status)
       end
     end
   end

data/lib/splitclient-rb/sse/sse_handler.rb

@@ -5,33 +5,22 @@ module SplitIoClient
     class SSEHandler
       attr_reader :sse_client
 
-      def initialize(metadata,
-                     synchronizer,
-                     repositories,
-                     notification_manager_keeper,
-                     telemetry_runtime_producer)
-        @config = metadata[:config]
-        @notification_manager_keeper = notification_manager_keeper
-        @splits_worker = SplitIoClient::SSE::Workers::SplitsWorker.new(synchronizer, @config, repositories[:splits])
-        @segments_worker = SplitIoClient::SSE::Workers::SegmentsWorker.new(synchronizer, @config, repositories[:segments])
-        @notification_processor = SplitIoClient::SSE::NotificationProcessor.new(@config, @splits_worker, @segments_worker)
-        @sse_client = SSE::EventSource::Client.new(@config, metadata[:api_key], telemetry_runtime_producer) do |client|
-          client.on_event { |event| handle_incoming_message(event) }
-          client.on_action { |action| process_action(action) }
-        end
-
-        @on = { action: ->(_) {} }
-
-        yield self if block_given?
+      def initialize(config,
+                     splits_worker,
+                     segments_worker,
+                     sse_client)
+        @config = config
+        @splits_worker = splits_worker
+        @segments_worker = segments_worker
+        @sse_client = sse_client
       end
 
       def start(token_jwt, channels)
-        url = "#{@config.streaming_service_url}?channels=#{channels}&v=1.1&accessToken=#{token_jwt}"
-        @sse_client.start(url)
+        @sse_client.start("#{@config.streaming_service_url}?channels=#{channels}&v=1.1&accessToken=#{token_jwt}")
       end
 
       def stop
-        @sse_client.close
+        @sse_client.close(Constants::PUSH_FORCED_STOP)
         stop_workers
       rescue StandardError => e
         @config.logger.debug("SSEHandler stop error: #{e.inspect}") if @config.debug_enabled
@@ -50,24 +39,6 @@ module SplitIoClient
         @splits_worker.stop
         @segments_worker.stop
       end
-
-      def on_action(&action)
-        @on[:action] = action
-      end
-
-      private
-
-      def process_action(action)
-        @on[:action].call(action)
-      end
-
-      def handle_incoming_message(notification)
-        if notification.occupancy?
-          @notification_manager_keeper.handle_incoming_occupancy_event(notification)
-        else
-          @notification_processor.process(notification)
-        end
-      end
     end
   end
 end

data/lib/splitclient-rb/sse/workers/segments_worker.rb

@@ -13,11 +13,6 @@ module SplitIoClient
         end
 
         def add_to_queue(change_number, segment_name)
-          unless @running.value
-            @config.logger.debug('segments worker not running.')
-            return
-          end
-
           item = { change_number: change_number, segment_name: segment_name }
           @config.logger.debug("SegmentsWorker add to queue #{item}")
           @queue.push(item)

data/lib/splitclient-rb/sse/workers/splits_worker.rb

@@ -33,21 +33,11 @@ module SplitIoClient
         end
 
         def add_to_queue(change_number)
-          unless @running.value
-            @config.logger.debug('splits worker not running.')
-            return
-          end
-
           @config.logger.debug("SplitsWorker add to queue #{change_number}")
           @queue.push(change_number)
         end
 
         def kill_split(change_number, split_name, default_treatment)
-          unless @running.value
-            @config.logger.debug('splits worker not running.')
-            return
-          end
-
           return if @splits_repository.get_change_number.to_i > change_number
 
           @config.logger.debug("SplitsWorker kill #{split_name}, #{change_number}")

data/lib/splitclient-rb/version.rb

@@ -1,3 +1,3 @@
 module SplitIoClient
-  VERSION = '7.3.3.pre.rc15'
+  VERSION = '7.3.4.pre.rc1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: splitclient-rb
 version: !ruby/object:Gem::Version
-  version: 7.3.3.pre.rc15
+  version: 7.3.4.pre.rc1
 platform: java
 authors:
 - Split Software
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-25 00:00:00.000000000 Z
+date: 2022-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement