kameleoon-client-ruby 3.3.0 → 3.5.0

data/lib/kameleoon/kameleoon_client.rb

@@ -1,26 +1,31 @@
 # frozen_string_literal: true
 
 require 'kameleoon/client_readiness'
-require 'kameleoon/targeting/models'
-require 'kameleoon/targeting/targeting_manager'
-require 'kameleoon/exceptions'
+require 'kameleoon/configuration/feature_flag'
+require 'kameleoon/configuration/variation'
+require 'kameleoon/configuration/data_file'
 require 'kameleoon/data/custom_data'
 require 'kameleoon/data/user_agent'
 require 'kameleoon/data/manager/assigned_variation'
 require 'kameleoon/data/manager/visitor_manager'
-require 'kameleoon/configuration/feature_flag'
-require 'kameleoon/configuration/variation'
-require 'kameleoon/configuration/data_file'
+require 'kameleoon/exceptions'
+require 'kameleoon/hybrid/manager'
+require 'kameleoon/managers/data/data_manager'
+require 'kameleoon/managers/remote_data/remote_data_manager'
+require 'kameleoon/managers/tracking/tracking_manager'
+require 'kameleoon/managers/tracking/visitor_tracking_registry'
+require 'kameleoon/managers/warehouse/warehouse_manager'
 require 'kameleoon/network/access_token_source'
 require 'kameleoon/network/activity_event'
 require 'kameleoon/network/network_manager'
 require 'kameleoon/network/url_provider'
 require 'kameleoon/network/cookie/cookie_manager'
-require 'kameleoon/managers/warehouse/warehouse_manager'
 require 'kameleoon/real_time/real_time_configuration_service'
-require 'kameleoon/hybrid/manager'
 require 'kameleoon/storage/cache_factory'
-require 'kameleoon/managers/remote_data/remote_data_manager'
+require 'kameleoon/targeting/models'
+require 'kameleoon/targeting/targeting_manager'
+require 'kameleoon/types/variable'
+require 'kameleoon/types/variation'
 require 'rufus/scheduler'
 require 'yaml'
 require 'json'
@@ -43,32 +48,50 @@ module Kameleoon
     def initialize(site_code, config)
       raise Exception::SiteCodeIsEmpty, 'Provided site_sode is empty' if site_code&.empty? != false
 
+      Logging::KameleoonLogger.info("CALL: KameleoonClient.new(site_code: '%s', config: %s)",
+                                    site_code, config)
+      @scheduler = Rufus::Scheduler.new
       @site_code = site_code
       @config = config
       @real_time_configuration_service = nil
       @update_configuration_handler = nil
       @fetch_configuration_update_job = nil
-      @data_file = Configuration::DataFile.new(config.environment, method(:log))
-      @visitor_manager = Kameleoon::DataManager::VisitorManager.new(config.session_duration_second, method(:log))
-      @hybrid_manager = Kameleoon::Hybrid::ManagerImpl.new(HYBRID_EXPIRATION_TIME, method(:log))
+      data_file = Configuration::DataFile.new(config.environment, nil)
+      @data_manager = Managers::Data::DataManager.new(data_file)
+      @visitor_manager = Kameleoon::DataManager::VisitorManager.new(
+        @data_manager, config.session_duration_second, @scheduler
+      )
+      @hybrid_manager = Hybrid::ManagerImpl.new(HYBRID_EXPIRATION_TIME, @data_manager)
       @network_manager = Network::NetworkManager.new(
         config.environment,
         config.default_timeout_millisecond,
-        Network::AccessTokenSourceFactory.new(config.client_id, config.client_secret, method(:log)),
-        Network::UrlProvider.new(site_code),
-        method(:log)
-      )
-      @warehouse_manager = Managers::Warehouse::WarehouseManager.new(@network_manager, @visitor_manager, method(:log))
-      @remote_data_manager = Kameleoon::Managers::RemoteData::RemoteDataManager.new(@network_manager, @visitor_manager,
-                                                                                    method(:log))
-      @cookie_manager = Network::Cookie::CookieManager.new(config.top_level_domain)
+        Network::AccessTokenSourceFactory.new(config.client_id, config.client_secret),
+        Network::UrlProvider.new(site_code)
+      )
+      @tracking_manager = Managers::Tracking::TrackingManager.new(
+        @data_manager, @network_manager, @visitor_manager, config.tracking_interval_second, @scheduler
+      )
+      @warehouse_manager = Managers::Warehouse::WarehouseManager.new(@network_manager, @visitor_manager)
+      @remote_data_manager = Managers::RemoteData::RemoteDataManager.new(
+        @data_manager, @network_manager, @visitor_manager
+      )
+      @cookie_manager = Network::Cookie::CookieManager.new(@data_manager, config.top_level_domain)
       @readiness = ClientReadiness.new
-      @targeting_manager = Kameleoon::Targeting::TargetingManager.new(@visitor_manager, @data_file)
-      @visitor_manager.custom_data_info = @data_file.custom_data_info
+      @targeting_manager = Targeting::TargetingManager.new(@data_manager, @visitor_manager)
+
+      if @config.verbose_mode == true && Logging::KameleoonLogger.log_level == Logging::LogLevel::WARNING
+        Logging::KameleoonLogger.log_level = Logging::LogLevel::INFO
+      end
+
+      Logging::KameleoonLogger.info("RETURN: KameleoonClient.new(site_code: '%s', config: %s)",
+                                    site_code, config)
     end
 
     def wait_init
-      @readiness.wait
+      Logging::KameleoonLogger.info('CALL: KameleoonClient.wait_init')
+      result = @readiness.wait
+      Logging::KameleoonLogger.info('RETURN: KameleoonClient.wait_init -> (result: %s)', result)
+      result
     end
 
     ##
@@ -98,14 +121,29 @@ module Kameleoon
     # visitor_code = get_visitor_code(cookies, 'my-domaine.com')
     #
     def get_visitor_code(cookies, default_visitor_code = nil)
-      @cookie_manager.get_or_add(cookies, default_visitor_code)
+      Logging::KameleoonLogger.info("CALL: KameleoonClient.get_visitor_code(cookies: %s, default_visitor_code: '%s')",
+                           cookies, default_visitor_code)
+      visitor_code = @cookie_manager.get_or_add(cookies, default_visitor_code)
+      Logging::KameleoonLogger.info(
+        "RETURN: KameleoonClient.get_visitor_code(cookies: %s, default_visitor_code: '%s') -> (visitor_code: '%s')",
+        cookies, default_visitor_code, visitor_code
+      )
+      visitor_code
     end
 
     def set_legal_consent(visitor_code, consent, cookies = nil)
