kameleoon-client-ruby 3.21.0 → 3.22.1

data/lib/kameleoon/kameleoon_client.rb

@@ -10,6 +10,13 @@ require 'kameleoon/data/manager/assigned_variation'
 require 'kameleoon/data/manager/forced_experiment_variation'
 require 'kameleoon/data/manager/legal_consent'
 require 'kameleoon/data/manager/visitor_manager'
+require 'kameleoon/events/data_file_update_event'
+require 'kameleoon/events/data_file_update_handler'
+require 'kameleoon/events/event_manager'
+require 'kameleoon/events/event_type'
+require 'kameleoon/events/http_request_failure'
+require 'kameleoon/events/http_request_handler'
+require 'kameleoon/events/request_type'
 require 'kameleoon/exceptions'
 require 'kameleoon/hybrid/manager'
 require 'kameleoon/managers/data/data_manager'
@@ -22,8 +29,7 @@ require 'kameleoon/network/activity_event'
 require 'kameleoon/network/network_manager'
 require 'kameleoon/network/url_provider'
 require 'kameleoon/network/cookie/cookie_manager'
-require 'kameleoon/real_time/real_time_configuration_service'
-require 'kameleoon/storage/cache_factory'
+require 'kameleoon/real_time/real_time_event_service'
 require 'kameleoon/targeting/models'
 require 'kameleoon/targeting/targeting_manager'
 require 'kameleoon/types/variable'
@@ -58,7 +64,8 @@ module Kameleoon
       @scheduler = Rufus::Scheduler.new
       @site_code = site_code
       @config = config
-      @real_time_configuration_service = nil
+      @disposed = false
+      @real_time_event_service = nil
       @update_configuration_handler = nil
       @fetch_configuration_update_job = nil
       data_file = Configuration::DataFile.new(config.environment, nil)
@@ -67,11 +74,13 @@ module Kameleoon
         @data_manager, config.session_duration_second, @scheduler
       )
       @hybrid_manager = Hybrid::ManagerImpl.new(HYBRID_EXPIRATION_TIME, @data_manager)
+      @event_manager = Events::EventManager.new
       @network_manager = Network::NetworkManager.new(
         config.environment,
         config.default_timeout_millisecond,
         Network::AccessTokenSourceFactory.new(config.client_id, config.client_secret),
-        Network::UrlProvider.new(site_code, config.network_domain)
+        Network::UrlProvider.new(site_code, config.network_domain),
+        @event_manager
       )
       @tracking_manager = Managers::Tracking::TrackingManager.new(
         @data_manager, @network_manager, @visitor_manager, config.tracking_interval_second, @scheduler
@@ -81,7 +90,7 @@ module Kameleoon
         @data_manager, @network_manager, @visitor_manager
       )
       @cookie_manager = Network::Cookie::CookieManager.new(@data_manager, @visitor_manager, config.top_level_domain)
-      @readiness = ClientReadiness.new
+      @readiness = ClientReadiness.new(site_code, config.environment)
       @targeting_manager = Targeting::TargetingManager.new(@data_manager, @visitor_manager)
 
       if @config.verbose_mode == true && Logging::KameleoonLogger.log_level == Logging::LogLevel::WARNING
@@ -95,25 +104,53 @@ module Kameleoon
     ##
     # Block until the SDK has loaded its configuration and is ready to use.
     #
-    # If the initial fetch fails the client keeps retrying in the background, so
-    # this method returns as soon as any fetch succeeds. The wait is always
-    # bounded by a timeout, so it never blocks indefinitely: when the timeout
-    # elapses before the configuration is loaded, the method returns false.
+    # The method returns the result of the configuration fetch: `true` once the
+    # SDK has been initialized, or `false` as soon as the fetch has failed
+    # (without waiting for background retries) or when no fetch result is
+    # available within the timeout. The failure which prevented the SDK from
+    # initializing is reported to the log.
+    #
+    # An expired timeout or a failed fetch does not affect the SDK state: the
+    # client keeps retrying in the background, and once the SDK becomes ready,
+    # a subsequent call returns true.
     #
     # @param [Integer, nil] timeout_millisecond Maximum time to wait, in
     #   milliseconds. When nil or negative, config.default_timeout_millisecond
     #   is applied.
