kameleoon-client-ruby 3.3.0 → 3.5.0

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'kameleoon/data/data'
+require 'kameleoon/logging/kameleoon_logger'
+require 'kameleoon/managers/tracking/tracking_builder'
+require 'kameleoon/managers/tracking/visitor_tracking_registry'
+
+module Kameleoon
+  module Managers
+    module Tracking
+      class TrackingManager
+        LINES_DELIMETER = "\n"
+        REQUEST_SIZE_LIMIT = 2560 * 1024 # 2.5 * 1024^2 characters
+
+        def initialize(
+          data_manager, network_manager, visitor_manager, track_interval_seconds, scheduler
+        )
+          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)
+          @data_manager = data_manager
+          @network_manager = network_manager
+          @visitor_manager = visitor_manager
+          @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, ' \
+              'track_interval_seconds: %s, scheduler)', track_interval_seconds
+          )
+        end
+
+        def stop
+          Logging::KameleoonLogger.debug('CALL: TrackingManager.stop')
+          @track_all_job&.unschedule
+          @track_all_job = nil
+          Logging::KameleoonLogger.debug('RETURN: TrackingManager.stop')
+        end
+
+        def add_visitor_code(visitor_code)
+          Logging::KameleoonLogger.debug("CALL: TrackingManager.add_visitor_code(visitor_code: '%s')", visitor_code)
+          @tracking_visitors.add(visitor_code)
+          Logging::KameleoonLogger.debug("RETURN: TrackingManager.add_visitor_code(visitor_code: '%s')", visitor_code)
+        end
+
+        def track_all
+          Logging::KameleoonLogger.debug('CALL: TrackingManager.track_all')
+          track(@tracking_visitors.extract)
+          Logging::KameleoonLogger.debug('RETURN: TrackingManager.track_all')
+        end
+
+        def track_visitor(visitor_code)
+          Logging::KameleoonLogger.debug("CALL: TrackingManager.track_visitor(visitor_code: '%s')", visitor_code)
+          track([visitor_code])
+          Logging::KameleoonLogger.debug("RETURN: TrackingManager.track_visitor(visitor_code: '%s')", visitor_code)
+        end
+
+        private
+
+        def track(visitor_codes)
+          builder = TrackingBuilder.new(visitor_codes, @data_manager.data_file, @visitor_manager, REQUEST_SIZE_LIMIT)
+          builder.build
+          unless builder.visitor_codes_to_keep.empty?
+            Logging::KameleoonLogger.warning(
+              'Visitor data to be tracked exceeded the request size limit. ' \
+              'Some visitor data is kept to be sent later. ' \
+              'If it is not caused by the peak load, decreasing the tracking interval is recommended.'
+            )
+            @tracking_visitors.add_all(builder.visitor_codes_to_keep)
+          end
+          perform_tracking_request(builder.visitor_codes_to_send, builder.unsent_visitor_data, builder.tracking_lines)
+        end
+
+        def perform_tracking_request(visitor_codes, visitor_data, tracking_lines)
+          return 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
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Kameleoon
+  module Managers
+    module Tracking
+      class LockVisitorTrackingRegistry
+        LIMITED_EXTRACTION_THRESHOLD_COEFFICIENT = 2
+        REMOVAL_FACTOR = 0.8
+
+        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
+        end
+
+        def add(visitor_code)
+          @mutex.synchronize { @visitors.add(visitor_code) }
+        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
+          end
+        end
+
+        def extract
+          should_extract_all_be_used ? extract_all : extract_limited
+        end
+
+        private
+
+        def should_extract_all_be_used
+          @visitors.size < @extraction_limit * LIMITED_EXTRACTION_THRESHOLD_COEFFICIENT
+        end
+
+        def extract_all
+          old_visitors = nil
+          new_visitors = Set.new
+          @mutex.synchronize do
+            old_visitors = @visitors
+            @visitors = new_visitors
+          end
+          old_visitors
+        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
+
+              extracted.push(vc)
+              i += 1
+              @visitors.delete(vc)
+            end
+          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)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kameleoon/managers/warehouse/warehouse_manager.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'kameleoon/data/custom_data'
+require 'kameleoon/logging/kameleoon_logger'
 require 'kameleoon/utils'
 
 module Kameleoon
