kameleoon-client-ruby 3.22.0 → 3.22.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f492badef67f0b4e09561d3a3d423e4497dbd7efe22d07641cac9485fe9e100
-  data.tar.gz: 95f7268b78ecd64bd4707c8fc8581251b8f07038a32eb044aebdb0b1cab652b6
+  metadata.gz: 7eceff94d1ab7a39dfa3603c7cfd124bad0c49a7315feb7e0bd938c45feca9f0
+  data.tar.gz: f3df43034ca7460e3fe21a47caa920e9ede1e65ac49cb5c04b0196198d4a2391
 SHA512:
-  metadata.gz: 194b5aeee439890f068abe5b0b4c0f11fb508844de81e54e5b5582cefed5c7849d17054cb469994b57244177b61b9cfb89ccfecf771d9c135cc7126a277140e8
-  data.tar.gz: 114ecb570390aa32386abf7074463d903884d6faadf8c7b3de77953bc38152dc70cdf3eb7d5d8ac64de127014f318a2d2e53359c830cb9af5d8f3118d581b8d7
+  metadata.gz: 7ed0b76309075aac725c827733a454754f6183001a600582f79e116c8774d5ac4e8448dbb7b58fcb006649d1801cc0d86ef0484b0e6ee70201d4eb6cf3aa92fd
+  data.tar.gz: 927ca5a73f64293a53b3f4e0083112ed0257de431c04fa80541102cd1fec954d80c122c9138448264090e017d78b02a8b1028ac4ed36d1e1ecb0b489b7822211

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'
@@ -1034,6 +1033,7 @@ module Kameleoon
       @visitor_manager.stop
       @tracking_manager.stop
       @scheduler.shutdown
+      @network_manager.close
       Logging::KameleoonLogger.debug('RETURN: KameleoonClient.dispose')
     end
 

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'concurrent/executor/thread_pool_executor'
 require 'kameleoon/data/data'
 require 'kameleoon/logging/kameleoon_logger'
 require 'kameleoon/managers/tracking/tracking_builder'
@@ -11,18 +12,28 @@ module Kameleoon
       class TrackingManager
         LINES_DELIMETER = "\n"
         REQUEST_SIZE_LIMIT = 2560 * 1024 # 2.5 * 1024^2 characters
+        PROBE_MAX_VISITORS = 1
+        MAX_SEND_THREADS = 8
+        MAX_QUEUED_REQUESTS = 32
+        SEND_THREAD_IDLE_SECONDS = 60
+        STOP_WAIT_SECONDS = 1
 
         def initialize(
-          data_manager, network_manager, visitor_manager, track_interval_seconds, scheduler
+          data_manager, network_manager, visitor_manager, track_interval_seconds, scheduler, executor: nil
         )
           Logging::KameleoonLogger.debug(
             '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
+          @executor = executor || Concurrent::ThreadPoolExecutor.new(
+            name: 'kameleoon-tracking', min_threads: 0, max_threads: MAX_SEND_THREADS,
+            max_queue: MAX_QUEUED_REQUESTS, idletime: SEND_THREAD_IDLE_SECONDS, fallback_policy: :abort
+          )
           @track_all_job = scheduler.schedule_every(track_interval_seconds, method(:track_all)) unless scheduler.nil?
           Logging::KameleoonLogger.debug(
             'RETURN: TrackingManager.new(data_manager, network_manager. visitor_manager, ' \
@@ -34,6 +45,10 @@ module Kameleoon
           Logging::KameleoonLogger.debug('CALL: TrackingManager.stop')
           @track_all_job&.unschedule
           @track_all_job = nil
+          # Queued requests still run; a later `track` is rejected and keeps its data (see `perform_tracking_request`).
+          # The wait lets in-flight requests finish before the client disposal closes the connections.
+          @executor.shutdown
+          @executor.wait_for_termination(STOP_WAIT_SECONDS)
           Logging::KameleoonLogger.debug('RETURN: TrackingManager.stop')
         end
 
@@ -45,10 +60,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 +81,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,26 +103,62 @@ 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
           visitor_data.each { |d| d.mark_as_transmitting if d.is_a?(Kameleoon::Data) }
-          Thread.new do
-            result = @network_manager.send_tracking_data(lines)
-            if result != false
-              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) }
-            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) }
-              @tracking_visitors.add_all(visitor_codes)
-            end
+          begin
+            @executor.post { send_tracking_request(visitor_codes, visitor_data, lines) }
+          rescue Concurrent::RejectedExecutionError
+            Logging::KameleoonLogger.warning(
+              'Tracking request pool is full or stopped: data of %s visitors is kept to be sent later',
+              visitor_codes.size
+            )
+            keep_for_later(visitor_codes, visitor_data)
+          end
+          true
+        end
+
+        def send_tracking_request(visitor_codes, visitor_data, lines)
+          result = @network_manager.send_tracking_data(lines)
+          if result != false
+            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)
+            enter_probe_mode
+            keep_for_later(visitor_codes, visitor_data)
           end
