kameleoon-client-ruby 3.18.0 → 3.20.0

data/lib/kameleoon/network/access_token_source.rb

@@ -5,6 +5,7 @@ require 'net/http'
 require 'time'
 require 'kameleoon/utils'
 require 'kameleoon/logging/kameleoon_logger'
+require 'base64'
 
 module Kameleoon
   module Network
@@ -13,6 +14,7 @@ module Kameleoon
       TOKEN_OBSOLESCENCE_GAP = 1800 # in seconds
       JWT_ACCESS_TOKEN_FIELD = 'access_token'
       JWT_EXPIRES_IN_FIELD = 'expires_in'
+      BASIC_AUTHORIZATION_PREFIX = 'Basic '
 
       def initialize(network_manager, client_id, client_secret)
         Logging::KameleoonLogger.debug(lambda {
@@ -23,15 +25,21 @@ module Kameleoon
         @client_id = client_id
         @client_secret = client_secret
         @fetching = false
+        @basic_auth_token = AccessTokenSource.construct_basic_token(client_id, client_secret)
         Logging::KameleoonLogger.debug(lambda {
           format("RETURN: AccessTokenSource.new(network_manager, client_id: '%s', client_secret: '%s')",
                  Utils::Strval.secret(client_id), Utils::Strval.secret(client_secret))
         })
       end
 
+      def self.construct_basic_token(client_id, client_secret)
+        basic_token_content = "#{client_id}:#{client_secret}"
+        "#{BASIC_AUTHORIZATION_PREFIX}#{Base64.strict_encode64(basic_token_content)}"
+      end
+
       def get_token(timeout = nil)
         Logging::KameleoonLogger.debug('CALL: AccessTokenSource.getToken(timeout: %s)', timeout)
-        now = Time.new.to_i
+        now = Time.new.to_f
         token = @cached_token
         return call_fetch_token(timeout) if token.nil? || token.expired?(now)
 
@@ -70,7 +78,7 @@ module Kameleoon
 
       def fetch_token(timeout = nil)
         Logging::KameleoonLogger.debug('CALL: AccessTokenSource.fetch_token(timeout: %s)', timeout)
-        response_content = @network_manager.fetch_access_jwtoken(@client_id, @client_secret, timeout)
+        response_content = @network_manager.fetch_access_jwtoken(@basic_auth_token, timeout)
         unless response_content
           Logging::KameleoonLogger.error('Failed to fetch access JWT')
           return nil
@@ -97,7 +105,7 @@ module Kameleoon
       end
 
       def handle_fetched_token(token, expires_in)
-        now = Time.new.to_i
+        now = Time.new.to_f
         exp_time = now + expires_in - TOKEN_EXPIRATION_GAP
         if expires_in > TOKEN_OBSOLESCENCE_GAP
           obs_time = now + expires_in - TOKEN_OBSOLESCENCE_GAP

data/lib/kameleoon/network/activity_event.rb

@@ -18,7 +18,7 @@ module Kameleoon
         @sent = false
       end
 
-      def obtain_full_post_text_line
+      def query
         params = {
           eventType: EVENT_TYPE,
           nonce: Kameleoon::Utils.generate_random_string(Kameleoon::NONCE_LENGTH)

data/lib/kameleoon/network/net_provider.rb

@@ -17,7 +17,10 @@ module Kameleoon
       def collect_headers(request)
         headers = { 'Content-Type' => request.content_type }
         headers.merge!(request.extra_headers) unless request.extra_headers.nil?
-        headers['Authorization'] = "Bearer #{request.access_token}" unless request.access_token.nil?
+        unless request.access_token.nil? || request.access_token.empty?
+          token_prefix = request.access_token.start_with?('Basic') ? '' : 'Bearer '
+          headers['Authorization'] = "#{token_prefix}#{request.access_token}"
+        end
         headers
       end
 

data/lib/kameleoon/network/network_manager.rb

@@ -70,16 +70,15 @@ module Kameleoon
         unwrap_response(*make_call(request, true, TRACKING_CALL_ATTEMPT_NUMBER - 1, TRACKING_CALL_RETRY_DELAY))
       end
 
-      def fetch_access_jwtoken(client_id, client_secret, timeout = nil)
+      def fetch_access_jwtoken(basic_auth_token, timeout = nil)
         url = @url_provider.make_access_token_url
         timeout = ensure_timeout(timeout)
         data_map = {
           grant_type: ACCESS_TOKEN_GRANT_TYPE,
-          client_id: client_id,
-          client_secret: client_secret
         }
         data = UriHelper.encode_query(data_map).encode('UTF-8')
         request = Request.new(Method::POST, url, ContentType::FORM, timeout, data: data)
+        request.authorize(basic_auth_token)
         unwrap_response(*make_call(request, false))
       end
 

data/lib/kameleoon/network/request.rb

@@ -11,12 +11,15 @@ module Kameleoon
         body = 'null'
         unless @data.nil?
           if @data.is_a?(String)
-            body = @data.start_with?('grant_type=client_credentials') ? '****' : @data
-          else
             body = @data
           end
         end
-        "Request{method:'#{@method}',url:'#{@url}',headers:#{@extra_headers},body:'#{body}'}"
+
+        headers = ''
+        headers += 'Authorization: ***' unless access_token.nil?
+        headers += @extra_headers.to_s unless @extra_headers.nil?
+
+        "Request{method:'#{@method}',url:'#{@url}',headers:#{headers},body:'#{body}'}"
       end
 
       def initialize(method, url, content_type, timeout, extra_headers: nil, data: nil)

data/lib/kameleoon/network/url_provider.rb

@@ -22,7 +22,7 @@ module Kameleoon
       CONFIGURATION_API_URL_FORMAT = 'https://%s/v3/%s'
       DATA_API_URL_FORMAT = 'https://%s%s?%s'
       RT_CONFIGURATION_URL_FORMAT = 'https://%s:8110/sse?%s'
-      ACCESS_TOKEN_URL_FORMAT = 'https://%s/oauth/token'
+      ACCESS_TOKEN_URL_FORMAT = 'https://%s/oauth/token?%s'
 
       TEST_DATA_API_DOMAIN = 'data.kameleoon.net'
       TEST_AUTOMATION_API_DOMAIN = 'api.kameleoon.net'
@@ -39,6 +39,15 @@ module Kameleoon
         @configuration_domain = DEFAULT_CONFIGURATION_DOMAIN
         @access_token_domain = DEFAULT_ACCESS_TOKEN_DOMAIN
         @is_custom_domain = false
+
+        url_params = {
+          sdkName: SDK_NAME,
+          sdkVersion: SDK_VERSION,
+          siteCode: @site_code
+        }
+        @access_token_url_params = UriHelper.encode_query(url_params)
+        url_params[:bodyUa] = true
+        @tracking_url_params = UriHelper.encode_query(url_params)
         update_domains(network_domain)
       end
 
@@ -60,7 +69,7 @@ module Kameleoon
           siteCode: @site_code,
           bodyUa: true
         }
-        format(DATA_API_URL_FORMAT, @data_api_domain, TRACKING_PATH, UriHelper.encode_query(params))
+        format(DATA_API_URL_FORMAT, @data_api_domain, TRACKING_PATH, @tracking_url_params)
       end
 
       def make_visitor_data_get_url(visitor_code, filter, is_unique_identifier = false)
@@ -104,11 +113,20 @@ module Kameleoon
       end
 
       def make_access_token_url
-        format(ACCESS_TOKEN_URL_FORMAT, @access_token_domain)
+        format(ACCESS_TOKEN_URL_FORMAT, @access_token_domain, @access_token_url_params)
       end
 
       private
 
+      def make_post_query_base(site_code)
+        data_map = {
+          "sdkName": Kameleoon::SDK_NAME,
+          "sdkVersion": Kameleoon::SDK_VERSION,
+          "siteCode": site_code
+        }
+        data = UriHelper.encode_query(data_map).encode('UTF-8')
+      end
+
       def update_domains(network_domain)
         return if network_domain.nil? || network_domain.empty?
 

data/lib/kameleoon/targeting/conditions/conversion_condition.rb

@@ -1,28 +1,43 @@
 # frozen_string_literal: true
 
 require 'kameleoon/data/conversion'
-require 'kameleoon/data/manager/data_array_storage'
+require 'kameleoon/targeting/conditions/visitor_scope_condition'
 
 module Kameleoon
-  # @api private
   module Targeting
-    # ConversionCondition is a condition for checking targeting of conversions of visitor
-    class ConversionCondition < Condition
+    class ConversionCondition < VisitorScopeCondition
       def initialize(json_condition)
-        super(json_condition)
+        super(json_condition, VisitScope::VISITOR)
         @goal_id = json_condition['goalId']
       end
 
-      def check(conversion_storage)
-        return false unless conversion_storage.is_a?(Kameleoon::DataManager::DataArrayStorage)
-        return true if @goal_id.nil?
+      def check(data)
+        return false unless data.is_a?(TargetingData)
 
-        is_targeted = false
-        conversion_storage.enumerate do |conversion|
-          is_targeted = conversion.is_a?(Kameleoon::Conversion) && (@goal_id == conversion.goal_id)
-          break if is_targeted
+        threshold = assignment_threshold(data.visitor_visits)
+        targeted_conversion?(data.conversions, threshold)
+      end
+
+      private
+
+      def targeted_conversion?(conversions, threshold)
+        return false unless conversions.respond_to?(:enumerate)
+
+        targeted = false
+        conversions.enumerate do |conversion|
+          targeted = (@goal_id.nil? || @goal_id == conversion.goal_id) && conversion.assignment_time >= threshold
+          break if targeted
+        end
+        targeted
+      end
+
+      class TargetingData
+        attr_reader :conversions, :visitor_visits
+
+        def initialize(conversions, visitor_visits)
+          @conversions = conversions
+          @visitor_visits = visitor_visits
         end
-        is_targeted
       end
     end
   end

data/lib/kameleoon/targeting/conditions/exclusive_experiment_condition.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
 require 'kameleoon/logging/kameleoon_logger'
-require 'kameleoon/targeting/condition'
+require 'kameleoon/targeting/conditions/visitor_scope_condition'
 
 module Kameleoon
   # @api private
   module Targeting
     # ExclusiveExperiment represents an instance of Exclusive Experiment condition in user account
-    class ExclusiveExperimentCondition < Condition
+    class ExclusiveExperimentCondition < VisitorScopeCondition
       module CampaignType
         EXPERIMENT = 'EXPERIMENT'
         PERSONALIZATION = 'PERSONALIZATION'
@@ -15,21 +15,22 @@ module Kameleoon
       end
 
       def initialize(json_condition)
-        super(json_condition)
+        super(json_condition, VisitScope::VISITOR)
 
         @campaign_type = json_condition['campaignType']
       end
 
       def check(data)
-        return false unless data.is_a?(ExclusiveExperimentInfo)
+        return false unless data.is_a?(TargetingData)
 
+        threshold = assignment_threshold(data.visitor_visits)
         case @campaign_type
         when CampaignType::EXPERIMENT
-          return check_experiment(data)
+          return check_experiment(data, threshold)
         when CampaignType::PERSONALIZATION
-          return check_personalization(data)
+          return check_personalization(data, threshold)
         when CampaignType::ANY
-          return check_personalization(data) && check_experiment(data)
+          return check_personalization(data, threshold) && check_experiment(data, threshold)
         end
         Logging::KameleoonLogger.error("Unexpected campaign type for '#{type}' condition: '#{@campaign_type}'")
         false
@@ -37,23 +38,41 @@ module Kameleoon
 
       private
 
-      def check_experiment(data)
-        size = data.variations_storage&.size || 0
-        size.zero? || (size == 1 && !data.variations_storage.get(data.current_experiment_id).nil?)
+      def check_experiment(data, threshold)
+        return true if data.variations.nil?
+
+        result = true
+        data.variations.enumerate do |variation|
+          if variation.experiment_id != data.current_experiment_id && variation.assignment_time >= threshold
+            result = false
+            break
+          end
+        end
+        result
       end
 
-      def check_personalization(data)
-        (data.personalizations_storage&.size || 0).zero?
+      def check_personalization(data, threshold)
+        return true if data.personalizations.nil?
+
+        result = true
+        data.personalizations.enumerate do |personalization|
+          if personalization.assignment_time >= threshold
+            result = false
+            break
+          end
+        end
+        result
       end
-    end
 
-    class ExclusiveExperimentInfo
-      attr_reader :current_experiment_id, :variations_storage, :personalizations_storage
+      class TargetingData
+        attr_reader :current_experiment_id, :variations, :personalizations, :visitor_visits
 
-      def initialize(current_experiment_id, variations_storage, personalizations_storage)
-        @current_experiment_id = current_experiment_id
-        @variations_storage = variations_storage
-        @personalizations_storage = personalizations_storage
+        def initialize(current_experiment_id, variations, personalizations, visitor_visits = nil)
+          @current_experiment_id = current_experiment_id
+          @variations = variations
+          @personalizations = personalizations
+          @visitor_visits = visitor_visits
+        end
       end
     end
   end

data/lib/kameleoon/targeting/conditions/target_experiment_condition.rb

@@ -1,17 +1,17 @@
 # frozen_string_literal: true
 
 require 'kameleoon/logging/kameleoon_logger'
-require 'kameleoon/targeting/condition'
+require 'kameleoon/targeting/conditions/visitor_scope_condition'
 
 module Kameleoon
   # @api private
   module Targeting
     # TargetExperiment represents an instance of Experiment condition in user account
-    class TargetExperimentCondition < Condition
+    class TargetExperimentCondition < VisitorScopeCondition
       include Kameleoon::Exception
 
       def initialize(json_condition)
-        super(json_condition)
+        super(json_condition, VisitScope::CURRENT_VISIT)
 
         @variation_id = json_condition['variationId'] || -1
         @experiment_id = json_condition['experimentId'] || -1
@@ -19,9 +19,10 @@ module Kameleoon
       end
 
       def check(data)
-        return false unless data.is_a?(TargetExperimentInfo)
+        return false unless data.is_a?(TargetingData)
 
-        variation = data.variations_storage&.get(@experiment_id)
+        variation = data.variations&.get(@experiment_id)
+        variation = nil if !variation.nil? && variation.assignment_time < assignment_threshold(data.visitor_visits)
         case @variation_match_type
         when Operator::ANY
           return !variation.nil?
@@ -33,13 +34,14 @@ module Kameleoon
         )
         false
       end
-    end
 
-    class TargetExperimentInfo
-      attr_reader :variations_storage
+      class TargetingData
+        attr_reader :variations, :visitor_visits
 
-      def initialize(variations_storage)
-        @variations_storage = variations_storage
+        def initialize(variations, visitor_visits = nil)
+          @variations = variations
+          @visitor_visits = visitor_visits
+        end
       end
     end
   end

data/lib/kameleoon/targeting/conditions/target_feature_flag_condition.rb

@@ -1,59 +1,63 @@
 # frozen_string_literal: true
 
-require 'kameleoon/targeting/condition'
+require 'kameleoon/targeting/conditions/visitor_scope_condition'
 require 'kameleoon/exceptions'
 
 module Kameleoon
   # @api private
   module Targeting
-    # TargetFeatureFlag represents an instance of FeatureFlag condition in user account
-    class TargetFeatureFlagCondition < Condition
+    class TargetFeatureFlagCondition < VisitorScopeCondition
       include Kameleoon::Exception
 
       def initialize(json_condition)
-        super(json_condition)
-
+        super(json_condition, VisitScope::CURRENT_VISIT)
         @feature_flag_id = json_condition['featureFlagId']
         @condition_variation_key = json_condition['variationKey']
         @condition_rule_id = json_condition['ruleId']
       end
 
       def check(data)
-        return false unless data.is_a?(TargetFeatureFlagInfo) && data.variations_storage.size.positive?
+        return false unless valid_data?(data)
 
         get_rules(data).any? { |rule| check_rule(data, rule) }
       end
 
       private
 
+      def valid_data?(data)
+        data.is_a?(TargetingData) && !data.data_file.nil? && data.variations&.size.to_i.positive?
+      end
+
       def check_rule(data, rule)
         return false unless rule.is_a?(Configuration::Rule)
-        return false if !@condition_rule_id.nil? && (@condition_rule_id != rule.id)
-
-        variation = data.variations_storage.get(rule.experiment.id)
-        return false if variation.nil?
+        return false if @condition_rule_id && @condition_rule_id != rule.id
 
-        return true if @condition_variation_key.nil?
+        variation = data.variations.get(rule.experiment.id)
+        return false if variation.nil? || variation.assignment_time < assignment_threshold(data.visitor_visits)
 
-        variation = data.data_file.variation_by_id[variation.variation_id]
+        check_variation_key(data.data_file, variation)
+      end
 
-        return false unless variation.is_a?(Configuration::VariationByExposition)
+      def check_variation_key(data_file, variation)
+        return true if @condition_variation_key.nil?
 
-        variation.variation_key == @condition_variation_key
+        resolved = data_file.variation_by_id[variation.variation_id]
+        resolved.is_a?(Configuration::VariationByExposition) &&
+          resolved.variation_key == @condition_variation_key
       end
 
       def get_rules(data)
-        feature_flag = data.data_file.feature_flag_by_id[@feature_flag_id]
-        feature_flag&.rules || []
+        data.data_file.feature_flag_by_id[@feature_flag_id]&.rules || []
       end
-    end
 
-    class TargetFeatureFlagInfo
-      attr_reader :data_file, :variations_storage
+      class TargetingData
+        attr_reader :data_file, :variations, :visitor_visits
 
-      def initialize(data_file, variations_storage)
-        @data_file = data_file
-        @variations_storage = variations_storage
+        def initialize(data_file, variations, visitor_visits = nil)
+          @data_file = data_file
+          @variations = variations
+          @visitor_visits = visitor_visits
+        end
       end
     end
   end

data/lib/kameleoon/targeting/conditions/target_personalization_condition.rb

@@ -1,32 +1,34 @@
 # frozen_string_literal: true
 
-require 'kameleoon/targeting/condition'
+require 'kameleoon/targeting/conditions/visitor_scope_condition'
 
 module Kameleoon
   # @api private
   module Targeting
     # TargetPersonalization represents an instance of Personalization condition in user account
-    class TargetPersonalizationCondition < Condition
+    class TargetPersonalizationCondition < VisitorScopeCondition
       include Kameleoon::Exception
 
       def initialize(json_condition)
-        super(json_condition)
+        super(json_condition, VisitScope::CURRENT_VISIT)
 
         @personalization_id = json_condition['personalizationId'] || -1
       end
 
       def check(data)
-        return false unless data.is_a?(TargetPersonalizationInfo)
+        return false unless data.is_a?(TargetingData)
 
-        !data.personalizations_storage&.get(@personalization_id).nil?
+        personalization = data.personalizations&.get(@personalization_id)
+        !personalization.nil? && personalization.assignment_time >= assignment_threshold(data.visitor_visits)
       end
-    end
 
-    class TargetPersonalizationInfo
-      attr_reader :personalizations_storage
+      class TargetingData
+        attr_reader :personalizations, :visitor_visits
 
-      def initialize(personalizations_storage)
-        @personalizations_storage = personalizations_storage
+        def initialize(personalizations, visitor_visits = nil)
+          @personalizations = personalizations
+          @visitor_visits = visitor_visits
+        end
       end
     end
   end

data/lib/kameleoon/targeting/conditions/time_elapsed_since_visit_condition.rb

@@ -19,9 +19,8 @@ module Kameleoon
 
         prev_visits = data.prev_visits
         if prev_visits.size >= 1
-          now = (Time.now.to_f * 1000).to_i # ... * 1000 for convert seconds to milliseconds
           visit_time = prev_visits[@is_first_visit ? prev_visits.size - 1 : 0].time_started
-          return check_targeting(now - visit_time)
+          return check_targeting(Time.now.to_f - visit_time)
         end
         false
       end

data/lib/kameleoon/targeting/conditions/unknown_condition.rb

@@ -8,6 +8,7 @@ module Kameleoon
     # UnknownCondition represents not defined condition, always returns that visitor is targeted (true)
     class UnknownCondition < Condition
       def check(_data)
+        Logging::KameleoonLogger.warning('Condition of unknown type \'%s\' evaluated as true', type)
         true
       end
     end

data/lib/kameleoon/targeting/conditions/visit_number_today_condition.rb

@@ -16,7 +16,7 @@ module Kameleoon
         return false unless data.is_a?(TargetingData) && !@condition_value.nil?
 
         number_of_visits_today = 0
-        start_of_day = (Time.new.to_date.to_time.to_f * 1000).to_i # ... * 1000 to convert seconds to milliseconds
+        start_of_day = Time.new.to_date.to_time.to_f
         data.visitor_visits.prev_visits.each do |visit|
           break if visit.time_started < start_of_day
 
@@ -31,7 +31,7 @@ module Kameleoon
 
         def initialize(current_visit_time_started, visitor_visits)
           @current_visit_time_started =
-            current_visit_time_started.is_a?(Integer) ? current_visit_time_started : (Time.new.to_f * 1000).to_i
+            current_visit_time_started.is_a?(Integer) ? current_visit_time_started : Time.new.to_f
           @visitor_visits = visitor_visits.is_a?(VisitorVisits) ? visitor_visits : VisitorVisits.new([])
         end
       end

data/lib/kameleoon/targeting/conditions/visitor_scope_condition.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'kameleoon/data/visitor_visits'
+require 'kameleoon/targeting/condition'
+
+module Kameleoon
+  # @api private
+  module Targeting
+    module VisitScope
+      CURRENT_VISIT = 'CURRENT_VISIT'
+      VISITOR = 'VISITOR'
+    end
+
+    class VisitorScopeCondition < Condition
+      MIN_VISITOR_VISIT_COUNT = 2
+      MAX_VISITOR_VISIT_COUNT = 25
+
+      def initialize(json_condition, default_visit_scope)
+        super(json_condition)
+        @visit_scope = parse_visit_scope(json_condition['visitScope'], default_visit_scope)
+        @visit_count = parse_visit_count(json_condition['visitCount'])
+      end
+
+      private
+
+      def assignment_threshold(visitor_visits)
+        return 0.0 unless visitor_visits.is_a?(Kameleoon::VisitorVisits)
+
+        prev_visits = visitor_visits.prev_visits
+        if @visit_scope == VisitScope::CURRENT_VISIT || @visit_count < MIN_VISITOR_VISIT_COUNT || prev_visits.empty?
+          return visitor_visits.time_started
+        end
+
+        visit_index = [[@visit_count - MIN_VISITOR_VISIT_COUNT, 0].max, prev_visits.size - 1].min
+        prev_visits[visit_index].time_started
+      end
+
+      def parse_visit_scope(value, default_visit_scope)
+        case value&.upcase
+        when VisitScope::CURRENT_VISIT
+          VisitScope::CURRENT_VISIT
+        when VisitScope::VISITOR
+          VisitScope::VISITOR
+        else
+          default_visit_scope
+        end
+      end
+
+      def parse_visit_count(value)
+        return value if value.is_a?(Integer) && value.positive?
+
+        MAX_VISITOR_VISIT_COUNT
+      end
+    end
+  end
+end

data/lib/kameleoon/targeting/targeting_manager.rb

@@ -2,6 +2,7 @@
 
 require 'kameleoon/logging/kameleoon_logger'
 require 'kameleoon/targeting/condition'
+require 'kameleoon/targeting/conditions/conversion_condition'
 require 'kameleoon/targeting/conditions/exclusive_experiment_condition'
 require 'kameleoon/targeting/conditions/sdk_language_condition'
 require 'kameleoon/targeting/conditions/segment_condition'
@@ -68,20 +69,26 @@ module Kameleoon
             }
           )
         when ConditionType::CONVERSIONS
