kameleoon-client-ruby 3.21.0 → 3.22.1

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/network/network_manager.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'kameleoon/events/event_manager'
 require 'kameleoon/logging/kameleoon_logger'
 require 'kameleoon/network/content_type'
 require 'kameleoon/network/fetched_configuration'
@@ -14,8 +15,8 @@ module Kameleoon
     ##
     # NetworkManager is used to make API calls.
     class NetworkManager
-      FETCH_CONFIGURATION_ATTEMPT_NUMBER = 3
-      TRACKING_CALL_ATTEMPT_NUMBER = 3
+      FETCH_CONFIGURATION_ATTEMPT_NUMBER = 2
+      TRACKING_CALL_ATTEMPT_NUMBER = 2
       TRACKING_CALL_RETRY_DELAY = 5.0 # in seconds
       SDK_TYPE_HEADER = 'X-Kameleoon-SDK-Type'
       SDK_VERSION_HEADER = 'X-Kameleoon-SDK-Version'
@@ -23,13 +24,14 @@ module Kameleoon
       HEADER_IF_MODIFIED_SINCE = 'If-Modified-Since'
       HEADER_LAST_MODIFIED = 'last-modified' # in lower case because the network lib casts response headers to lower
 
-      attr_reader :environment, :default_timeout, :access_token_source, :url_provider
+      attr_reader :environment, :default_timeout, :access_token_source, :url_provider, :event_manager
 
-      def initialize(environment, default_timeout, access_token_source_factory, url_provider)
+      def initialize(environment, default_timeout, access_token_source_factory, url_provider, event_manager)
         @environment = environment
         @default_timeout = default_timeout
         @access_token_source = access_token_source_factory.create(self)
         @url_provider = url_provider
+        @event_manager = event_manager
         @sync_net_provider = SyncNetProvider.new
       end
 
@@ -39,7 +41,8 @@ module Kameleoon
         headers = { SDK_TYPE_HEADER => SDK_NAME, SDK_VERSION_HEADER => SDK_VERSION }
         headers[HEADER_IF_MODIFIED_SINCE] = if_modified_since if if_modified_since
         request = Request.new(Method::GET, url, ContentType::JSON, timeout, extra_headers: headers)
-        response, success = make_call(request, false, FETCH_CONFIGURATION_ATTEMPT_NUMBER - 1)
+        response, success = make_call(Events::RequestType::DATAFILE, request, false,
+                                      FETCH_CONFIGURATION_ATTEMPT_NUMBER - 1)
         return nil unless success
         return FetchedConfiguration.new(nil, nil) if response.code == 304
 
@@ -51,14 +54,14 @@ module Kameleoon
         url = @url_provider.make_api_data_get_request_url(key)
         timeout = ensure_timeout(timeout)
         request = Request.new(Method::GET, url, ContentType::JSON, timeout)
-        unwrap_response(*make_call(request, true))
+        unwrap_response(*make_call(Events::RequestType::REMOTE_DATA, request, true))
       end
 
       def get_remote_visitor_data(visitor_code, filter, is_unique_identifier, timeout = nil)
         url = @url_provider.make_visitor_data_get_url(visitor_code, filter, is_unique_identifier)
         timeout = ensure_timeout(timeout)
         request = Request.new(Method::GET, url, ContentType::JSON, timeout)
-        unwrap_response(*make_call(request, true))
+        unwrap_response(*make_call(Events::RequestType::REMOTE_VISITOR_DATA, request, true))
       end
 
       def send_tracking_data(lines, timeout = nil)
@@ -67,7 +70,8 @@ module Kameleoon
         url = @url_provider.make_tracking_url
         timeout = ensure_timeout(timeout)
         request = Request.new(Method::POST, url, ContentType::WILDCARD, timeout, data: lines)