-    # @return [Boolean] true if the SDK is ready, false if the timeout elapsed first.
+    # @return [Boolean] true if the SDK is ready, false if the fetch failed or
+    #   the timeout elapsed first.
     def wait_init(timeout_millisecond = nil)
       Logging::KameleoonLogger.info('CALL: KameleoonClient.wait_init(timeout_millisecond: %s)', timeout_millisecond)
       if timeout_millisecond.nil? || timeout_millisecond.negative?
         timeout_millisecond = @config.default_timeout_millisecond
       end
-      result = @readiness.wait(timeout_millisecond / 1000.0)
+      error = @readiness.wait_with_timeout(timeout_millisecond / 1000.0)
+      if error.nil?
+        Logging::KameleoonLogger.info('Kameleoon is initialized')
+      else
+        Logging::KameleoonLogger.error('Kameleoon failed to initialize due to error: %s', error.message)
+      end
+      result = error.nil?
       Logging::KameleoonLogger.info('RETURN: KameleoonClient.wait_init -> (result: %s)', result)
       result
     end
 
+    ##
+    # Indicates whether the SDK is ready for use, i.e. its configuration has been
+    # successfully loaded. Unlike `wait_init`, it returns immediately without blocking.
+    #
+    # It returns `true` if the SDK has been successfully initialized, `false` otherwise
+    # (including while the initialization is still pending or has failed).
+    #
+    # Readiness is monotonic: once the SDK becomes ready it stays ready.
+    #
+    # @return [Boolean] whether the SDK is ready for use.
+    def is_ready? # rubocop:disable Naming/PredicateName
+      ready = @readiness.ready?
+      Logging::KameleoonLogger.info('CALL/RETURN: KameleoonClient.is_ready? -> (ready: %s)', ready)
+      ready
+    end
+
     ##
     # Obtain a visitor code.
     #
@@ -712,6 +749,24 @@ module Kameleoon
       map_active_features
     end
 
+    ##
+    # Sets the SDK event handler for the specified event type.
+    #
+    # The handler is called when the corresponding SDK event occurs. Supported event types are
+    # defined in `Kameleoon::Events::EventType`. Passing `nil` clears the handler for the
+    # specified event type.
+    #
+    # @param event_type [Symbol] The SDK event type to handle, one of the
+    # `Kameleoon::Events::EventType` constants.
+    # @param handler [Object, nil] The handler to register, or `nil` to remove the current handler.
+    # The handler must respond to the methods required by the selected event type
+    # (see `Kameleoon::Events::HttpRequestHandler` and `Kameleoon::Events::DataFileUpdateHandler`).
+    def set_event_handler(event_type, handler)
+      Logging::KameleoonLogger.info("CALL: KameleoonClient.set_event_handler(event_type: '%s', handler)", event_type)
+      @event_manager.set_event_handler(event_type, handler)
+      Logging::KameleoonLogger.info("RETURN: KameleoonClient.set_event_handler(event_type: '%s', handler)", event_type)
+    end
+
     ##
     # The `on_update_configuration()` method allows you to handle the event when configuration
     # has updated data. It takes one input parameter: callable **handler**. The handler
@@ -719,7 +774,13 @@ module Kameleoon
     #
     # @param handler [Callable | NilClass] The handler that will be called when the configuration
     # is updated using a real-time configuration event.
+    #
+    # DEPRECATED. Please use `set_event_handler(Kameleoon::Events::EventType::DATAFILE_UPDATE, handler)` instead.
     def on_update_configuration(handler)
+      Logging::KameleoonLogger.info(
+        '[DEPRECATION] `on_update_configuration` is deprecated. ' \
+        'Please use `set_event_handler(Kameleoon::Events::EventType::DATAFILE_UPDATE, handler)` instead.'
+      )
       Logging::KameleoonLogger.info('CALL/RETURN: KameleoonClient.on_update_configuration(handler)')
       @update_configuration_handler = handler
     end
@@ -826,44 +887,41 @@ module Kameleoon
 
     HYBRID_EXPIRATION_TIME = 5
 
