kameleoon-client-ruby 3.3.0 → 3.5.0

data/lib/kameleoon/kameleoon_client_config.rb

@@ -1,29 +1,56 @@
 # frozen_string_literal: true
 
+require 'kameleoon/logging/kameleoon_logger'
+
 module Kameleoon
   # KameleoonClient configuration which can be used instead of an external configuration file
   class KameleoonClientConfig
     DEFAULT_REFRESH_INTERVAL_MINUTES = 60
     DEFAULT_SESSION_DURATION_MINUTES = 30
     DEFAULT_TIMEOUT_MILLISECONDS = 10_000
+    DEFAULT_TRACKING_INTERVAL_MILLISECONDS = 1000
+    MIN_TRACKING_INTERVAL_MILLISECONDS = 300
+    MAX_TRACKING_INTERVAL_MILLISECONDS = 1000
 
     attr_reader :client_id, :client_secret, :refresh_interval_second, :session_duration_second,
-                :default_timeout_millisecond, :environment, :top_level_domain, :verbose_mode
+                :default_timeout_millisecond, :tracking_interval_second, :environment, :top_level_domain,
+                :verbose_mode
+
+    def to_s
+      'KameleoonClientConfig{' \
+        "client_id:'#{Utils::Strval.secret(@client_id)}'," \
+        "client_secret:'#{Utils::Strval.secret(@client_secret)}'," \
+        "refresh_interval_second:#{@refresh_interval_second}," \
+        "session_duration_second:#{@session_duration_second}," \
+        "environment:'#{@environment}'," \
+        "default_timeout_millisecond:#{@default_timeout_millisecond}," \
+        "top_level_domain:'#{@top_level_domain}'," \
+        "verbose_mode:#{verbose_mode}" \
+        '}'
+    end
 
+    # verbose_mode is DEPRECATED. Please use `KameleoonLogger.log_level` instead.
     def initialize(
       client_id,
       client_secret,
       refresh_interval_minute: DEFAULT_REFRESH_INTERVAL_MINUTES,
       session_duration_minute: DEFAULT_SESSION_DURATION_MINUTES,
       default_timeout_millisecond: DEFAULT_TIMEOUT_MILLISECONDS,
+      tracking_interval_millisecond: DEFAULT_TRACKING_INTERVAL_MILLISECONDS,
       environment: nil,
       top_level_domain: nil,
-      verbose_mode: false
+      verbose_mode: nil
     )
       raise Exception::ConfigCredentialsInvalid, 'Client ID is not specified' if client_id&.empty? != false
       raise Exception::ConfigCredentialsInvalid, 'Client secret is not specified' if client_secret&.empty? != false
 
-      @verbose_mode = verbose_mode || false
+      unless verbose_mode.nil?
+        Logging::KameleoonLogger.warning(
+          '[DEPRECATION] `verbose_mode` is deprecated. Please use `KameleoonLogger.log_level` instead.'
+        )
+      end
+
+      @verbose_mode = verbose_mode
 
       @client_id = client_id
       @client_secret = client_secret
@@ -31,8 +58,10 @@ module Kameleoon
       if refresh_interval_minute.nil?
         refresh_interval_minute = DEFAULT_REFRESH_INTERVAL_MINUTES
       elsif refresh_interval_minute <= 0
-        log('Configuration refresh interval must have positive value. ' \
-          "Default refresh interval (#{DEFAULT_REFRESH_INTERVAL_MINUTES} minutes) is applied.")
+        Logging::KameleoonLogger.warning(lambda {
+          'Configuration refresh interval must have positive value. ' \
+          "Default refresh interval (#{DEFAULT_REFRESH_INTERVAL_MINUTES} minutes) was applied."
+        })
         refresh_interval_minute = DEFAULT_REFRESH_INTERVAL_MINUTES
       end
       @refresh_interval_second = refresh_interval_minute * 60
@@ -40,8 +69,10 @@ module Kameleoon
       if session_duration_minute.nil?
         session_duration_minute = DEFAULT_SESSION_DURATION_MINUTES
       elsif session_duration_minute <= 0
-        log('Session duration must have positive value. ' \
-          "Default session duration (#{DEFAULT_SESSION_DURATION_MINUTES} minutes) is applied.")
+        Logging::KameleoonLogger.warning(lambda {
+          'Session duration must have positive value. ' \
+          "Default session duration (#{DEFAULT_SESSION_DURATION_MINUTES} minutes) was applied."
+        })
         session_duration_minute = DEFAULT_SESSION_DURATION_MINUTES
       end
       @session_duration_second = session_duration_minute * 60