+      Logging::KameleoonLogger.info(
+        "CALL: KameleoonClient.set_legal_consent(visitor_code: '%s', consent: %s, cookies: %s)",
+        visitor_code, consent, cookies
+      )
       Utils::VisitorCode.validate(visitor_code)
       visitor = @visitor_manager.get_or_create_visitor(visitor_code)
       visitor.legal_consent = consent
       @cookie_manager.update(visitor_code, consent, cookies)
+      Logging::KameleoonLogger.info(
+        "RETURN: KameleoonClient.set_legal_consent(visitor_code: '%s', consent: %s, cookies: %s)",
+        visitor_code, consent, cookies
+      )
     end
 
     ##
@@ -122,8 +160,14 @@ module Kameleoon
     # @raise [Kameleoon::Exception::VisitorCodeInvalid] If the visitor code is empty or longer than 255 chars
     #
     def add_data(visitor_code, *args)
+      Logging::KameleoonLogger.info("CALL: KameleoonClient.add_data(visitor_code: '%s', args: %s)",
+                                    visitor_code, args)
       Utils::VisitorCode.validate(visitor_code)
       @visitor_manager.add_data(visitor_code, *args)
+      Logging::KameleoonLogger.info(
+        "RETURN: KameleoonClient.add_data(visitor_code: '%s', args: %s)",
+        visitor_code, args
+      )
     end
 
     ##
@@ -138,15 +182,24 @@ module Kameleoon
     # @param [String] visitor_code Visitor code
     # @param [Integer] goal_id Id of the goal
     # @param [Float] revenue Optional - Revenue of the conversion.
-    # @param [Bool] is_unique_identifier Parameter that specifies whether the visitorCode is a unique identifier.
-    # This field is optional.
+    # @param [Bool] is_unique_identifier(DEPRECATED) Parameter that specifies whether the visitorCode is a unique
+    # identifier. This field is optional.
     #
     # @raise [Kameleoon::Exception::VisitorCodeInvalid] If the visitor code is empty or longer than 255 chars
     #
-    def track_conversion(visitor_code, goal_id, revenue = 0.0, is_unique_identifier: false)
+    def track_conversion(visitor_code, goal_id, revenue = 0.0, is_unique_identifier: nil)
+      Logging::KameleoonLogger.info(
+        "CALL: KameleoonClient.track_conversion(visitor_code: '%s', goal_id: %s, revenue: %s, is_unique_identifier: %s)",
+        visitor_code, goal_id, revenue, is_unique_identifier
+      )
       Utils::VisitorCode.validate(visitor_code)
+      set_unique_identifier(visitor_code, is_unique_identifier) unless is_unique_identifier.nil?
       add_data(visitor_code, Conversion.new(goal_id, revenue))
-      flush(visitor_code, is_unique_identifier: is_unique_identifier)
+      @tracking_manager.add_visitor_code(visitor_code)
+      Logging::KameleoonLogger.info(
+        "RETURN: KameleoonClient.track_conversion(visitor_code: '%s', goal_id: %s, revenue: %s, is_unique_identifier: %s)",
+        visitor_code, goal_id, revenue, is_unique_identifier
+      )
     end
 
     ##
@@ -157,20 +210,44 @@ module Kameleoon
     # With this method you can manually send it.
     #
     # @param [String] visitor_code Optional field - Visitor code, without visitor code it flush all of the data
-    # @param [Bool] is_unique_identifier Parameter that specifies whether the visitorCode is a unique identifier.
-    # This field is optional.
-    #
-    # @raise [Kameleoon::Exception::VisitorCodeInvalid] If the visitor code is not nil and is empty or longer than 255 chars
-    #
-    def flush(visitor_code = nil, is_unique_identifier: false)
-      Utils::VisitorCode.validate(visitor_code) unless visitor_code.nil?
+    # @param [Bool] instant A boolean flag indicating whether the data should be sent instantly (`true`) or
+    # according to the scheduled tracking interval (`false`).
+    # @param [Bool] is_unique_identifier(DEPRECATED) Parameter that specifies whether the visitorCode is a unique
+    # identifier. This field is optional.
+    #
+    # @raise [Kameleoon::Exception::VisitorCodeInvalid] If the visitor code is not nil and is empty or
+    # longer than 255 chars
+    #
+    def flush(visitor_code = nil, instant: false, is_unique_identifier: nil)
+      Logging::KameleoonLogger.info(
+        "CALL: KameleoonClient.flush(visitor_code: '%s', instant: %s, is_unique_identifier: %s)",
+                                    visitor_code, instant, is_unique_identifier
+      )
       if visitor_code.nil?
         @visitor_manager.enumerate do |visitor_code, visitor|
-          _send_tracking_request(visitor_code, visitor, false, is_unique_identifier)
+          has_unsent_data = false
+          visitor.enumerate_sendable_data do |data|
+            if data.unsent
+              has_unsent_data = true
+              next false
+            end
+            next true
+          end
+          @tracking_manager.add_visitor_code(visitor_code) if has_unsent_data
         end
       else
-        _send_tracking_request(visitor_code, nil, true, is_unique_identifier)
+        Utils::VisitorCode.validate(visitor_code)
+        set_unique_identifier(visitor_code, is_unique_identifier) unless is_unique_identifier.nil?
+        if instant
+          @tracking_manager.track_visitor(visitor_code)
+        else
+          @tracking_manager.add_visitor_code(visitor_code)
+        end
       end
+      Logging::KameleoonLogger.info(
+        "RETURN: KameleoonClient.flush(visitor_code: '%s', instant: %s, is_unique_identifier: %s)",
+        visitor_code, instant, is_unique_identifier
+      )
     end
 
     ##
@@ -186,20 +263,117 @@ module Kameleoon
     #
     # @param [String] visitor_code Unique identifier of the user. This field is mandatory.
     # @param [String] feature_key Key of the feature flag you want to expose to a user. This field is mandatory.
