kameleoon-client-ruby 1.1.2 → 2.1.0

data/lib/kameleoon/client.rb

@@ -4,7 +4,13 @@ require 'kameleoon/targeting/models'
 require 'kameleoon/request'
 require 'kameleoon/exceptions'
 require 'kameleoon/cookie'
-require 'kameleoon/query_graphql'
+require 'kameleoon/configuration/feature_flag'
+require 'kameleoon/configuration/variation'
+require 'kameleoon/configuration/settings'
+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'
@@ -13,6 +19,7 @@ require 'em-synchrony/em-http'
 require 'em-synchrony/fiber_iterator'
 require 'objspace'
 require 'time'
+require 'ostruct'
 
 module Kameleoon
   ##
@@ -26,23 +33,35 @@ module Kameleoon
     ##
     # You should create Client with the Client Factory only.
     #
-    def initialize(site_code, path_config_file, blocking, interval, default_timeout, client_id = nil, client_secret = nil)
+    def initialize(site_code, path_config_file, interval, default_timeout, client_id = nil, client_secret = nil)
       config = YAML.load_file(path_config_file)
       @site_code = site_code
-      @blocking = blocking
       @default_timeout = config['default_timeout'] || default_timeout # in ms
       refresh_interval = config['actions_configuration_refresh_interval']
       @interval = refresh_interval.nil? ? interval : "#{refresh_interval}m"
-      @tracking_url = config['tracking_url'] || "https://api-ssx.kameleoon.com"
-      @api_data_url = "https://api-data.kameleoon.com"
+      @tracking_url = config['tracking_url'] || API_SSX_URL
+      @api_data_url = 'https://api-data.kameleoon.com'
+      @events_url = 'https://events.kameleoon.com:8110/'
+      @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)
+      )
     end
 
     ##
@@ -69,16 +88,22 @@ module Kameleoon
     #
     # @example
     # cookies = {'kameleoonVisitorCode' => '1234asdf4321fdsa'}
-    # visitor_code = obtain_visitor_code(cookies, 'my-domaine.com')
+    # visitor_code = get_visitor_code(cookies, 'my-domaine.com')
     #
