splitclient-rb 7.2.0.pre.rc1-java → 7.2.3.pre.rc1-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5764d0cc133ca646667feff52d835db4e3904212
-  data.tar.gz: 9639b14c964fd32db9b956243310ff52407c1897
+  metadata.gz: 82dba9aec3fee3c5432638185912f7a0a99f80e9
+  data.tar.gz: 3ca561bf1fbc93340182e0c8d7416b811dc6d417
 SHA512:
-  metadata.gz: 65cc44b9910152d1b921ed528d6c6a3791e9b084382222713ff58caa54d4bb643a768bf9a4d986a991670e9e836f9bc74c38732d2884fee501003e1fa8832f99
-  data.tar.gz: da292d84762016a2a2b3277ff7d5001af863e8dc85f5826b22d8abb45a6de25df94c09355a7fea47e35a60b4398f355d2c0d42104464980e9b6d74283011b1e8
+  metadata.gz: 56196cd84b90313f8061dbf0eb4cb96127c084cd363abf7935c98ad090388beafd470b97b50d451cf2c588896ff4433fd9fe2b811b20bf568afc84a40f59fe9b
+  data.tar.gz: 20a873e2e90614563439d2b3cad835238515bce7b768c9ec27be089e66ad6fe3a5a0704ac9b829289d485a6388afcb7e3cfd597aa96aa07813b2ff2983602c30

data/.rubocop.yml

@@ -10,6 +10,9 @@ Metrics/MethodLength:
 Metrics/ClassLength:
   Max: 150
 
+Metrics/CyclomaticComplexity:
+  Max: 8
+
 Metrics/LineLength:
   Max: 130
   Exclude:

data/CHANGES.txt

@@ -1,5 +1,12 @@
 CHANGES
 
+7.2.2 (Dec 18, 2020)
+- Fixed issue: undefined local variable or method post_impressions_count
+
+7.2.1 (Oct 23, 2020)
+- Updated redis dependency to >= 4.2.2.
+- Updated ably error handling. 
+
 7.2.0 (Sep 25, 2020)
 - Added deduplication logic for impressions data.
   - Now there are two modes for Impressions when the SDK is in standalone mode, OPTIMIZED (default) that only ships unique impressions and DEBUG for times where you need to send ALL impressions to debug an integration.

data/lib/splitclient-rb/cache/senders/impressions_count_sender.rb

@@ -40,32 +40,32 @@ module SplitIoClient
               @config.logger.info('Posting impressions count due to shutdown')
             end
           end
+        end
 
-          def post_impressions_count
-            @impressions_api.post_count(formatter(@impression_counter.pop_all))
-          rescue StandardError => error
-            @config.log_found_exception(__method__.to_s, error)
-          end
-
-          def formatter(counts)
-            return if counts.empty?
+        def post_impressions_count
+          @impressions_api.post_count(formatter(@impression_counter.pop_all))
+        rescue StandardError => error
+          @config.log_found_exception(__method__.to_s, error)
+        end
 
-            formated_counts = {pf: []}
+        def formatter(counts)
+          return if counts.empty?
 
-            counts.each do |key, value|              
-              key_splited = key.split('::')
-              
-              formated_counts[:pf] << {
-                f: key_splited[0].to_s, # feature name
-                m: key_splited[1].to_i, # time frame
-                rc: value # count
-              }
-            end
+          formated_counts = {pf: []}
 
-            formated_counts
-          rescue StandardError => error
-            @config.log_found_exception(__method__.to_s, error)
+          counts.each do |key, value|              
+            key_splited = key.split('::')
+            
+            formated_counts[:pf] << {
+              f: key_splited[0].to_s, # feature name
+              m: key_splited[1].to_i, # time frame
+              rc: value # count
+            }
           end
+
+          formated_counts
+        rescue StandardError => error
+          @config.log_found_exception(__method__.to_s, error)
         end
       end
     end

data/lib/splitclient-rb/constants.rb

