kameleoon-client-ruby 3.2.0 → 3.4.0

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

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require 'kameleoon/data/custom_data'
+require 'kameleoon/logging/kameleoon_logger'
+require 'kameleoon/network/activity_event'
+require 'kameleoon/network/uri_helper'
+
+module Kameleoon
+  module Managers
+    module Tracking
+      class TrackingBuilder
+        attr_reader :visitor_codes_to_send, :visitor_codes_to_keep, :tracking_lines, :unsent_visitor_data
+
+        def initialize(visitor_codes, data_file, visitor_manager, request_size_limit)
+          @visitor_codes = visitor_codes
+          @data_file = data_file
+          @visitor_manager = visitor_manager
+          @request_size_limit = request_size_limit
+          @built = false
+          @total_size = 0
+          # result
+          @visitor_codes_to_send = []
+          @visitor_codes_to_keep = []
+          @tracking_lines = []
+          @unsent_visitor_data = []
+        end
+
+        # Not thread-safe
+        def build
+          return if @built
+
+          @visitor_codes.each do |visitor_code|
+            if @total_size <= @request_size_limit
+              visitor = @visitor_manager.get_visitor(visitor_code)
+              is_consent_given = consent_given?(visitor)
+              data = collect_tracking_data(visitor_code, visitor, is_consent_given)
+              if !data.empty?
+                log_visitor_track_sending(visitor_code, is_consent_given, data)
+                @visitor_codes_to_send.push(visitor_code)
+                @unsent_visitor_data.concat(data)
+              else
+                log_visitor_track_no_data(visitor_code, is_consent_given)
+              end
+            else
+              @visitor_codes_to_keep.push(visitor_code)
+            end
+          end
+          @built = true
+        end
+
+        private
+
+        def log_visitor_track_sending(visitor_code, is_consent_given, data)
+          Logging::KameleoonLogger.debug(
+            "Sending tracking request for unsent data %s of visitor '%s' with given (or not required) consent %s",
+            data, visitor_code, is_consent_given
+          )
+        end
+
+        def log_visitor_track_no_data(visitor_code, is_consent_given)
+          Logging::KameleoonLogger.debug(
+            "No data to send for visitor '%s' with given (or not required) consent %s",
+            visitor_code, is_consent_given
+          )
+        end
+
+        def consent_given?(visitor)
+          !@data_file.settings.is_consent_required || visitor&.legal_consent
+        end
+
+        def collect_tracking_data(visitor_code, visitor, is_consent_given)
+          use_mapping_value, visitor = create_self_visitor_link_if_required(visitor_code, visitor)
+          Logging::KameleoonLogger.info(
+            "'%s' was used as a %s for visitor data tracking.",
+            visitor_code, (use_mapping_value ? 'mapping value' : 'visitor code')
+          )
+          unsent_data = get_unsent_visitor_data(visitor, is_consent_given)
+          collect_tracking_lines(visitor_code, visitor, unsent_data, use_mapping_value)
+          unsent_data
+        end
+
+        def create_self_visitor_link_if_required(visitor_code, visitor)
+          is_mapped = !visitor&.mapping_identifier.nil?
+          is_unique_identifier = visitor&.is_unique_identifier
+          # need to find if anonymous visitor is behind unique (anonym doesn't exist if MappingIdentifier == null)
+          if is_unique_identifier && !is_mapped
+            # We haven't anonymous behind, in this case we should create "fake" anonymous with id == visitorCode
+            # and link it with with mapping value == visitorCode (like we do as we have real anonymous visitor)
+            visitor = @visitor_manager.add_data(
+              visitor_code, CustomData.new(@data_file.custom_data_info.mapping_identifier_index, visitor_code)
+            )
+          end
+          use_mapping_value = is_unique_identifier && (visitor_code != visitor&.mapping_identifier)
+          [use_mapping_value, visitor]
+        end
+
+        def get_unsent_visitor_data(visitor, is_consent_given)
+          unsent_data = []
+          unless visitor.nil?
+            if is_consent_given
+              visitor.enumerate_sendable_data do |data|
+                unsent_data.push(data) if data.unsent
+                next true
+              end
+            else
+              visitor.conversions.enumerate do |c|
+                unsent_data.push(c) if c.unsent
+                next true
+              end
+              if @data_file.has_any_targeted_delivery_rule
+                visitor.variations.enumerate do |av|
+                  unsent_data.push(av) if av.unsent && (av.rule_type == Configuration::RuleType::TARGETED_DELIVERY)
+                  next true
+                end
+              end
+            end
+          end
+          unsent_data.push(Network::ActivityEvent.new) if unsent_data.empty? && is_consent_given
+          unsent_data
+        end
+
+        def collect_tracking_lines(visitor_code, visitor, unsent_data, use_mapping_value)
+          visitor_code_param = Network::UriHelper.encode_query(
+            { (use_mapping_value ? :mappingValue : :visitorCode) => visitor_code }
+          )
+          user_agent = visitor&.user_agent
+          unsent_data.each do |data|
+            line = data.obtain_full_post_text_line
+            next if line.empty?
+
+            line = add_line_params(line, visitor_code_param, user_agent)
+            @tracking_lines.push(line)
+            @total_size += line.size
+            user_agent = nil
+          end
+        end
+
+        def add_line_params(tracking_line, visitor_code_param, user_agent)
+          tracking_line += "&#{visitor_code_param}"
+          unless user_agent.nil?
+            user_agent_param = Network::UriHelper.encode_query({ userAgent: user_agent })
+            tracking_line += "&#{user_agent_param}"
+          end
+          tracking_line
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+# 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.debug('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.debug('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,75 @@ 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.consent_required?
+            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.consent_required?
+            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 +87,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.consent_required?
+          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 +110,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