-    def fetch_configuration_initially
-      Logging::KameleoonLogger.info('Initial configuration fetch is started.')
-      Thread.new do
-        ok = false
-        begin
-          ok = obtain_configuration
-          Logging::KameleoonLogger.error('Initial configuration fetch failed') unless ok
-        rescue StandardError => e
-          Logging::KameleoonLogger.error('Initial configuration fetch failed: %s', e)
-        end
-        @readiness.set(ok)
-        real_time_update = ok && @data_manager.data_file.settings.real_time_update
-        manage_configuration_update(real_time_update)
-      end
-    end
-
+    # Fetches the configuration in a background thread; used for the initial fetch,
+    # the polling schedule, and the streaming events alike. The fetch outcome settles
+    # the client readiness, and a failed fetch always falls back to the polling mode:
+    # a streaming event means the configuration has changed, so staying in the
+    # streaming mode would leave the SDK serving the outdated configuration until
+    # the next event arrives. The server-provided settings are not mutated, so a
+    # later successful fetch switches back to streaming when requested.
     def fetch_configuration_job(time_stamp = nil)
       Thread.new do
+        cause = nil
         ok = false
         begin
           ok = obtain_configuration(time_stamp)
         rescue StandardError => e
+          cause = e
           Logging::KameleoonLogger.error('Error occurred during configuration fetching: %s', e)
         end
-        # Release any threads still waiting in `wait_init` once a (re)fetch
-        # finally succeeds after an unsuccessful initial fetch.
-        @readiness.set(ok)
-        real_time_update = @data_manager.data_file.settings.real_time_update
-        if !ok && real_time_update
-          @data_manager.data_file.settings.real_time_update = false
-          real_time_update = false
-          Logging::KameleoonLogger.warning('Switching to polling mode due to failed fetch')
-        end
-        manage_configuration_update(real_time_update)
+        settle_readiness(ok, cause)
+        manage_configuration_update(ok && @data_manager.data_file.settings.real_time_update)
       end
     end
 
-    def start_configuration_update_job_if_needed
+    # A successful fetch marks the SDK ready, a failed one reports the failure so
+    # `wait_init` fails fast instead of sleeping out its timeout. A failure never
+    # reverts an already-ready client.
+    def settle_readiness(ok, cause)
+      if ok
+        @readiness.mark_ready
+      else
+        cause ||= Exception::KameleoonError.new('configuration fetch failed')
+        @readiness.mark_not_ready(cause)
+      end
+    end
+
+    def start_polling_datafile_update
       return unless @fetch_configuration_update_job.nil?
 
       @fetch_configuration_update_job = @scheduler.schedule_every @config.refresh_interval_second do
@@ -872,7 +930,7 @@ module Kameleoon
       end
     end
 
-    def stop_configuration_update_job_if_needed
+    def stop_polling_datafile_update
       return if @fetch_configuration_update_job.nil?
 
       @fetch_configuration_update_job&.unschedule
@@ -880,27 +938,34 @@ module Kameleoon
       Logging::KameleoonLogger.info('Scheduled job to fetch configuration is stopped.')
     end
 
-    def start_real_time_configuration_service_if_needed
-      return unless @real_time_configuration_service.nil?
+    def start_real_time_event_service_if_needed
+      return unless @real_time_event_service.nil?
 
       url = @network_manager.url_provider.make_real_time_url
       fetch_func = proc { |real_time_event| fetch_configuration_job(real_time_event.time_stamp) }
-      @real_time_configuration_service =
-        Kameleoon::RealTime::RealTimeConfigurationService.new(url, fetch_func)
+      @real_time_event_service =
+        Kameleoon::RealTime::RealTimeEventService.new(url, fetch_func)
     end
 
-    def stop_real_time_configuration_service_if_needed
-      @real_time_configuration_service&.close
-      @real_time_configuration_service = nil
+    def stop_real_time_event_service_if_needed
+      @real_time_event_service&.close
+      @real_time_event_service = nil
     end
 
+    # A disposed client must not (re)start the update services: a fetch which was
+    # in flight when `dispose` ran would otherwise resurrect them. `@disposed` is
+    # set before `dispose` stops the services, so a fetch completing after that
+    # point can only stop things.
     def manage_configuration_update(is_real_time_update)
-      if is_real_time_update
-        stop_configuration_update_job_if_needed
-        start_real_time_configuration_service_if_needed
+      if @disposed
+        stop_polling_datafile_update
+        stop_real_time_event_service_if_needed
+      elsif is_real_time_update
+        stop_polling_datafile_update
+        start_real_time_event_service_if_needed
       else
-        stop_real_time_configuration_service_if_needed
-        start_configuration_update_job_if_needed
+        stop_real_time_event_service_if_needed
+        start_polling_datafile_update
       end
     end
 
