kameleoon-client-ruby 3.1.1 → 3.3.0

data/lib/kameleoon/network/access_token_source.rb

@@ -20,12 +20,12 @@ module Kameleoon
         @log_func = log_func
       end
 
-      def get_token
+      def get_token(timeout = nil)
         now = Time.new.to_i
         token = @cached_token
-        return fetch_token if token.nil? || token.expired?(now)
+        return call_fetch_token(timeout) if token.nil? || token.expired?(now)
 
-        Thread.new { fetch_token } if !@fetching && token.obsolete?(now)
+        run_fetch_token if !@fetching && token.obsolete?(now)
         token.value
       end
 
@@ -35,9 +35,26 @@ module Kameleoon
 
       private
 
-      def fetch_token
+      def call_fetch_token(timeout)
         @fetching = true
-        response_content = @network_manager.fetch_access_jwtoken(@client_id, @client_secret)
+        fetch_token(timeout)
+      rescue StandardError => e
+        @fetching = false
+        @log_func&.call("Failed to call access token fetching: #{e}")
+        nil
+      end
+
+      def run_fetch_token
+        # setting `@fetching` here to reduce the number of requests until new thread started
+        @fetching = true
+        Thread.new { fetch_token }
+      rescue StandardError => e
+        @fetching = false
+        @log_func&.call("Failed to run access token fetching: #{e}")
+      end
+
+      def fetch_token(timeout = nil)
+        response_content = @network_manager.fetch_access_jwtoken(@client_id, @client_secret, timeout)
         unless response_content
           @log_func&.call('Failed to fetch access JWT')
           return nil

data/lib/kameleoon/network/network_manager.rb

@@ -45,17 +45,17 @@ module Kameleoon
         make_call(request, true)
       end
 
-      def get_remote_visitor_data(visitor_code, timeout = nil)
-        url = @url_provider.make_visitor_data_get_url(visitor_code)
+      def get_remote_visitor_data(visitor_code, filter, is_unique_identifier, timeout = nil)
+        url = @url_provider.make_visitor_data_get_url(visitor_code, filter, is_unique_identifier)
         timeout = ensure_timeout(timeout)
         request = Request.new(Method::GET, url, ContentType::JSON, timeout)
         make_call(request, true)
       end
 
-      def send_tracking_data(visitor_code, lines, user_agent, timeout = nil)
+      def send_tracking_data(visitor_code, lines, user_agent, is_unique_identifier, timeout = nil)
         return if lines.nil? || lines.empty?
 
-        url = @url_provider.make_tracking_url(visitor_code)
+        url = @url_provider.make_tracking_url(visitor_code, is_unique_identifier)
         timeout = ensure_timeout(timeout)
         data = (lines.map(&:obtain_full_post_text_line).join("\n") || '').encode('UTF-8')
         request = Request.new(Method::POST, url, ContentType::TEXT, timeout, user_agent: user_agent, data: data)
@@ -87,11 +87,13 @@ module Kameleoon
           delay(retry_delay) if attempt.positive? && retry_delay.positive?
           try_authorize(request) if try_access_token_auth
           response = @sync_net_provider.make_request(request)
-          if !response.error.nil?
+          if response.success?
+            success = true
+          elsif !response.error.nil?
             log_failure(request, "Error occurred during request: #{response.error}")
-          elsif response.code / 100 != 2
+          else
             log_failure(request, "Received unexpected status code '#{response.code}'")
-            if ((response.code == 401) || (response.code == 403)) && request.access_token
+            if response.code == 401 && request.access_token
               @log_func&.call("Unexpected rejection of access token '#{request.access_token}'")
               @access_token_source.discard_token(request.access_token)
               if attempt == retry_limit
@@ -101,8 +103,6 @@ module Kameleoon
                 attempt -= 1
               end
             end
-          else
-            success = true
           end
           attempt += 1
         end
@@ -126,7 +126,7 @@ module Kameleoon
       end
 
       def try_authorize(request)
-        token = @access_token_source.get_token
+        token = @access_token_source.get_token(request.timeout)
         request.authorize(token)
       end
     end

data/lib/kameleoon/network/response.rb

@@ -15,7 +15,7 @@ module Kameleoon
       end
 
       def success?
-        @error.nil? && (@code / 100 == 2)
+        @error.nil? && ((@code / 100 == 2) || (@code == 403))
       end
     end
   end

data/lib/kameleoon/network/url_provider.rb

@@ -37,25 +37,29 @@ module Kameleoon
         @data_api_domain = domain if domain.is_a?(String)
       end
 
-      def make_tracking_url(visitor_code)
+      def make_tracking_url(visitor_code, is_unique_identifier = false)
         params = {
           sdkName: SDK_NAME,
           sdkVersion: SDK_VERSION,
-          siteCode: @site_code,
-          visitorCode: visitor_code
+          siteCode: @site_code
         }
+        params[is_unique_identifier ? :mappingValue : :visitorCode] = visitor_code
         "https://#{@data_api_domain}#{TRACKING_PATH}?#{UriHelper.encode_query(params)}"
       end
 
-      def make_visitor_data_get_url(visitor_code)
-        params = {
-          siteCode: @site_code,
-          visitorCode: visitor_code,
-          currentVisit: true,
-          maxNumberPreviousVisits: 1,
-          customData: true,
-          version: 0
-        }
+      def make_visitor_data_get_url(visitor_code, filter, is_unique_identifier = false)
+        params = { siteCode: @site_code }
+        params[is_unique_identifier ? :mappingValue : :visitorCode] = visitor_code
+        params[:maxNumberPreviousVisits] = filter.previous_visit_amount
+        params[:version] = 0
+        params[:kcs] = true if filter.kcs
+        params[:currentVisit] = true if filter.current_visit
+        params[:customData] = true if filter.custom_data
+        params[:conversion] = true if filter.conversions
+        params[:geolocation] = true if filter.geolocation
+        params[:experiment] = true if filter.experiments
+        params[:page] = true if filter.page_views
+        params[:staticData] = true if filter.device || filter.browser || filter.operating_system
         "https://#{@data_api_domain}#{VISITOR_DATA_PATH}?#{UriHelper.encode_query(params)}"
       end
 

data/lib/kameleoon/targeting/condition.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'kameleoon/exceptions'
 
 module Kameleoon
@@ -6,15 +7,27 @@ module Kameleoon
   module Targeting
     module ConditionType
       CUSTOM_DATUM = 'CUSTOM_DATUM'
-      TARGET_EXPERIMENT = 'TARGET_EXPERIMENT'
-      EXCLUSIVE_EXPERIMENT = 'EXCLUSIVE_EXPERIMENT'
+      TARGET_FEATURE_FLAG = 'TARGET_FEATURE_FLAG'
+      EXCLUSIVE_FEATURE_FLAG = 'EXCLUSIVE_FEATURE_FLAG'
       PAGE_URL = 'PAGE_URL'
+      PAGE_VIEWS = 'PAGE_VIEWS'
+      PREVIOUS_PAGE = 'PREVIOUS_PAGE'
       PAGE_TITLE = 'PAGE_TITLE'
       VISITOR_CODE = 'VISITOR_CODE'
       DEVICE_TYPE = 'DEVICE_TYPE'
       BROWSER = 'BROWSER'
       SDK_LANGUAGE = 'SDK_LANGUAGE'
       CONVERSIONS = 'CONVERSIONS'
+      COOKIE = 'COOKIE'
+      OPERATING_SYSTEM = 'OPERATING_SYSTEM'
+      GEOLOCATION = 'GEOLOCATION'
+      SEGMENT = 'SEGMENT'
+      FIRST_VISIT = 'FIRST_VISIT'
+      LAST_VISIT = 'LAST_VISIT'
+      VISITS = 'VISITS'
+      SAME_DAY_VISITS = 'SAME_DAY_VISITS'
+      NEW_VISITORS = 'NEW_VISITORS'
+      HEAT_SLICE = 'HEAT_SLICE'
     end
 
     module Operator
@@ -52,6 +65,15 @@ module Kameleoon
       def get_last_targeting_data(list_data, data_type)
         list_data.select { |data| data.instance == data_type }.last
       end
+
+      def is_regex_match(value, pattern)
+        begin
+          return pattern.match? value
+        rescue StandardError => e
+          log "Failed to match with regex (targeting): #{e}"
+        end
+        false
+      end
     end
   end
 end

data/lib/kameleoon/targeting/condition_factory.rb

@@ -1,13 +1,24 @@
 require_relative 'conditions/custom_datum'
-require_relative 'conditions/target_experiment'
-require_relative 'conditions/exclusive_experiment'
+require_relative 'conditions/target_feature_flag_condition'
+require_relative 'conditions/exclusive_feature_flag_condition'
 require_relative 'conditions/page_title_condition'
 require_relative 'conditions/page_url_condition'