@@ -6,5 +6,11 @@ class SplitIoClient::Constants
   CONTROL_SEC = 'control_sec'
   OCCUPANCY_CHANNEL_PREFIX = '[?occupancy=metrics.publishers]'
   FETCH_BACK_OFF_BASE_RETRIES = 1
+  PUSH_CONNECTED = 'PUSH_CONNECTED'
+  PUSH_RETRYABLE_ERROR = 'PUSH_RETRYABLE_ERROR'
+  PUSH_NONRETRYABLE_ERROR = 'PUSH_NONRETRYABLE_ERROR'
+  PUSH_SUBSYSTEM_DOWN = 'PUSH_SUBSYSTEM_DOWN'
+  PUSH_SUBSYSTEM_READY = 'PUSH_SUBSYSTEM_READY'
+  PUSH_SUBSYSTEM_OFF = 'PUSH_SUBSYSTEM_OFF'
 end
   

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

@@ -19,12 +19,13 @@ module SplitIoClient
         if response[:push_enabled] && @sse_handler.start(response[:token], response[:channels])
           schedule_next_token_refresh(response[:exp])
           @back_off.reset
-          return
+          return true
         end
 
         stop_sse
 
         schedule_next_token_refresh(@back_off.interval) if response[:retry]
+        false
       rescue StandardError => e
         @config.logger.error("start_sse: #{e.inspect}")
       end

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

@@ -11,8 +11,7 @@ module SplitIoClient
       )
         @synchronizer = synchronizer
         notification_manager_keeper = SplitIoClient::SSE::NotificationManagerKeeper.new(config) do |manager|
-          manager.on_occupancy { |publisher_available| process_occupancy(publisher_available) }
-          manager.on_push_shutdown { process_push_shutdown }
+          manager.on_action { |action| process_action(action) }
         end
         @sse_handler = SplitIoClient::SSE::SSEHandler.new(
           config,
@@ -21,8 +20,7 @@ module SplitIoClient
           repositories[:segments],
           notification_manager_keeper
         ) do |handler|
-          handler.on_connected { process_connected }
-          handler.on_disconnect { |reconnect| process_disconnect(reconnect) }
+          handler.on_action { |action| process_action(action) }
         end
 
         @push_manager = PushManager.new(config, @sse_handler, api_key)
@@ -44,10 +42,10 @@ module SplitIoClient
       # Starts tasks if stream is enabled.
       def start_stream
         @config.logger.debug('Starting push mode ...')
-        stream_start_thread
+        sync_all_thread
         @synchronizer.start_periodic_data_recording
 
-        stream_start_sse_thread
+        start_sse_connection_thread
       end
 
       def start_poll
@@ -59,23 +57,24 @@ module SplitIoClient
       end
 
       # Starts thread which fetch splits and segments once and trigger task to periodic data recording.
-      def stream_start_thread
+      def sync_all_thread
         @config.threads[:sync_manager_start_stream] = Thread.new do
           begin
             @synchronizer.sync_all
           rescue StandardError => e
-            @config.logger.error("stream_start_thread error : #{e.inspect}")
+            @config.logger.error("sync_all_thread error : #{e.inspect}")
           end
         end
       end
 
       # Starts thread which connect to sse and after that fetch splits and segments once.
-      def stream_start_sse_thread
+      def start_sse_connection_thread
         @config.threads[:sync_manager_start_sse] = Thread.new do
           begin
-            @push_manager.start_sse
+            connected = @push_manager.start_sse
+            @synchronizer.start_periodic_fetch unless connected
           rescue StandardError => e
-            @config.logger.error("stream_start_sse_thread error : #{e.inspect}")
+            @config.logger.error("start_sse_connection_thread error : #{e.inspect}")
           end
         end
       end
@@ -84,6 +83,46 @@ module SplitIoClient
         PhusionPassenger.on_event(:starting_worker_process) { |forked| start_stream if forked }
       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