-    def obtain_visitor_code(cookies, top_level_domain, default_visitor_code = nil)
+    def get_visitor_code(cookies, top_level_domain, default_visitor_code = nil)
       read_and_write(cookies, top_level_domain, 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 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
@@ -90,56 +115,35 @@ module Kameleoon
     # @return [Integer] Id of the variation
     #
     # @raise [Kameleoon::Exception::ExperimentConfigurationNotFound] Raise when experiment configuration is not found
-    # @raise [Kameleoon::Exception::NotActivated] 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::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, timeout = @default_timeout)
+    def trigger_experiment(visitor_code, experiment_id)
       check_visitor_code(visitor_code)
-      experiment = @experiments.find { |experiment| experiment['id'].to_s == experiment_id.to_s }
+      experiment = @experiments.find { |exp| exp.id.to_s == experiment_id.to_s }
       if experiment.nil?
-        raise Exception::ExperimentConfigurationNotFound.new(experiment_id)
-      end
-      if @blocking
-        variation_id = nil
-        EM.synchrony do
-          connexion_options = { :connect_timeout => (timeout.to_f / 1000.0) }
-          body = (data_not_sent(visitor_code).map { |data| data.obtain_full_post_text_line }.join("\n") || "").encode("UTF-8")
-          path = get_experiment_register_url(visitor_code, experiment_id)
-          request_options = { :path => path, :body => body }
-          log "Trigger experiment request: " + request_options.inspect
-          log "Trigger experiment connexion:" + connexion_options.inspect
-          request = EM::Synchrony.sync post(request_options, @tracking_url, connexion_options)
-          if is_successful(request)
-            variation_id = request.response
-          else
-            log "Failed to trigger experiment: " + request.inspect
-            raise Exception::ExperimentConfigurationNotFound.new(experiment_id) if variation_id.nil?
-          end
-          EM.stop
-        end
-        if variation_id.nil? || variation_id.to_s == "null" || variation_id.to_s == ""
-          raise Exception::NotTargeted.new(visitor_code)
-        elsif variation_id.to_s == "0"
-          raise Exception::NotActivated.new(visitor_code)
-        end
-        variation_id.to_i
-      else
-        check_site_code_enable(experiment)
-        visitor_data = @data.select { |key, value| key.to_s == visitor_code }.values.flatten! || []
-        if experiment['targetingSegment'].nil? || experiment['targetingSegment'].check_tree(visitor_data)
-          threshold = obtain_hash_double(visitor_code, experiment['respoolTime'], experiment['id'])
-          experiment['deviations'].each do |key, value|
-            threshold -= value
-            if threshold < 0
-              track_experiment(visitor_code, experiment_id, key)
-              return key.to_s.to_i
-            end
-          end
+        raise Exception::ExperimentConfigurationNotFound.new(experiment_id),
+              "Experiment #{experiment_id} is not found"
+      end
+      check_site_code_enable(experiment)
+      if check_targeting(visitor_code, experiment_id, experiment)
+        # saved_variation = get_valid_saved_variation(visitor_code, experiment)
+        variation_id = calculate_variation_for_experiment(visitor_code, experiment)
+        if !variation_id.nil?
+          track_experiment(visitor_code, experiment_id, variation_id)
+          save_variation(visitor_code, experiment_id, variation_id)
+          variation_id
+        else
           track_experiment(visitor_code, experiment_id, REFERENCE, true)
-          raise Exception::NotActivated.new(visitor_code)
+          raise Exception::NotAllocated.new(visitor_code),
+                "Experiment #{experiment_id} is not active for visitor #{visitor_code}"
         end
-        raise Exception::NotTargeted.new(visitor_code)
+      else
+        raise Exception::NotTargeted.new(visitor_code),
+              "Experiment #{experiment_id} is not targeted for visitor #{visitor_code}"
       end
     end
 
@@ -158,15 +162,14 @@ module Kameleoon
     #
     def add_data(visitor_code, *args)
       check_visitor_code(visitor_code)
-      while ObjectSpace.memsize_of(@data) > @data_maximum_size * (2**20) do
-        @data.shift
-      end
-      unless args.empty?
-        if @data.key?(visitor_code)
-          @data[visitor_code].push(*args)
-        else
-          @data[visitor_code] = args
+      @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
     end
 
@@ -174,8 +177,10 @@ module Kameleoon
     # Track conversions on a particular goal
     #
     # This method requires visitor_code and goal_id to track conversion on this particular goal.
-    # In addition, this method also accepts revenue as a third optional argument to track revenue. The visitor_code usually is identical to the one that was used when triggering the experiment.
-    # The track_conversion method doesn't return any value. This method is non-blocking as the server call is made asynchronously.
+    # In addition, this method also accepts revenue as a third optional argument to track revenue.
+    # The visitor_code usually is identical to the one that was used when triggering the experiment.
+    # The track_conversion method doesn't return any value.
+    # This method is non-blocking as the server call is made asynchronously.
     #
     # @param [String] visitor_code Visitor code
     # @param [Integer] goal_id Id of the goal
@@ -212,7 +217,7 @@ module Kameleoon
     ##
     # Obtain variation associated data.
     #
-    # To retrieve JSON data associated with a variation, call the obtain_variation_associated_data method of our SDK.
+    # 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.
@@ -224,74 +229,137 @@ module Kameleoon
     #
     # @raise [Kameleoon::Exception::VariationNotFound] Raise exception if the variation is not found.
     #
-    def obtain_variation_associated_data(variation_id)
-      variation = @experiments.map { |experiment| experiment['variations'] }.flatten.select { |variation| variation['id'].to_i == variation_id.to_i }.first
+    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)
+        raise Exception::VariationConfigurationNotFound.new(variation_id),
+              "Variation key #{variation_id} not found"
       else
         JSON.parse(variation['customJson'])
       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
     #
-    # 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.
+    # DEPRECATED. Please use `is_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
+    #
+    # This method takes a visitor_code and feature_key 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 feature flag 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 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
+    #
+    def feature_active?(visitor_code, feature_key)
+      _, variation_key = _get_feature_variation_key(visitor_code, feature_key)
+      variation_key != Kameleoon::Configuration::VariationType::VARIATION_OFF
+    end
+
+    #
+    # get_feature_variation_key returns a variation key for visitor code
+    #
+    # This method takes a visitorCode and featureKey as mandatory arguments and
+    # returns a variation assigned for a given visitor
+    # If such a user has never been associated with any feature flag rules, the SDK returns a default variation key
+    # 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
+    # @param [String] feature_key
     #
-    # @raise [Kameleoon::Exception::FeatureConfigurationNotFound]
-    # @raise [Kameleoon::Exception::NotTargeted]
+    # @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
     #
-    def activate_feature(visitor_code, feature_key, timeout = @default_timeout)
-      check_visitor_code(visitor_code)
-      feature_flag = get_feature_flag(feature_key)
-      id = feature_flag['id']
-      if @blocking
-        result = nil
-        EM.synchrony do
-          connexion_options = { :connect_timeout => (timeout.to_f / 1000.0) }
-          request_options = {
-            :path => get_experiment_register_url(visitor_code, id),
-            :body => (data_not_sent(visitor_code).map { |data| data.obtain_full_post_text_line }.join("\n") || "").encode("UTF-8")
-          }
-          log "Activate feature request: " + request_options.inspect
-          log "Activate feature connexion:" + connexion_options.inspect
-          request = EM::Synchrony.sync post(request_options, @tracking_url, connexion_options)
-          if is_successful(request)
-            result = request.response
-          else
-            log "Failed to get activation:" + result.inspect
-          end
-          EM.stop
-        end
-        raise Exception::FeatureConfigurationNotFound.new(id) if result.nil?
-        result.to_s != "null"
+    def get_feature_variation_key(visitor_code, feature_key)
+      _, variation_key = _get_feature_variation_key(visitor_code, feature_key)
+      variation_key
+    end
 
