kameleoon-client-ruby 3.2.0 → 3.4.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,17 +80,38 @@ 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
     end
@@ -67,7 +119,7 @@ module Kameleoon
     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 consent_required?
+          @container.is_consent_required
+        end
+
+        class Container
+          attr_reader :data_file, :is_consent_required
+
+          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
+            @is_consent_required = 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,57 +1,72 @@
 # 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
-end
+end

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

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-#
+
 require 'kameleoon/data/manager/page_view_visit'
 require 'kameleoon/data/manager/assigned_variation'
 require 'kameleoon/data/visitor_visits'
@@ -8,13 +8,15 @@ require 'kameleoon/data/device'
 require 'kameleoon/data/conversion'
 require 'kameleoon/data/custom_data'
 require 'kameleoon/data/geolocation'
+require 'kameleoon/data/kcs_heat'
 require 'kameleoon/data/page_view'
 
 module Kameleoon
   module Managers
     module RemoteData
       class RemoteVisitorData
-        attr_reader :custom_data_dict, :page_view_visits, :conversions, :experiments, :device, :browser, :operating_system, :geolocation, :previous_visitor_visits
+        attr_reader :custom_data_dict, :page_view_visits, :conversions, :experiments, :device, :browser,
+                    :operating_system, :geolocation, :previous_visitor_visits, :kcs_heat
 
         def initialize(hash)
           current_visit = hash['currentVisit']
@@ -30,12 +32,14 @@ module Kameleoon
             end
             @previous_visitor_visits = VisitorVisits.new(times_started)
           end
+          @kcs_heat = parse_kcs_heat(hash['kcs'])
         end
 
         def collect_data_to_add
           data_to_add = []
           data_to_add.concat(@custom_data_dict.values) unless @custom_data_dict.nil?
           data_to_add.push(@previous_visitor_visits) unless @previous_visitor_visits.nil?
+          data_to_add.push(@kcs_heat) unless @kcs_heat.nil?
           data_to_add.concat(@page_view_visits.values) unless @page_view_visits.nil?
           data_to_add.concat(@experiments.values) unless @experiments.nil?
           data_to_add.concat(conversions_single_objects)
@@ -95,7 +99,7 @@ module Kameleoon
             page_view_visit = @page_view_visits[href]
             if page_view_visit.nil?
               page_view = PageView.new(href, page_event['data']['title'])
-              @page_view_visits[href] = Kameleoon::DataManager::PageViewVisit.new(page_view, 1, page_event['time'])
+              @page_view_visits[href] = DataManager::PageViewVisit.new(page_view, 1, page_event['time'])
             else
               page_view_visit.increase_page_visits
             end
@@ -108,7 +112,10 @@ module Kameleoon
             id = experiment_event['data']['id']
             variation = @experiments[id]
             if variation.nil?
-              variation = Kameleoon::DataManager::AssignedVariation.new(id, experiment_event['data']['variationId'], Kameleoon::Configuration::RuleType::UNKNOWN, assignment_time: experiment_event['time'])
+              variation = DataManager::AssignedVariation.new(
+                id, experiment_event['data']['variationId'],
+                Configuration::RuleType::UNKNOWN, assignment_time: experiment_event['time']
+              )
               @experiments[id] = variation
             end
           end
@@ -130,33 +137,52 @@ module Kameleoon
 
         def parse_static_data(static_data_event)
           return if @device != nil && @browser != nil && @operating_system != nil
+
           data = static_data_event['data']
-          if @device == nil
+          if @device.nil?
             device_type = data['deviceType']
-            @device = Device.new(device_type) if device_type != nil
+            @device = Device.new(device_type) unless device_type.nil?
           end
-          if @browser == nil
-            browser_type = Kameleoon::BrowserType.from_name(data['browser'])
-            @browser = Browser.new(browser_type, data['browserVersion']) if browser_type != nil
+          if @browser.nil?
+            browser_type = BrowserType.from_name(data['browser'])
+            @browser = Browser.new(browser_type, data['browserVersion']) unless browser_type.nil?
           end
-          if @operating_system == nil
-            operating_system_type = Kameleoon::OperatingSystemType.from_name(data['os'])
-            @operating_system = OperatingSystem.new(operating_system_type) if operating_system_type != nil
+          if @operating_system.nil?
+            operating_system_type = OperatingSystemType.from_name(data['os'])
+            @operating_system = OperatingSystem.new(operating_system_type) unless operating_system_type.nil?
           end
         end
 
         def conversions_single_objects
           objects = []
-          unless @conversions.nil?
-            objects += @conversions
-          end
+          objects += @conversions unless @conversions.nil?
           objects.push(@device) unless @device.nil?
           objects.push(@browser) unless @browser.nil?
           objects.push(@operating_system) unless @operating_system.nil?
           objects.push(@geolocation) unless @geolocation.nil?
           objects
         end
+
+        def parse_kcs_heat(kcs)
+          return nil if kcs.nil?
+
+          value_map = {}
+          kcs.each do |str_key_moment_id, goal_scores|
+            next unless str_key_moment_id.is_a?(String) && goal_scores.is_a?(Hash)
+
+            goal_score_map = {}
+            goal_scores.each do |str_goal_id, score|
+              next unless str_goal_id.is_a?(String) && (score.is_a?(Float) || score.is_a?(Integer))
+
+              goal_id = str_goal_id.to_i
+              goal_score_map[goal_id] = score
+            end
+            key_moment_id = str_key_moment_id.to_i
+            value_map[key_moment_id] = goal_score_map
+          end
+          KcsHeat.new(value_map)
+        end
       end
     end
   end
-end
+end