splitclient-rb 7.3.3 → 7.3.4.pre.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 69076f1dccfed6a33995ffb44369f40ecec01b99e7bc5b427c7a451e4bef3ee0
-  data.tar.gz: f298a3f2879a399a990d2d29d30fcb129b264e1ed09eece6b61653439a1a55b9
+  metadata.gz: 895e6e3e570a766e5d19204859badb148352932d5fe7384a67dce0af2673ad07
+  data.tar.gz: 6e7683dd3a30e0f11543ad867242855f30192a3136e43da57131ee1875d9d377
 SHA512:
-  metadata.gz: 33f2ebae7e70a1b929f6bf7f049e8687202ef8e17d950d5d872f281a680bd9f82f03e77bc1ca8e73b25bc9e1e4498ce3701160158ffb98b030702f50b6764435
-  data.tar.gz: 2e80a76e93049d612806d2889bb707e77fce20e6487cd046c0e26fecdf5770fa35170076d6d652518e05929155943f50bc8e2e4842a9233960427eafbab739a5
+  metadata.gz: 4b5eb76ea2781a14df571e8d1de214cf06bd36fb306c80c760b926e273444e1335b3266344c3d7c267f0bbdf15e58a087e60a0d0ae1c2026ad53ac1c19550a32
+  data.tar.gz: 35e95abd19a875c34e27cac924a766b0b63e44421865051609a1a3a5a2609529d47103aa196c320c9484267bbf5837630c26641fae3717a61c1d532b40fa209d

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:

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/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,27 +55,6 @@ module SplitIoClient
         end
       end
 
-      def 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
@@ -124,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.')
@@ -147,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/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,7 +42,7 @@ module SplitIoClient
 
           @connected.make_false
           @socket&.close
-          dispatch_action(action) unless action.nil?
+          push_status(status)
         rescue StandardError => e
           @config.logger.error("SSEClient close Error: #{e.inspect}")
         end
@@ -76,8 +75,8 @@ module SplitIoClient
         def connect_thread(latch)
           @config.threads[:connect_stream] = Thread.new do
             @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
           end
         end
@@ -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(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/version.rb

@@ -1,3 +1,3 @@
 module SplitIoClient
-  VERSION = '7.3.3'
+  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
+  version: 7.3.4.pre.rc1
 platform: ruby
 authors:
 - Split Software
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-28 00:00:00.000000000 Z
+date: 2022-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: allocation_stats
@@ -519,9 +519,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.2.32
 signing_key: