kameleoon-client-ruby 2.2.0 → 3.0.0

data/lib/kameleoon/{client.rb → kameleoon_client.rb}

@@ -1,27 +1,25 @@
 # frozen_string_literal: true
 
+require 'kameleoon/client_readiness'
 require 'kameleoon/targeting/models'
 require 'kameleoon/exceptions'
-require 'kameleoon/cookie'
 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/settings'
+require 'kameleoon/configuration/data_file'
 require 'kameleoon/network/activity_event'
-require 'kameleoon/network/experiment_event'
 require 'kameleoon/network/url_provider'
 require 'kameleoon/network/network_manager'
+require 'kameleoon/network/cookie/cookie_manager'
 require 'kameleoon/real_time/real_time_configuration_service'
-require 'kameleoon/storage/variation_storage'
 require 'kameleoon/hybrid/manager'
 require 'kameleoon/storage/cache_factory'
 require 'rufus/scheduler'
 require 'yaml'
 require 'json'
-require 'em-synchrony'
-require 'em-synchrony/em-http'
-require 'em-synchrony/fiber_iterator'
 require 'objspace'
 require 'time'
 require 'ostruct'
@@ -30,45 +28,37 @@ module Kameleoon
   ##
   # Client for Kameleoon
   #
-  class Client
-    include Cookie
+  class KameleoonClient
     include Exception
 
+    attr_reader :site_code
+
     ##
-    # You should create Client with the Client Factory only.
+    # You should create KameleoonClient with the Client Factory only.
     #
-    def initialize(site_code, path_config_file, interval, default_timeout, client_id = nil, client_secret = nil)
-      config = YAML.load_file(path_config_file)
+    def initialize(site_code, config)
+      raise Exception::SiteCodeIsEmpty, 'Provided site_sode is empty' if site_code&.empty? != false
+
       @site_code = site_code
-      @default_timeout = config['default_timeout'] || default_timeout # in ms
-      refresh_interval = config['actions_configuration_refresh_interval']
-      @interval = refresh_interval.nil? ? interval : "#{refresh_interval}m"
+      @config = config
       @real_time_configuration_service = nil
       @update_configuration_handler = nil
       @fetch_configuration_update_job = nil
-      @client_id = client_id || config['client_id']
-      @client_secret = client_secret || config['client_secret']
-      @data_maximum_size = config['visitor_data_maximum_size'] || 500 # mb
-      @environment = config['environment'] || DEFAULT_ENVIRONMENT
-      @settings = Kameleoon::Configuration::Settings.new
-      @verbose_mode = config['verbose_mode'] || false
-      @experiments = []
-      @feature_flags = []
-      @data = {}
-      @user_agents = {}
-      @variation_storage = Kameleoon::Storage::VariationStorage.new
-      @hybrid_manager = Kameleoon::Hybrid::ManagerImpl.new(
-        CACHE_EXPIRATION_TIMEOUT,
-        CACHE_EXPIRATION_TIMEOUT * 3,
-        Kameleoon::Storage::CacheFactoryImpl.new,
-        method(:log)
-      )
+      @data_file = Configuration::DataFile.new(config.environment)
+      @visitor_manager = Kameleoon::DataManager::VisitorManager.new(config.session_duration_second)
+      @hybrid_manager = Kameleoon::Hybrid::ManagerImpl.new(HYBRID_EXPIRATION_TIME, method(:log))
       @network_manager = Network::NetworkManager.new(
-        @environment,
-        @default_timeout,
-        Network::UrlProvider.new(@site_code, Network::UrlProvider::DEFAULT_DATA_API_URL),
+        config.environment,
+        config.default_timeout_millisecond,
+        Network::UrlProvider.new(site_code, Network::UrlProvider::DEFAULT_DATA_API_URL),
         method(:log)
       )
+      @cookie_manager = Network::Cookie::CookieManager.new(config.top_level_domain)
+      @readiness = ClientReadiness.new
+    end
+
+    def wait_init
+      @readiness.wait
     end
 
     ##
@@ -80,8 +70,8 @@ module Kameleoon
     # @note The implementation logic is described here:
     # First we check if a kameleoonVisitorCode cookie or query parameter associated with the current HTTP request can be
     # found. If so, we will use this as the visitor identifier. If no cookie / parameter is found in the current
-    # request, we either randomly generate a new identifier, or use the defaultVisitorCode argument as identifier if it
-    # is passed. This allows our customers to use their own identifiers as visitor codes, should they wish to.
+    # request, we either randomly generate a new identifier, or use the default_visitor_code argument as identifier if
+    # it is passed. This allows our customers to use their own identifiers as visitor codes, should they wish to.
     # This can have the added benefit of matching Kameleoon visitors with their own users without any additional
     # look-ups in a matching table.
     # In any case, the server-side (via HTTP header) kameleoonVisitorCode cookie is set with the value. Then this
@@ -97,61 +87,15 @@ module Kameleoon
     # cookies = {'kameleoonVisitorCode' => '1234asdf4321fdsa'}
     # visitor_code = get_visitor_code(cookies, 'my-domaine.com')
     #
-    def get_visitor_code(cookies, top_level_domain, default_visitor_code = nil)
-      read_and_write(cookies, top_level_domain, cookies, default_visitor_code)
+    def get_visitor_code(cookies, default_visitor_code = nil)
+      @cookie_manager.get_or_add(cookies, default_visitor_code)
     end
 
-    # DEPRECATED. Please use `get_visitor_code` instead.
-    def obtain_visitor_code(cookies, top_level_domain, default_visitor_code = nil)
-      warn '[DEPRECATION] `obtain_visitor_code` is deprecated.  Please use `get_visitor_code` instead.'
-      get_visitor_code(cookies, top_level_domain, default_visitor_code)
-    end
-
-    ##
-    # Trigger an experiment.
-    #
-    # If such a visitor_code has never been associated with any variation, the SDK returns a randomly selected variation
-    # If a user with a given visitor_code is already registered with a variation, it will detect the previously
-    # registered variation and return the variation_id.
-    # You have to make sure that proper error handling is set up in your code as shown in the example to the right to
-    # catch potential exceptions.
-    #
-    # @param [String] visitor_code Visitor code
-    # @param [Integer] experiment_id Id of the experiment you want to trigger.
-    #
-    # @return [Integer] Id of the variation
-    #
-    # @raise [Kameleoon::Exception::ExperimentConfigurationNotFound] Raise when experiment configuration is not found
-    # @raise [Kameleoon::Exception::NotAllocated] The visitor triggered the experiment, but did not activate it.
-    # Usually, this happens because the user has been associated with excluded traffic
-    # @raise [Kameleoon::Exception::NotTargeted] The visitor is not targeted by the experiment, as the
-    # associated targeting segment conditions were not fulfilled. He should see the reference variation
-    # @raise [Kameleoon::Exception::VisitorCodeNotValid] If the visitor code is empty or longer than 255 chars
-    #
-    def trigger_experiment(visitor_code, experiment_id)
-      check_visitor_code(visitor_code)
-      experiment = @experiments.find { |exp| exp.id.to_s == experiment_id.to_s }
-      if experiment.nil?
-        raise Exception::ExperimentConfigurationNotFound.new(experiment_id),
-              "Experiment #{experiment_id} is not found"
-      end
-      check_site_code_enable(experiment)
-      targeted = check_targeting(visitor_code, experiment_id, experiment)
-      if targeted
-        # saved_variation = get_valid_saved_variation(visitor_code, experiment)
-        variation_id = calculate_variation_for_experiment(visitor_code, experiment)
-        save_variation(visitor_code, experiment_id, variation_id)
-      end
-      _send_tracking_request(visitor_code, experiment_id, variation_id)
-      unless targeted
-        raise Exception::NotTargeted.new(visitor_code),
-              "Experiment #{experiment_id} is not targeted for visitor #{visitor_code}"
-      end
-      if variation_id.nil?
-        raise Exception::NotAllocated.new(visitor_code),
-              "Experiment #{experiment_id} is not active for visitor #{visitor_code}"
-      end
-      variation_id
+    def set_legal_consent(visitor_code, consent, cookies = nil)
+      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)
     end
 
     ##
