splitclient-rb 7.3.3.pre.rc16-java → 7.3.4.pre.rc2-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bacbe3dee8e47bd0dd38b5f3428fb79ac6f48990
-  data.tar.gz: 2a108b99a72b99376b44d27b71a3f1da08588091
+  metadata.gz: 7ea2b0463e8a3c2f13075209d9e0cb8b189696b3
+  data.tar.gz: 601571ffb3a015fbf8dcb468577b05caced467c7
 SHA512:
-  metadata.gz: 7727d3e058742acce12710687e0f01fef50096ad60071faf0443ef3d31e6ae942d30018e7ae2464d5fc89e6a6bd4cc591d4713a32ba6d5deb60f60c99f99ba74
-  data.tar.gz: 79b9bfebc6a073c6bf4b8efe3707d1acb5d214baf976a715fe2f9d815a9aaa334891d24e95a4c7127aaafa0dc57f3f6b296ff1c3a4783ae9e2019fc1153a95ee
+  metadata.gz: c1eaa3106070a63477fa3951ff55a0c24c4287d379384da95852fb34ddc2a20d61557d3282e40f4c56d14f915f6bd615223b8830a8bd0d2b9afd36d32331f83e
+  data.tar.gz: bde0cdac66e0bdeb0e5e02fc8e77ef8c834c56a767fdf197c398add674e1dbf1e19c683feda9384ab5ce2f80571d0c633e50e8417ab2cd3c0dfab8b7005b1cb3

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/cache/adapters/redis_adapter.rb

@@ -160,7 +160,7 @@ module SplitIoClient
         end
 
         def pipelined
-          @redis.pipelined do
+          @redis.pipelined do |pipeline|
             yield
           end
         end

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

@@ -18,7 +18,7 @@ module SplitIoClient
         @config.logger.debug("Auth service response push_enabled: #{response[:push_enabled]}") if @config.debug_enabled
 
         if response[:push_enabled] && @sse_handler.start(response[:token], response[:channels])
-          schedule_next_token_refresh(200)
+          schedule_next_token_refresh(response[:exp])
           @back_off.reset
           record_telemetry(response[:exp])
 
@@ -34,7 +34,6 @@ module SplitIoClient
       end
 
       def stop_sse
-        @config.logger.error('## STOP SSE')
         @sse_handler.stop
         SplitIoClient::Helpers::ThreadHelper.stop(:schedule_next_token_refresh, @config)
       end
@@ -47,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(action = nil)
+        def close(status = nil)
           unless connected?
             @config.logger.error('SSEClient already disconected.') if @config.debug_enabled
             return
@@ -43,8 +42,7 @@ module SplitIoClient
 
           @connected.make_false
           @socket&.close
-          @config.logger.error('## CLOSE SSE')
-          dispatch_action(action) unless action.nil?
+          push_status(status)
         rescue StandardError => e
           @config.logger.error("SSEClient close Error: #{e.inspect}")
         end
@@ -76,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) unless action.nil?
+            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
 
@@ -99,6 +95,8 @@ module SplitIoClient
               @config.logger.error(e.inspect)
               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
@@ -133,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
@@ -189,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(Constants::PUSH_NONRETRYABLE_ERROR)
+        @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.rc16'
+  VERSION = '7.3.4.pre.rc2'
 end

metadata

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