@@ -9,24 +10,40 @@ module Kameleoon
       class WarehouseManager
         WAREHOUSE_AUDIENCES_FIELD_NAME = 'warehouseAudiences'
 
-        def initialize(network_manager, visitor_manager, log_func = nil)
+        def initialize(network_manager, visitor_manager)
+          Logging::KameleoonLogger.debug('CALL: WarehouseManager.new(networkManager, visitorManager)')
           @network_manager = network_manager
           @visitor_manager = visitor_manager
-          @log_func = log_func
+          Logging::KameleoonLogger.debug('RETURN: WarehouseManager.new(networkManager, visitorManager)')
         end
 
         def get_visitor_warehouse_audience(visitor_code, custom_data_index, warehouse_key = nil, timeout = nil)
+          Logging::KameleoonLogger.debug(
+            "CALL: WarehouseManager.get_visitor_warehouse_audience(visitor_code: '%s', custom_data_index: %s," \
+              " warehouse_key: '%s', timeout: %s)", visitor_code, custom_data_index, warehouse_key, timeout
+          )
           Utils::VisitorCode.validate(visitor_code)
           remote_data_key = warehouse_key.nil? || warehouse_key.empty? ? visitor_code : warehouse_key
           response = @network_manager.get_remote_data(remote_data_key, timeout)
-          return nil unless response.is_a?(String)
+          unless response.is_a?(String)
+            Logging::KameleoonLogger.debug(
+              "RETURN: WarehouseManager.get_visitor_warehouse_audience(visitor_code: '%s', custom_data_index: %s," \
+                " warehouse_key: '%s', timeout: %s) -> (custom_data: nil)",
+              visitor_code, custom_data_index, warehouse_key, timeout
+            )
+            return nil
+          end
 
           remote_data = JSON.parse(response)
           warehouse_audiences = remote_data.is_a?(Hash) ? remote_data[WAREHOUSE_AUDIENCES_FIELD_NAME] : nil
           data_values = warehouse_audiences.is_a?(Hash) ? warehouse_audiences.keys : []
           warehouse_audiences_data = CustomData.new(custom_data_index, *data_values)
-          visitor = @visitor_manager.get_or_create_visitor(visitor_code)
-          visitor.add_data(@log_func, warehouse_audiences_data)
+          @visitor_manager.add_data(visitor_code, warehouse_audiences_data)
+          Logging::KameleoonLogger.debug(
+            "RETURN: WarehouseManager.get_visitor_warehouse_audience(visitor_code: '%s', custom_data_index: %s," \
+              " warehouse_key: '%s', timeout: %s) -> (custom_data: %s)",
+            visitor_code, custom_data_index, warehouse_key, timeout, warehouse_audiences_data
+          )
           warehouse_audiences_data
         end
       end

data/lib/kameleoon/network/access_token_source.rb

@@ -3,6 +3,8 @@
 require 'json'
 require 'net/http'
 require 'time'
+require 'kameleoon/utils'
+require 'kameleoon/logging/kameleoon_logger'
 
 module Kameleoon
   module Network
@@ -12,25 +14,38 @@ module Kameleoon
       JWT_ACCESS_TOKEN_FIELD = 'access_token'
       JWT_EXPIRES_IN_FIELD = 'expires_in'
 
-      def initialize(network_manager, client_id, client_secret, log_func)
+      def initialize(network_manager, client_id, client_secret)
+        Logging::KameleoonLogger.debug(lambda {
+          format("CALL: AccessTokenSource.new(network_manager, client_id: '%s', client_secret: '%s')",
+                 Utils::Strval.secret(client_id), Utils::Strval.secret(client_secret))
+        })
         @network_manager = network_manager
         @client_id = client_id
         @client_secret = client_secret
         @fetching = false