@@ -49,25 +80,46 @@ module Kameleoon
       if default_timeout_millisecond.nil?
         @default_timeout_millisecond = DEFAULT_TIMEOUT_MILLISECONDS
       elsif default_timeout_millisecond <= 0
-        log('Default timeout must have positive value. ' \
-          "Default timeout (#{DEFAULT_TIMEOUT_MILLISECONDS} ms) is applied.")
+        Logging::KameleoonLogger.warning(lambda {
+          'Default timeout must have positive value. ' \
+          "Default timeout (#{DEFAULT_TIMEOUT_MILLISECONDS} ms) was applied."
+        })
         @default_timeout_millisecond = DEFAULT_TIMEOUT_MILLISECONDS
       else
         @default_timeout_millisecond = default_timeout_millisecond
       end
 
+      if tracking_interval_millisecond.nil?
+        tracking_interval_millisecond = DEFAULT_TRACKING_INTERVAL_MILLISECONDS
+      elsif tracking_interval_millisecond < MIN_TRACKING_INTERVAL_MILLISECONDS
+        Logging::KameleoonLogger.warning(lambda {
+          'Tracking interval must not be shorter than ' \
+          "#{MIN_TRACKING_INTERVAL_MILLISECONDS} ms. Minimum possible interval was applied."
+        })
+        tracking_interval_millisecond = MIN_TRACKING_INTERVAL_MILLISECONDS
+      elsif tracking_interval_millisecond > MAX_TRACKING_INTERVAL_MILLISECONDS
+        Logging::KameleoonLogger.warning(lambda {
+          'Tracking interval must not be longer than ' \
+          "#{MAX_TRACKING_INTERVAL_MILLISECONDS} ms. Maximum possible interval was applied."
+        })
+        tracking_interval_millisecond = MAX_TRACKING_INTERVAL_MILLISECONDS
+      end
+      @tracking_interval_second = tracking_interval_millisecond / 1000.0
+
       @environment = environment
 
       if top_level_domain.nil?
-        log('Setting top level domain is strictly recommended, otherwise you may have problems when using subdomains.')
+        Logging::KameleoonLogger.warning(
+          'Setting top level domain is strictly recommended, otherwise you may have problems when using subdomains.'
+        )
       end
-      @top_level_domain = top_level_domain
+      @top_level_domain = Utils::Domain.validate_top_level_domain(top_level_domain)
     end
 
     def self.read_from_yaml(path)
       yaml = YAML.load_file(path) if File.exist?(path)
       if yaml.nil?
-        warn "Kameleoon SDK: Configuration file with path #{path} does not exist"
+        Logging::KameleoonLogger.warning(-> { "Configuration file with path '#{path}' does not exist" })
         yaml = {}
       end
       KameleoonClientConfig.new(
@@ -76,16 +128,11 @@ module Kameleoon
         refresh_interval_minute: yaml['refresh_interval_minute'],
         session_duration_minute: yaml['session_duration_minute'],
         default_timeout_millisecond: yaml['default_timeout_millisecond'],
+        tracking_interval_millisecond: yaml['tracking_interval_millisecond'],
         environment: yaml['environment'],
         top_level_domain: yaml['top_level_domain'],
         verbose_mode: yaml['verbose_mode']
       )
     end
-
-    private
-
-    def log(text)
-      print "Kameleoon SDK Log: #{text}\n" if @verbose_mode
-    end
   end
 end

data/lib/kameleoon/kameleoon_client_factory.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'concurrent'
+require 'kameleoon/logging/kameleoon_logger'
 require 'kameleoon/kameleoon_client'
 require 'kameleoon/kameleoon_client_config'
 
@@ -12,25 +13,37 @@ module Kameleoon
     @clients = Concurrent::Map.new
 
     def self.create(site_code, config: nil, config_path: CONFIG_PATH)
+      Logging::KameleoonLogger.info(
+        "CALL: KameleoonClientFactory.create(site_code: '%s', config: %s, config_path: '%s')",
+        site_code, config, config_path
+      )
       unless config.is_a?(KameleoonClientConfig)
         config_path = CONFIG_PATH unless config_path.is_a?(String)
         config = KameleoonClientConfig.read_from_yaml(config_path)
       end
       key = get_client_key(site_code, config.environment)