-      else
-        check_site_code_enable(feature_flag)
-        visitor_data = @data.select { |key, value| key.to_s == visitor_code }.values.flatten! || []
-        unless feature_flag['targetingSegment'].nil? || feature_flag['targetingSegment'].check_tree(visitor_data)
-          raise Exception::NotTargeted.new(visitor_code)
-        end
+    ##
+    # Retrieves a feature variable value from assigned for visitor variation
+    #
+    # A feature variable can be changed easily via our web application.
+    #
+    # @param [String] visitor_code
+    # @param [String] feature_key
+    # @param [String] variable_name
+    #
+    # @raise [Kameleoon::Exception::FeatureConfigurationNotFound] 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
+    #
+    def get_feature_variable(visitor_code, feature_key, variable_name)
+      feature_flag, variation_key = _get_feature_variation_key(visitor_code, feature_key)
+      variation = feature_flag.get_variation_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)
+    end
 
-        if is_feature_flag_scheduled(feature_flag, Time.now.to_i)
-          threshold = obtain_hash_double(visitor_code, {}, id)
-          if threshold >= 1 - feature_flag['expositionRate']
-            track_experiment(visitor_code, id, feature_flag["variations"].first['id'])
-            true
-          else
-            track_experiment(visitor_code, id, REFERENCE, true)
-            false
-          end
-        else
-          false
-        end
+    ##
+    # Retrieves all feature variable values for a given variation
+    #
+    # This method takes a feature_key and variation_key as mandatory arguments and
+    # returns a list of variables for a given variation key
+    # A feature variable can be changed easily via our web application.
+    #
+    # @param [String] feature_key
+    # @param [String] variation_key
+    #
+    # @raise [Kameleoon::Exception::FeatureConfigurationNotFound] Feature Flag isn't found in this configuration
+    # @raise [Kameleoon::Exception::VariationConfigurationNotFound]
+    #
+    def get_feature_all_variables(feature_key, variation_key)
+      feature_flag = find_feature_flag(feature_key)
+      variation = feature_flag.get_variation_key(variation_key)
+      if variation.nil?
+        raise Exception::VariationConfigurationNotFound.new(variation_key),
+              "Variation key #{variation_key} not found"
       end
+      variables = {}
+      variation.variables.each { |var| variables[var.key] = _parse_feature_variable(var) }
+      variables
     end
 
     ##
@@ -302,287 +370,256 @@ module Kameleoon
     # @param [String | Integer] feature_key
     # @param [String] variable_key
     #
-    # @raise [Kameleoon::Exception::FeatureConfigurationNotFound]
+    # @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)
-      feature_flag = get_feature_flag(feature_key)
-      custom_json = JSON.parse(feature_flag["variations"].first['customJson'])[variable_key.to_s]
-      if custom_json.nil?
-        raise Exception::FeatureVariableNotFound.new("Feature variable not found")
-      end
-      case custom_json['type']
-      when "Boolean"
-        return custom_json['value'].downcase == "true"
-      when "String"
-        return custom_json['value']
-      when "Number"
-        return custom_json['value'].to_i
-      when "JSON"
-        return JSON.parse(custom_json['value'])
-      else
-        raise TypeError.new("Unknown type for feature variable")
-      end
+      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 retrieved_data_from_remote_source 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 servers via the use of our Data API. 
-    # This method, along with the availability of our highly scalable servers for this purpose, provides a convenient way
-    # to quickly store massive amounts of data that can be later retrieved for each of your visitors / users.
+    # The get_remote_date 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
+    # servers via the use of our Data API.
+    # This method, along with the availability of our highly scalable servers for this purpose, provides a convenient
+    # way to quickly store massive amounts of data that can be later retrieved for each of your visitors / users.
     #
     # @param [String] key Key you want to retrieve data. This field is mandatory.
-    # @param [Int] timeout Timeout for request. Equals default_timeout in a config file. This field is optional.
+    # @param [Int] timeout Timeout for request (in milliseconds). Equals default_timeout in a config file.
+    # This field is optional.
     #
     # @return [Hash] Hash object of the json object.