@@ -927,34 +992,44 @@ module Kameleoon
       if response.configuration
         configuration = JSON.parse(response.configuration)
         data_file = Configuration::DataFile.new(@config.environment, configuration, response.last_modified)
-        apply_new_configuration(data_file)
-        call_update_handler_if_needed(!time_stamp.nil?)
+        source = time_stamp.nil? ? Events::DataFileUpdateEvent::Source::POLLING
+                                 : Events::DataFileUpdateEvent::Source::STREAMING
+        apply_new_configuration(data_file, source)
         Logging::KameleoonLogger.info('Feature flags are fetched: %s', response.inspect)
       end
       true
     end
 
-    def apply_new_configuration(data_file)
-      Logging::KameleoonLogger.debug('CALL: KameleoonClient.apply_new_configuration(data_file: %s)', data_file)
+    def apply_new_configuration(data_file, source)
+      Logging::KameleoonLogger.debug('CALL: KameleoonClient.apply_new_configuration(data_file: %s, source: %s)',
+                                     data_file, source)
       @data_manager.data_file = data_file
       @network_manager.url_provider.apply_data_api_domain(data_file.settings.data_api_domain)
-      Logging::KameleoonLogger.debug('RETURN: KameleoonClient.apply_new_configuration(data_file: %s)', data_file)
+      @event_manager.fire_data_file_update(Events::DataFileUpdateEvent.new(source, data_file.date_modified))
+      call_deprecated_update_handler if source == Events::DataFileUpdateEvent::Source::STREAMING
+      Logging::KameleoonLogger.debug('RETURN: KameleoonClient.apply_new_configuration(data_file: %s, source: %s)',
+                                     data_file, source)
     end
 
     ##
-    # Call the handler when configuration was updated with new time stamp.
-    #
-    # @param need_call [Bool] Indicates if we need to call handler or not.
-    def call_update_handler_if_needed(need_call)
-      return if !need_call || @update_configuration_handler.nil?
-
-      @update_configuration_handler.call
+    # Call the deprecated update configuration handler when configuration was updated
+    # by a real-time (streaming) notification.
+    def call_deprecated_update_handler
+      handler = @update_configuration_handler
+      return if handler.nil?
+
+      begin
+        handler.call
+      rescue StandardError => e
+        Logging::KameleoonLogger.warning('Update configuration handler failed: %s', e)
+      end
     end
 
     def dispose(_object_id = nil)
       Logging::KameleoonLogger.debug('CALL: KameleoonClient.dispose')
-      stop_configuration_update_job_if_needed
-      stop_real_time_configuration_service_if_needed
+      @disposed = true
+      stop_polling_datafile_update
+      stop_real_time_event_service_if_needed
       @visitor_manager.stop
       @tracking_manager.stop
       @scheduler.shutdown

data/lib/kameleoon/kameleoon_client_factory.rb

@@ -24,7 +24,7 @@ module Kameleoon
       key = get_client_key(site_code, config.environment)
       client = @clients.compute_if_absent(key) do
         client = KameleoonClient.new(site_code, config)