-      @clients.compute_if_absent(key) do
+      client = @clients.compute_if_absent(key) do
         client = KameleoonClient.new(site_code, config)
-        client.send(:log, "Client created with site code: #{site_code}")
         client.send(:fetch_configuration_initially)
         client
       end
+      Logging::KameleoonLogger.info(
+        "RETURN: KameleoonClientFactory.create(site_code: '%s', config: %s, config_path: '%s') -> (client)",
+        site_code, config, config_path
+      )
+      client
     end
 
     def self.forget(site_code, environment = nil)
+      Logging::KameleoonLogger.info("CALL: KameleoonClientFactory.forget(site_code: '%s', environment: '%s')",
+                                    site_code, environment)
       key = get_client_key(site_code, environment)
       @clients.compute_if_present(key) do |client|
         client.send(:dispose)
         nil
       end
+      Logging::KameleoonLogger.info("RETURN: KameleoonClientFactory.forget(site_code: '%s', environment: '%s')",
+                           site_code, environment)
     end
 
     private_class_method

data/lib/kameleoon/logging/default_logger.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'kameleoon/logging/logger'
+
+module Kameleoon
+  module Logging
+    # A default implementation of a logger that prints log messages to the console.
+    # This logger implements the Logger interface.
+    class DefaultLogger < Logger
+
+      # Logs a message at the specified log level.
+      #
+      # @param level [LogLevel] the log level
+      # @param message [String] the log message
+      def log(level, message)
+        puts message
+      end
+    end
+  end
+end

data/lib/kameleoon/logging/kameleoon_logger.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'kameleoon/logging/default_logger'
+
+module Kameleoon
+  module Logging
+    module LogLevel
+      NONE = 0
+      ERROR = 1
+      WARNING = 2
+      INFO = 3
+      DEBUG = 4
+
+      def self.name_from_level(log_level)
+        case log_level
+        when LogLevel::NONE
+          'NONE'
+        when LogLevel::ERROR
+          'ERROR'
+        when LogLevel::WARNING
+          'WARNING'
+        when LogLevel::INFO
+          'INFO'
+        when LogLevel::DEBUG
+          'DEBUG'
+        end
+      end
+    end
+
+    module KameleoonLogger
+      extend self
+
+      @logger = DefaultLogger.new
+      @log_level = LogLevel::WARNING
+
+      attr_accessor :logger, :log_level
+
+      def log(level, data, *args)
+        return unless check_level(level)
+
+        if data.class.method_defined?(:call)
+          message = data.call
+        else
+          message = args.empty? ? data : data % args
+        end
+
+        write_message(level, message)
+      end
+
+      def info(data, *args)
+        log(LogLevel::INFO, data, *args)
+      end
+
+      def error(data, *args)
+        log(LogLevel::ERROR, data, *args)
+      end
+
+      def warning(data, *args)
+        log(LogLevel::WARNING, data, *args)
+      end
+
+      def debug(data, *args)
+        log(LogLevel::DEBUG, data, *args)
+      end
+
+      private
+
+      def check_level(level)
+        level <= @log_level && level != LogLevel::NONE
+      end
+
+      def write_message(level, message)
+        @logger.log(level, "Kameleoon [#{LogLevel.name_from_level(level)}]: #{message}")
+      end
+    end
+  end
+end

data/lib/kameleoon/logging/logger.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Kameleoon
+  module Logging
+    class Logger
+
+      def log(level, message)
+        raise NotImplementedError, 'Subclasses must implement log(level, message)'
+      end
+    end
+  end
+end

data/lib/kameleoon/managers/data/data_manager.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Kameleoon
+  module Managers
+    module Data
+      class DataManager
+        def initialize(data_file)
+          self.data_file = data_file
+        end
+
+        def data_file
+          @container.data_file
+        end
+
+        def data_file=(value)
+          @container = Container.new(value)
+        end
+
+        def visitor_code_managed?
+          @container.visitor_code_managed
+        end
+
+        class Container
+          attr_reader :data_file, :visitor_code_managed
+
+          def initialize(data_file)
+            @data_file = data_file
+            # Regarding GDPR policy we should set visitorCode if legal consent isn't required or we have at
+            # least one Targeted Delivery rule in datafile
+            @visitor_code_managed = data_file.settings.is_consent_required && !data_file.has_any_targeted_delivery_rule
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kameleoon/managers/remote_data/remote_data_manager.rb

@@ -1,54 +1,71 @@
 # frozen_string_literal: true
 