+        rescue StandardError => e
+          Logging::KameleoonLogger.error('Error occurred within tracking request: %s', e)
+          keep_for_later(visitor_codes, visitor_data)
+        end
+
+        def keep_for_later(visitor_codes, visitor_data)
+          visitor_data.each { |d| d.mark_as_unsent if d.is_a?(Kameleoon::Data) }
+          @tracking_visitors.add_all(visitor_codes)
+        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/network/net_provider.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 require 'net/http'
+require 'net/http/persistent'
 require 'kameleoon/version'
 require 'kameleoon/network/response'
+require 'kameleoon/logging/kameleoon_logger'
 require 'kameleoon/exceptions'
 
 module Kameleoon
@@ -12,6 +14,9 @@ module Kameleoon
         raise KameleoonError, 'Call of not implemented method!'
       end
 
+      # Releases the resources held by the provider (e.g. kept-alive connections); no-op by default.
+      def close; end
+
       private
 
       def collect_headers(request)
@@ -29,7 +34,27 @@ module Kameleoon
       end
     end
 
+    # Performs requests over kept-alive connections managed by `Net::HTTP::Persistent`.
+    #
+    # `Net::HTTP::Persistent` timeouts are per client, while the SDK timeout is per request, so one client (with its
+    # own connection pool) is kept per distinct timeout value. In practice that is the default timeout plus the few
+    # values callers pass explicitly.
     class SyncNetProvider < NetProvider
+      # Idle connections are reconnected before use after this long; keeps a request from hitting a connection the
+      # server has already dropped.
+      IDLE_TIMEOUT = 15 # seconds
+      # Guards against a caller passing a different timeout on every request (each value would keep its own idle
+      # connections). Requests with further timeout values are sent on a one-off connection with their own timeout.
+      MAX_CLIENTS = 16
+
+      def initialize
+        super()
+        @clients = {}
+        @clients_mutex = Mutex.new
+        @overflow_warned = false
+        @closed = false
+      end
+
       def make_request(request)
         for _ in 0..8 do
           response = make_single_request(request)
@@ -44,10 +69,17 @@ module Kameleoon
         response
       end
 
+      def close
+        @clients_mutex.synchronize do
+          @closed = true
+          @clients.each_value(&:shutdown)
+          @clients.clear
+        end
+      end
+
       private
 
       def make_single_request(request)
-        resp = nil
         case request.method
         when Method::GET
           req = Net::HTTP::Get.new(request.url)
@@ -57,21 +89,71 @@ module Kameleoon
         else
           return unknown_method_response(request.method, request)
         end
-        timeout = request.timeout.to_f / 1000.0
-        headers = collect_headers(request)
-        headers.each { |k, v| req[k] = v }
+        collect_headers(request).each { |k, v| req[k] = v }
         uri = URI(request.url)
-        Net::HTTP.start(uri.hostname, uri.port, use_ssl: true, open_timeout: timeout,
-                                                read_timeout: timeout, ssl_timeout: timeout) do |http|
-          resp = http.request(req)
-        end
+        timeout = request.timeout.to_f / 1000.0
+        client = client_for(timeout)
+        resp = client ? client.request(uri, req) : request_once(uri, req, timeout)
         body = resp.body
         body = nil if body&.empty?
-        headers = resp.to_hash
-        Response.new(nil, resp.code.to_i, body, headers, request)
+        Response.new(nil, resp.code.to_i, body, resp.to_hash, request)
       rescue StandardError => e
         Response.new(e, nil, nil, nil, request)
       end