-        unwrap_response(*make_call(request, true, TRACKING_CALL_ATTEMPT_NUMBER - 1, TRACKING_CALL_RETRY_DELAY))
+        unwrap_response(*make_call(Events::RequestType::TRACKING, request, true,
+                                   TRACKING_CALL_ATTEMPT_NUMBER - 1, TRACKING_CALL_RETRY_DELAY))
       end
 
       def fetch_access_jwtoken(basic_auth_token, timeout = nil)
@@ -79,12 +83,12 @@ module Kameleoon
         data = UriHelper.encode_query(data_map).encode('UTF-8')
         request = Request.new(Method::POST, url, ContentType::FORM, timeout, data: data)
         request.authorize(basic_auth_token)
-        unwrap_response(*make_call(request, false))
+        unwrap_response(*make_call(Events::RequestType::ACCESS_TOKEN, request, false))
       end
 
       private
 
-      def make_call(request, try_access_token_auth, retry_limit = 0, retry_delay = 0)
+      def make_call(request_type, request, try_access_token_auth, retry_limit = 0, retry_delay = 0)
         Logging::KameleoonLogger.debug('Running request %s with access token %s, retry limit %s, retry delay %s ms',
                                        request, try_access_token_auth, retry_limit, retry_delay)
         attempt = 0
@@ -93,7 +97,10 @@ module Kameleoon
         while !success && (attempt <= retry_limit)
           delay(retry_delay) if attempt.positive? && retry_delay.positive?
           try_authorize(request) if try_access_token_auth
+          start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
           response = @sync_net_provider.make_request(request)
+          duration_millis = (Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond) - start_time).round
+          fire_http_request_event(request_type, response, duration_millis)
           if response.success?
             success = true
           elsif !response.error.nil?
@@ -122,6 +129,22 @@ module Kameleoon
         [response, success]
       end
 
+      def fire_http_request_event(request_type, response, duration_millis)
+        if response.success?
+          @event_manager.fire_http_request_succeeded(request_type, response.code, duration_millis)
+        else
+          failure =
+            if response.error.nil?
+              Events::HttpRequestFailure.from_http_status(response.code)
+            elsif response.error.is_a?(Timeout::Error)
+              Events::HttpRequestFailure.of_cancellation
+            else
+              Events::HttpRequestFailure.from_exception(response.error)
+            end
+          @event_manager.fire_http_request_failed(request_type, failure, duration_millis)
+        end
+      end
+
       def get_log_level(attempt, attempt_count)
         attempt < attempt_count ? Logging::LogLevel::WARNING : Logging::LogLevel::ERROR
       end

data/lib/kameleoon/real_time/{real_time_configuration_service.rb → real_time_event_service.rb}

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Kameleoon Real Time Configuration Service
+# Kameleoon Real Time Event Service
 
 require 'json'
 require 'kameleoon/logging/kameleoon_logger'
@@ -10,19 +10,24 @@ require 'kameleoon/real_time/sse_client'
 
 module Kameleoon
   module RealTime
-    CONFIGURATION_UPDATE_EVENT = 'configuration-update-event'
+    DATA_FILE_UPDATE_EVENT = 'configuration-update-event'
 
     ##
-    # RealTimeConfigurationService is used for fetching updates of configuration
+    # RealTimeEventService is used for fetching updates of configuration
     # (experiments and feature flags) in real time.
-    class RealTimeConfigurationService
+    class RealTimeEventService
+      # Delay before re-establishing a failed SSE connection, so a persistent
+      # failure does not turn into a hot reconnect loop.
+      RECONNECT_DELAY_SECONDS = 3
+
       ##
       # Parametrized initializer.
       #
       # @param url [String]
       # @param update_handler [Callable[Kameleoon::RealTime::RealTimeEvent] | NilClass] Handler which
       # is synchronously called for gotten RealTimeEvent objects.