+require_relative 'conditions/page_view_number_condition'
+require_relative 'conditions/previous_page_condition'
 require_relative 'conditions/visitor_code_condition'
 require_relative 'conditions/device_condition'
 require_relative 'conditions/conversion_condition'
 require_relative 'conditions/browser_condition'
 require_relative 'conditions/sdk_language_condition'
+require_relative 'conditions/geolocation_condition'
+require_relative 'conditions/kcs_heat_range_condition'
+require_relative 'conditions/operating_system_condition'
+require_relative 'conditions/cookie_condition'
+require_relative 'conditions/segment_condition'
+require_relative 'conditions/visit_number_total_condition'
+require_relative 'conditions/visit_number_today_condition'
+require_relative 'conditions/visitor_new_return_condition'
+require_relative 'conditions/time_elapsed_since_visit_condition'
 require_relative 'conditions/unknown_condition'
 
 module Kameleoon
@@ -19,12 +30,16 @@ module Kameleoon
         case condition_json['targetingType']
         when ConditionType::CUSTOM_DATUM
           CustomDatum.new(condition_json)
-        when ConditionType::TARGET_EXPERIMENT
-          TargetExperiment.new(condition_json)
-        when ConditionType::EXCLUSIVE_EXPERIMENT
-          ExclusiveExperiment.new(condition_json)
+        when ConditionType::TARGET_FEATURE_FLAG
+          TargetFeatureFlagCondition.new(condition_json)
+        when ConditionType::EXCLUSIVE_FEATURE_FLAG
+          ExclusiveFeatureFlagCondition.new(condition_json)
         when ConditionType::PAGE_URL
           PageUrlCondition.new(condition_json)
+        when ConditionType::PAGE_VIEWS
+          PageViewNumberCondition.new(condition_json)
+        when ConditionType::PREVIOUS_PAGE
+          PreviousPageCondition.new(condition_json)
         when ConditionType::PAGE_TITLE
           PageTitleCondition.new(condition_json)
         when ConditionType::VISITOR_CODE
@@ -37,6 +52,24 @@ module Kameleoon
           BrowserCondition.new(condition_json)
         when ConditionType::SDK_LANGUAGE
           SdkLanguageCondition.new(condition_json)
+        when ConditionType::GEOLOCATION
+          GeolocationCondition.new(condition_json)
+        when ConditionType::OPERATING_SYSTEM
+          OperatingSystemCondition.new(condition_json)
+        when ConditionType::COOKIE
+          CookieCondition.new(condition_json)
+        when ConditionType::SEGMENT
+          SegmentCondition.new(condition_json)
+        when ConditionType::VISITS
+          VisitNumberTotalCondition.new(condition_json)
+        when ConditionType::SAME_DAY_VISITS
+          VisitNumberTodayCondition.new(condition_json)
+        when ConditionType::NEW_VISITORS
+          VisitorNewReturnCondition.new(condition_json)
+        when ConditionType::FIRST_VISIT, ConditionType::LAST_VISIT
+          TimeElapsedSinceVisitCondition.new(condition_json)
+        when ConditionType::HEAT_SLICE
+          KcsHeatRangeCondition.new(condition_json)
         else
           UnknownCondition.new(condition_json)
         end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'kameleoon/data/cookie'