-    # @param [Bool] is_unique_identifier Parameter that specifies whether the visitorCode is a unique identifier.
-    # This field is optional.
+    # @param [Bool] is_unique_identifier(DEPRECATED) Parameter that specifies whether the visitorCode is a unique
+    # identifier. This field is optional.
+    # @param [Bool] track Optional flag indicating whether tracking of the feature evaluation is enabled
+    # (`true`) or disabled (`false`); the default value is `true`.
+    #
+    # @return [Bool] If the user has not been associated with your feature flag before, the SDK returns
+    # a random boolean value (`true` if the user should have this feature or `false` if not).
     #
     # @raise [Kameleoon::Exception::FeatureNotFound] Feature Flag isn't found in this configuration
     # @raise [Kameleoon::Exception::VisitorCodeInvalid] If the visitor code is empty or longer than 255 chars
     #
-    def feature_active?(visitor_code, feature_key, is_unique_identifier: false)
-      _, variation_key = _get_feature_variation_key(visitor_code, feature_key, is_unique_identifier)
-      variation_key != Kameleoon::Configuration::VariationType::VARIATION_OFF
+    def feature_active?(visitor_code, feature_key, is_unique_identifier: nil, track: true)
+      Logging::KameleoonLogger.info(
+        "CALL: KameleoonClient.feature_active?(visitor_code: '%s', feature_key: '%s', " \
+        'is_unique_identifier: %s, track: %s)',
+        visitor_code, feature_key, is_unique_identifier, track
+      )
+      Utils::VisitorCode.validate(visitor_code)
+      set_unique_identifier(visitor_code, is_unique_identifier) unless is_unique_identifier.nil?
+      feature_flag = @data_manager.data_file.get_feature_flag(feature_key)
+      variation_key, = get_variation_info(visitor_code, feature_flag, track)
+      feature_active = variation_key != Kameleoon::Configuration::VariationType::VARIATION_OFF
+      @tracking_manager.add_visitor_code(visitor_code) if track
+      Logging::KameleoonLogger.info(
+        "RETURN: KameleoonClient.feature_active?(visitor_code: '%s', feature_key: '%s', " \
+        'is_unique_identifier: %s, track: %s) -> (feature_active: %s)',
+        visitor_code, feature_key, is_unique_identifier, track, feature_active
+      )
+      feature_active
     rescue Exception::FeatureEnvironmentDisabled
+      Logging::KameleoonLogger.debug('Feature environment disabled')
       false
     end
 
+    ##
+    # Retrieves the variation assigned to the given visitor for a specific feature flag.
+    #
+    # @param [String] visitor_code The unique identifier of the visitor.
+    # @param [String] feature_key The unique identifier of the feature flag.
+    # @param [Bool] track Optional flag indicating whether tracking of the feature evaluation is enabled
+    # (`true`) or disabled (`false`); the default value is `true`.
+    #
+    # @return [Kameleoon::Types::Variation] The variation assigned to the visitor if the visitor is associated with some
+    # rule of the feature flag, otherwise the method returns the default variation of the feature flag.
+    #
+    # @raise [Kameleoon::Exception::VisitorCodeInvalid] If the visitor code is empty or longer than 255 chars.
+    # @raise [Kameleoon::Exception::FeatureNotFound] Feature Flag isn't found in this configuration.
+    # @raise [Kameleoon::Exception::FeatureEnvironmentDisabled] If the requested feature flag is disabled for
+    # the current environment.
+    def get_variation(visitor_code, feature_key, track: true)
+      Logging::KameleoonLogger.info(
+        "CALL: KameleoonClient.get_variation(visitor_code: '%s', feature_key: '%s', track: %s)",
+        visitor_code, feature_key, track
+      )
+      Utils::VisitorCode.validate(visitor_code)
+      feature_flag = @data_manager.data_file.get_feature_flag(feature_key)
+      variation_key, var_by_exp, rule = get_variation_info(visitor_code, feature_flag, track)
+      variation = feature_flag.get_variation_by_key(variation_key)
+      external_variation = make_external_variation(variation, var_by_exp&.variation_id, rule&.experiment_id)
+      @tracking_manager.add_visitor_code(visitor_code) if track
+      Logging::KameleoonLogger.info(
+        "RETURN: KameleoonClient.get_variation(visitor_code: '%s', feature_key: '%s', track: %s)" \
+        ' -> (variation: %s)',
+        visitor_code, feature_key, track, external_variation
+      )
+      external_variation
+    end
+
+    ##
+    # Forms a dictionary of variations assigned to a given visitor across all feature flags.
+    # This method iterates over all available feature flags and returns the assigned variation for each flag
+    # associated with the specified visitor.
     #
+    # @param [String] visitor_code The unique identifier of the visitor.
+    # @param [Bool] only_active Optional flag indicating whether to return only variations for active feature
+    # flags (`true`) or for any feature flags (`false`); the default value is `false`.
+    # @param [Bool] track Optional flag indicating whether tracking of the feature evaluation is enabled
+    # (`true`) or disabled (`false`); the default value is `true`.
+    #
+    # @return [Hash] A hash consisting of feature flag keys as keys (`String`) and their corresponding
+    # variations (or the default variation of that feature flag) as values (`Kameleoon::Types::Variation`).
+    #
+    # @raise [Kameleoon::Exception::VisitorCodeInvalid] If the visitor code is empty or longer than 255 chars.
+    def get_variations(visitor_code, only_active: false, track: true)
+      Logging::KameleoonLogger.info(
+        "CALL: KameleoonClient.get_variations(visitor_code: '%s', only_active: %s, track: %s)",
+        visitor_code, only_active, track
+      )
+      Utils::VisitorCode.validate(visitor_code)
+      variations = {}
+      @data_manager.data_file.feature_flags.each_value do |feature_flag|
+        next unless feature_flag.environment_enabled
+
+        variation_key, var_by_exp, rule = get_variation_info(visitor_code, feature_flag, track)
+        next if only_active && (variation_key == Configuration::VariationType::VARIATION_OFF)
+
+        variation = feature_flag.get_variation_by_key(variation_key)
+        variations[feature_flag.feature_key] =
+          make_external_variation(variation, var_by_exp&.variation_id, rule&.experiment_id)
+      end
+      variations.freeze
+      @tracking_manager.add_visitor_code(visitor_code) if track
+      Logging::KameleoonLogger.info(
+        "RETURN: KameleoonClient.get_variations(visitor_code: '%s', only_active: %s, track: %s)" \
+        ' -> (variations: %s)',
+        visitor_code, only_active, track, variations
+      )
+      variations
+    end
+
+    ##
     # get_feature_variation_key returns a variation key for visitor code
     #
     # This method takes a visitorCode and featureKey as mandatory arguments and