-        client.send(:fetch_configuration_initially)
+        client.send(:fetch_configuration_job)
         client
       end
       Logging::KameleoonLogger.info(

data/lib/kameleoon/managers/tracking/tracking_manager.rb

@@ -11,6 +11,7 @@ module Kameleoon
       class TrackingManager
         LINES_DELIMETER = "\n"
         REQUEST_SIZE_LIMIT = 2560 * 1024 # 2.5 * 1024^2 characters
+        PROBE_MAX_VISITORS = 1
 
         def initialize(
           data_manager, network_manager, visitor_manager, track_interval_seconds, scheduler
@@ -19,7 +20,8 @@ module Kameleoon
             'CALL: TrackingManager.new(data_manager, network_manager. visitor_manager, ' \
               'track_interval_seconds: %s, scheduler)', track_interval_seconds
           )
-          @tracking_visitors = LockVisitorTrackingRegistry.new(visitor_manager)
+          @tracking_visitors = ConcurrentVisitorTrackingRegistry.new(visitor_manager)
+          @probe_mode = false
           @data_manager = data_manager
           @network_manager = network_manager
           @visitor_manager = visitor_manager
@@ -45,10 +47,19 @@ module Kameleoon
 
         def track_all
           Logging::KameleoonLogger.debug('CALL: TrackingManager.track_all')
-          track(@tracking_visitors.extract)
+          if @probe_mode
+            track_probe
+          else
+            track(@tracking_visitors.extract)
+          end
           Logging::KameleoonLogger.debug('RETURN: TrackingManager.track_all')
         end
 
+        # Test purpose only
+        def probe_mode?
+          @probe_mode
+        end
+
         def track_visitor(visitor_code)
           Logging::KameleoonLogger.debug("CALL: TrackingManager.track_visitor(visitor_code: '%s')", visitor_code)
           track([visitor_code])
@@ -57,6 +68,14 @@ module Kameleoon
 
         private
 
+        # Sends one visitor's data; visitors without data are dropped (as on the normal path) until one is found.
+        def track_probe
+          until (visitor_code = @tracking_visitors.extract(PROBE_MAX_VISITORS)).empty?
+            return if track(visitor_code)
+          end
+        end
+
+        # Returns whether a request was sent.
         def track(visitor_codes)
           builder = TrackingBuilder.new(visitor_codes, @data_manager.data_file, @visitor_manager, REQUEST_SIZE_LIMIT)
           builder.build
@@ -71,8 +90,9 @@ module Kameleoon
           perform_tracking_request(builder.visitor_codes_to_send, builder.unsent_visitor_data, builder.tracking_lines)
         end
 
+        # Returns whether a request was sent.
         def perform_tracking_request(visitor_codes, visitor_data, tracking_lines)
-          return if visitor_data.empty?
+          return false if visitor_data.empty?
 
           lines = tracking_lines.join(LINES_DELIMETER)
           # mark unsent data as transmitted
@@ -83,14 +103,32 @@ module Kameleoon
               Logging::KameleoonLogger.info('Successful request for tracking visitors: %s, data: %s',
                                             visitor_codes, visitor_data)
               visitor_data.each { |d| d.mark_as_sent if d.is_a?(Kameleoon::Data) }
+              leave_probe_mode
             else
               Logging::KameleoonLogger.error('Tracking request failed')
               Logging::KameleoonLogger.info('Failed request for tracking visitors: %s, data: %s',
                                             visitor_codes, visitor_data)
               visitor_data.each { |d| d.mark_as_unsent if d.is_a?(Kameleoon::Data) }
+              enter_probe_mode
               @tracking_visitors.add_all(visitor_codes)
             end
           end
+          true
+        end
+
+        def enter_probe_mode
+          return if @probe_mode
+
+          @probe_mode = true
+          Logging::KameleoonLogger.info("Tracking request failed: only one visitor's data per tracking request " \
+                                        'will be sent until a request succeeds')
+        end
+
+        def leave_probe_mode
+          return unless @probe_mode
+
+          @probe_mode = false
+          Logging::KameleoonLogger.info('Tracking request succeeded: full-size tracking requests are restored')
         end
       end
     end

data/lib/kameleoon/managers/tracking/visitor_tracking_registry.rb

@@ -1,91 +1,91 @@
 # frozen_string_literal: true
 
-require 'set'
-
 module Kameleoon
   module Managers
     module Tracking
-      class LockVisitorTrackingRegistry
+      # Visitor codes waiting for a tracking request, in a Hash used as an insertion-ordered set.
+      #
+      # Lock-free on the hot path (MRI): `add` is a single Hash#[]=, which the GVL makes atomic (String keys hash
+      # in C, so no Ruby code runs inside it), and request threads never block on the registry. The Hash is never
+      # swapped out; `extract` removes with Hash#shift (O(1), oldest first) under a lock that only serializes
+      # extractors, so a concurrently added code is either returned now or kept for the next extraction, never
+      # lost. Nothing here iterates the live Hash: an `add` during iteration would raise in the request thread.
+      # Other engines run threads in parallel and take the lock on `add` as well: JRuby's Hash raises
+      # ConcurrencyError on unsynchronized concurrent writes; TruffleRuby's shared collections are thread-safe,
+      # but the lock-free path has not been measured there.
+      class ConcurrentVisitorTrackingRegistry
         LIMITED_EXTRACTION_THRESHOLD_COEFFICIENT = 2
         REMOVAL_FACTOR = 0.8
+        UNLIMITED_EXTRACTION = 2**62
+        LOCK_FREE_ADD = (RUBY_ENGINE == 'ruby')
 
         def initialize(visitor_manager, storage_limit = 1_000_000, extraction_limit = 20_000)
           @visitor_manager = visitor_manager
           @storage_limit = storage_limit
           @extraction_limit = extraction_limit
-          @visitors = Set.new
-          @mutex = Mutex.new
+          @visitors = {}
+          @extract_mutex = Mutex.new
         end
 
-        def add(visitor_code)
-          @mutex.synchronize { @visitors.add(visitor_code) }
-        end
+        if LOCK_FREE_ADD
+          def add(visitor_code)
+            @visitors[visitor_code] = true
+          end
 
-        def add_all(visitor_codes)
-          @mutex.synchronize do
-            @visitors.merge(visitor_codes)
-            if @visitors.size > @storage_limit
-              erase_nonexistent_visitors
-              erase_to_storage_limit
-            end
+          def add_all(visitor_codes)
+            visitor_codes.each { |vc| @visitors[vc] = true }
+            erase_to_storage_limit if @visitors.size > @storage_limit
+          end
+        else
+          def add(visitor_code)
+            @extract_mutex.synchronize { @visitors[visitor_code] = true }
           end
+
+          def add_all(visitor_codes)
+            @extract_mutex.synchronize { visitor_codes.each { |vc| @visitors[vc] = true } }
+            erase_to_storage_limit if @visitors.size > @storage_limit # takes the (non-reentrant) mutex itself
+          end
+        end
+
+        # Removes and returns visitor codes, oldest first: all of them while the registry holds no more than
+        # `limit` codes and fewer than twice the extraction limit, otherwise `min(limit, extraction_limit)`.
+        def extract(limit = UNLIMITED_EXTRACTION)
+          @extract_mutex.synchronize { shift_visitors(extraction_count(@visitors.size, limit)) }
         end
 
-        def extract
-          should_extract_all_be_used ? extract_all : extract_limited
+        # Test purpose only
+        def visitors
+          @visitors.keys
         end
 
         private
 
-        def should_extract_all_be_used
-          @visitors.size < @extraction_limit * LIMITED_EXTRACTION_THRESHOLD_COEFFICIENT
-        end
+        def extraction_count(size, limit)
+          return size if (size <= limit) && (size < @extraction_limit * LIMITED_EXTRACTION_THRESHOLD_COEFFICIENT)
 
-        def extract_all
-          old_visitors = nil
-          new_visitors = Set.new
-          @mutex.synchronize do
-            old_visitors = @visitors
-            @visitors = new_visitors
-          end
-          old_visitors
+          [limit, @extraction_limit].min
         end
 
-        def extract_limited
-          extracted = nil
-          @mutex.synchronize do
-            if should_extract_all_be_used
-              extracted = extract_all
-              next
-            end
-            i = 0
-            extracted = []
-            @visitors.each do |vc|
-              break if i >= @extraction_limit
+        # Fewer than `count` codes come back only if the registry runs empty meanwhile.
+        def shift_visitors(count)
+          extracted = []
+          while extracted.size < count
+            pair = @visitors.shift
+            break if pair.nil?
 
-              extracted.push(vc)
-              i += 1
-              @visitors.delete(vc)
-            end
+            extracted.push(pair[0])
           end
           extracted
         end
 
-        # Not thread-safe
-        def erase_nonexistent_visitors
-          @visitors.delete_if { |vc| @visitor_manager.get_visitor(vc).nil? }
-        end
-
-        # Not thread-safe
         def erase_to_storage_limit
-          visitors_to_remove_count = @visitors.size - (@storage_limit * REMOVAL_FACTOR).to_i
-          return if visitors_to_remove_count <= 0
-
-          @visitors.each do |vc|
-            break if visitors_to_remove_count.zero?
-
-            visitors_to_remove_count -= 1
-            @visitors.delete(vc)
+          @extract_mutex.synchronize do
+            # Drain and re-insert instead of `delete_if`, so that concurrent adds never hit an iteration in progress.
+            # Codes added while draining stay in the live Hash.
+            drained = shift_visitors(@visitors.size)
+            drained.each { |vc| @visitors[vc] = true unless @visitor_manager.peek_visitor(vc).nil? }
+            visitors_to_remove_count = @visitors.size - (@storage_limit * REMOVAL_FACTOR).to_i
+            visitors_to_remove_count.times { @visitors.shift }
           end
         end
       end