+require 'kameleoon/version'
+
+module Kameleoon
+  # @api private
+  module Targeting
+
+    class CookieCondition < Condition
+      def initialize(json_condition)
+        super(json_condition)
+        @condition_name = json_condition['name']
+        @name_match_type = json_condition['nameMatchType']
+        @condition_value = json_condition['value']
+        @value_match_type = json_condition['valueMatchType']
+      end
+
+      def check(cookie)
+        cookie.is_a?(Kameleoon::Cookie) && check_values(select_values(cookie))
+      end
+
+      private
+
+      def select_values(cookie)
+        case @name_match_type
+        when Kameleoon::Targeting::Operator::EXACT
+          value = cookie.cookies[@condition_name]
+          return value != nil ? [value] : []
+        when Kameleoon::Targeting::Operator::CONTAINS
+          return cookie.cookies.select{|key| key.include? @condition_name}.values()
+        when Kameleoon::Targeting::Operator::REGULAR_EXPRESSION
+          return cookie.cookies.select{|key| is_regex_match(@condition_name, key)}.values()
+        else
+          log "Unexpected comparing operation for Cookie condition (name): #{@name_match_type}"
+        end
+        []
+      end
+
+      def check_values(values)
+        case @value_match_type
+        when Kameleoon::Targeting::Operator::EXACT
+          return values.any? {|value| value == @condition_value}
+        when Kameleoon::Targeting::Operator::CONTAINS
+          return values.any? {|value| value.include? @condition_value}
+        when Kameleoon::Targeting::Operator::REGULAR_EXPRESSION
+          return values.any? {|value| is_regex_match(@condition_value, value)}
+        else
+          log "Unexpected comparing operation for Cookie condition (name): #{@name_match_type}"
+          return false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'kameleoon/targeting/condition'
+
+module Kameleoon
+  # @api private
+  module Targeting
+    # ExclusiveExperiment represents an instance of Exclusive Experiment condition in user account
+    class ExclusiveFeatureFlagCondition < Condition
+      def check(data)
+        return false unless data.is_a?(ExclusiveFeatureFlagInfo)
+
+        size = data.variations_storage&.size || 0
+        size.zero? || (size == 1 && !data.variations_storage.get(data.current_experiment_id).nil?)
+      end
+    end
+
+    class ExclusiveFeatureFlagInfo
+      attr_reader :current_experiment_id, :variations_storage
+
+      def initialize(current_experiment_id, variations_storage)
+        @current_experiment_id = current_experiment_id
+        @variations_storage = variations_storage
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'kameleoon/data/geolocation'
+require 'kameleoon/version'
+
+module Kameleoon
+  # @api private
+  module Targeting
+
+    class GeolocationCondition < Condition
+      def initialize(json_condition)
+        super(json_condition)
+        @country = json_condition['country']
+        @region = json_condition['region']
+        @city = json_condition['city']
+      end
+
+      def check(geolocation)
+        geolocation.is_a?(Kameleoon::Geolocation) && check_targeting(geolocation)
+      end
+
+      private
+
+      def check_targeting(geolocation)
+        return false if !@country.is_a?(String) || !@country.casecmp?(geolocation.country)
+        return false if @region.is_a?(String) && !@region.casecmp?(geolocation.region)
+        return false if @city.is_a?(String) && !@city.casecmp?(geolocation.city)
+
+        true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'kameleoon/data/device'
+
+module Kameleoon
+  # @api private
+  module Targeting
+    # KcsHeatRangeCondition is a condition for checking KCS heat
+    class KcsHeatRangeCondition < Condition
+      def initialize(json_condition)
+        super(json_condition)
+        @goal_id = json_condition['goalId'] || -1
+        @key_moment_id = json_condition['keyMomentId'] || -1
+        @lower_bound = json_condition['lowerBound'] || Float::MAX
+        @upper_bound = json_condition['upperBound'] || Float::MIN
+      end
+
+      def check(kcs_heat)
+        kcs_heat.is_a?(Kameleoon::KcsHeat) && check_targeting(kcs_heat)
+      end
+
+      private
+
+      def check_targeting(kcs_heat)
+        return false unless kcs_heat.values.is_a?(Hash)
+
+        goal_scores = kcs_heat.values[@key_moment_id]
+        return false unless goal_scores.is_a?(Hash)
+
+        score = goal_scores[@goal_id]
+        return false unless score.is_a?(Float) || score.is_a?(Integer)
+
+        (score >= @lower_bound) && (score <= @upper_bound)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'kameleoon/data/cookie'
+require 'kameleoon/version'
+
+module Kameleoon
+  # @api private
+  module Targeting
+
+    class NumberCondition < Condition
+      def initialize(json_condition, value)
+        super(json_condition)
+        @match_type = json_condition['matchType']
+        @condition_value = value
+      end
+
+      def check(value)
+        check_targeting(value)
+      end
+
+      protected
+
+      def check_targeting(value)
+        case @match_type
+        when Kameleoon::Targeting::Operator::EQUAL
+          return value == @condition_value
+        when Kameleoon::Targeting::Operator::GREATER
+          return @condition_value != nil && value > @condition_value
+        when Kameleoon::Targeting::Operator::LOWER
+          return @condition_value != nil && value < @condition_value
+        else
+          log "Unexpected comparing operation for #{type} condition: #{@match_type}"
+        end
+        false
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'kameleoon/data/operating_system'
+require 'kameleoon/version'
+
+module Kameleoon
+  # @api private
+  module Targeting
+
+    class OperatingSystemCondition < Condition
+      def initialize(json_condition)
+        super(json_condition)
+        @os_type = Kameleoon::OperatingSystemType.from_name(json_condition['os'])
+      end
+
+      def check(operating_system)
+        operating_system.is_a?(Kameleoon::OperatingSystem) && check_targeting(operating_system)
+      end
+
+      private
+
+      def check_targeting(operating_system)
+        @os_type != nil && operating_system.os_type == @os_type
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'kameleoon/targeting/conditions/number_condition'
+require 'kameleoon/data/manager/page_view_visit'
+
+module Kameleoon
+  # @api private
+  module Targeting
+
+    class PageViewNumberCondition < NumberCondition
+      def initialize(json_condition)
+        page_count = json_condition['pageCount']
+        super(json_condition, page_count)
+      end
+
+      def check(page_view_visit_storage)
+        return false unless page_view_visit_storage.is_a?(Kameleoon::DataManager::DataMapStorage)
+
+        count = 0
+        page_view_visit_storage.enumerate do |visit|
+          return false unless visit.is_a?(Kameleoon::DataManager::PageViewVisit)
+          count += visit.count
+        end
+        check_targeting(count)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'kameleoon/targeting/conditions/string_value_condition'
+require 'kameleoon/data/manager/page_view_visit'
+
+module Kameleoon
+  # @api private
+  module Targeting
+
+    class PreviousPageCondition < StringValueCondition
+      def initialize(json_condition)
+        super(json_condition, json_condition['url'])
+      end
+
+      def check(page_view_visit_storage)
+        is_targeted = false
+        if page_view_visit_storage.is_a?(Kameleoon::DataManager::DataMapStorage)
+          most_recent_visit = nil
+          second_most_recent_visit = nil
+          page_view_visit_storage.enumerate do |visit|
+            return false unless visit.is_a?(Kameleoon::DataManager::PageViewVisit)
+            if most_recent_visit == nil || visit.last_timestamp > most_recent_visit.last_timestamp
+              second_most_recent_visit = most_recent_visit
+              most_recent_visit = visit
+            elsif second_most_recent_visit == nil || visit.last_timestamp > second_most_recent_visit.last_timestamp
+              second_most_recent_visit = visit
+            end
+          end
+          is_targeted = second_most_recent_visit != nil && check_targeting(second_most_recent_visit.page_view.url)
+        end
+        is_targeted
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'kameleoon/data/geolocation'
+require 'kameleoon/version'
+
+module Kameleoon
+  # @api private
+  module Targeting
+
+    class SegmentCondition < Condition
+      def initialize(json_condition)
+        super(json_condition)
+        @segment_id = json_condition["segmentId"]
+      end
+
+      def check(data)
+        data.is_a?(SegmentInfo) && check_targeting(data)
+      end
+
+      private
+
+      def check_targeting(segment_info)
+        rule = segment_info.data_file.rule_by_segment_id[@segment_id]
+        return false unless rule.is_a?(Kameleoon::Configuration::Rule)
+        rule.targeting_segment.check_tree(->(type) {segment_info.condition_data(type)})
+      end
+    end
+
+    class SegmentInfo
+      attr_reader :data_file
+
+      def initialize(data_file, condition_data)
+        @data_file = data_file
+        @condition_data = condition_data
+      end
+
+      def condition_data(type)
+        @condition_data.call(type)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'kameleoon/targeting/condition'
+require 'kameleoon/exceptions'
+
+module Kameleoon
+  # @api private
+  module Targeting
+    # TargetExperiment represents an instance of Experiment condition in user account
+    class TargetFeatureFlagCondition < Condition
+      include Kameleoon::Exception
+
+      def initialize(json_condition)
+        super(json_condition)
+
+        @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?(Kameleoon::Targeting::TargetFeatureFlagInfo) && data.variations_storage.size != 0
+
+        get_rules(data).any? { |rule| check_rule(data, rule) }
+      end
+
+      private def check_rule(data, rule)
+        return false if !rule.is_a?(Kameleoon::Configuration::Rule) || rule.experiment_id.nil?
+
+        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 true if @condition_variation_key.nil?
+
+        variation = data.data_file.variation_by_id[variation.variation_id]
+
+        return false unless variation.is_a?(Kameleoon::Configuration::VariationByExposition)
+
+        variation.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 || []
+      end
+    end
+
+    class TargetFeatureFlagInfo
+      attr_reader :data_file, :variations_storage
+
+      def initialize(data_file, variations_storage)
+        @data_file = data_file
+        @variations_storage = variations_storage
+      end
+    end
+  end
+end