@@ -210,16 +384,33 @@ module Kameleoon
     #
     # @param [String] visitor_code
     # @param [String] feature_key
-    # @param [Bool] is_unique_identifier Parameter that specifies whether the visitorCode is a unique identifier.
-    # This field is optional.
+    # @param [Bool] is_unique_identifier(DEPRECATED) Parameter that specifies whether the visitorCode is a unique
+    # identifier. This field is optional.
     #
     # @raise [Kameleoon::Exception::FeatureNotFound] Feature Flag isn't found in this configuration
     # @raise [Kameleoon::Exception::VisitorCodeInvalid] If the visitor code is empty or longer than 255 chars
     # @raise [Kameleoon::Exception::FeatureEnvironmentDisabled] If the requested feature flag is disabled for
     # the current environment
     #
-    def get_feature_variation_key(visitor_code, feature_key, is_unique_identifier: false)
-      _, variation_key = _get_feature_variation_key(visitor_code, feature_key, is_unique_identifier)
+    # DEPRECATED. Please use `get_variation(visitor_code, feature_key, track: true)` instead.
+    def get_feature_variation_key(visitor_code, feature_key, is_unique_identifier: nil)
+      Logging::KameleoonLogger.info(
+        '[DEPRECATION] `get_feature_variation_key` is deprecated. ' \
+        'Please use `get_variation(visitor_code, feature_key, track: true)` instead.'
+      )
+      Logging::KameleoonLogger.info(
+        "CALL: KameleoonClient.get_feature_variation_key(visitor_code: '%s', feature_key: '%s', " \
+          'is_unique_identifier: %s)',
+        visitor_code, feature_key, is_unique_identifier
+      )
+      Utils::VisitorCode.validate(visitor_code)
+      set_unique_identifier(visitor_code, is_unique_identifier) unless is_unique_identifier.nil?
+      _, variation_key = _get_feature_variation_key(visitor_code, feature_key)
+      Logging::KameleoonLogger.info(
+        "RETURN: KameleoonClient.get_feature_variation_key(visitor_code: '%s', feature_key: '%s', " \
+          "is_unique_identifier: %s) -> (variation_key: '%s')",
+        visitor_code, feature_key, is_unique_identifier, variation_key
+      )
       variation_key
     end
 
@@ -231,8 +422,8 @@ module Kameleoon
     # @param [String] visitor_code
     # @param [String] feature_key
     # @param [String] variable_name
-    # @param [Bool] is_unique_identifier Parameter that specifies whether the visitorCode is a unique identifier.
-    # This field is optional.
+    # @param [Bool] is_unique_identifier(DEPRECATED) Parameter that specifies whether the visitorCode is a unique
+    # identifier. This field is optional.
     #
     # @raise [Kameleoon::Exception::FeatureNotFound] Feature Flag isn't found in this configuration
     # @raise [Kameleoon::Exception::FeatureVariableNotFound]
@@ -240,15 +431,32 @@ module Kameleoon
     # @raise [Kameleoon::Exception::FeatureEnvironmentDisabled] If the requested feature flag is disabled for
     # the current environment
     #
-    def get_feature_variable(visitor_code, feature_key, variable_name, is_unique_identifier: false)
-      feature_flag, variation_key = _get_feature_variation_key(visitor_code, feature_key, is_unique_identifier)
-      variation = feature_flag.get_variation_key(variation_key)
+    # DEPRECATED. Please use `get_variation(visitor_code, feature_key, track: true)` instead.
+    def get_feature_variable(visitor_code, feature_key, variable_name, is_unique_identifier: nil)
+      Logging::KameleoonLogger.info(
+        '[DEPRECATION] `get_feature_variable` is deprecated. ' \
+        'Please use `get_variation(visitor_code, feature_key, track: true)` instead.'
+      )
+      Logging::KameleoonLogger.info(
+        "CALL: KameleoonClient.get_feature_variable(visitor_code: '%s', feature_key: '%s', variable_name: '%s', " \
+          'is_unique_identifier: %s)', visitor_code, feature_key, variable_name, is_unique_identifier
+      )
+      Utils::VisitorCode.validate(visitor_code)
+      set_unique_identifier(visitor_code, is_unique_identifier) unless is_unique_identifier.nil?
+      feature_flag, variation_key = _get_feature_variation_key(visitor_code, feature_key)
+      variation = feature_flag.get_variation_by_key(variation_key)
       variable = variation&.get_variable_by_key(variable_name)
       if variable.nil?
         raise Exception::FeatureVariableNotFound.new(variable_name),
               "Feature variable #{variable_name} not found"
       end
-      _parse_feature_variable(variable)
+      value = _parse_feature_variable(variable)
+      Logging::KameleoonLogger.info(
+        "RETURN: KameleoonClient.get_feature_variable(visitor_code: '%s', feature_key: '%s', variable_name: '%s', " \
+          'is_unique_identifier: %s) -> (variable: %s)',
+        visitor_code, feature_key, variable_name, is_unique_identifier, value
+      )
+      value
     end
 
     ##
@@ -265,15 +473,28 @@ module Kameleoon
     # @raise [Kameleoon::Exception::FeatureVariationNotFound]
     # @raise [Kameleoon::Exception::FeatureEnvironmentDisabled]
     #
+    # DEPRECATED. Please use `get_variation(visitor_code, feature_key, track: false)` instead.
     def get_feature_variation_variables(feature_key, variation_key)
-      feature_flag = @data_file.get_feature_flag(feature_key)
-      variation = feature_flag.get_variation_key(variation_key)
+      Logging::KameleoonLogger.info(
+        '[DEPRECATION] `get_feature_variation_variables` is deprecated. ' \
+        'Please use `get_variation(visitor_code, feature_key, track: false)` instead.'
+      )
+      Logging::KameleoonLogger.info(
+        "CALL: KameleoonClient.get_feature_variation_variables(feature_key: '%s', variation_key: '%s')",
+        feature_key, variation_key
+      )
+      feature_flag = @data_manager.data_file.get_feature_flag(feature_key)
+      variation = feature_flag.get_variation_by_key(variation_key)
       if variation.nil?
         raise Exception::FeatureVariationNotFound.new(variation_key),
               "Variation key #{variation_key} not found"
       end
       variables = {}
       variation.variables.each { |var| variables[var.key] = _parse_feature_variable(var) }