-        @log_func = log_func
+        Logging::KameleoonLogger.debug(lambda {
+          format("RETURN: AccessTokenSource.new(network_manager, client_id: '%s', client_secret: '%s')",
+                 Utils::Strval.secret(client_id), Utils::Strval.secret(client_secret))
+        })
       end
 
       def get_token(timeout = nil)
+        Logging::KameleoonLogger.debug('CALL: AccessTokenSource.getToken(timeout: %s)', timeout)
         now = Time.new.to_i
         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
       end
 
       def discard_token(token)
+        Logging::KameleoonLogger.debug("CALL: AccessTokenSource.discard_token(token: '%s')", token)
         @cached_token = nil if @cached_token&.value == token
+        Logging::KameleoonLogger.debug("RETURN: AccessTokenSource.discard_token(token: '%s')", token)
+        @cached_token
       end
 
       private
@@ -40,7 +55,7 @@ module Kameleoon
         fetch_token(timeout)
       rescue StandardError => e
         @fetching = false
-        @log_func&.call("Failed to call access token fetching: #{e}")
+        Logging::KameleoonLogger.error("Failed to call access token fetching: #{e}")
         nil
       end
 
@@ -50,13 +65,14 @@ module Kameleoon
         Thread.new { fetch_token }
       rescue StandardError => e
         @fetching = false
-        @log_func&.call("Failed to run access token fetching: #{e}")
+        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(@client_id, @client_secret, timeout)
         unless response_content
-          @log_func&.call('Failed to fetch access JWT')
+          Logging::KameleoonLogger.error('Failed to fetch access JWT')
           return nil
         end
         begin
@@ -64,14 +80,18 @@ module Kameleoon
           token = jwt[JWT_ACCESS_TOKEN_FIELD]
           expires_in = jwt[JWT_EXPIRES_IN_FIELD]
         rescue JSON::ParserError => e
