kameleoon-client-ruby 2.0.0 → 2.1.1

data/lib/kameleoon/client.rb

@@ -4,10 +4,17 @@ require 'kameleoon/targeting/models'
 require 'kameleoon/request'
 require 'kameleoon/exceptions'
 require 'kameleoon/cookie'
+require 'kameleoon/data/user_agent'
 require 'kameleoon/configuration/feature_flag'
 require 'kameleoon/configuration/variation'
-require 'kameleoon/configuration/feature_flag_v2'
+require 'kameleoon/configuration/settings'
+require 'kameleoon/network/activity_event'
+require 'kameleoon/network/experiment_event'
+require 'kameleoon/network/url_provider'
+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'
@@ -36,19 +43,28 @@ module Kameleoon
       @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"
+      data_api_url = config['tracking_url'] || Network::UrlProvider::DEFAULT_DATA_API_URL
+      @url_provider = Network::UrlProvider.new(@site_code, data_api_url)
+      @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 = []
-      @feature_flags_v2 = []
       @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
 
     ##
@@ -112,25 +128,26 @@ module Kameleoon
       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)
+        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_key = saved_variation || variation_for_experiment(visitor_code, experiment)
-        if !variation_key.nil?
-          track_experiment(visitor_code, experiment_id, variation_key)
-          @variation_storage.update_variation(visitor_code, experiment_id, variation_key) if saved_variation.nil?
-          variation_key
-        else
-          track_experiment(visitor_code, experiment_id, REFERENCE, true)
-          raise Exception::NotAllocated.new(visitor_code),
-                "Experiment #{experiment_id} is not active for visitor #{visitor_code}"
-        end
-      else
+      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
     end
 
     ##
@@ -148,9 +165,7 @@ 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
+      @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)
@@ -196,7 +211,7 @@ module Kameleoon
     def flush(visitor_code = nil)
       check_visitor_code(visitor_code) unless visitor_code.nil?
       if !visitor_code.nil?
-        track_data(visitor_code)
+        _send_tracking_request(visitor_code)
       else
         @data.select { |_, values| values.any? { |data| !data.sent } }.each_key { |key| flush(key) }
       end
@@ -252,28 +267,11 @@ module Kameleoon
     # @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 `is_feature_active` instead.
     def activate_feature(visitor_code, feature_key)
-      check_visitor_code(visitor_code)
-      feature_flag = find_feature_flag(feature_key)
-      check_site_code_enable(feature_flag)
-      unless check_targeting(visitor_code, feature_flag.id.to_i, feature_flag)
-        raise Exception::NotTargeted.new(visitor_code),
-              "Visitor '#{visitor_code}' is not targeted for FF with key '#{feature_key}'"
-      end
-
-      if feature_flag.is_scheduled_active(Time.now.to_i)
-        threshold = obtain_hash_double(visitor_code, {}, feature_flag.id)
-        if threshold >= 1 - feature_flag.exposition_rate
-          track_experiment(visitor_code, feature_flag.id, feature_flag.variations.first['id'])
-          true
-        else
-          track_experiment(visitor_code, feature_flag.id, REFERENCE, none_variation: true)
-          false
-        end
-      else
-        false
-      end
+      warn '[DEPRECATION] `activate_feature` is deprecated.  Please use `feature_active?` instead.'
+      feature_active?(visitor_code, feature_key)
     end
 
     ##
@@ -356,7 +354,7 @@ module Kameleoon
     # @raise [Kameleoon::Exception::VariationConfigurationNotFound]
     #
     def get_feature_all_variables(feature_key, variation_key)
-      feature_flag = find_feature_flag_v2(feature_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),
@@ -381,54 +379,47 @@ module Kameleoon
     # 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.'
-      feature_flag = find_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'
-        custom_json['value']
-      when 'String'
-        custom_json['value']
-      when 'Number'
-        custom_json['value'].to_i
-      when 'JSON'
-        JSON.parse(custom_json['value'])
-      else
-        raise TypeError.new('Unknown type for feature variable')
-      end
+      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_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
+    # 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_data(key, timeout = @default_timeout)
       connexion_options = { connect_timeout: (timeout.to_f / 1000.0) }
-      path = get_api_data_request_url(key)
+      url = @url_provider.make_api_data_get_request_url(key)
       log "Retrieve API Data connexion: #{connexion_options.inspect}"
-      response = get_sync(@api_data_url + path, connexion_options)
-      if successful_sync?(response)
-        JSON.parse(response.body) unless response.nil?
-      else
-        return nil
-      end
+      response = get_sync(url, connexion_options)
+      return nil unless successful_sync?(response)
+
+      JSON.parse(response.body) unless response.nil?
+    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
 
     ##
     # Returns a list of all experiment ids
     #
     # @return [Array] array of all experiment ids
-    def get_experiment_list
+    def get_experiment_list # rubocop:disable Naming/AccessorMethodName
       @experiments.map { |it| it.id.to_i }
     end
 
@@ -443,7 +434,7 @@ module Kameleoon
       list_ids = []
       @experiments.each do |experiment|
         next unless check_targeting(visitor_code, experiment.id.to_i, experiment)