+
+      def client_for(timeout)
+        @clients_mutex.synchronize do
+          return nil if @closed
+
+          client = @clients[timeout]
+          return client if client
+
+          if @clients.size >= MAX_CLIENTS
+            unless @overflow_warned
+              @overflow_warned = true
+              Logging::KameleoonLogger.warning(
+                'More than %s distinct request timeouts in use; requests with further timeout values ' \
+                'are sent without connection reuse', MAX_CLIENTS
+              )
+            end
+            return nil
+          end
+
+          @clients[timeout] = build_client(timeout)
+        end
+      end
+
+      # Sends the request on a connection which is closed afterwards, honouring `timeout` (seconds).
+      def request_once(uri, req, timeout)
+        Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https', open_timeout: timeout,
+                                                read_timeout: timeout, write_timeout: timeout) do |http|
+          http.request(req)
+        end
+      end
+
+      # The timeout is applied as given, also when it is zero or negative (as `Net::HTTP` did before pooling):
+      # validating it is the callers' concern.
+      def build_client(timeout)
+        http = Net::HTTP::Persistent.new(name: "kameleoon-sdk-#{timeout}", proxy: proxy_setting)
+        http.idle_timeout = IDLE_TIMEOUT
+        http.open_timeout = timeout
+        http.read_timeout = timeout
+        http.write_timeout = timeout
+        http
+      end
+
+      # `:ENV` keeps the `http_proxy`/`no_proxy` support that plain `Net::HTTP` has by default. net-http-persistent
+      # 4.0.8 parses `no_proxy` with `Array#filter_map` (Ruby 2.7+), so on older Rubies with `no_proxy` set the proxy
+      # URI is passed directly, without the bypass list (Kameleoon hosts are not expected to be in it anyway).
+      def proxy_setting
+        no_proxy = ENV['no_proxy'] || ENV['NO_PROXY']
+        return :ENV if RUBY_VERSION >= '2.7' || no_proxy.nil? || no_proxy.empty?
+
+        env_proxy = ENV['http_proxy'] || ENV['HTTP_PROXY']
+        return nil if env_proxy.nil? || env_proxy.empty? || no_proxy == '*'
+
+        URI(env_proxy.match?(%r{\Ahttps?://}) ? env_proxy : "http://#{env_proxy}")
+      end
     end
   end
 end

data/lib/kameleoon/network/network_manager.rb

@@ -86,6 +86,12 @@ module Kameleoon
         unwrap_response(*make_call(Events::RequestType::ACCESS_TOKEN, request, false))
       end
 
+      # Closes the kept-alive connections. A request still running completes on its connection; a request started
+      # afterwards fails with an error response.
+      def close
+        @sync_net_provider.close
+      end
+
       private
 
       def make_call(request_type, request, try_access_token_auth, retry_limit = 0, retry_delay = 0)

data/lib/kameleoon/real_time/sse_request.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'restclient'
+require 'net/http'
 
 module Kameleoon
   module RealTime
@@ -31,8 +31,11 @@ module Kameleoon
       ##
       # Starts SSE connection and stay in the loop until close.
       def start
-        RestClient::Request.execute(method: :get, url: @url, headers: @headers, read_timeout: nil,
-                                    block_response: method(:handle_resp))
+        uri = URI(@url)
+        # No read timeout: the stream is expected to stay silent between events.
+        Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https', read_timeout: nil) do |http|
+          http.request(Net::HTTP::Get.new(uri, @headers)) { |resp| handle_resp(resp) }
+        end
       end
 
       ##

data/lib/kameleoon/version.rb

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

metadata

@@ -1,43 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: kameleoon-client-ruby
 version: !ruby/object:Gem::Version
-  version: 3.22.0
+  version: 3.22.2
 platform: ruby
 authors:
 - Kameleoon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-08-27 00:00:00.000000000 Z
+date: 2026-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: em-http-request
+  name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.1.5
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.1.5
-- !ruby/object:Gem::Dependency
-  name: em-synchrony
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.6
+        version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.6
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: rufus-scheduler
   requirement: !ruby/object:Gem::Requirement
@@ -53,19 +39,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.7'
 - !ruby/object:Gem::Dependency
-  name: rest-client
+  name: net-http-persistent
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.1'
+        version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.1'
+        version: '4.0'
 description: Kameleoon Client Ruby Software Development Kit
 email:
 - sdk@kameleoon.com
@@ -155,8 +141,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