-          @log_func&.call("Failed to parse access JWT: #{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?
-          @log_func&.call('Failed to read access JWT')
+          Logging::KameleoonLogger.error('Failed to read access JWT')
           return nil
         end
-        handle_fetched_token(token, expires_in)
+        token = handle_fetched_token(token, expires_in)
+        Logging::KameleoonLogger.debug(
+          "RETURN: AccessTokenSource.fetch_token(timeout: %s) -> (token: '%s')", timeout, token
+        )
+        token
       ensure
         @fetching = false
       end
@@ -83,9 +103,14 @@ module Kameleoon
           obs_time = now + expires_in - TOKEN_OBSOLESCENCE_GAP
         else
           obs_time = exp_time
-          unless @log_func.nil?
-            issue = expires_in <= TOKEN_EXPIRATION_GAP ? 'cache the token' : 'refresh cached token in background'
-            @log_func.call("Access token life time (#{expires_in}s) is not long enough to #{issue}")
+          if expires_in <= TOKEN_EXPIRATION_GAP
+            Logging::KameleoonLogger.error(
+              'Access token life time (%ss) is not long enough to cache the token', expires_in
+            )
+          else
+            Logging::KameleoonLogger.warning(
+              'Access token life time (%ss) is not long enough to refresh cached token in background', expires_in
+            )
           end
         end
         @cached_token = ExpiringToken.new(token, exp_time, obs_time)
@@ -112,14 +137,21 @@ module Kameleoon
     end
 
     class AccessTokenSourceFactory
-      def initialize(client_id, client_secret, log_func)
+      def initialize(client_id, client_secret)
+        Logging::KameleoonLogger.debug(lambda {
+          format("CALL: AccessTokenSourceFactory.new(client_id: '%s', client_secret: '%s')",
+                 Utils::Strval.secret(client_id), Utils::Strval.secret(client_secret))
+        })
         @client_id = client_id
         @client_secret = client_secret
-        @log_func = log_func
+        Logging::KameleoonLogger.debug(lambda {
+          format("RETURN: AccessTokenSourceFactory.new(client_id: '%s', client_secret: '%s')",
+                 Utils::Strval.secret(client_id), Utils::Strval.secret(client_secret))
+        })
       end
 
       def create(network_manager)
-        AccessTokenSource.new(network_manager, @client_id, @client_secret, @log_func)
+        AccessTokenSource.new(network_manager, @client_id, @client_secret)
       end
     end
   end

data/lib/kameleoon/network/cookie/cookie_manager.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'kameleoon/utils'
+require 'kameleoon/logging/kameleoon_logger'
 
 module Kameleoon
   module Network
@@ -10,49 +11,76 @@ module Kameleoon
       COOKIE_TTL_SECONDS = 380 * 86_400 # 380 days in seconds
 
       class CookieManager
-        attr_accessor :consent_required
-
-        def initialize(top_level_domain)
-          @consent_required = false
+        def initialize(data_manager, top_level_domain)
+          Logging::KameleoonLogger.debug("CALL: CookieManager.new(top_level_domain: '%s')", top_level_domain)
+          @data_manager = data_manager
           @top_level_domain = top_level_domain
+          Logging::KameleoonLogger.debug("RETURN: CookieManager.new(top_level_domain: '%s')", top_level_domain)
         end
 
         def get_or_add(cookies, default_visitor_code = nil)
           return if cookies.nil?
 
+          Logging::KameleoonLogger.debug(
+            "CALL: CookieManager.get_or_add(cookies: %s, default_visitor_code: '%s')",
+            cookies, default_visitor_code
+          )
+
           visitor_code = get_visitor_code_from_cookies(cookies)
           unless visitor_code.nil?
             Utils::VisitorCode.validate(visitor_code)
+            Logging::KameleoonLogger.debug("Read visitor code '%s' from cookies %s", visitor_code, cookies)
             # Remove adding cookies when we will be sure that it doesn't break anything
-            add(visitor_code, cookies) unless @consent_required
+            add(visitor_code, cookies) unless @data_manager.visitor_code_managed?
+            Logging::KameleoonLogger.debug(
+              "RETURN: CookieManager.get_or_add(cookies: %s, default_visitor_code: '%s') -> (visitor_code: '%s')",
+              cookies, default_visitor_code, visitor_code
+            )
             return visitor_code
           end
 
           if default_visitor_code.nil?
             visitor_code = Utils::VisitorCode.generate
-            add(visitor_code, cookies) unless @consent_required
+            Logging::KameleoonLogger.debug("Generated new visitor code '%s'", visitor_code)
+            add(visitor_code, cookies) unless @data_manager.visitor_code_managed?
+            Logging::KameleoonLogger.debug(
+              "RETURN: CookieManager.get_or_add(cookies: %s, default_visitor_code: '%s') -> (visitor_code: '%s')",
+              cookies, default_visitor_code, visitor_code
+            )
             return visitor_code
           end
 
           visitor_code = default_visitor_code
           Utils::VisitorCode.validate(visitor_code)
+          Logging::KameleoonLogger.debug("Used default visitor code '{%s}'", default_visitor_code)
           add(visitor_code, cookies)
+          Logging::KameleoonLogger.debug(
+            "RETURN: CookieManager.get_or_add(cookies: %s, default_visitor_code: '%s') -> (visitor_code: '%s')",
+            cookies, default_visitor_code, visitor_code
+          )
           visitor_code
         end
 
         def update(visitor_code, consent, cookies)
           return if cookies.nil?
 
+          Logging::KameleoonLogger.debug("CALL: CookieManager.update(visitor_code: '%s', consent: %s, cookies: %s)",
+                                         visitor_code, consent, cookies)
+
           if consent
             add(visitor_code, cookies)
           else
             remove(cookies)
           end
+          Logging::KameleoonLogger.debug("RETURN: CookieManager.update(visitor_code: '%s', consent: %s, cookies: %s)",
+                                         visitor_code, consent, cookies)
         end
 
         private
 
         def add(visitor_code, cookies)
+          Logging::KameleoonLogger.debug("CALL: CookieManager.add(visitor_code: '%s', cookies: %s)",
+                                         visitor_code, cookies)
           cookie = {
             value: visitor_code,
             expires: Time.now + COOKIE_TTL_SECONDS,
@@ -60,13 +88,20 @@ module Kameleoon
             domain: @top_level_domain
           }
           cookies[VISITOR_CODE_COOKIE] = cookie
+          Logging::KameleoonLogger.debug("RETURN: CookieManager.add(visitor_code: '%s', cookies: %s)",
+                                         visitor_code, cookies)
+          cookies
         end
 
         def remove(cookies)
-          cookies[VISITOR_CODE_COOKIE] = nil if @consent_required
+          Logging::KameleoonLogger.debug('CALL: CookieManager.remove(cookies: %s)', cookies)
+          cookies[VISITOR_CODE_COOKIE] = nil if @data_manager.visitor_code_managed?
+          Logging::KameleoonLogger.debug('RETURN: CookieManager.remove(cookies: %s)', cookies)
+          cookies
         end
 
         def get_visitor_code_from_cookies(cookies)
+          Logging::KameleoonLogger.debug('CALL: CookieManager.get_visitor_code_from_cookies(cookies: %s)', cookies)
           cookie = cookies[VISITOR_CODE_COOKIE]
           case cookie
           when String
@@ -76,6 +111,10 @@ module Kameleoon
           end
           visitor_code = visitor_code[COOKIE_KEY_JS.size..] if visitor_code&.start_with?(COOKIE_KEY_JS)
           visitor_code = nil if visitor_code&.empty?
+          Logging::KameleoonLogger.debug(
+            "RETURN: CookieManager.get_visitor_code_from_cookies(cookies: %s) -> (visitor_code: '%s')",
+            cookies, visitor_code
+          )
           visitor_code
         end
       end

data/lib/kameleoon/network/net_provider.rb

@@ -8,7 +8,7 @@ require 'kameleoon/exceptions'
 module Kameleoon
   module Network
     class NetProvider
-      def make_request(request)
+      def make_request(_request)
         raise KameleoonError, 'Call of not implemented method!'
       end
 
@@ -18,7 +18,6 @@ module Kameleoon
         headers = { 'Content-Type' => request.content_type }
         headers.merge!(request.extra_headers) unless request.extra_headers.nil?
         headers['Authorization'] = "Bearer #{request.access_token}" unless request.access_token.nil?
-        headers['User-Agent'] = request.user_agent unless request.user_agent.nil?
         headers
       end
 
@@ -50,7 +49,7 @@ module Kameleoon
         body = resp.body
         body = nil if body&.empty?
         Response.new(nil, resp.code.to_i, body, request)
-      rescue => e
+      rescue StandardError => e
         Response.new(e, nil, nil, request)
       end
     end

data/lib/kameleoon/network/network_manager.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'kameleoon/logging/kameleoon_logger'
 require 'kameleoon/network/content_type'
 require 'kameleoon/network/method'
 require 'kameleoon/network/request'
@@ -21,13 +22,12 @@ module Kameleoon
 
       attr_reader :environment, :default_timeout, :access_token_source, :url_provider
 
-      def initialize(environment, default_timeout, access_token_source_factory, url_provider, log_func = nil)
+      def initialize(environment, default_timeout, access_token_source_factory, url_provider)
         @environment = environment
         @default_timeout = default_timeout
         @access_token_source = access_token_source_factory.create(self)
         @url_provider = url_provider
         @sync_net_provider = SyncNetProvider.new
-        @log_func = log_func
       end
 
       def fetch_configuration(timestamp = nil, timeout = nil)
@@ -52,17 +52,13 @@ module Kameleoon
         make_call(request, true)
       end
 
-      def send_tracking_data(visitor_code, lines, user_agent, is_unique_identifier, timeout = nil)
+      def send_tracking_data(lines, timeout = nil)
         return if lines.nil? || lines.empty?
 
-        url = @url_provider.make_tracking_url(visitor_code, is_unique_identifier)
+        url = @url_provider.make_tracking_url
         timeout = ensure_timeout(timeout)
-        data = (lines.map(&:obtain_full_post_text_line).join("\n") || '').encode('UTF-8')
-        request = Request.new(Method::POST, url, ContentType::TEXT, timeout, user_agent: user_agent, data: data)
-        Thread.new do
-          result = make_call(request, true, TRACKING_CALL_ATTEMPT_NUMBER - 1, TRACKING_CALL_RETRY_DELAY)
-          lines.each(&:mark_as_sent) if result != false
-        end
+        request = Request.new(Method::POST, url, ContentType::TEXT, timeout, data: lines)
+        make_call(request, true, TRACKING_CALL_ATTEMPT_NUMBER - 1, TRACKING_CALL_RETRY_DELAY)
       end
 
       def fetch_access_jwtoken(client_id, client_secret, timeout = nil)
@@ -81,6 +77,8 @@ module Kameleoon
       private
 
       def make_call(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
         success = false
         while !success && (attempt <= retry_limit)
@@ -90,33 +88,31 @@ module Kameleoon
           if response.success?
             success = true
           elsif !response.error.nil?
-            log_failure(request, "Error occurred during request: #{response.error}")
+            log_level = attempt < retry_limit ? Logging::LogLevel::WARNING : Logging::LogLevel::ERROR
+            Logging::KameleoonLogger.log(log_level, "%s call '%s' failed: Error occurred during request: %s",
+                                         request.method, request.url, response.error)
           else
-            log_failure(request, "Received unexpected status code '#{response.code}'")
+            log_level = attempt < retry_limit ? Logging::LogLevel::WARNING : Logging::LogLevel::ERROR
+            Logging::KameleoonLogger.log(log_level, "%s call '%s' failed: Received unexpected status code '%s'",
+                                         request.method, request.url, response.code)
             if response.code == 401 && request.access_token
-              @log_func&.call("Unexpected rejection of access token '#{request.access_token}'")
+              Logging::KameleoonLogger.warning("Unexpected rejection of access token '#{request.access_token}'")
               @access_token_source.discard_token(request.access_token)
               if attempt == retry_limit
                 try_access_token_auth = false
                 retry_delay = 0
                 request.authorize(nil)
                 attempt -= 1
+                Logging::KameleoonLogger.error("Wrong Kameleoon API access token slows down the SDK's requests")
               end
             end
           end
           attempt += 1
         end
+        Logging::KameleoonLogger.debug('Fetched response %s for request %s', response, request)
         success ? response.body : false
       end
 
-      def log_failure(request, message)
-        return if @log_func.nil?
-
-        premsg = "#{request.method} call '#{request.url}' "
-        premsg += request.data.nil? ? 'failed' : "(data '#{request.data}') failed"
-        @log_func.call("#{premsg}: #{message}")
-      end
-
       def delay(period)
         sleep(period)
       end

data/lib/kameleoon/network/request.rb

@@ -5,14 +5,25 @@ module Kameleoon
     ##
     # Request represents HTTP request.
     class Request
-      attr_reader :method, :url, :content_type, :timeout, :user_agent, :extra_headers, :data, :access_token
+      attr_reader :method, :url, :content_type, :timeout, :extra_headers, :data, :access_token
 
-      def initialize(method, url, content_type, timeout, user_agent: nil, extra_headers: nil, data: nil)
+      def to_s
+        body = 'null'
+        unless @data.nil?
+          if @data.is_a?(String)
+            body = @data.start_with?('grant_type=client_credentials') ? '****' : @data
+          else
+            body = @data
+          end
+        end
+        "HttpRequest{Method:'#{@method}',Url:'#{@url}',Headers:#{@extra_headers},Body:'#{body}'}"
+      end
+
+      def initialize(method, url, content_type, timeout, extra_headers: nil, data: nil)
         @method = method
         @url = url
         @content_type = content_type
         @timeout = timeout
-        @user_agent = user_agent
         @extra_headers = extra_headers
         @data = !data.nil? && data.is_a?(String) ? data.encode('UTF-8') : data
       end

data/lib/kameleoon/network/response.rb

@@ -7,6 +7,10 @@ module Kameleoon
     class Response
       attr_reader :error, :code, :body, :request
 
+      def to_s
+        "HttpResponse{Code:'#{@code}',Reason:'#{@error}',Body:#{@body}}"
+      end
+
       def initialize(error, code, body, request)
         @error = error
         @code = code