-        next if only_allocated && variation_for_experiment(visitor_code, experiment).nil?
+        next if only_allocated && calculate_variation_for_experiment(visitor_code, experiment).nil?
 
         list_ids.push(experiment.id.to_i)
       end
@@ -454,8 +445,8 @@ module Kameleoon
     # Returns a list of all feature flag keys
     #
     # @return [Array] array of all feature flag keys
-    def get_feature_list
-      @feature_flags_v2.map(&:feature_key)
+    def get_feature_list # rubocop:disable Naming/AccessorMethodName
+      @feature_flags.map(&:feature_key)
     end
 
     ##
@@ -467,40 +458,113 @@ module Kameleoon
     def get_active_feature_list_for_visitor(visitor_code)
       check_visitor_code(visitor_code)
       list_keys = []
-      @feature_flags_v2.each do |feature_flag|
-        variation_key, = _calculate_variation_key_for_feature(visitor_code, feature_flag)
-        list_keys.push(feature_flag.feature_key) if variation_key != Kameleoon::Configuration::VariationType::VARIATION_OFF
+      @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
       end
       list_keys
     end
 
+    ##
+    # 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
+
+    ##
+    # 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
+
     private
 
-    API_SSX_URL = 'https://api-ssx.kameleoon.com'
     REFERENCE = 0
     DEFAULT_ENVIRONMENT = 'production'
-    attr :site_code, :client_id, :client_secret, :access_token, :experiments, :feature_flags, :feature_flags_v2, :scheduler, :data,
+    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
 
     def fetch_configuration
-      @scheduler = Rufus::Scheduler.singleton
-      @scheduler.every @interval do
-        log('Scheduled job to fetch configuration is starting.')
-        fetch_configuration_job
-      end
-      @scheduler.schedule '0s' do
-        log('Start-up, fetching is starting')
+      Rufus::Scheduler.singleton.in '0s' do
+        log('Initial configuration fetch is started.')
         fetch_configuration_job
       end
     end
 
-    def fetch_configuration_job
+    def fetch_configuration_job(time_stamp = nil)
       EM.synchrony do
-        obtain_configuration(@site_code, @environment)
+        begin
+          ok = obtain_configuration(@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 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 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
+
+    def start_real_time_configuration_service_if_needed
+      return unless @real_time_configuration_service.nil?
+
+      url = @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))
+    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 = nil
+    end
+
+    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
@@ -515,26 +579,35 @@ module Kameleoon
     #   { 'field' => field, 'operator' => operator, 'parameters' => parameters }
     # end
 
-    def obtain_configuration(site_code, environment = @environment)
-      log "Fetching configuration from Client-Config service"
-      request_path = "mobile?siteCode=#{site_code}"
-      request_path += "&environment=#{environment}" unless environment.nil?
-      request = request_configuration(request_path)
-      return unless request
+    def obtain_configuration(environment = @environment, time_stamp = nil)
+      log 'Fetching configuration from Client-Config service'
+      url = @url_provider.make_configuration_url(environment, time_stamp)
+      request = request_configuration(url)
+      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['featureFlags']) ||
-                       @feature_flags
-      feature_flags_v2_new = Kameleoon::Configuration::FeatureFlagV2.create_from_array(
+      @feature_flags = Kameleoon::Configuration::FeatureFlag.create_from_array(
         configuration['featureFlagConfigurations']
       )
-      @feature_flags_v2 = feature_flags_v2_new || @feature_flags_v2
+      @settings.update(configuration['configuration'])
+      call_update_handler_if_needed(!time_stamp.nil?)
       log "Feature flags are fetched: #{request.inspect}"
+      true
     end
 
-    def variation_for_experiment(visitor_code, experiment)
+    ##
+    # 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 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
@@ -543,8 +616,8 @@ module Kameleoon
       nil
     end
 
-    def request_configuration(path)
-      request = EM::Synchrony.sync get({ path: path }, CLIENT_CONFIG_URL)
+    def request_configuration(url)
+      request = EM::Synchrony.sync get({}, url)
       unless successful?(request)
         log "Failed to fetch #{request.inspect}"
         return false
@@ -552,60 +625,9 @@ module Kameleoon
       request
     end
 
-    def get_common_ssx_parameters(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}"
-      if variation_id.nil?
-        return url
-      end
-      url += "&variationId=#{variation_id}"
-      if none_variation
-        url += '&noneVariation=true'
-      end
-      url
-    end
-
-    def get_data_register_url(visitor_code)
-      "/dataTracking?#{URI.encode_www_form(get_common_ssx_parameters(visitor_code))}"
-    end
-
-    def get_api_data_request_url(key)
-      mapKey = {
-        siteCode: site_code,
-        key: key
-      }
-      "/data?#{URI.encode_www_form(mapKey)}"
-    end
-
     def find_feature_flag(feature_key)
-      case feature_key
-      when String
-        feature_flag = @feature_flags.select { |ff| ff.identification_key == feature_key }.first
-      when 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"
-      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 find_feature_flag_v2(feature_key)
       if feature_key.is_a?(String)
-        feature_flag = @feature_flags_v2.select { |ff| ff.feature_key == feature_key }.first
+        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.'
@@ -616,67 +638,6 @@ module Kameleoon
       feature_flag
     end
 
-    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(&: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}"
-      Thread.new do
-        while trial < 10
-          log "Send Experiment Tracking #{options.inspect}"
-          response = post_sync(options, @tracking_url)
-          log "Response #{response.inspect}"
-          if successful_sync?(response)
-            data_not_sent.each { |it| it.sent = true }
-            success = true
-            break
-          end
-          trial += 1
-        end
-        if success
-          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
-
-    def track_data(visitor_code)
-      Thread.new do
-        trials = 0
-        data_not_sent = data_not_sent(visitor_code)
-        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(&:obtain_full_post_text_line).join("\n") || '').encode('UTF-8'),
-            head: { 'Content-Type': 'text/plain' }
-          }
-          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 successful_sync?(response)
-            data_not_sent.each { |it| it.sent = true }
-            success = true
-            break
-          end
-          trials += 1
-        end
-        if success
-          log "Post to data tracking is done after #{trials + 1} trials"
-        else
-          log "Post to data tracking is failed after #{trials} trials"
-        end
-      end
-    end
-
     def check_site_code_enable(campaign)
       raise Exception::SiteCodeDisabled.new(site_code), site_code unless campaign.site_enabled
     end