@@ -165,19 +109,12 @@ module Kameleoon
     # @param [String] visitor_code Visitor code
     # @param [...Data] data Data to associate with the visitor code
     #
-    # @raise [Kameleoon::Exception::VisitorCodeNotValid] If the visitor code is empty or longer than 255 chars
+    # @raise [Kameleoon::Exception::VisitorCodeInvalid] If the visitor code is empty or longer than 255 chars
     #
     def add_data(visitor_code, *args)
-      check_visitor_code(visitor_code)
-      @data.shift while ObjectSpace.memsize_of(@data) > @data_maximum_size * (2**20)
-      args.each do |data_element|
-        if data_element.is_a?(UserAgent)
-          add_user_agent_data(visitor_code, data_element)
-          next
-        end
-        @data[visitor_code] = [] unless @data.key?(visitor_code)
-        @data[visitor_code].push(data_element)
-      end
+      Utils::VisitorCode.validate(visitor_code)
+      visitor = @visitor_manager.get_or_create_visitor(visitor_code)
+      visitor.add_data(method(:log), *args)
     end
 
     ##
@@ -193,10 +130,10 @@ module Kameleoon
     # @param [Integer] goal_id Id of the goal
     # @param [Float] revenue Optional - Revenue of the conversion.
     #
-    # @raise [Kameleoon::Exception::VisitorCodeNotValid] If the visitor code is empty or longer than 255 chars
+    # @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)
-      check_visitor_code(visitor_code)
+      Utils::VisitorCode.validate(visitor_code)
       add_data(visitor_code, Conversion.new(goal_id, revenue))
       flush(visitor_code)
     end
@@ -210,74 +147,17 @@ module Kameleoon
     #
     # @param [String] visitor_code Optional field - Visitor code, without visitor code it flush all of the data
     #
-    # @raise [Kameleoon::Exception::VisitorCodeNotValid] If the visitor code is not null and empty or longer than 255 chars
+    # @raise [Kameleoon::Exception::VisitorCodeInvalid] If the visitor code is not nil and is empty or longer than 255 chars
     #
     def flush(visitor_code = nil)
-      check_visitor_code(visitor_code) unless visitor_code.nil?
-      if !visitor_code.nil?
-        _send_tracking_request(visitor_code)
-      else
-        @data.select { |_, values| values.any? { |data| !data.sent } }.each_key { |key| flush(key) }
-      end
-    end
-
-    ##
-    # Obtain variation associated data.
-    #
-    # To retrieve JSON data associated with a variation, call the get_variation_associated_data method of our SDK.
-    # The JSON data usually represents some metadata of the variation, and can be configured on our web application
-    # interface or via our Automation API.
-    # This method takes the variationID as a parameter and will return the data as a json string.
-    # It will throw an exception () if the variation ID is wrong or corresponds to an experiment that is not yet online.
-    #
-    # @param [Integer] variation_id
-    #
-    # @return [Hash] Hash object of the json object.
-    #
-    # @raise [Kameleoon::Exception::VariationNotFound] Raise exception if the variation is not found.
-    #
-    def get_variation_associated_data(variation_id)
-      variation = @experiments.map(&:variations).flatten.select { |var| var['id'].to_i == variation_id.to_i }.first
-      if variation.nil?
-        raise Exception::VariationConfigurationNotFound.new(variation_id),
-              "Variation key #{variation_id} not found"
+      Utils::VisitorCode.validate(visitor_code) unless visitor_code.nil?
+      if visitor_code.nil?
+        @visitor_manager.enumerate { |visitor_code, visitor| _send_tracking_request(visitor_code, visitor, false) }
       else
-        JSON.parse(variation['customJson'])
+        _send_tracking_request(visitor_code, nil, true)
       end
     end
 