+        @sse_handler.start_workers
+      end
+
+      def process_subsystem_down
+        @sse_handler.stop_workers
+        @synchronizer.start_periodic_fetch
+      end
+
+      def process_push_shutdown
+        @push_manager.stop_sse
+        @sse_handler.stop_workers
+        @synchronizer.start_periodic_fetch
+      rescue StandardError => e
+        @config.logger.error("process_push_shutdown error: #{e.inspect}")
+      end
+
       def process_connected
         if @sse_connected.value
           @config.logger.debug('Streaming already connected.')
@@ -115,28 +154,6 @@ module SplitIoClient
       rescue StandardError => e
         @config.logger.error("process_disconnect error: #{e.inspect}")
       end
-
-      def process_occupancy(push_enable)
-        if push_enable
-          @synchronizer.stop_periodic_fetch
-          @synchronizer.sync_all
-          @sse_handler.start_workers
-          return
-        end
-
-        @sse_handler.stop_workers
-        @synchronizer.start_periodic_fetch
-      rescue StandardError => e
-        @config.logger.error("process_occupancy error: #{e.inspect}")
-      end
-
-      def process_push_shutdown
-        @push_manager.stop_sse
-        @sse_handler.stop_workers
-        @synchronizer.start_periodic_fetch
-      rescue StandardError => e
-        @config.logger.error("process_push_shutdown error: #{e.inspect}")
-      end
     end
   end
 end

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

@@ -9,6 +9,7 @@ module SplitIoClient
       class Client
         DEFAULT_READ_TIMEOUT = 70
         CONNECT_TIMEOUT = 30_000
+        OK_CODE = 200
         KEEP_ALIVE_RESPONSE = "c\r\n:keepalive\n\n\r\n".freeze
         ERROR_EVENT_TYPE = 'error'.freeze
 
@@ -16,9 +17,10 @@ module SplitIoClient
           @config = config
           @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: ->(_) {}, connected: ->(_) {}, disconnect: ->(_) {} }
+          @on = { event: ->(_) {}, action: ->(_) {} }
 
           yield self if block_given?
         end
@@ -27,16 +29,12 @@ module SplitIoClient
           @on[:event] = action
         end
 
-        def on_connected(&action)
-          @on[:connected] = action
+        def on_action(&action)
+          @on[:action] = action
         end
 
-        def on_disconnect(&action)
-          @on[:disconnect] = action
-        end
-
-        def close(reconnect = false)
-          dispatch_disconnect(reconnect)
+        def close(action = Constants::PUSH_NONRETRYABLE_ERROR)
+          dispatch_action(action)
           @connected.make_false
           SplitIoClient::Helpers::ThreadHelper.stop(:connect_stream, @config)
           @socket&.close
@@ -72,16 +70,18 @@ module SplitIoClient
         end
 
         def connect_stream(latch)
-          socket_write(latch)
+          socket_write
 
-          while @connected.value
+          while connected? || @first_event.value
             begin
               partial_data = @socket.readpartial(10_000, timeout: @read_timeout)
 
+              read_first_event(partial_data, latch)
+
               raise 'eof exception' if partial_data == :eof
             rescue StandardError => e
               @config.logger.error('Error reading partial data: ' + e.inspect) if @config.debug_enabled
-              close(true) # close conexion & reconnect
+              close(Constants::PUSH_RETRYABLE_ERROR)
               return
             end
 
@@ -89,14 +89,31 @@ module SplitIoClient
           end
         end
 
-        def socket_write(latch)
+        def socket_write
+          @first_event.make_true
           @socket = socket_connect
           @socket.write(build_request(@uri))
-          dispatch_connected
         rescue StandardError => e
           @config.logger.error("Error during connecting to #{@uri.host}. Error: #{e.inspect}")