@@ -686,7 +647,7 @@ module Kameleoon
     end
 
     def log(text)
-      print "Kameleoon Log: #{text}\n" if @verbose_mode
+      print "Kameleoon SDK Log: #{text}\n" if @verbose_mode
     end
 
     def add_user_agent_data(visitor_code, user_agent)
@@ -698,15 +659,16 @@ module Kameleoon
       headers['User-Agent'] = user_agent.value unless user_agent.nil?
     end
 
-    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
+    # 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
@@ -716,8 +678,17 @@ module Kameleoon
     def get_condition_data(type, visitor_code, campaign_id)
       condition_data = nil
       case type
-      when Kameleoon::Targeting::ConditionType::CUSTOM_DATUM
+      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::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)
       when Kameleoon::Targeting::ConditionType::EXCLUSIVE_EXPERIMENT
@@ -732,11 +703,15 @@ 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_v2(feature_key)
-      variation_key, rule = _calculate_variation_key_for_feature(visitor_code, feature_flag)
-      if !rule.nil? && rule.type == Kameleoon::Configuration::RuleType::EXPERIMENTATION
-        _send_tracking_request(visitor_code, variation_key, rule)
-      end
+      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?
+        experiment_id = rule.experiment_id
+        variation_id = variation.variation_id unless variation.nil?
+        save_variation(visitor_code, experiment_id, variation_id)
+      end
+      _send_tracking_request(visitor_code, experiment_id, variation_id)
       [feature_flag, variation_key]
     end
 
@@ -744,37 +719,79 @@ module Kameleoon
     # 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
-      unless feature_flag.rules.empty?
+      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_v2(visitor_code, feature_flag.id)
-        # uses for variation's expositions
-        hash_variation = obtain_hash_double_v2(visitor_code, feature_flag.id, 'variation')
-        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)
-
-          # check main expostion for rule with hashRule
-          if hash_rule < rule.exposition
-            # get variation key with new hashVariation
-            variation_key = rule.get_variation_key(hash_variation)
-            # variation_key can be nil for experiment rules only, for targeted rule will be always exist
-            return [variation_key, rule] unless variation_key.nil?
-          # if visitor is targeted for targeted rule then break cycle -> return default
-          elsif rule.type == Kameleoon::Configuration::RuleType::TARGETED_DELIVERY
-            break
-          end
+        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
+          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)
+          # get variation key with new hashVariation
+          variation = rule.get_variation(hash_variation)
+          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
-      [feature_flag.default_variation_key, nil]
+      [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
     end
 
     ##
-    # helper method for sending tracking requests for new FF v2
-    def _send_tracking_request(visitor_code, variation_key, rule)
-      if !rule.experiment_id.nil?
-        track_experiment(visitor_code, rule.experiment_id, rule.get_variation_id_by_key(variation_key))
+    # helper method for sending tracking requests for new FF
+    def _send_tracking_request(visitor_code, experiment_id = nil, variation_id = nil)
+      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?
       else
-        log 'An attempt to send a request with null experimentId was blocked'
+        data_not_sent.append(Network::ExperimentEvent.new(experiment_id, variation_id))
+      end
+      options = {
+        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])
+      url = @url_provider.make_tracking_url(visitor_code)
+      trial = 0
+      success = false
+      log "Start post tracking: #{data_not_sent.inspect}"
+      Thread.new do
+        while trial < 10
+          log "Send tracking #{options.inspect}"
+          response = post_sync(options, url)
+          log "Response #{response.inspect}"
+          if successful_sync?(response)
+            data_not_sent.each { |it| it.sent = true }
+            success = true
+            break
+          end
+          trial += 1
+        end
+        if success
+          log "Post to tracking is done after #{trial + 1} trials"
+        else
+          log "Post to tracking is failed after #{trial} trials"
+        end
       end
     end