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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5764d0cc133ca646667feff52d835db4e3904212
-  data.tar.gz: 9639b14c964fd32db9b956243310ff52407c1897
+  metadata.gz: 5cacf8fc2c5e7cc181a03ef93f0757d203a8c135
+  data.tar.gz: 2087e7e94e486a11d6aef70dc2ba9866065ccef7
 SHA512:
-  metadata.gz: 65cc44b9910152d1b921ed528d6c6a3791e9b084382222713ff58caa54d4bb643a768bf9a4d986a991670e9e836f9bc74c38732d2884fee501003e1fa8832f99
-  data.tar.gz: da292d84762016a2a2b3277ff7d5001af863e8dc85f5826b22d8abb45a6de25df94c09355a7fea47e35a60b4398f355d2c0d42104464980e9b6d74283011b1e8
+  metadata.gz: aea9a06f4742233f7517068ed81bf31eebf462cf2095a9faa5baa8b12134ea4f2c83e37253b698d0cb943c4461c12a85eccce14f5db4f1ea0005fbe49ecaa468
+  data.tar.gz: 3831f2c06cdb55b2f7551501f5ffe7d01f511c9f97fe13d0a635e50ff5e7365118a47fd24780b6626731766ecaed0a901c5e590a79a0f02c4fa946e3bfb2bf22

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,18 @@
 CHANGES
 
+7.2.3 (Feb 24, 2021)
+- Fixed missing segment fetch after an SPLIT_UPDATE.
+- Updated streaming logic to support multiregion.
+- Updated sse client connection logic to read confirmation event.
+- Updated naming of retryable erros.
+
+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/fetchers/segment_fetcher.rb

@@ -27,14 +27,22 @@ module SplitIoClient
           end
         end
 
+        def fetch_segments_if_not_exists(names)
+          names.each do |name|
+            change_number = @segments_repository.get_change_number(name)
+
+            fetch_segment(name) if change_number == -1
+          end
+        rescue StandardError => error
+          @config.log_found_exception(__method__.to_s, error)
+        end
+
         def fetch_segment(name)
           @semaphore.synchronize do
             segments_api.fetch_segments_by_names([name])
-            true
           end
         rescue StandardError => error
           @config.log_found_exception(__method__.to_s, error)
-          false
         end
 
         def fetch_segments

data/lib/splitclient-rb/cache/fetchers/split_fetcher.rb

@@ -41,11 +41,11 @@ module SplitIoClient
             @config.logger.debug("segments seen(#{data[:segment_names].length}): #{data[:segment_names].to_a}") if @config.debug_enabled
 
             @sdk_blocker.splits_ready!
-            true
+
+            data[:segment_names]
           end
         rescue StandardError => error
           @config.log_found_exception(__method__.to_s, error)
-          false
         end
 
         def stop_splits_thread

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,10 @@ 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/engine/synchronizer.rb

@@ -30,7 +30,7 @@ module SplitIoClient
       def sync_all
         @config.threads[:sync_all_thread] = Thread.new do
           @config.logger.debug('Synchronizing Splits and Segments ...') if @config.debug_enabled
-          fetch_splits
+          @split_fetcher.fetch_splits
           fetch_segments
         end
       end
@@ -53,21 +53,12 @@ module SplitIoClient
       end
 
       def fetch_splits
-        back_off = SplitIoClient::SSE::EventSource::BackOff.new(SplitIoClient::Constants::FETCH_BACK_OFF_BASE_RETRIES, 1)
-        loop do
-          break if @split_fetcher.fetch_splits
-
-          sleep(back_off.interval)
-        end
+        segment_names = @split_fetcher.fetch_splits
+        @segment_fetcher.fetch_segments_if_not_exists(segment_names) unless segment_names.empty?
       end
 
       def fetch_segment(name)
-        back_off = SplitIoClient::SSE::EventSource::BackOff.new(SplitIoClient::Constants::FETCH_BACK_OFF_BASE_RETRIES, 1)
-        loop do
-          break if @segment_fetcher.fetch_segment(name)
-
-          sleep(back_off.interval)
-        end
+        @segment_fetcher.fetch_segment(name)
       end
 
       private

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
@@ -45,6 +43,11 @@ module SplitIoClient
         end
 
         def start(url)
+          if connected?
+            @config.logger.debug('SSEClient already running.')
+            return true
+          end
+
           @uri = URI(url)
           latch = Concurrent::CountDownLatch.new(1)
 
@@ -72,16 +75,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 +94,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 +159,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 +170,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/sse/workers/segments_worker.rb

@@ -48,12 +48,13 @@ module SplitIoClient
         def perform
           while (item = @queue.pop)
             segment_name = item[:segment_name]
-            change_number = item[:change_number]
-            since = @segments_repository.get_change_number(segment_name)
+            cn = item[:change_number]
+            @config.logger.debug("SegmentsWorker change_number dequeue #{segment_name}, #{cn}")
 
-            unless since >= change_number
-              @config.logger.debug("SegmentsWorker fetch_segment with #{since}")
+            attempt = 0
+            while cn > @segments_repository.get_change_number(segment_name).to_i && attempt <= Workers::MAX_RETRIES_ALLOWED
               @synchronizer.fetch_segment(segment_name)
+              attempt += 1
             end
           end
         end

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

@@ -3,6 +3,8 @@
 module SplitIoClient
   module SSE
     module Workers
+      MAX_RETRIES_ALLOWED = 10
+
       class SplitsWorker
         def initialize(synchronizer, config, splits_repository)
           @synchronizer = synchronizer
@@ -59,11 +61,12 @@ module SplitIoClient
 
         def perform
           while (change_number = @queue.pop)
-            since = @splits_repository.get_change_number
+            @config.logger.debug("SplitsWorker change_number dequeue #{change_number}")
 
-            unless since.to_i >= change_number
-              @config.logger.debug("SplitsWorker fetch_splits with #{since}")
+            attempt = 0
+            while change_number > @splits_repository.get_change_number.to_i && attempt <= Workers::MAX_RETRIES_ALLOWED
               @synchronizer.fetch_splits
+              attempt += 1
             end
           end
         end

data/lib/splitclient-rb/version.rb

@@ -1,3 +1,3 @@
 module SplitIoClient
-  VERSION = '7.2.0.pre.rc1'
+  VERSION = '7.2.3'
 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
 platform: java
 authors:
 - Split Software
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-19 00:00:00.000000000 Z
+date: 2021-02-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -450,9 +450,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project:
 rubygems_version: 2.6.14