kameleoon-client-ruby 3.22.0 → 3.22.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f492badef67f0b4e09561d3a3d423e4497dbd7efe22d07641cac9485fe9e100
-  data.tar.gz: 95f7268b78ecd64bd4707c8fc8581251b8f07038a32eb044aebdb0b1cab652b6
+  metadata.gz: 04efd3ab470f352395de3161c329086e07893f9a29d2e8d55085cc4ab00788c3
+  data.tar.gz: 62d498e4f19ec285358b29672d622e0476e70ae31cbf39bd480bf33dbe5b335b
 SHA512:
-  metadata.gz: 194b5aeee439890f068abe5b0b4c0f11fb508844de81e54e5b5582cefed5c7849d17054cb469994b57244177b61b9cfb89ccfecf771d9c135cc7126a277140e8
-  data.tar.gz: 114ecb570390aa32386abf7074463d903884d6faadf8c7b3de77953bc38152dc70cdf3eb7d5d8ac64de127014f318a2d2e53359c830cb9af5d8f3118d581b8d7
+  metadata.gz: 0431f162cc71fb10db0c3920bef2a9d04c35713dfdfd467fc750ac16345c3cfd5965b8abb17c335ad8a7e7226d85c776a14d5d76030c7173969b00a61b309fd1
+  data.tar.gz: 683b9a9e65838df67344bc3b5ff05d8b04eb37fe5328ec4532f4d18b141d9957ca6709b3373adc22ce4f52791d3d0e90be8927693acfe159add2ba991812dc16

data/lib/kameleoon/configuration/custom_data_info.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'set'
 require 'kameleoon/logging/kameleoon_logger'
 
 module Kameleoon

data/lib/kameleoon/hybrid/manager.rb

@@ -17,7 +17,7 @@ module Kameleoon
       end
     end
 
-    # Implementation of Cache with auto cleaning feature
+    # Implementation of Manager with auto-expiring visitor variations
     class ManagerImpl < Manager
       def initialize(expiration_time, data_manager)
         super()

data/lib/kameleoon/kameleoon_client.rb

@@ -30,7 +30,6 @@ require 'kameleoon/network/network_manager'
 require 'kameleoon/network/url_provider'
 require 'kameleoon/network/cookie/cookie_manager'
 require 'kameleoon/real_time/real_time_event_service'
-require 'kameleoon/storage/cache_factory'
 require 'kameleoon/targeting/models'
 require 'kameleoon/targeting/targeting_manager'
 require 'kameleoon/types/variable'

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

data/lib/kameleoon/network/access_token_source.rb

@@ -6,10 +6,12 @@ require 'time'
 require 'kameleoon/utils'
 require 'kameleoon/logging/kameleoon_logger'
 require 'base64'
+require 'concurrent'
 
 module Kameleoon
   module Network
     class AccessTokenSource
+      SILENCE_PERIOD = 300 # in seconds
       TOKEN_EXPIRATION_GAP = 60 # in seconds
       TOKEN_OBSOLESCENCE_GAP = 1800 # in seconds
       JWT_ACCESS_TOKEN_FIELD = 'access_token'
@@ -24,7 +26,10 @@ module Kameleoon
         @network_manager = network_manager
         @client_id = client_id
         @client_secret = client_secret