+      Logging::KameleoonLogger.info(
+        "RETURN: KameleoonClient.get_feature_variation_variables(feature_key: '%s', variation_key: '%s') " \
+          '-> (variables: %s)', feature_key, variation_key, variables
+      )
       variables
     end
 
@@ -290,7 +511,14 @@ module Kameleoon
     #
     # @return [Hash] Hash object of the json object.
     def get_remote_data(key, timeout = @default_timeout)
-      @remote_data_manager.get_data(key, timeout)
+      Logging::KameleoonLogger.info("CALL: KameleoonClient.get_remote_data(key: '%s', timeout: %s)",
+                                    key, timeout)
+      remote_data = @remote_data_manager.get_data(key, timeout)
+      Logging::KameleoonLogger.info(
+        "RETURN: KameleoonClient.get_remote_data(key: '%s', timeout: %s) -> (remote_data: %s)",
+        key, timeout, remote_data
+      )
+      remote_data
     end
 
     ##
@@ -304,12 +532,24 @@ module Kameleoon
     # for a visitor. If not specified, the default value is `True`. This field is optional.
     # @param [Integer] timeout Timeout for request (in milliseconds). Equals default_timeout in a config file.
     # This field is optional.
-    # @param [Bool] is_unique_identifier Parameter that specifies whether the visitorCode is a unique identifier.
-    # This field is optional.
+    # @param [Bool] is_unique_identifier(DEPRECATED) Parameter that specifies whether the visitorCode is a unique
+    # identifier. This field is optional.
     #
     # @return [Array] An array of data assigned to the given visitor.
-    def get_remote_visitor_data(visitor_code, timeout = nil, add_data: true, filter: nil, is_unique_identifier: false)
-      @remote_data_manager.get_visitor_data(visitor_code, add_data, filter, is_unique_identifier, timeout)
+    #
+    def get_remote_visitor_data(visitor_code, timeout = nil, add_data: true, filter: nil, is_unique_identifier: nil)
+      Logging::KameleoonLogger.info(
+        "CALL: KameleoonClient.get_remote_visitor_data(visitor_code: '%s', timeout: %s, add_data: %s, " \
+          'filter: %s, is_unique_identifier: %s)', visitor_code, timeout, add_data, filter, is_unique_identifier
+      )
+      set_unique_identifier(visitor_code, is_unique_identifier) unless is_unique_identifier.nil?
+      visitor_data = @remote_data_manager.get_visitor_data(visitor_code, add_data, filter, timeout)
+      Logging::KameleoonLogger.info(
+        "RETURN: KameleoonClient.get_remote_visitor_data(visitor_code: '%s', timeout: %s, add_data: %s, " \
+          'filter: %s, is_unique_identifier: %s) -> (visitor_data: %s)',
+        visitor_code, timeout, add_data, filter, is_unique_identifier, visitor_data
+      )
+      visitor_data
     end
 
     ##
@@ -336,7 +576,18 @@ module Kameleoon
     #
     # @return [Kameleoon::CustomData] A `CustomData` instance confirming that the data has been added to the visitor.
     def get_visitor_warehouse_audience(visitor_code, custom_data_index, timeout = nil, warehouse_key: nil)
-      @warehouse_manager.get_visitor_warehouse_audience(visitor_code, custom_data_index, warehouse_key, timeout)
+      Logging::KameleoonLogger.info(
+        "CALL: KameleoonClient.get_visitor_warehouse_audience(visitor_code: '%s', custom_data_index: %s, " \
+          "timeout: %s, warehouse_key: '%s')", visitor_code, custom_data_index, timeout, warehouse_key
+      )
+      warehouse_audience = @warehouse_manager.get_visitor_warehouse_audience(visitor_code,
+                                                                             custom_data_index, warehouse_key, timeout)
+      Logging::KameleoonLogger.info(
+        "RETURN: KameleoonClient.get_visitor_warehouse_audience(visitor_code: '%s', custom_data_index: %s, " \
+          "timeout: %s, warehouse_key: '%s') -> (warehouse_audience: %s)",
+        visitor_code, custom_data_index, timeout, warehouse_key, warehouse_audience
+      )
+      warehouse_audience
     end
 
     ##
@@ -344,7 +595,10 @@ module Kameleoon
     #
     # @return [Array] array of all feature flag keys
     def get_feature_list # rubocop:disable Naming/AccessorMethodName
-      @data_file.feature_flags.keys
+      Logging::KameleoonLogger.info('CALL: KameleoonClient.get_feature_list')
+      features = @data_manager.data_file.feature_flags.keys
+      Logging::KameleoonLogger.info('RETURN: KameleoonClient.get_feature_list -> (features: %s)', features)
+      features
     end
 
     ##
@@ -356,16 +610,23 @@ module Kameleoon
     #
     # DEPRECATED. Please use `get_active_features` instead.
     def get_active_feature_list_for_visitor(visitor_code)
-      warn '[DEPRECATION] `get_active_feature_list_for_visitor` is deprecated.  Please use `get_active_features` instead.'
+      Logging::KameleoonLogger.info('[DEPRECATION] `get_active_feature_list_for_visitor` is deprecated.' \
+                                         ' Please use `get_active_features` instead.')
+      Logging::KameleoonLogger.info("CALL: KameleoonClient.get_active_feature_list_for_visitor(visitor_code: '%s')",
+                                    visitor_code)
       Utils::VisitorCode.validate(visitor_code)
       list_keys = []
-      @data_file.feature_flags.each do |feature_key, feature_flag|
+      @data_manager.data_file.feature_flags.each do |feature_key, feature_flag|
         next unless feature_flag.environment_enabled
 
         variation, rule, = _calculate_variation_key_for_feature(visitor_code, feature_flag)
         variation_key = _get_variation_key(variation, rule, feature_flag)
         list_keys.push(feature_key) if variation_key != Kameleoon::Configuration::VariationType::VARIATION_OFF
       end
+      Logging::KameleoonLogger.info(
+        "RETURN: KameleoonClient.get_active_feature_list_for_visitor(visitor_code: '%s') -> (features: %s)",
+        visitor_code, list_keys
+      )
       list_keys
     end
 
@@ -378,11 +639,18 @@ module Kameleoon
     # @raise [Kameleoon::Exception::VisitorCodeInvalid] If the visitor code is empty or longer than 255 chars or is nil
     #
     # @return [Hash] Hash of active features for a visitor
+    #
+    # DEPRECATED. Please use `get_variations(visitor_code, only_active: true, track: false)` instead.
     def get_active_features(visitor_code)