-    #
-    #
-    def retrieve_data_from_remote_source(key, timeout = @default_timeout)
+    def get_remote_date(key, timeout = @default_timeout)
       connexion_options = { connect_timeout: (timeout.to_f / 1000.0) }
       path = get_api_data_request_url(key)
       log "Retrieve API Data connexion: #{connexion_options.inspect}"
       response = get_sync(@api_data_url + path, connexion_options)
-      if is_successful_sync(response)
-        JSON.parse(response.body) unless response.nil?
-      else
-        return nil
-      end
+      return nil unless successful_sync?(response)
+
+      JSON.parse(response.body) unless response.nil?
     end
 
-    private
+    ##
+    # 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_date(key, timeout)
+    end
 
-    API_SSX_URL = 'https://api-ssx.kameleoon.com'
-    REFERENCE = 0
-    STATUS_ACTIVE = 'ACTIVE'
-    FEATURE_STATUS_DEACTIVATED = 'DEACTIVATED'
-    DEFAULT_ENVIRONMENT = 'production'
-    attr :site_code, :client_id, :client_secret, :access_token, :experiments, :feature_flags, :scheduler, :data,
-         :blocking, :tracking_url, :default_timeout, :interval, :memory_limit, :verbose_mode
+    ##
+    # 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
 
-    def fetch_configuration
-      @scheduler = Rufus::Scheduler.singleton
-      @scheduler.every @interval do
-        log('Scheduled job to fetch configuration is starting.')
-        fetch_configuration_job_graphql
-      end
-      @scheduler.schedule '0s' do
-        log('Start-up, fetching is starting')
-        fetch_configuration_job_graphql
+    ##
+    # 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
 
-    def fetch_configuration_job_graphql
-      EM.synchrony do
-        obtain_access_token
-        @experiments = obtain_experiments_graphql(@site_code) || @experiments
-        @feature_flags = obtain_feature_flags_graphql(@site_code, @environment) || @feature_flags
-        EM.stop
-      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)
     end
 
-    def fetch_configuration_job
-      EM.synchrony do
-        obtain_access_token
-        site = obtain_site
-        if site.nil? || site.empty?
-          @experiments ||= []
-          @feature_flags ||= []
-        else
-          site_id = site.first['id']
-          @experiments = obtain_tests(site_id) || @experiments
-          @feature_flags = obtain_feature_flags(site_id) || @feature_flags
+    ##
+    # 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
+    #
+    # @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)
+      list_keys = []
+      @feature_flags.each do |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
-        EM.stop
       end
+      list_keys
     end
 
-    def hash_headers
-      if @access_token.nil?
-        CredentialsNotFound.new
-      end
-      {
-        'Authorization' => 'Bearer ' + @access_token.to_s,
-        'Content-Type' => 'application/json'
-      }
+    ##
+    # The `on_update_configuration()` method allows you to handle the event when configuration
+    # has updated data. It takes one input parameter: callable **handler**. The handler
+    # that will be called when the configuration is updated using a real-time configuration event.
+    #
+    # @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)
+      @update_configuration_handler = handler
     end
 
-    def hash_filter(field, operator, parameters)
-      { 'field' => field, 'operator' => operator, 'parameters' => parameters }
+    ##
+    # The `get_engine_tracking_code` returns the JavasScript code to be inserted in your page
+    # to send automatically the exposure events to the analytics solution you are using.
+    #
+    # @param [String] visitor_code The user's unique identifier. This field is mandatory.
+    #
+    # @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)
     end
 
-    def obtain_site
-      log "Fetching site"
-      query_params = { 'perPage' => 1 }
-      filters = [hash_filter('code', 'EQUAL', [@site_code])]
-      request = fetch_one('sites', query_params, filters)
-      if request != false
-        sites = JSON.parse(request.response)
-        log "Sites are fetched: " + sites.inspect
-        sites
-      end
-    end
+    private
 
-    def obtain_access_token
-      log "Fetching bearer token"
-      body = {
-        'grant_type' => 'client_credentials',
-        'client_id' => @client_id,
-        'client_secret' => @client_secret
-      }
-      header = { 'Content-Type' => 'application/x-www-form-urlencoded' }
+    API_SSX_URL = 'https://api-ssx.kameleoon.com'
+    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
 
-      request = EM::Synchrony.sync post({ :path => '/oauth/token', :body => body, :head => header })
-      if is_successful(request)
-        @access_token = JSON.parse(request.response)['access_token']
-        log "Bearer Token is fetched: " + @access_token.to_s
-      else
-        log "Failed to fetch bearer token: " + request.inspect
+    def fetch_configuration
+      Rufus::Scheduler.singleton.in '0s' do
+        log('Initial configuration fetch is started.')
+        fetch_configuration_job
       end
     end
 