-      def initialize(url, update_handler, sse_request_source = nil)
+      # @param reconnect_delay [Numeric] Delay in seconds before a reconnect attempt.
+      def initialize(url, update_handler, sse_request_source = nil, reconnect_delay: RECONNECT_DELAY_SECONDS)
         @url = url
         @update_handler = update_handler
         @need_close = false
@@ -32,6 +37,7 @@ module Kameleoon
           'Connection': 'Keep-Alive'
         }
         @sse_request_source = sse_request_source
+        @reconnect_delay = reconnect_delay
         @sse_thread = nil
         @sse_client = nil
         create_sse_client
@@ -42,7 +48,7 @@ module Kameleoon
       def close
         return if @need_close
 
-        Logging::KameleoonLogger.info('Real-time configuration service is shutting down')
+        Logging::KameleoonLogger.info('Real-time event service is shutting down')
         @need_close = true
         return if @sse_thread.nil?
 
@@ -60,7 +66,7 @@ module Kameleoon
       def init_sse_client
         message_handler = proc do |message|
           Logging::KameleoonLogger.debug("Got SSE event: #{message.event}")
-          if message.event == CONFIGURATION_UPDATE_EVENT
+          if message.event == DATA_FILE_UPDATE_EVENT
             event_dict = JSON.parse(message.data)
             @update_handler&.call(RealTimeEvent.new(event_dict))
           end
@@ -90,6 +96,9 @@ module Kameleoon
           rescue StandardError => e
             Logging::KameleoonLogger.error("Error occurred within SSE client: #{e}")
           end
+          # The delay is applied to every re-establishment (a failed connection and
+          # a dropped stream alike), so a persistent failure cannot produce a hot loop.
+          sleep(@reconnect_delay) unless @need_close
         end
       end
     end

data/lib/kameleoon/targeting/conditions/unknown_condition.rb

@@ -5,11 +5,11 @@ require 'kameleoon/targeting/condition'
 module Kameleoon
   # @api private
   module Targeting
-    # UnknownCondition represents not defined condition, always returns that visitor is targeted (true)
+    # UnknownCondition represents not defined condition, always returns that visitor is not targeted (false)
     class UnknownCondition < Condition
       def check(_data)
-        Logging::KameleoonLogger.warning('Condition of unknown type \'%s\' evaluated as true', type)
-        true
+        Logging::KameleoonLogger.warning('Condition of unknown type \'%s\' evaluated as false', type)
+        false
       end
     end
   end

data/lib/kameleoon/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Kameleoon
-  SDK_VERSION = '3.21.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.21.0
+  version: 3.22.1
 platform: ruby
 authors:
 - Kameleoon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-07-02 00:00:00.000000000 Z
+date: 2026-09-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: em-http-request
@@ -114,6 +114,14 @@ files:
 - lib/kameleoon/data/unique_identifier.rb
 - lib/kameleoon/data/user_agent.rb
 - lib/kameleoon/data/visitor_visits.rb
+- lib/kameleoon/events/data_file_update_event.rb
+- lib/kameleoon/events/data_file_update_handler.rb
+- lib/kameleoon/events/event_handler.rb
+- lib/kameleoon/events/event_manager.rb
+- lib/kameleoon/events/event_type.rb
+- lib/kameleoon/events/http_request_failure.rb
+- lib/kameleoon/events/http_request_handler.rb
+- lib/kameleoon/events/request_type.rb
 - lib/kameleoon/exceptions.rb
 - lib/kameleoon/hybrid/manager.rb
 - lib/kameleoon/kameleoon_client.rb
@@ -141,14 +149,12 @@ files:
 - lib/kameleoon/network/response.rb
 - lib/kameleoon/network/uri_helper.rb
 - lib/kameleoon/network/url_provider.rb
-- lib/kameleoon/real_time/real_time_configuration_service.rb
 - lib/kameleoon/real_time/real_time_event.rb
+- lib/kameleoon/real_time/real_time_event_service.rb
 - lib/kameleoon/real_time/sse_client.rb
 - 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