+      Logging::KameleoonLogger.info(
+        '[DEPRECATION] `get_active_features` is deprecated. ' \
+        'Please use `get_variations(visitor_code, only_active: true, track: false)` instead.'
+      )
+      Logging::KameleoonLogger.info("CALL: KameleoonClient.get_active_features(visitor_code: '%s')", visitor_code)
       Utils::VisitorCode.validate(visitor_code)
       map_active_features = {}
 
-      @data_file.feature_flags.each_value do |feature_flag|
+      @data_manager.data_file.feature_flags.each_value do |feature_flag|
         next unless feature_flag.environment_enabled
 
         var_by_exp, rule = _calculate_variation_key_for_feature(visitor_code, feature_flag)
@@ -390,27 +658,15 @@ module Kameleoon
 
         next if variation_key == Configuration::VariationType::VARIATION_OFF
 
-        variation = feature_flag.get_variation_key(variation_key)
-        variables = {}
-
-        variation&.variables&.each do |variable|
-          variables[variable.key] = Kameleoon::Types::Variable.new(
-            variable.key,
-            variable.type,
-            _parse_feature_variable(variable)
-          )
-        end
-
-        variables.freeze
-        map_active_features[feature_flag.feature_key] = Kameleoon::Types::Variation.new(
-          variation_key,
-          var_by_exp ? var_by_exp.variation_id : nil,
-          rule ? rule.experiment_id : nil,
-          variables
-        )
+        variation = feature_flag.get_variation_by_key(variation_key)
+        map_active_features[feature_flag.feature_key] =
+          make_external_variation(variation, var_by_exp&.variation_id, rule&.experiment_id)
       end
 
       map_active_features.freeze
+      Logging::KameleoonLogger.info("RETURN: KameleoonClient.get_active_features(visitor_code: '%s') -> (features: %s)",
+                                    visitor_code, map_active_features)
+      map_active_features
     end
 
     ##
@@ -421,6 +677,7 @@ module Kameleoon
     # @param handler [Callable | NilClass] The handler that will be called when the configuration
     # is updated using a real-time configuration event.
     def on_update_configuration(handler)
+      Logging::KameleoonLogger.info('CALL/RETURN: KameleoonClient.on_update_configuration(handler)')
       @update_configuration_handler = handler
     end
 
@@ -433,8 +690,14 @@ module Kameleoon
     # @return [String] JavasScript code to be inserted in your page to send automatically
     # the exposure events to the analytics solution you are using.
     def get_engine_tracking_code(visitor_code)
+      Logging::KameleoonLogger.info("CALL: KameleoonClient.get_engine_tracking_code(visitor_code: '%s')", visitor_code)
       visitor_variations = @visitor_manager.get_visitor(visitor_code)&.variations
-      @hybrid_manager.get_engine_tracking_code(visitor_variations)
+      engine_tracking_code = @hybrid_manager.get_engine_tracking_code(visitor_variations)
+      Logging::KameleoonLogger.info(
+        "RETURN: KameleoonClient.get_engine_tracking_code(visitor_code: '%s') -> (engine_tracking_code: '%s')",
+        visitor_code, engine_tracking_code
+      )
+      engine_tracking_code
     end
 
     private
@@ -442,17 +705,17 @@ module Kameleoon
     HYBRID_EXPIRATION_TIME = 5
 
     def fetch_configuration_initially
-      log('Initial configuration fetch is started.')
+      Logging::KameleoonLogger.info('Initial configuration fetch is started.')
       Thread.new do
         ok = false
         begin
           ok = obtain_configuration
-          log('Initial configuration fetch failed') unless ok
+          Logging::KameleoonLogger.error('Initial configuration fetch failed') unless ok
         rescue StandardError => e
-          log("Initial configuration fetch failed: #{e}")
+          Logging::KameleoonLogger.error('Initial configuration fetch failed: %s', e)
         end
         @readiness.set(ok)
-        manage_configuration_update(@data_file.settings.real_time_update) if ok
+        manage_configuration_update(@data_manager.data_file.settings.real_time_update) if ok
       end
     end
 
@@ -462,21 +725,23 @@ module Kameleoon
         begin
           ok = obtain_configuration(time_stamp)
         rescue StandardError => e
-          log("Error occurred during configuration fetching: #{e}")
+          Logging::KameleoonLogger.error('Error occurred during configuration fetching: %s', e)
         end
-        if !ok && @data_file.settings.real_time_update
-          @data_file.settings.real_time_update = false
-          log('Switching to polling mode due to failed fetch')
+        real_time_update = @data_manager.data_file.settings.real_time_update
+        if !ok && real_time_update
+          @data_manager.data_file.settings.real_time_update = false
+          real_time_update = false
+          Logging::KameleoonLogger.warning('Switching to polling mode due to failed fetch')
         end
-        manage_configuration_update(@data_file.settings.real_time_update)
+        manage_configuration_update(real_time_update)
       end
     end
 
     def start_configuration_update_job_if_needed
       return unless @fetch_configuration_update_job.nil?
 
-      @fetch_configuration_update_job = Rufus::Scheduler.singleton.schedule_every @config.refresh_interval_second do
-        log('Scheduled job to fetch configuration is started.')
+      @fetch_configuration_update_job = @scheduler.schedule_every @config.refresh_interval_second do
+        Logging::KameleoonLogger.info('Scheduled job to fetch configuration is started.')
         fetch_configuration_job
       end
     end
@@ -484,9 +749,9 @@ module Kameleoon
     def stop_configuration_update_job_if_needed
       return if @fetch_configuration_update_job.nil?
 
-      @fetch_configuration_update_job.unschedule
+      @fetch_configuration_update_job&.unschedule
       @fetch_configuration_update_job = nil
-      log('Scheduled job to fetch configuration is stopped.')
+      Logging::KameleoonLogger.info('Scheduled job to fetch configuration is stopped.')
     end
 
     def start_real_time_configuration_service_if_needed
@@ -495,13 +760,11 @@ module Kameleoon
       url = @network_manager.url_provider.make_real_time_url
       fetch_func = proc { |real_time_event| fetch_configuration_job(real_time_event.time_stamp) }
       @real_time_configuration_service =
-        Kameleoon::RealTime::RealTimeConfigurationService.new(url, fetch_func, method(:log))
+        Kameleoon::RealTime::RealTimeConfigurationService.new(url, fetch_func)
     end
 
     def stop_real_time_configuration_service_if_needed