-          close
-        ensure
+          close(Constants::PUSH_NONRETRYABLE_ERROR)
+        end
+
+        def read_first_event(data, latch)
+          return unless @first_event.value
+
+          response_code = @event_parser.first_event(data)
+          @config.logger.debug("SSE client first event code: #{response_code}")
+
+          error_event = false
+          events = @event_parser.parse(data)
+          events.each { |e| error_event = true if e.event_type == ERROR_EVENT_TYPE }
+          @first_event.make_false
+
+          if response_code == OK_CODE && !error_event
+            @connected.make_true
+            dispatch_action(Constants::PUSH_CONNECTED)
+          end
+
           latch.count_down
         end
 
@@ -137,9 +154,9 @@ module SplitIoClient
         def dispatch_error(event)
           @config.logger.error("Event error: #{event.event_type}, #{event.data}")
           if event.data['code'] >= 40_140 && event.data['code'] <= 40_149
-            close(true) # close conexion & reconnect
+            close(Constants::PUSH_RETRYABLE_ERROR)
           elsif event.data['code'] >= 40_000 && event.data['code'] <= 49_999
-            close # close conexion
+            close(Constants::PUSH_NONRETRYABLE_ERROR)
           end
         end
 
@@ -148,15 +165,9 @@ module SplitIoClient
           @on[:event].call(event)
         end
 
-        def dispatch_connected
-          @connected.make_true
-          @config.logger.debug('Dispatching connected') if @config.debug_enabled
-          @on[:connected].call
-        end
-
-        def dispatch_disconnect(reconnect)
-          @config.logger.debug('Dispatching disconnect') if @config.debug_enabled
-          @on[:disconnect].call(reconnect)
+        def dispatch_action(action)
+          @config.logger.debug("Dispatching action: #{action}") if @config.debug_enabled
+          @on[:action].call(action)
         end
       end
     end

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

@@ -4,6 +4,8 @@ module SplitIoClient
   module SSE
     module EventSource
       class EventParser
+        BAD_REQUEST_CODE = 400
+
         def initialize(config)
           @config = config
         end
@@ -27,10 +29,17 @@ module SplitIoClient
 
           events
         rescue StandardError => e
-          @config.logger.error("Error during parsing a event: #{e.inspect}")
+          @config.logger.debug("Error during parsing a event: #{e.inspect}")
           []
         end
 
+        def first_event(raw_data)
+          raw_data.split("\n")[0].split(' ')[1].to_i
+        rescue StandardError => e
+          @config.logger.debug("Error parsing first event: #{e.inspect}")
+          BAD_REQUEST_CODE
+        end
+
         private
 
         def parse_event_data(data, type)

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'concurrent/atomics'
+require 'concurrent'
 
 module SplitIoClient
   module SSE
@@ -8,7 +8,9 @@ module SplitIoClient
       def initialize(config)
         @config = config
         @publisher_available = Concurrent::AtomicBoolean.new(true)
-        @on = { occupancy: ->(_) {}, push_shutdown: ->(_) {} }
+        @publishers_pri = Concurrent::AtomicFixnum.new
+        @publishers_sec = Concurrent::AtomicFixnum.new
+        @on = { action: ->(_) {} }
 
         yield self if block_given?
       end
@@ -16,19 +18,15 @@ module SplitIoClient
       def handle_incoming_occupancy_event(event)
         if event.data['type'] == 'CONTROL'
           process_event_control(event.data['controlType'])
-        elsif event.channel == SplitIoClient::Constants::CONTROL_PRI
-          process_event_occupancy(event.data['metrics']['publishers'])
+        else
+          process_event_occupancy(event.channel, event.data['metrics']['publishers'])
         end
       rescue StandardError => e
         @config.logger.error(e)
       end
 
-      def on_occupancy(&action)
-        @on[:occupancy] = action
-      end
-
-      def on_push_shutdown(&action)
-        @on[:push_shutdown] = action
+      def on_action(&action)
+        @on[:action] = action
       end
 
       private
@@ -36,35 +34,42 @@ module SplitIoClient
       def process_event_control(type)
         case type
         when 'STREAMING_PAUSED'
-          dispatch_occupancy_event(false)
+          dispatch_action(Constants::PUSH_SUBSYSTEM_DOWN)
         when 'STREAMING_RESUMED'