+require 'kameleoon/logging/kameleoon_logger'
 require 'kameleoon/managers/remote_data/remote_visitor_data'
 require 'kameleoon/types/remote_visitor_data_filter'
+require 'kameleoon/utils'
 
 module Kameleoon
   module Managers
     module RemoteData
       class RemoteDataManager
-        attr_reader :network_manager, :visitor_manger, :log_func
+        attr_reader :network_manager, :visitor_manger
 
-        def initialize(network_manager, visitor_manger, log_func = nil)
+        def initialize(data_manager, network_manager, visitor_manger)
+          Logging::KameleoonLogger.debug('CALL: RemoteDataManager.new(data_manager, networkManager, visitorManager)')
+          @data_manager = data_manager
           @network_manager = network_manager
           @visitor_manger = visitor_manger
-          @log_func = log_func
+          Logging::KameleoonLogger.debug('RETURN: RemoteDataManager.new(data_manager, networkManager, visitorManager)')
         end
 
         def get_data(key, timeout)
+          Logging::KameleoonLogger.debug("CALL: RemoteDataManager.get_data(key: '%s', timeout: %s)", key, timeout)
           response = @network_manager.get_remote_data(key, timeout)
-          JSON.parse(response) if response
+          data = JSON.parse(response) if response
+          Logging::KameleoonLogger.debug(
+            "RETURN: RemoteDataManager.get_data(key: '%s', timeout: %s) -> (remote_data: %s)",
+            key, timeout, data
+          )
+          data
         rescue StandardError => e
-          log("Parsing of visitor data of '#{key}' failed: #{e}")
+          Logging::KameleoonLogger.error("Parsing of remote data of '#{key}' failed: #{e}")
           raise
         end
 
-        def get_visitor_data(visitor_code, add_data, filter = nil, is_unique_identifier = false, timeout = nil)
+        def get_visitor_data(visitor_code, add_data, filter = nil, timeout = nil)
+          Logging::KameleoonLogger.debug(
+            "CALL: RemoteDataManager.get_visitor_data(visitor_code: '%s', add_data: %s, filter: %s, timeout: %s)",
+            visitor_code, add_data, filter, timeout
+          )
           Utils::VisitorCode.validate(visitor_code)
-          filter = Kameleoon::Types::RemoteVisitorDataFilter.new unless filter.is_a?(Kameleoon::Types::RemoteVisitorDataFilter)
+          filter = Types::RemoteVisitorDataFilter.new unless filter.is_a?(Types::RemoteVisitorDataFilter)
+          is_unique_identifier = @visitor_manger.get_visitor(visitor_code)&.is_unique_identifier || false
           response = @network_manager.get_remote_visitor_data(visitor_code, filter, is_unique_identifier, timeout)
           (data_to_add, data_to_return) = parse_custom_data_array(visitor_code, response)
           if add_data && !data_to_add.empty?
+            # Cannot use `VisitorManager.add_data` because it could use remote visitor data for mapping.
             visitor = @visitor_manger.get_or_create_visitor(visitor_code)
-            visitor.add_data(@log_func, *data_to_add, overwrite: false)
+            visitor.add_data(*data_to_add, overwrite: false)
           end
+          Logging::KameleoonLogger.debug(
+            "RETURN: RemoteDataManager.get_visitor_data(visitor_code: '%s', add_data: %s, filter: %s," \
+              ' timeout: %s) -> (visitor_data: %s)',
+            visitor_code, add_data, filter, timeout, data_to_return
+          )
           data_to_return
         end
 
         ##
         # helper method used by `get_remote_visitor_data`
         def parse_custom_data_array(visitor_code, response)
-          remote_visitor_data = Kameleoon::Managers::RemoteData::RemoteVisitorData.new(JSON.parse(response))
-          remote_visitor_data.mark_data_as_sent(@visitor_manger.custom_data_info)
+          remote_visitor_data = RemoteVisitorData.new(JSON.parse(response))
+          remote_visitor_data.mark_data_as_sent(@data_manager.data_file.custom_data_info)
           [remote_visitor_data.collect_data_to_add, remote_visitor_data.collect_data_to_return]
         rescue StandardError => e
-          log("Parsing of visitor data of '#{visitor_code}' failed: #{e}")
+          Logging::KameleoonLogger.error("Parsing of remote visitor data of '#{visitor_code}' failed: #{e}")
           raise
         end
-
-        def log(text)
-          @log_func&.call(text)
-        end
       end
     end
   end

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