-      return if @real_time_configuration_service.nil?
-
-      @real_time_configuration_service.close
+      @real_time_configuration_service&.close
       @real_time_configuration_service = nil
     end
 
@@ -530,24 +793,23 @@ module Kameleoon
     # end
 
     def obtain_configuration(time_stamp = nil)
-      log 'Fetching configuration from Client-Config service'
+      Logging::KameleoonLogger.info('Fetching configuration from Client-Config service')
       response = @network_manager.fetch_configuration(time_stamp)
       return false unless response
 
       configuration = JSON.parse(response)
-      @data_file = Configuration::DataFile.new(@config.environment, method(:log)).init(configuration)
-      apply_new_configuration(@data_file)
+      data_file = Configuration::DataFile.new(@config.environment, configuration)
+      apply_new_configuration(data_file)
       call_update_handler_if_needed(!time_stamp.nil?)
-      log "Feature flags are fetched: #{response.inspect}"
+      Logging::KameleoonLogger.info('Feature flags are fetched: %s', response.inspect)
       true
     end
 
     def apply_new_configuration(data_file)
-      @cookie_manager.consent_required =
-        data_file.settings.is_consent_required && !data_file.has_any_targeted_delivery_rule
+      Logging::KameleoonLogger.debug('CALL: KameleoonClient.apply_new_configuration(data_file: %s)', data_file)
+      @data_manager.data_file = data_file
       @network_manager.url_provider.apply_data_api_domain(data_file.settings.data_api_domain)
-      @targeting_manager = Kameleoon::Targeting::TargetingManager.new(@visitor_manager, data_file)
-      @visitor_manager.custom_data_info = data_file.custom_data_info
+      Logging::KameleoonLogger.debug('RETURN: KameleoonClient.apply_new_configuration(data_file: %s)', data_file)
     end
 
     ##
@@ -561,13 +823,13 @@ module Kameleoon
     end
 
     def dispose
+      Logging::KameleoonLogger.debug('CALL: KameleoonClient.dispose')
       stop_configuration_update_job_if_needed
       stop_real_time_configuration_service_if_needed
       @visitor_manager.stop
-    end
-
-    def log(text)
-      print "Kameleoon SDK Log: #{text}\n" if @verbose_mode
+      @tracking_manager.stop
+      @scheduler.shutdown
+      Logging::KameleoonLogger.debug('RETURN: KameleoonClient.dispose')
     end
 
     # Uncomment when using storage
@@ -585,29 +847,68 @@ module Kameleoon
       @targeting_manager.check_targeting(visitor_code, campaign_id, exp_ff_rule)
     end
 
+    def get_variation_info(visitor_code, feature_flag, track)
+      Logging::KameleoonLogger.debug(
+        "CALL: KameleoonClient.get_variation_info(visitor_code: '%s', feature_flag: %s, track: %s)",
+        visitor_code, feature_flag, track
+      )
+      var_by_exp, rule = _calculate_variation_key_for_feature(visitor_code, feature_flag)
+      variation_key = _get_variation_key(var_by_exp, rule, feature_flag)
+      save_variation(visitor_code, rule, var_by_exp, track: track)
+      Logging::KameleoonLogger.debug(
+        "RETURN: KameleoonClient.get_variation_info(visitor_code: '%s', feature_flag: %s, track: %s)" \
+        ' -> (variation_key: %s, variation_by_exposition: %s, rule: %s)',
+        visitor_code, feature_flag, track, variation_key, var_by_exp, rule
+      )
+      [variation_key, var_by_exp, rule]
+    end
+
     ##
     # helper method for getting variation key for feature flag
-    def _get_feature_variation_key(visitor_code, feature_key, is_unique_identifier = false)
-      feature_flag = @data_file.get_feature_flag(feature_key)
+    def _get_feature_variation_key(visitor_code, feature_key)
+      Logging::KameleoonLogger.debug(
+        "CALL: KameleoonClient._get_feature_variation_key(visitor_code: '%s', feature_key: '%s')",
+        visitor_code, feature_key
+      )
+      feature_flag = @data_manager.data_file.get_feature_flag(feature_key)
       variation, rule = _calculate_variation_key_for_feature(visitor_code, feature_flag)
       variation_key = _get_variation_key(variation, rule, feature_flag)
-      visitor = nil
-      unless rule.nil?
-        experiment_id = rule.experiment_id
-        variation_id = variation.variation_id unless variation.nil?
-        visitor = @visitor_manager.get_or_create_visitor(visitor_code)
-        unless experiment_id.nil? || variation_id.nil?
-          as_variation = Kameleoon::DataManager::AssignedVariation.new(experiment_id, variation_id, rule.type)
-          visitor.assign_variation(as_variation)
-        end
-      end
-      flush(visitor_code, is_unique_identifier: is_unique_identifier)
+      save_variation(visitor_code, rule, variation)
+      @tracking_manager.add_visitor_code(visitor_code)
+      Logging::KameleoonLogger.debug(
+        "RETURN: KameleoonClient._get_feature_variation_key(visitor_code: '%s', feature_key: '%s')" \
+          " -> (feature_flag: %s, variation_key: '%s')",
+        visitor_code, feature_key, feature_flag, variation_key
+      )
       [feature_flag, variation_key]
     end
 
+    def save_variation(visitor_code, rule, var_by_exp, track: true)
+      experiment_id = rule&.experiment_id
+      variation_id = var_by_exp&.variation_id
+      return if experiment_id.nil? || variation_id.nil?
+
+      Logging::KameleoonLogger.debug(
+        "CALL: KameleoonClient.save_variation(visitor_code: '%s', rule: %s, var_by_exp: %s, track: %s)",
+        visitor_code, rule, var_by_exp, track
+      )
+      visitor = @visitor_manager.get_or_create_visitor(visitor_code)
+      as_variation = Kameleoon::DataManager::AssignedVariation.new(experiment_id, variation_id, rule.type)
+      as_variation.mark_as_sent unless track
+      visitor.assign_variation(as_variation)
+      Logging::KameleoonLogger.debug(
+        "RETURN: KameleoonClient.save_variation(visitor_code: '%s', rule: %s, var_by_exp: %s, track: %s)",
+        visitor_code, rule, var_by_exp, track
+      )
+    end
+
     ##
     # helper method for calculate variation key for feature flag
     def _calculate_variation_key_for_feature(visitor_code, feature_flag)