-        @fetching = false
+        @cached_token = nil
+        @silent_after_fetch_failure_until = 0.0 # 0 = never silenced
+        @fetching = nil # Concurrent::Event of the in-flight fetch, shared by all concurrent callers; nil when idle
+        @fetching_mutex = Mutex.new
         @basic_auth_token = AccessTokenSource.construct_basic_token(client_id, client_secret)
         Logging::KameleoonLogger.debug(lambda {
           format("RETURN: AccessTokenSource.new(network_manager, client_id: '%s', client_secret: '%s')",
@@ -37,16 +42,24 @@ module Kameleoon
         "#{BASIC_AUTHORIZATION_PREFIX}#{Base64.strict_encode64(basic_token_content)}"
       end
 
+      # Returns the access token, or `nil` if it cannot be obtained. Fetches a new token if the cached one is
+      # expired or obsolete, unless a recent fetch failure has put the source in the silence period.
       def get_token(timeout = nil)
-        Logging::KameleoonLogger.debug('CALL: AccessTokenSource.getToken(timeout: %s)', timeout)
-        now = Time.new.to_f
+        Logging::KameleoonLogger.debug('CALL: AccessTokenSource.get_token(timeout: %s)', timeout)
+        now = Process.clock_gettime(Process::CLOCK_REALTIME)
         token = @cached_token
-        return call_fetch_token(timeout) if token.nil? || token.expired?(now)
-
-        run_fetch_token if !@fetching && token.obsolete?(now)
-        Logging::KameleoonLogger.debug("RETURN: AccessTokenSource.getToken(timeout: %s) -> (token: '%s')",
-                                       timeout, token.value)
-        token.value
+        silent = now < @silent_after_fetch_failure_until
+        if !token.nil? && !token.expired?(now)
+          refresh_token_in_background(timeout) if token.obsolete?(now) && !silent
+          value = token.value
+        elsif silent
+          value = nil
+        else
+          value = fetch_token(timeout)
+        end
+        Logging::KameleoonLogger.debug("RETURN: AccessTokenSource.get_token(timeout: %s) -> (token: '%s')",
+                                       timeout, value)
+        value
       end
 
       def discard_token(token)
@@ -58,54 +71,114 @@ module Kameleoon
 
       private
 
-      def call_fetch_token(timeout)
-        @fetching = true
-        fetch_token(timeout)
-      rescue StandardError => e
-        @fetching = false
-        Logging::KameleoonLogger.error("Failed to call access token fetching: #{e}")
-        nil
-      end
-
-      def run_fetch_token
-        # setting `@fetching` here to reduce the number of requests until new thread started
-        @fetching = true
-        Thread.new { fetch_token }
-      rescue StandardError => e
-        @fetching = false
-        Logging::KameleoonLogger.error("Failed to run access token fetching: #{e}")
-      end
-
-      def fetch_token(timeout = nil)
-        Logging::KameleoonLogger.debug('CALL: AccessTokenSource.fetch_token(timeout: %s)', timeout)
-        response_content = @network_manager.fetch_access_jwtoken(@basic_auth_token, timeout)
-        unless response_content
-          Logging::KameleoonLogger.error('Failed to fetch access JWT')
-          return nil
+      NO_FETCH = [nil, false].freeze
+
+      # The first caller performs the request; concurrent callers wait for it - no longer than their own request
+      # timeout - and then read the cached token.
+      def fetch_token(timeout)
+        fetching, owner = claim_fetch(false)
+        if fetching.nil?
+          cached_token_value
+        elsif owner
+          perform_fetch(fetching, timeout)
+        else
+          unless fetching.wait(timeout.nil? ? nil : timeout / 1000.0)
+            Logging::KameleoonLogger.debug('Access token fetch has not completed within %s ms', timeout)
+          end
+          cached_token_value
         end
+      end
+
+      # Refreshes a valid but obsolete token while it keeps being served.
+      def refresh_token_in_background(timeout)
+        fetching, owner = claim_fetch(true)
+        Thread.new { perform_fetch(fetching, timeout) } if owner
+      rescue StandardError => e # e.g. ThreadError: the thread limit is reached
+        enter_silence(e)
+        complete_fetch(fetching)
+      end
+
+      # Returns `[event, owner]`: the event of the in-flight fetch and whether the caller has just registered it
+      # (and so must perform it); NO_FETCH when no request is needed anymore.
+      def claim_fetch(refresh)
+        @fetching_mutex.synchronize do
+          return [@fetching, false] unless @fetching.nil?
+          # get_token decided without the mutex; meanwhile another caller's fetch may have cached a token, or failed
+          # and started the silence period.
+          return NO_FETCH unless fetch_needed?(refresh)
+
+          @fetching = Concurrent::Event.new
+          [@fetching, true]
+        end
+      end
+
+      # `refresh`: the caller holds a valid but obsolete token, which is worth a request only while still obsolete.
+      def fetch_needed?(refresh)
+        now = Process.clock_gettime(Process::CLOCK_REALTIME)
+        return false if now < @silent_after_fetch_failure_until
+
+        token = @cached_token
+        token.nil? || token.expired?(now) || (refresh && token.obsolete?(now))
+      end
+
+      def cached_token_value
+        token = @cached_token
+        token.nil? || token.expired?(Process.clock_gettime(Process::CLOCK_REALTIME)) ? nil : token.value
+      end
+
+      def perform_fetch(fetching, timeout)
+        Logging::KameleoonLogger.debug('CALL: AccessTokenSource.perform_fetch(timeout: %s)', timeout)
+        token = nil
         begin
+          response_content = @network_manager.fetch_access_jwtoken(@basic_auth_token, timeout)
+          raise FetchError, 'access token request failed' unless response_content
+
           jwt = JSON.parse(response_content)
-          token = jwt[JWT_ACCESS_TOKEN_FIELD]
-          expires_in = jwt[JWT_EXPIRES_IN_FIELD]
-        rescue JSON::ParserError => e
-          Logging::KameleoonLogger.error("Failed to parse access JWT: #{e}")
-          return nil
-        end
-        unless token.is_a?(String) && !token.empty? && expires_in.is_a?(Integer) && expires_in.positive?
-          Logging::KameleoonLogger.error('Failed to read access JWT')
-          return nil
+          raise FetchError, "access token response is not a JSON object: '#{jwt}'" unless jwt.is_a?(Hash)
+
+          expires_in = read_expires_in(jwt)
+          token = read_access_token(jwt)
+          @cached_token = new_expiring_token(token, expires_in)
+          Logging::KameleoonLogger.info('Fetched access token')
+        rescue StandardError => e
+          token = nil
+          enter_silence(e)
+        ensure
+          complete_fetch(fetching) # also on non-StandardError, so that waiters are never stuck
         end
-        token = handle_fetched_token(token, expires_in)
-        Logging::KameleoonLogger.debug(
-          "RETURN: AccessTokenSource.fetch_token(timeout: %s) -> (token: '%s')", timeout, token
-        )
+        Logging::KameleoonLogger.debug("RETURN: AccessTokenSource.perform_fetch(timeout: %s) -> (token: '%s')",
+                                       timeout, token)
         token
-      ensure
-        @fetching = false
       end
 
-      def handle_fetched_token(token, expires_in)
-        now = Time.new.to_f
+      def enter_silence(error)
+        @silent_after_fetch_failure_until = Process.clock_gettime(Process::CLOCK_REALTIME) + SILENCE_PERIOD
+        Logging::KameleoonLogger.warning('Failed to fetch access token (%s: %s); it will not be requested for %ds',
+                                         error.class, error.message, SILENCE_PERIOD)
+      end
+
+      def complete_fetch(fetching)
+        # Clear before waking the waiters so that a waiter re-entering get_token can start a new fetch.
+        @fetching_mutex.synchronize { @fetching = nil if @fetching.equal?(fetching) }
+        fetching.set
+      end
+
+      def read_expires_in(jwt)
+        expires_in = jwt[JWT_EXPIRES_IN_FIELD]
+        return expires_in if expires_in.is_a?(Integer) && expires_in.positive?
+
+        raise FetchError, "access token response has no valid '#{JWT_EXPIRES_IN_FIELD}' field: '#{expires_in}'"
+      end
+
+      def read_access_token(jwt)
+        token = jwt[JWT_ACCESS_TOKEN_FIELD]
+        return token if token.is_a?(String) && !token.empty?
+
+        raise FetchError, "access token response has no valid '#{JWT_ACCESS_TOKEN_FIELD}' field"
+      end
+
+      def new_expiring_token(token, expires_in)
+        now = Process.clock_gettime(Process::CLOCK_REALTIME)
         exp_time = now + expires_in - TOKEN_EXPIRATION_GAP
         if expires_in > TOKEN_OBSOLESCENCE_GAP
           obs_time = now + expires_in - TOKEN_OBSOLESCENCE_GAP
@@ -121,9 +194,10 @@ module Kameleoon
             )
           end
         end
-        @cached_token = ExpiringToken.new(token, exp_time, obs_time)
-        token
+        ExpiringToken.new(token, exp_time, obs_time)
       end
+
+      class FetchError < StandardError; end
     end
 
     class ExpiringToken

data/lib/kameleoon/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Kameleoon
-  SDK_VERSION = '3.22.0'
+  SDK_VERSION = '3.22.1'
   SDK_NAME = 'RUBY'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kameleoon-client-ruby
 version: !ruby/object:Gem::Version
-  version: 3.22.0
+  version: 3.22.1
 platform: ruby
 authors:
 - Kameleoon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-08-27 00:00:00.000000000 Z
+date: 2026-09-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: em-http-request
@@ -155,8 +155,6 @@ files:
 - lib/kameleoon/real_time/sse_message.rb
 - lib/kameleoon/real_time/sse_request.rb
 - lib/kameleoon/sem_version.rb
-- lib/kameleoon/storage/cache.rb
-- lib/kameleoon/storage/cache_factory.rb
 - lib/kameleoon/targeting/condition.rb
 - lib/kameleoon/targeting/condition_factory.rb
 - lib/kameleoon/targeting/conditions/browser_condition.rb

data/lib/kameleoon/storage/cache.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-require 'concurrent'
-
-module Kameleoon
-  module Storage
-    # Will be useful for Ruby 3.0
-    # Abstract Cache class (interface)
-    class Cache
-      def get(_key)
-        raise 'Abstract method `read` called'
-      end
-
-      def set(_key, _value)
-        raise 'Abstract method `write` called'
-      end
-
-      def active_items
-        raise 'Abstract method `active_items` called'
-      end
-    end
-
-    # Implementation of Cache with auto cleaning feature
-    class CacheImpl < Cache
-      def initialize(expiration_time, cleaning_interval)
-        super()
-        @mutex = Mutex.new
-        @expiration_time = expiration_time
-        @cleaning_interval = cleaning_interval
-        @cache = {}
-      end
-
-      def set(key, value)
-        @mutex.synchronize do
-          start_cleaner_timer if @cleaning_interval.positive? && @cleaner_timer.nil?
-          @cache[key] = { value: value, expired: Time.now + @expiration_time }
-        end
-      end
-
-      def get(key)
-        entry = @cache[key]
-        return entry[:value] unless entry.nil? || expired?(entry)
-
-        @mutex.synchronize { @cache.delete(key) }
-        nil
-      end
-
-      def active_items
-        active_items = {}
-        remove_expired_entries
-        @mutex.synchronize do
-          @cache.each_pair { |key, entry| active_items[key] = entry[:value] }
-        end
-        active_items
-      end
-
-      private
-
-      def start_cleaner_timer
-        @cleaner_timer = Concurrent::TimerTask.new(execution_interval: @cleaning_interval) do
-          remove_expired_entries
-        end
-        @cleaner_timer.execute
-      end
-
-      def stop_cleaner_timer
-        @cleaner_timer&.shutdown
-        @cleaner_timer = nil
-      end
-
-      def remove_expired_entries
-        time = Time.now
-        @mutex.synchronize do
-          @cache.delete_if { |_, entry| expired?(entry, time) }
-          stop_cleaner_timer if @cache.empty?
-        end
-      end
-
-      def expired?(entry, time = Time.now)
-        entry[:expired] <= time
-      end
-    end
-  end
-end

data/lib/kameleoon/storage/cache_factory.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require 'concurrent'
-require_relative 'cache'
-
-module Kameleoon
-  module Storage
-    # Will be useful for Ruby 3.0
-    # Abstract CacheFactory class (interface)
-    class CacheFactory
-      def create(_experiration_time, _cleaning_time)
-        raise 'Abstract method `create` called'
-      end
-    end
-
-    # Implementation of CacheFactory with auto cleaning feature
-    class CacheFactoryImpl < CacheFactory
-      def create(expiration_time, cleaning_interval)
-        CacheImpl.new(expiration_time, cleaning_interval)
-      end
-    end
-  end
-end