-          condition_data = visitor.conversions unless visitor.nil?
+          condition_data = ConversionCondition::TargetingData.new(visitor&.conversions, visitor&.visitor_visits)
         when ConditionType::SDK_LANGUAGE
           condition_data = SdkInfo.new(Kameleoon::SDK_NAME, Kameleoon::SDK_VERSION)
         when ConditionType::VISITOR_CODE
           condition_data = visitor_code
         when ConditionType::TARGET_FEATURE_FLAG
-          condition_data = TargetFeatureFlagInfo.new(@data_manager.data_file, visitor.variations) unless visitor.nil?
+          condition_data = TargetFeatureFlagCondition::TargetingData.new(
+            @data_manager.data_file, visitor&.variations, visitor&.visitor_visits
+          )
         when ConditionType::TARGET_EXPERIMENT
-          condition_data = TargetExperimentInfo.new(visitor&.variations)
+          condition_data = TargetExperimentCondition::TargetingData.new(visitor&.variations, visitor&.visitor_visits)
         when ConditionType::TARGET_PERSONALIZATION
-          condition_data = TargetPersonalizationInfo.new(visitor&.personalizations)
+          condition_data = TargetPersonalizationCondition::TargetingData.new(
+            visitor&.personalizations, visitor&.visitor_visits
+          )
         when ConditionType::EXCLUSIVE_EXPERIMENT
           unless campaign_id.nil?
-            condition_data = ExclusiveExperimentInfo.new(campaign_id, visitor&.variations, visitor&.personalizations)
+            condition_data = ExclusiveExperimentCondition::TargetingData.new(
+              campaign_id, visitor&.variations, visitor&.personalizations, visitor&.visitor_visits
+            )
           end
         when ConditionType::FIRST_VISIT,
           ConditionType::LAST_VISIT,