-    # DEPRECATED. Please use `get_variation_associated_data` instead.
-    def obtain_variation_associated_data(variation_id)
-      warn '[DEPRECATION] `obtain_variation_associated_data` is deprecated.
-            Please use `get_variation_associated_data` instead.'
-      get_variation_associated_data(variation_id)
-    end
-
-    # #
-    # Activate a feature toggle.
-
-    # This method takes a visitor_code and feature_key (or feature_id) as mandatory arguments to check if the specified
-    # feature will be active for a given user.
-    # If such a user has never been associated with this feature flag, the SDK returns a boolean value randomly
-    # (true if the user should have this feature or false if not). If a user with a given visitorCode is already
-    # registered with this feature flag, it will detect the previous featureFlag value.
-    # You have to make sure that proper error handling is set up in your code as shown in the example
-    # to the right to catch potential exceptions.
-
-    # @param [String] visitor_code
-    # @param [String | Integer] feature_key
-
-    # @raise [Kameleoon::Exception::FeatureConfigurationNotFound] Feature Flag isn't found in this configuration
-    # @raise [Kameleoon::Exception::NotTargeted] The visitor is not targeted by the experiment, as the
-    # associated targeting segment conditions were not fulfilled. He should see the reference variation
-    # @raise [Kameleoon::Exception::VisitorCodeNotValid] If the visitor code is empty or longer than 255 chars
-    #
-    # DEPRECATED. Please use `feature_active?` instead.
-    def activate_feature(visitor_code, feature_key)
-      warn '[DEPRECATION] `activate_feature` is deprecated.  Please use `feature_active?` instead.'
-      feature_active?(visitor_code, feature_key)
-    end
-
     ##
     # Check if feature is active for a given visitor code
     #
@@ -292,12 +172,14 @@ 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.
     #
-    # @raise [Kameleoon::Exception::FeatureConfigurationNotFound] Feature Flag isn't found in this configuration
-    # @raise [Kameleoon::Exception::VisitorCodeNotValid] 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::VisitorCodeInvalid] If the visitor code is empty or longer than 255 chars
     #
     def feature_active?(visitor_code, feature_key)
       _, variation_key = _get_feature_variation_key(visitor_code, feature_key)
       variation_key != Kameleoon::Configuration::VariationType::VARIATION_OFF
+    rescue Exception::FeatureEnvironmentDisabled
+      false
     end
 
     #
@@ -312,8 +194,10 @@ module Kameleoon
     # @param [String] visitor_code
     # @param [String] feature_key
     #
-    # @raise [Kameleoon::Exception::FeatureConfigurationNotFound] Feature Flag isn't found in this configuration
-    # @raise [Kameleoon::Exception::VisitorCodeNotValid] 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::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)
       _, variation_key = _get_feature_variation_key(visitor_code, feature_key)
@@ -329,9 +213,11 @@ module Kameleoon
     # @param [String] feature_key
     # @param [String] variable_name
     #
-    # @raise [Kameleoon::Exception::FeatureConfigurationNotFound] Feature Flag isn't found in this configuration
+    # @raise [Kameleoon::Exception::FeatureNotFound] Feature Flag isn't found in this configuration
     # @raise [Kameleoon::Exception::FeatureVariableNotFound]
-    # @raise [Kameleoon::Exception::VisitorCodeNotValid] If the visitor code is empty or longer than 255 chars
+    # @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_variable(visitor_code, feature_key, variable_name)
       feature_flag, variation_key = _get_feature_variation_key(visitor_code, feature_key)
@@ -354,14 +240,15 @@ module Kameleoon
     # @param [String] feature_key
     # @param [String] variation_key
     #
-    # @raise [Kameleoon::Exception::FeatureConfigurationNotFound] Feature Flag isn't found in this configuration
-    # @raise [Kameleoon::Exception::VariationConfigurationNotFound]
+    # @raise [Kameleoon::Exception::FeatureNotFound] Feature Flag isn't found in this configuration
+    # @raise [Kameleoon::Exception::FeatureVariationNotFound]
+    # @raise [Kameleoon::Exception::FeatureEnvironmentDisabled]
     #
-    def get_feature_all_variables(feature_key, variation_key)
-      feature_flag = find_feature_flag(feature_key)
+    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)
       if variation.nil?
-        raise Exception::VariationConfigurationNotFound.new(variation_key),
+        raise Exception::FeatureVariationNotFound.new(variation_key),
               "Variation key #{variation_key} not found"
       end
       variables = {}
@@ -369,27 +256,6 @@ module Kameleoon
       variables
     end
 
-    ##
-    # Retrieve a feature variable.
-    #
-    # A feature variable can be changed easily via our web application.
-    #
-    # @param [String | Integer] feature_key
-    # @param [String] variable_key
-    #
-    # @raise [Kameleoon::Exception::FeatureConfigurationNotFound] Feature Flag isn't found in this configuration
-    # @raise [Kameleoon::Exception::FeatureVariableNotFound]
-    #
-    # DEPRECATED. Please use `get_feature_variable` instead.
-    def obtain_feature_variable(feature_key, variable_key)
-      warn '[DEPRECATION] `obtain_feature_variable` is deprecated.  Please use `get_feature_variable` instead.'
-      all_variables = get_feature_all_variables(
-        feature_key,
-        Configuration::VariationType::VARIATION_OFF
-      )
-      all_variables[variable_key]
-    end
-
     ##
     # The get_remote_data method allows you to retrieve data (according to a key passed as argument)
     # stored on a remote Kameleoon server. Usually data will be stored on our remote
@@ -407,13 +273,6 @@ module Kameleoon
       JSON.parse(response) if response
     end
 
-    ##
-    # DEPRECATED. Please use `get_feature_variable` instead.
-    def retrieve_data_from_remote_source(key, timeout = @default_timeout)
-      warn '[DEPRECATION] `retrieve_data_from_remote_source` is deprecated.  Please use `get_remote_date` instead.'
-      get_remote_data(key, timeout)
-    end
-
     ##
     # The get_remote_visitor_data is a method for retrieving custom data for
     # the latest visit of `visitor_code` from Kameleoon Data API and optionally adding it
@@ -434,55 +293,27 @@ module Kameleoon
       data_array
     end
 
-    ##
-    # Returns a list of all experiment ids
-    #
-    # @return [Array] array of all experiment ids
-    def get_experiment_list # rubocop:disable Naming/AccessorMethodName
-      @experiments.map { |it| it.id.to_i }
-    end
-
-    ##
-    # Returns a list of all experiment ids targeted for a visitor
-    # if only_allocated is `true` returns a list of allocated experiments for a visitor
-    #
-    # @raise [Kameleoon::Exception::VisitorCodeNotValid] If the visitor code is empty or longer than 255 chars
-    #
-    # @return [Array] array of all experiment ids accorging to a only_allocated parameter
-    def get_experiment_list_for_visitor(visitor_code, only_allocated: true)
-      list_ids = []
-      @experiments.each do |experiment|
-        next unless check_targeting(visitor_code, experiment.id.to_i, experiment)
-        next if only_allocated && calculate_variation_for_experiment(visitor_code, experiment).nil?
-
-        list_ids.push(experiment.id.to_i)
-      end
-      list_ids
-    end
-
     ##
     # Returns a list of all feature flag keys
     #
     # @return [Array] array of all feature flag keys
     def get_feature_list # rubocop:disable Naming/AccessorMethodName
-      @feature_flags.map(&:feature_key)
+      @data_file.feature_flags.keys
     end
 
     ##
     # Returns a list of active feature flag keys for a visitor
     #
-    # @raise [Kameleoon::Exception::VisitorCodeNotValid] If the visitor code is empty or longer than 255 chars
+    # @raise [Kameleoon::Exception::VisitorCodeInvalid] If the visitor code is empty or longer than 255 chars
     #
     # @return [Array] array of active feature flag keys for a visitor
     def get_active_feature_list_for_visitor(visitor_code)
-      check_visitor_code(visitor_code)
+      Utils::VisitorCode.validate(visitor_code)
       list_keys = []
-      @feature_flags.each do |feature_flag|
+      @data_file.feature_flags.each do |feature_key, feature_flag|
         variation, rule, = _calculate_variation_key_for_feature(visitor_code, feature_flag)
         variation_key = _get_variation_key(variation, rule, feature_flag)
-        if variation_key != Kameleoon::Configuration::VariationType::VARIATION_OFF
-          list_keys.push(feature_flag.feature_key)
-        end
+        list_keys.push(feature_key) if variation_key != Kameleoon::Configuration::VariationType::VARIATION_OFF
       end
       list_keys
     end
@@ -507,44 +338,49 @@ 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)
-      @hybrid_manager.get_engine_tracking_code(visitor_code)
+      visitor_variations = @visitor_manager.get_visitor(visitor_code)&.variations
+      @hybrid_manager.get_engine_tracking_code(visitor_variations)
     end
 
     private
 
-    REFERENCE = 0
-    DEFAULT_ENVIRONMENT = 'production'
-    CACHE_EXPIRATION_TIMEOUT = 5
-    attr :site_code, :client_id, :client_secret, :access_token, :experiments, :feature_flags, :scheduler, :data,
-         :tracking_url, :default_timeout, :interval, :memory_limit, :verbose_mode
+    HYBRID_EXPIRATION_TIME = 5
 
-    def fetch_configuration
-      Rufus::Scheduler.singleton.in '0s' do
-        log('Initial configuration fetch is started.')
-        fetch_configuration_job
+    def fetch_configuration_initially
+      log('Initial configuration fetch is started.')
+      Thread.new do
+        ok = false
+        begin
+          ok = obtain_configuration
+          log('Initial configuration fetch failed') unless ok
+        rescue StandardError => e
+          log("Initial configuration fetch failed: #{e}")
+        end
+        @readiness.set(ok)
+        manage_configuration_update(@data_file.settings.real_time_update) if ok
       end
     end
 
     def fetch_configuration_job(time_stamp = nil)
-      EM.synchrony do
+      Thread.new do
+        ok = false
         begin
           ok = obtain_configuration(time_stamp)
-          if !ok && @settings.real_time_update
-            @settings.real_time_update = false
-            log('Switching to polling mode due to failed fetch')
-          end
         rescue StandardError => e
           log("Error occurred during configuration fetching: #{e}")
         end