+      Logging::KameleoonLogger.debug(
+        "CALL: KameleoonClient._calculate_variation_key_for_feature(visitor_code: '%s', feature_flag: %s)",
+        visitor_code, feature_flag
+      )
       # no rules -> return default_variation_key
       feature_flag.rules.each do |rule|
         # check if visitor is targeted for rule, else next rule
@@ -618,20 +919,41 @@ module Kameleoon
         code_for_hash = vis&.mapping_identifier || visitor_code
         # uses for rule exposition
         hash_rule = Utils::HashDouble.obtain_rule(code_for_hash, rule.id, rule.respool_time)
+        Logging::KameleoonLogger.debug("Calculated hash_rule: %s for visitor_code: '%s'", hash_rule, code_for_hash)
         # check main expostion for rule with hashRule
         if hash_rule <= rule.exposition
-          return [rule.first_variation, rule] if rule.targeted_delivery_type?
+          if rule.targeted_delivery_type?
+            Logging::KameleoonLogger.debug(
+              "RETURN: KameleoonClient._calculate_variation_key_for_feature(visitor_code: '%s', feature_flag: %s) " \
+                '-> (variation: %s, rule: %s)',
+              visitor_code, feature_flag, rule.first_variation, rule
+            )
+            return [rule.first_variation, rule]
+          end
 
           # uses for variation's expositions
           hash_variation = Utils::HashDouble.obtain_rule(code_for_hash, rule.experiment_id, rule.respool_time)
+          Logging::KameleoonLogger.debug(
+            "Calculated hash_variation: %s for visitor_code: '%s'", hash_variation, code_for_hash
+          )
           # get variation key with new hashVariation
           variation = rule.get_variation(hash_variation)
-          return [variation, rule] unless variation.nil?
+          unless variation.nil?
+            Logging::KameleoonLogger.debug(
+              "RETURN: KameleoonClient._calculate_variation_key_for_feature(visitor_code: '%s', " \
+                'feature_flag: %s) -> (variation: %s, rule: %s)', visitor_code, feature_flag, variation, rule
+            )
+            return [variation, rule]
+          end
         # if visitor is targeted for targeted rule then break cycle -> return default
         elsif rule.targeted_delivery_type?
           break
         end
       end
+      Logging::KameleoonLogger.debug(
+        "RETURN: KameleoonClient._calculate_variation_key_for_feature(visitor_code: '%s', feature_flag: %s) " \
+          '-> (variation: nil, rule: nil)', visitor_code, feature_flag
+      )
       [nil, nil]
     end
 
@@ -642,71 +964,48 @@ module Kameleoon
       feature_flag.default_variation_key
     end
 
-    ##
-    # helper method for sending tracking requests for new FF
-    def _send_tracking_request(visitor_code, visitor = nil, force_request = true, is_unique_identifier = false)
-      if visitor.nil?
-        visitor = @visitor_manager.get_visitor(visitor_code)
-        return if visitor.nil? && @data_file.settings.is_consent_required
-      end
-      use_mapping_value, visitor = create_anonymous_if_required(visitor_code, visitor, is_unique_identifier)
-      consent = consent_provided?(visitor)
-      user_agent = visitor&.user_agent
-      unsent = visitor.nil? ? [] : select_unsent_data(visitor, consent)
-      if unsent.empty?
-        return unless force_request && consent
-
-        unsent.push(Network::ActivityEvent.new)
-      end
-      log "Start post tracking: #{unsent.inspect}"
-      @network_manager.send_tracking_data(visitor_code, unsent, user_agent, use_mapping_value)
-    end
-
-    def create_anonymous_if_required(visitor_code, visitor, is_unique_identifier)
-      use_mapping_value = is_unique_identifier && !visitor&.mapping_identifier.nil?
-      # need to find if anonymous visitor is behind unique (anonym doesn't exist if MappingIdentifier == null)
-      if is_unique_identifier && visitor&.mapping_identifier.nil?
-        # 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, visitor]
-    end
-
-    def select_unsent_data(visitor, consent)
-      unsent = []
-      if consent
-        visitor.enumerate_sendable_data { |data| unsent.push(data) unless data.sent }
-      else
-        visitor.conversions.enumerate { |conversion| unsent.push(conversion) unless conversion.sent }
-        if @data_file.has_any_targeted_delivery_rule
-          visitor.variations.enumerate do |variation|
-            unsent.push(variation) unless
-              variation.sent || (variation.rule_type != Configuration::RuleType::TARGETED_DELIVERY)
-          end
-        end
+    def make_external_variation(internal_variation, variation_id, experiment_id)
+      Logging::KameleoonLogger.debug(
+        'CALL: KameleoonClient.make_external_variation(internal_variation: %s, variation_id: %s, experiment_id: %s)',
+        internal_variation, variation_id, experiment_id
+      )
+      variables = {}
+      internal_variation&.variables&.each do |variable|
+        variables[variable.key] = Types::Variable.new(
+          variable.key,
+          variable.type,
+          _parse_feature_variable(variable)
+        )
       end
-      unsent
+      variables.freeze
+      variation = Types::Variation.new(internal_variation&.key, variation_id, experiment_id, variables)
+      Logging::KameleoonLogger.debug(
+        'RETURN: KameleoonClient.make_external_variation(internal_variation: %s, variation_id: %s, experiment_id: %s)' \
+        ' -> (variation: %s)',
+        internal_variation, variation_id, experiment_id, variation
+      )
+      variation
     end
 
     ##
     # helper method for fetching values from a Variable
     def _parse_feature_variable(variable)
       case variable.type
-      when 'BOOLEAN', 'STRING', 'NUMBER'
+      when 'BOOLEAN', 'STRING', 'NUMBER', 'JS', 'CSS'
         variable.value
       when 'JSON'
         JSON.parse(variable.value)
       else
-        raise TypeError.new('Unknown type for feature variable'),
-              'Unknown type for feature variable'
+        Logging::KameleoonLogger.error("Unknown type '#{variable.type}' for feature variable")
+        variable.value
       end
     end
 
-    def consent_provided?(visitor)
-      !@data_file.settings.is_consent_required || visitor&.legal_consent
+    def set_unique_identifier(visitor_code, is_unique_identifier)
+      Logging::KameleoonLogger.info(
+        "The 'isUniqueIdentifier' parameter is deprecated. Please, add 'UniqueIdentifier' to a visitor instead."
+      )
+      @visitor_manager.add_data(visitor_code, UniqueIdentifier.new(is_unique_identifier))
     end
   end
 end