-    def obtain_variation(variation_id)
-      request = fetch_one('variations/' + variation_id.to_s)
-      if request != false
-        JSON.parse(request.response)
+    def fetch_configuration_job(time_stamp = nil)
+      EM.synchrony do
+        begin
+          ok = obtain_configuration(@site_code, @environment, 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
       end
     end
 
-    def obtain_segment(segment_id)
-      request = fetch_one('segments/' + segment_id.to_s)
-      if request != false
-        JSON.parse(request.response)
+    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
+        log('Scheduled job to fetch configuration is started.')
+        fetch_configuration_job
       end
     end
 
-    def complete_experiment(experiment)
-      unless experiment['variations'].nil?
-        experiment['variations'] = experiment['variations'].map { |variationId| obtain_variation(variationId) }
-      end
-      unless experiment['targetingSegmentId'].nil?
-        experiment['targetingSegment'] = Kameleoon::Targeting::Segment.new(obtain_segment(experiment['targetingSegmentId']))
-      end
-      experiment
+    def stop_configuration_update_job_if_needed
+      return if @fetch_configuration_update_job.nil?
+
+      @fetch_configuration_update_job.unschedule
+      @fetch_configuration_update_job = nil
+      log('Scheduled job to fetch configuration is stopped.')
     end
 
-    # fetching segment for both types: experiments and feature_flags (campaigns)
-    def complete_campaign_graphql(campaign)
-      campaign['id'] = campaign['id'].to_i
-      campaign['status'] = campaign['status']
-      unless campaign['deviations'].nil?
-        campaign['deviations'] = Hash[*campaign['deviations'].map { |it| [ it['variationId'] == '0' ? 'origin' : it['variationId'], it['value'] ] }.flatten]
-      end
-      unless campaign['respoolTime'].nil?
-        campaign['respoolTime'] = Hash[*campaign['respoolTime'].map { |it| [ it['variationId'] == '0' ? 'origin' : it['variationId'], it['value'] ] }.flatten]
-      end
-      unless campaign['variations'].nil?
-        campaign['variations'] = campaign['variations'].map { |it| {'id' => it['id'].to_i, 'customJson' => it['customJson']} }
-      end
-      unless campaign['segment'].nil?
-        campaign['targetingSegment'] = Kameleoon::Targeting::Segment.new((campaign['segment']))
-      end
-      campaign
+    def start_real_time_configuration_service_if_needed
+      return unless @real_time_configuration_service.nil?
+
+      events_url = "#{@events_url}sse?siteCode=#{@site_code}"
+      fetch_func = proc { |real_time_event| fetch_configuration_job(real_time_event.time_stamp) }
+      @real_time_configuration_service =
+        Kameleoon::RealTime::RealTimeConfigurationService.new(events_url, fetch_func, method(:log))
     end
 
-    def complete_experiment(experiment)
-      unless experiment['variations'].nil?
-        experiment['variations'] = experiment['variations'].map { |variationId| obtain_variation(variationId) }
-      end
-      unless experiment['targetingSegmentId'].nil?
-        experiment['targetingSegment'] = Kameleoon::Targeting::Segment.new(obtain_segment(experiment['targetingSegmentId']))
-      end
-      experiment
+    def stop_real_time_configuration_service_if_needed
+      return if @real_time_configuration_service.nil?
+
+      @real_time_configuration_service.close
+      @real_time_configuration_service = nil
     end
 
-    def obtain_experiments_graphql(site_code, per_page = -1)
-      log "Fetching experiments GraphQL"
-      experiments = fetch_all_graphql("v1/graphql?perPage=#{per_page}", Kameleoon::Query.query_experiments(site_code)).map { |it| JSON.parse(it.response)['data']['experiments']['edges'] }.flatten.map do |experiment|
-          complete_campaign_graphql(experiment['node'])
-      end
-      log "Experiment are fetched: " + experiments.inspect
-      experiments
-    end
-
-    def obtain_tests(site_id, per_page = -1)
-      log "Fetching experiments"
-      query_values = { 'perPage' => per_page }
-      filters = [
-        hash_filter('siteId', 'EQUAL', [site_id]),
-        hash_filter('status', 'IN', ['ACTIVE', 'DEVIATED']),
-        hash_filter('type', 'IN', ['SERVER_SIDE', 'HYBRID'])
-      ]
-      experiments = fetch_all('experiments', query_values, filters).map { |it| JSON.parse(it.response) }.flatten.map do |test|
-        complete_experiment(test)
-      end
-      log "Experiment are fetched: " + experiments.inspect
-      experiments
+    def manage_configuration_update(is_real_time_update)
+      if is_real_time_update
+        stop_configuration_update_job_if_needed
+        start_real_time_configuration_service_if_needed
+      else
+        stop_real_time_configuration_service_if_needed
+        start_configuration_update_job_if_needed
+      end
+    end
+
+    # def hash_headers
+    #   if @access_token.nil?
+    #     CredentialsNotFound.new
+    #   end
+    #   {
+    #     'Authorization' => 'Bearer ' + @access_token.to_s,
+    #     'Content-Type' => 'application/json'
+    #   }
+    # end
+
+    # def hash_filter(field, operator, parameters)
+    #   { 'field' => field, 'operator' => operator, 'parameters' => parameters }
+    # end
+
+    def obtain_configuration(site_code, environment = @environment, time_stamp = nil)
+      log 'Fetching configuration from Client-Config service'
+      request_path = "mobile?siteCode=#{site_code}"
+      request_path += "&environment=#{environment}" unless environment.nil?
+      request_path += "&ts=#{time_stamp}" unless time_stamp.nil?
+      request = request_configuration(request_path)
+      return false unless request
+
+      configuration = JSON.parse(request.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'])
+      call_update_handler_if_needed(!time_stamp.nil?)
+      log "Feature flags are fetched: #{request.inspect}"
+      true
     end
 
-    def obtain_feature_flags_graphql(site_id, environment = @environment, per_page = -1)
-      log "Fetching feature flags GraphQL"
-      feature_flags = fetch_all_graphql("v1/graphql?perPage=#{per_page}", Kameleoon::Query.query_feature_flags(site_code, environment)).map { |it| JSON.parse(it.response)['data']['featureFlags']['edges'] }.flatten.map do |feature_flag|
-          complete_campaign_graphql(feature_flag['node'])
-      end
-      log "Feature flags are fetched: " + feature_flags.inspect
-      feature_flags
-    end
-
-    def obtain_feature_flags(site_id, per_page = -1)
-      log "Fetching feature flags"
-      query_values = { 'perPage' => per_page }
-      filters = [
-        hash_filter('siteId', 'EQUAL', [site_id]),
-        hash_filter('status', 'IN', ['ACTIVE', 'PAUSED'])
-      ]
-      feature_flags = fetch_all('feature-flags', query_values, filters).map { |it| JSON.parse(it.response) }.flatten.map do |ff|
-        complete_experiment(ff)
-      end
-      log "Feature flags are fetched: " + feature_flags.inspect
-      feature_flags
-    end
-
-    def fetch_all_graphql(path, query_graphql = {})
-      results = []
-      current_page = 1
-      loop do
-        http = fetch_one_graphql(path, query_graphql)
-        break if http == false
-        results.push(http)
-        break if http.response_header["X-Pagination-Page-Count"].to_i <= current_page
-        current_page += 1
-      end
-      results
-    end
-
-    def fetch_all(path, query_values = {}, filters = [])
-      results = []
-      current_page = 1
-      loop do
-        query_values['page'] = current_page
-        http = fetch_one(path, query_values, filters)
-        break if http == false
-        results.push(http)
-        break if http.response_header["X-Pagination-Page-Count"].to_i <= current_page
-        current_page += 1
-      end
-      results
+    ##
+    # Call the handler when configuraiton was updated with new time stamp.
+    #
+    # @param need_call [Bool] Indicates if we need to call handler or not.
+    def call_update_handler_if_needed(need_call)
+      return if !need_call || @update_configuration_handler.nil?
+
+      @update_configuration_handler.call
     end
 
-    def fetch_one_graphql(path, query_graphql = {})
-      request = EM::Synchrony.sync post({ :path => path, :body => query_graphql, :head => hash_headers })
-      unless is_successful(request)
-        log "Failed to fetch" + request.inspect
-        return false
+    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
-      request
+      nil
     end
 
-    def fetch_one(path, query_values = {}, filters = [])
-      unless filters.empty?
-        query_values['filter'] = filters.to_json
-      end
-      request = EM::Synchrony.sync get({ :path => path, :query => query_values, :head => hash_headers })
-      unless is_successful(request)
-        log "Failed to fetch" + request.inspect
+    def request_configuration(path)
+      request = EM::Synchrony.sync get({ path: path }, CLIENT_CONFIG_URL)
+      unless successful?(request)
+        log "Failed to fetch #{request.inspect}"
         return false
       end
       request
@@ -590,27 +627,25 @@ module Kameleoon
 
     def get_common_ssx_parameters(visitor_code)
       {
-        :nonce => Kameleoon::Utils.generate_random_string(16),
-        :siteCode => @site_code,
-        :visitorCode => visitor_code
+        nonce: Kameleoon::Utils.generate_random_string(16),
+        siteCode: @site_code,
+        visitorCode: visitor_code
       }
     end
 
     def get_experiment_register_url(visitor_code, experiment_id, variation_id = nil, none_variation = false)
-      url = "/experimentTracking?" + URI.encode_www_form(get_common_ssx_parameters(visitor_code))
-      url += "&experimentId=" + experiment_id.to_s
-      if variation_id.nil?
-        return url
-      end
-      url += "&variationId=" + variation_id.to_s
-      if none_variation
-        url += "&noneVariation=true"
-      end
+      url = "/experimentTracking?#{URI.encode_www_form(get_common_ssx_parameters(visitor_code))}"
+      url += "&experimentId=#{experiment_id}"
+      return url if variation_id.nil?
+
+      url += "&variationId=#{variation_id}"
+      url += '&noneVariation=true' if none_variation
+
       url
     end
 
     def get_data_register_url(visitor_code)
-      "/dataTracking?" + URI.encode_www_form(get_common_ssx_parameters(visitor_code))
+      "/dataTracking?#{URI.encode_www_form(get_common_ssx_parameters(visitor_code))}"
     end
 
     def get_api_data_request_url(key)
@@ -621,52 +656,36 @@ module Kameleoon
       "/data?#{URI.encode_www_form(mapKey)}"
     end
 
-    def get_feature_flag(feature_key)
+    def find_feature_flag(feature_key)
       if feature_key.is_a?(String)
-        feature_flag = @feature_flags.select { |ff| ff['identificationKey'] == feature_key}.first
-      elsif feature_key.is_a?(Integer)
-        feature_flag = @feature_flags.select { |ff| ff['id'].to_i == feature_key}.first
-        print "\nPassing `feature_key` with type of `int` to `activate_feature` or `obtain_feature_variable` "\
-        "is deprecated, it will be removed in next releases. This is necessary to support multi-environment feature\n"
+        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.")
-      end
-      if feature_flag.nil?
-        raise Exception::FeatureConfigurationNotFound.new(feature_key)
+        raise TypeError.new('Feature key should be a String or an Integer.'),
+              'Feature key should be a String or an Integer.'
       end
-      feature_flag
-    end
+      error_message = "Feature #{feature_key} not found"
+      raise Exception::FeatureConfigurationNotFound.new(feature_key), error_message if feature_flag.nil?
 
-    def is_feature_flag_scheduled(feature_flag, date)
-      current_status = feature_flag['status'] == STATUS_ACTIVE
-      if feature_flag['featureStatus'] == FEATURE_STATUS_DEACTIVATED || feature_flag['schedules'].empty?
-        return current_status
-      end
-      feature_flag['schedules'].each do |schedule|
-        if (schedule['dateStart'].nil? || Time.parse(schedule['dateStart']).to_i < date) &&
-           (schedule['dateEnd'].nil? || Time.parse(schedule['dateEnd']).to_i > date)
-          return true
-        end
-      end
-      false
+      feature_flag
     end
 
-    def track_experiment(visitor_code, experiment_id, variation_id = nil, none_variation = false)
+    def track_experiment(visitor_code, experiment_id, variation_id = nil, none_variation: false)
       data_not_sent = data_not_sent(visitor_code)
       options = {
-        :path => get_experiment_register_url(visitor_code, experiment_id, variation_id, none_variation),
-        :body => (data_not_sent.map{ |it| it.obtain_full_post_text_line }.join("\n") || "").encode("UTF-8"),
-        :head => { "Content-Type" => "text/plain"}
+        path: get_experiment_register_url(visitor_code, experiment_id, variation_id, none_variation),
+        body: (data_not_sent.map(&:obtain_full_post_text_line).join("\n") || '').encode('UTF-8'),
+        head: { 'Content-Type': 'text/plain' }
       }
+      set_user_agent_to_headers(visitor_code, options[:head])
       trial = 0
       success = false
-      log "Start post tracking experiment: " + data_not_sent.inspect
+      log "Start post tracking experiment: #{data_not_sent.inspect}"
       Thread.new do
         while trial < 10
-          log "Send Experiment Tracking " + options.inspect
+          log "Send Experiment Tracking #{options.inspect}"
           response = post_sync(options, @tracking_url)
-          log "Response " + response.inspect
-          if is_successful_sync(response)
+          log "Response #{response.inspect}"
+          if successful_sync?(response)
             data_not_sent.each { |it| it.sent = true }
             success = true
             break
@@ -674,9 +693,9 @@ module Kameleoon
           trial += 1
         end
         if success
-          log "Post to experiment tracking is done after " + (trial + 1).to_s + " trials"
-        else 
-          log "Post to experiment tracking is failed after " + trial.to_s + " trials"          
+          log "Post to experiment tracking is done after #{trial + 1} trials"
+        else
+          log "Post to experiment tracking is failed after #{trial} trials"
         end
       end
     end
@@ -685,17 +704,18 @@ module Kameleoon
       Thread.new do
         trials = 0
         data_not_sent = data_not_sent(visitor_code)
-        log "Start post tracking data: " + data_not_sent.inspect
+        log "Start post tracking data: #{data_not_sent.inspect}"
         while trials < 10 && !data_not_sent.empty?
           options = {
-            :path => get_data_register_url(visitor_code),
-            :body => (data_not_sent.map{ |it| it.obtain_full_post_text_line }.join("\n") || "").encode("UTF-8"),
-            :head => { "Content-Type" => "text/plain" }
+            path: get_data_register_url(visitor_code),
+            body: (data_not_sent.map(&:obtain_full_post_text_line).join("\n") || '').encode('UTF-8'),
+            head: { 'Content-Type': 'text/plain' }
           }
-          log "Post tracking data for visitor_code: " + visitor_code + " with options: " + options.inspect
+          set_user_agent_to_headers(visitor_code, options[:head])
+          log "Post tracking data for visitor_code: #{visitor_code} with options: #{options.inspect}"
           response = post_sync(options, @tracking_url)
-          log "Response " + response.inspect
-          if is_successful_sync(response)
+          log "Response #{response.inspect}"
+          if successful_sync?(response)
             data_not_sent.each { |it| it.sent = true }
             success = true
             break
@@ -703,17 +723,15 @@ module Kameleoon
           trials += 1
         end
         if success
-          log "Post to data tracking is done after " + (trials + 1).to_s + " trials"
+          log "Post to data tracking is done after #{trials + 1} trials"
         else
-          log "Post to data tracking is failed after " + trials.to_s + " trials"          
+          log "Post to data tracking is failed after #{trials} trials"
         end
       end
     end
 
-    def check_site_code_enable(exp_or_ff)
-      unless exp_or_ff['site'].nil? || exp_or_ff['site']['isKameleoonEnabled']
-        raise Exception::SiteCodeDisabled.new(site_code)
-      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)
@@ -721,8 +739,127 @@ module Kameleoon
     end
 
     def log(text)
-      if @verbose_mode
-        print "Kameleoon Log: " + text.to_s + "\n"
+      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)
+    #   unless variation_id.nil?
+    #     return @variation_storage.variation_valid?(visitor_code,
+    #                                                experiment.id.to_i,
+    #                                                experiment.respool_time[variation_id])
+    #   end
+    #   nil
+    # end
+
+    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) })
+    end
+
+    def get_condition_data(type, visitor_code, campaign_id)
+      condition_data = nil
+      case type
+      when Kameleoon::Targeting::ConditionType::CUSTOM_DATUM
+        condition_data = (@data[visitor_code] || []).flatten
+      when Kameleoon::Targeting::ConditionType::TARGET_EXPERIMENT
+        condition_data = @variation_storage.get_hash_saved_variation_id(visitor_code)
+      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)
+      end
+      condition_data
+    end
+
+    ##
+    # 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)
+      variation, rule = _calculate_variation_key_for_feature(visitor_code, feature_flag)
+      variation_key = _get_variation_key(variation, rule, feature_flag)
+      unless rule.nil?
+        save_variation(visitor_code, rule.experiment_id, variation.variation_id) unless variation.nil?
+        variation_id = variation.variation_id unless variation.nil?
+        _send_tracking_request(visitor_code, rule.experiment_id, variation_id)
+      end
+      [feature_flag, variation_key]
+    end
+
+    ##
+    # helper method for calculate variation key for feature flag
+    def _calculate_variation_key_for_feature(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
+        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)
+        # check main expostion for rule with hashRule
+        if hash_rule <= rule.exposition
+          # uses for variation's expositions
+          hash_variation = obtain_hash_double_rule(visitor_code, rule.experiment_id, rule.respool_time)
+          # get variation key with new hashVariation
+          variation = rule.get_variation(hash_variation)
+          # variation_key can be nil for experiment rules only, for targeted rule will be always exist
+          return [variation, rule] unless variation.nil?
+        # if visitor is targeted for targeted rule then break cycle -> return default
+        elsif rule.targeted_delivery_type?
+          break
+        end
+      end
+      [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.experiment_type?
+
+      feature_flag.default_variation_key
+    end
+
+    ##
+    # helper method for sending tracking requests for new FF
+    def _send_tracking_request(visitor_code, experiment_id, variation_id)
+      if !experiment_id.nil?
+        variation_reference_id = variation_id || 0
+        track_experiment(visitor_code, experiment_id, variation_reference_id)
+      else
+        log 'An attempt to send a request with null experimentId was blocked'
+      end
+    end
+
+    ##
+    # helper method for fetching values from a Variable
+    def _parse_feature_variable(variable)
+      case variable.type
+      when 'BOOLEAN', 'STRING', 'NUMBER'
+        variable.value
+      when 'JSON'
+        JSON.parse(variable.value)
+      else
+        raise TypeError.new('Unknown type for feature variable'),
+              'Unknown type for feature variable'
       end
     end
   end