-          dispatch_occupancy_event(true) if @publisher_available.value
+          dispatch_action(Constants::PUSH_SUBSYSTEM_READY) if @publisher_available.value
         when 'STREAMING_DISABLED'
-          dispatch_push_shutdown
+          dispatch_action(Constants::PUSH_SUBSYSTEM_OFF)
         else
           @config.logger.error("Incorrect event type: #{incoming_notification}")
         end
       end
 
-      def process_event_occupancy(publishers)
-        @config.logger.debug("Occupancy process event with #{publishers} publishers") if @config.debug_enabled
-        if publishers <= 0 && @publisher_available.value
+      def process_event_occupancy(channel, publishers)
+        @config.logger.debug("Processed occupancy event with #{publishers} publishers. Channel: #{channel}")
+
+        update_publishers(channel, publishers)
+
+        if !are_publishers_available? && @publisher_available.value
           @publisher_available.make_false
-          dispatch_occupancy_event(false)
-        elsif publishers >= 1 && !@publisher_available.value
+          dispatch_action(Constants::PUSH_SUBSYSTEM_DOWN)
+        elsif are_publishers_available? && !@publisher_available.value
           @publisher_available.make_true
-          dispatch_occupancy_event(true)
+          dispatch_action(Constants::PUSH_SUBSYSTEM_READY)
         end
       end
 
-      def dispatch_occupancy_event(push_enable)
-        @config.logger.debug("Dispatching occupancy event with publisher avaliable: #{push_enable}")
-        @on[:occupancy].call(push_enable)
+      def update_publishers(channel, publishers)
+        @publishers_pri.value = publishers if channel == Constants::CONTROL_PRI
+        @publishers_sec.value = publishers if channel == Constants::CONTROL_SEC
+      end
+
+      def are_publishers_available?
+        @publishers_pri.value.positive? || @publishers_sec.value.positive?
       end
 
-      def dispatch_push_shutdown
-        @config.logger.debug('Dispatching push shutdown')
-        @on[:push_shutdown].call
+      def dispatch_action(action)
+        @config.logger.debug("Dispatching action: #{action}")
+        @on[:action].call(action)
       end
     end
   end

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

@@ -13,11 +13,10 @@ module SplitIoClient
         @notification_processor = SplitIoClient::SSE::NotificationProcessor.new(config, @splits_worker, @segments_worker)
         @sse_client = SSE::EventSource::Client.new(@config) do |client|
           client.on_event { |event| handle_incoming_message(event) }
-          client.on_connected { process_connected }
-          client.on_disconnect { |reconnect| process_disconnect(reconnect) }
+          client.on_action { |action| process_action(action) }
         end
 
-        @on = { connected: ->(_) {}, disconnect: ->(_) {} }
+        @on = { action: ->(_) {} }
 
         yield self if block_given?
       end
@@ -48,22 +47,14 @@ module SplitIoClient
         @segments_worker.stop
       end
 
-      def on_connected(&action)
-        @on[:connected] = action
-      end
-
-      def on_disconnect(&action)
-        @on[:disconnect] = action
-      end
-
-      def process_disconnect(reconnect)
-        @on[:disconnect].call(reconnect)
+      def on_action(&action)
+        @on[:action] = action
       end
 
       private
 
-      def process_connected
-        @on[:connected].call
+      def process_action(action)
+        @on[:action].call(action)
       end
 
       def handle_incoming_message(notification)

data/lib/splitclient-rb/version.rb

@@ -1,3 +1,3 @@
 module SplitIoClient
-  VERSION = '7.2.0.pre.rc1'
+  VERSION = '7.2.3.pre.rc1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: splitclient-rb
 version: !ruby/object:Gem::Version
-  version: 7.2.0.pre.rc1
+  version: 7.2.3.pre.rc1
 platform: java
 authors:
 - Split Software
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-19 00:00:00.000000000 Z
+date: 2021-01-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement