kameleoon-client-ruby 3.22.1 → 3.22.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 04efd3ab470f352395de3161c329086e07893f9a29d2e8d55085cc4ab00788c3
-  data.tar.gz: 62d498e4f19ec285358b29672d622e0476e70ae31cbf39bd480bf33dbe5b335b
+  metadata.gz: 7eceff94d1ab7a39dfa3603c7cfd124bad0c49a7315feb7e0bd938c45feca9f0
+  data.tar.gz: f3df43034ca7460e3fe21a47caa920e9ede1e65ac49cb5c04b0196198d4a2391
 SHA512:
-  metadata.gz: 0431f162cc71fb10db0c3920bef2a9d04c35713dfdfd467fc750ac16345c3cfd5965b8abb17c335ad8a7e7226d85c776a14d5d76030c7173969b00a61b309fd1
-  data.tar.gz: 683b9a9e65838df67344bc3b5ff05d8b04eb37fe5328ec4532f4d18b141d9957ca6709b3373adc22ce4f52791d3d0e90be8927693acfe159add2ba991812dc16
+  metadata.gz: 7ed0b76309075aac725c827733a454754f6183001a600582f79e116c8774d5ac4e8448dbb7b58fcb006649d1801cc0d86ef0484b0e6ee70201d4eb6cf3aa92fd
+  data.tar.gz: 927ca5a73f64293a53b3f4e0083112ed0257de431c04fa80541102cd1fec954d80c122c9138448264090e017d78b02a8b1028ac4ed36d1e1ecb0b489b7822211

data/lib/kameleoon/kameleoon_client.rb

@@ -1033,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'
@@ -12,9 +13,13 @@ module Kameleoon
         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, ' \
@@ -25,6 +30,10 @@ module Kameleoon
           @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, ' \
@@ -36,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
 
@@ -97,25 +110,42 @@ module Kameleoon
           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) }
-              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
+          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
 

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.1'
+  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.1
+  version: 3.22.2
 platform: ruby
 authors:
 - Kameleoon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-09-11 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