-        manage_configuration_update(@settings.real_time_update)
-        EM.stop
+        if !ok && @data_file.settings.real_time_update
+          @data_file.settings.real_time_update = false
+          log('Switching to polling mode due to failed fetch')
+        end
+        manage_configuration_update(@data_file.settings.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 @interval do
+      @fetch_configuration_update_job = Rufus::Scheduler.singleton.schedule_every @config.refresh_interval_second do
         log('Scheduled job to fetch configuration is started.')
         fetch_configuration_job
       end
@@ -604,12 +440,10 @@ module Kameleoon
       return false unless response
 
       configuration = JSON.parse(response)
-      @experiments = Kameleoon::Configuration::Experiment.create_from_array(configuration['experiments']) ||
-                     @experiments
-      @feature_flags = Kameleoon::Configuration::FeatureFlag.create_from_array(
-        configuration['featureFlagConfigurations']
-      )
-      @settings.update(configuration['configuration'])
+      @data_file = Configuration::DataFile.new(@config.environment).init(configuration)
+      @cookie_manager.consent_required =
+        @data_file.settings.is_consent_required && !@data_file.has_any_targeted_delivery_rule
+
       call_update_handler_if_needed(!time_stamp.nil?)
       log "Feature flags are fetched: #{response.inspect}"
       true
@@ -625,49 +459,16 @@ module Kameleoon
       @update_configuration_handler.call
     end
 
-    def calculate_variation_for_experiment(visitor_code, experiment)
-      threshold = obtain_hash_double(visitor_code, experiment.respool_time, experiment.id)
-      experiment.deviations.each do |key, value|
-        threshold -= value
-        return key.to_s.to_i if threshold.negative?
-      end
-      nil
-    end
-
-    def find_feature_flag(feature_key)
-      if feature_key.is_a?(String)
-        feature_flag = @feature_flags.select { |ff| ff.feature_key == feature_key }.first
-      else
-        raise TypeError.new('Feature key should be a String or an Integer.'),
-              'Feature key should be a String or an Integer.'
-      end
-      error_message = "Feature #{feature_key} not found"
-      raise Exception::FeatureConfigurationNotFound.new(feature_key), error_message if feature_flag.nil?
-
-      feature_flag
-    end
-
-    def check_site_code_enable(campaign)
-      raise Exception::SiteCodeDisabled.new(site_code), site_code unless campaign.site_enabled
-    end
-
-    def data_not_sent(visitor_code)
-      @data.key?(visitor_code) ? @data[visitor_code].reject(&:sent) : []
+    def 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
     end
 
-    def add_user_agent_data(visitor_code, user_agent)
-      @user_agents[visitor_code] = user_agent
-    end
-
-    def set_user_agent_to_headers(visitor_code, headers)
-      user_agent = @user_agents[visitor_code]
-      headers['User-Agent'] = user_agent.value unless user_agent.nil?
-    end
-
     # Uncomment when using storage
     # def get_valid_saved_variation(visitor_code, experiment)
     #   variation_id = @variation_storage.get_variation_id(visitor_code, experiment.id.to_i)
@@ -681,29 +482,38 @@ module Kameleoon
 
     def check_targeting(visitor_code, campaign_id, exp_ff_rule)
       segment = exp_ff_rule.targeting_segment
-      segment.nil? || segment.check_tree(->(type) { get_condition_data(type, visitor_code, campaign_id) })
+      return true if segment.nil?
+
+      visitor = @visitor_manager.get_visitor(visitor_code)
+      segment.check_tree(->(type) { get_condition_data(type, visitor, visitor_code, campaign_id) })
     end
 
-    def get_condition_data(type, visitor_code, campaign_id)
+    def get_condition_data(type, visitor, visitor_code, campaign_id)
       condition_data = nil
       case type
-      when Kameleoon::Targeting::ConditionType::CUSTOM_DATUM,
-           Kameleoon::Targeting::ConditionType::PAGE_TITLE,
-           Kameleoon::Targeting::ConditionType::PAGE_URL,
-           Kameleoon::Targeting::ConditionType::DEVICE_TYPE,
-           Kameleoon::Targeting::ConditionType::BROWSER,
-           Kameleoon::Targeting::ConditionType::CONVERSIONS
-        condition_data = (@data[visitor_code] || []).flatten
+      when Kameleoon::Targeting::ConditionType::CUSTOM_DATUM
+        condition_data = visitor.custom_data unless visitor.nil?
+      when Kameleoon::Targeting::ConditionType::PAGE_TITLE,
+           Kameleoon::Targeting::ConditionType::PAGE_URL
+        condition_data = visitor.page_view_visits unless visitor.nil?
+      when Kameleoon::Targeting::ConditionType::DEVICE_TYPE
+        condition_data = visitor.device unless visitor.nil?
+      when Kameleoon::Targeting::ConditionType::BROWSER
+        condition_data = visitor.browser unless visitor.nil?
+      when Kameleoon::Targeting::ConditionType::CONVERSIONS
+        condition_data = visitor.conversions unless visitor.nil?
       when Kameleoon::Targeting::ConditionType::SDK_LANGUAGE
         condition_data = Kameleoon::Targeting::SdkInfo.new(Kameleoon::SDK_NAME, Kameleoon::SDK_VERSION)
       when Kameleoon::Targeting::ConditionType::VISITOR_CODE
         condition_data = visitor_code
       when Kameleoon::Targeting::ConditionType::TARGET_EXPERIMENT
-        condition_data = @variation_storage.get_hash_saved_variation_id(visitor_code)
+        condition_data = visitor.variations unless visitor.nil?
       when Kameleoon::Targeting::ConditionType::EXCLUSIVE_EXPERIMENT
-        condition_data = OpenStruct.new
-        condition_data.experiment_id = campaign_id
-        condition_data.storage = @variation_storage.get_hash_saved_variation_id(visitor_code)
+        unless visitor.nil?
+          condition_data = OpenStruct.new
+          condition_data.experiment_id = campaign_id
+          condition_data.storage = visitor.variations
+        end
       end
       condition_data
     end
@@ -711,16 +521,21 @@ module Kameleoon
     ##
     # helper method for getting variation key for feature flag
     def _get_feature_variation_key(visitor_code, feature_key)
-      check_visitor_code(visitor_code)
-      feature_flag = find_feature_flag(feature_key)
+      Utils::VisitorCode.validate(visitor_code)
+      feature_flag = @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?
-        save_variation(visitor_code, experiment_id, variation_id)
+        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
-      _send_tracking_request(visitor_code, experiment_id, variation_id)
+      _send_tracking_request(visitor_code, visitor)
       [feature_flag, variation_key]
     end
 
@@ -733,13 +548,13 @@ module Kameleoon
         next unless check_targeting(visitor_code, feature_flag.id, rule)
 
         # uses for rule exposition
-        hash_rule = obtain_hash_double_rule(visitor_code, rule.id, rule.respool_time)
+        hash_rule = Utils::HashDouble.obtain_rule(visitor_code, rule.id, rule.respool_time)
         # check main expostion for rule with hashRule
         if hash_rule <= rule.exposition
           return [rule.variation_by_exposition[0], rule] if rule.targeted_delivery_type?
 
           # uses for variation's expositions
-          hash_variation = obtain_hash_double_rule(visitor_code, rule.experiment_id, rule.respool_time)
+          hash_variation = Utils::HashDouble.obtain_rule(visitor_code, rule.experiment_id, rule.respool_time)
           # get variation key with new hashVariation
           variation = rule.get_variation(hash_variation)
           return [variation, rule] unless variation.nil?
@@ -751,16 +566,8 @@ module Kameleoon
       [nil, nil]
     end
 
-    def save_variation(visitor_code, experiment_id, variation_id)
-      return if experiment_id.nil? || variation_id.nil?
-
-      @variation_storage.update_variation(visitor_code, experiment_id, variation_id)
-      @hybrid_manager.add_variation(visitor_code, experiment_id, variation_id)
-    end
-
     def _get_variation_key(var_by_exp, rule, feature_flag)
       return var_by_exp.variation_key unless var_by_exp.nil?
-
       return Kameleoon::Configuration::VariationType::VARIATION_OFF if !rule.nil? && rule.experimentation_type?
 
       feature_flag.default_variation_key
@@ -768,16 +575,37 @@ module Kameleoon
 
     ##
     # helper method for sending tracking requests for new FF
-    def _send_tracking_request(visitor_code, experiment_id = nil, variation_id = nil)
-      user_agent = @user_agents[visitor_code]&.value
-      data_not_sent = data_not_sent(visitor_code)
-      if experiment_id.nil? || variation_id.nil?
-        data_not_sent.append(Network::ActivityEvent.new) if data_not_sent.empty?
+    def _send_tracking_request(visitor_code, visitor = nil, force_request = true)
+      if visitor.nil?
+        visitor = @visitor_manager.get_visitor(visitor_code)
+        return if visitor.nil? && @data_file.settings.is_consent_required
+      end
+      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)
+    end
+
+    def select_unsent_data(visitor, consent)
+      unsent = []
+      if consent
+        visitor.enumerate_sendable_data { |data| unsent.push(data) unless data.sent }
       else
-        data_not_sent.append(Network::ExperimentEvent.new(experiment_id, variation_id))
+        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
       end
-      log "Start post tracking: #{data_not_sent.inspect}"
-      @network_manager.send_tracking_data(visitor_code, data_not_sent, user_agent)
+      unsent
     end
 
     ##
@@ -816,5 +644,9 @@ module Kameleoon
       log("Parsing of visitor data of '#{visitor_code}' failed: #{e}")
       []
     end
+
+    def consent_provided?(visitor)
+      !@data_file.settings.is_consent_required || visitor&.legal_consent
+    end
   end
 end