kameleoon-client-ruby 3.3.0 → 3.5.0

data/lib/kameleoon/network/url_provider.rb

@@ -37,13 +37,13 @@ module Kameleoon
         @data_api_domain = domain if domain.is_a?(String)
       end
 
-      def make_tracking_url(visitor_code, is_unique_identifier = false)
+      def make_tracking_url
         params = {
           sdkName: SDK_NAME,
           sdkVersion: SDK_VERSION,
-          siteCode: @site_code
+          siteCode: @site_code,
+          bodyUa: true
         }
-        params[is_unique_identifier ? :mappingValue : :visitorCode] = visitor_code
         "https://#{@data_api_domain}#{TRACKING_PATH}?#{UriHelper.encode_query(params)}"
       end
 

data/lib/kameleoon/real_time/real_time_configuration_service.rb

@@ -3,6 +3,7 @@
 # Kameleoon Real Time Configuration Service
 
 require 'json'
+require 'kameleoon/logging/kameleoon_logger'
 require 'kameleoon/real_time/real_time_event'
 require 'kameleoon/real_time/sse_request'
 require 'kameleoon/real_time/sse_client'
@@ -21,8 +22,7 @@ module Kameleoon
       # @param url [String]
       # @param update_handler [Callable[Kameleoon::RealTime::RealTimeEvent] | NilClass] Handler which
       # is synchronously called for gotten RealTimeEvent objects.
-      # @param log_func [Callable[String] | NilClass] Callable object which synchronously called to log.
-      def initialize(url, update_handler, log_func, sse_request_source = nil)
+      def initialize(url, update_handler, sse_request_source = nil)
         @url = url
         @update_handler = update_handler
         @need_close = false
@@ -31,7 +31,6 @@ module Kameleoon
           'Cache-Control': 'no-cache',
           'Connection': 'Keep-Alive'
         }
-        @log_func = log_func
         @sse_request_source = sse_request_source
         @sse_thread = nil
         @sse_client = nil
@@ -43,13 +42,13 @@ module Kameleoon
       def close
         return if @need_close
 
-        @log_func&.call('Real-time configuration service is shutting down')
+        Logging::KameleoonLogger.info('Real-time configuration service is shutting down')
         @need_close = true
         return if @sse_thread.nil?
 
         @sse_thread.kill
         @sse_thread = nil
-        @sse_client.call_close_handler
+        @sse_client&.call_close_handler
       end
 
       private
@@ -60,7 +59,7 @@ module Kameleoon
 
       def init_sse_client
         message_handler = proc do |message|
-          @log_func&.call("Got SSE event: #{message.event}")
+          Logging::KameleoonLogger.debug("Got SSE event: #{message.event}")
           if message.event == CONFIGURATION_UPDATE_EVENT
             event_dict = JSON.parse(message.data)
             @update_handler&.call(RealTimeEvent.new(event_dict))
@@ -68,14 +67,14 @@ module Kameleoon
         end
         sse_request = make_sse_request
         @sse_client = SseClient.new(sse_request, message_handler)
-        @log_func&.call('Created SSE client')
+        Logging::KameleoonLogger.info('Created SSE client')
       end
 
       def make_sse_request
-        open_handler = proc { @log_func&.call('SSE connection open') }
-        close_handler = proc { @log_func&.call('SSE connection closed') }
+        open_handler = proc { Logging::KameleoonLogger.info('SSE connection open') }
+        close_handler = proc { Logging::KameleoonLogger.info('SSE connection closed') }
         unexpected_status_code_handler =
-          proc { |resp| @log_func&.call("Unexpected status code of SSE response: #{resp.code}") }
+          proc { |resp| Logging::KameleoonLogger.error("Unexpected status code of SSE response: #{resp.code}") }
         if @sse_request_source.nil?
           return SseRequest.new(@url, @headers, open_handler, close_handler, unexpected_status_code_handler)
         end
@@ -89,7 +88,7 @@ module Kameleoon
           begin
             @sse_client.start
           rescue StandardError => e
-            @log_func&.call("Error occurred within SSE client: #{e}")
+            Logging::KameleoonLogger.error("Error occurred within SSE client: #{e}")
           end
         end
       end

data/lib/kameleoon/sdk_version.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'kameleoon/logging/kameleoon_logger'
+
+module Kameleoon
+  # SdkManager is a helper method for fetching / obtaining version of SDK from string
+  class SdkVersion
+    def self.get_version_components(version_string)
+      versions = [0, 0, 0]
+
+      version_parts = version_string.split('.')
+      version_parts.each_with_index do |part, i|
+        versions[i] = Integer(part)
+      rescue ArgumentError
+        Logging::KameleoonLogger.error('Invalid version component, index: %s, value: %s', i, part)
+        return nil
+      end
+      versions
+    end
+
+    def self.get_float_version(version_string)
+      version_components = get_version_components(version_string)
+
+      return Float::NAN if version_components.nil?
+
+      major = version_components[0]
+      minor = version_components[1]
+      "#{major}.#{minor}".to_f
+    end
+  end
+end

data/lib/kameleoon/targeting/condition.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'kameleoon/exceptions'
+require 'kameleoon/logging/kameleoon_logger'
 
 module Kameleoon
   # @api private
@@ -47,12 +48,13 @@ module Kameleoon
 
     # Base class for all targeting conditions
     class Condition
-      attr_reader :type, :include
+      attr_reader :type, :include, :id
 
       def initialize(json_condition)
         raise Exception::NotFound.new('targetingType'), 'targetingType missed' if json_condition['targetingType'].nil?
 
         @type = json_condition['targetingType']
+        @id = json_condition['id']
         @include = json_condition['isInclude'].nil? ? true : json_condition['isInclude']
       end
 
@@ -70,7 +72,7 @@ module Kameleoon
         begin
           return pattern.match? value
         rescue StandardError => e
-          log "Failed to match with regex (targeting): #{e}"
+          Logging::KameleoonLogger.error("Failed to match with regex (targeting): #{e}")
         end
         false
       end

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

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
 require 'kameleoon/data/browser'
-require 'kameleoon/version'
+require 'kameleoon/logging/kameleoon_logger'
+require 'kameleoon/sdk_version'
 
 module Kameleoon
   # @api private
   module Targeting
-
     CHROME = 'CHROME'
     INTERNET_EXPLORER = 'IE'
     FIREFOX = 'FIREFOX'
@@ -44,7 +44,7 @@ module Kameleoon
         when Operator::LOWER
           browser.version < version_number
         else
-          puts "Unexpected comparing operation for Browser condition: #{@version_match_type}"
+          Logging::KameleoonLogger.error("Unexpected comparing operation for 'Browser' condition: '#{@version_match_type}'")
           false
         end
       end

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

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
 require 'kameleoon/data/cookie'
+require 'kameleoon/logging/kameleoon_logger'
 require 'kameleoon/version'
 
 module Kameleoon
   # @api private
   module Targeting
-
     class CookieCondition < Condition
       def initialize(json_condition)
         super(json_condition)
@@ -26,13 +26,13 @@ module Kameleoon
         case @name_match_type
         when Kameleoon::Targeting::Operator::EXACT
           value = cookie.cookies[@condition_name]
-          return value != nil ? [value] : []
+          return !value.nil? ? [value] : []
         when Kameleoon::Targeting::Operator::CONTAINS
-          return cookie.cookies.select{|key| key.include? @condition_name}.values()
+          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()
+          return cookie.cookies.select { |key| is_regex_match(@condition_name, key) }.values
         else
-          log "Unexpected comparing operation for Cookie condition (name): #{@name_match_type}"
+          Logging::KameleoonLogger.error("Unexpected comparing operation for 'Cookie' condition (name): '#{@name_match_type}'")
         end
         []
       end
@@ -40,14 +40,14 @@ module Kameleoon
       def check_values(values)
         case @value_match_type
         when Kameleoon::Targeting::Operator::EXACT
-          return values.any? {|value| value == @condition_value}
+          values.any? { |value| value == @condition_value }
         when Kameleoon::Targeting::Operator::CONTAINS
-          return values.any? {|value| value.include? @condition_value}
+          values.any? { |value| value.include? @condition_value }
         when Kameleoon::Targeting::Operator::REGULAR_EXPRESSION
-          return values.any? {|value| is_regex_match(@condition_value, value)}
+          values.any? { |value| is_regex_match(@condition_value, value) }
         else
-          log "Unexpected comparing operation for Cookie condition (name): #{@name_match_type}"
-          return false
+          Logging::KameleoonLogger.error("Unexpected comparing operation for 'Cookie' condition (name): '#{@name_match_type}'")
+          false
         end
       end
     end

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

@@ -6,7 +6,6 @@ require 'kameleoon/version'
 module Kameleoon
   # @api private
   module Targeting
-
     class GeolocationCondition < Condition
       def initialize(json_condition)
         super(json_condition)

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

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
 require 'kameleoon/data/cookie'
+require 'kameleoon/logging/kameleoon_logger'
 require 'kameleoon/version'
 
 module Kameleoon
   # @api private
   module Targeting
-
     class NumberCondition < Condition
       def initialize(json_condition, value)
         super(json_condition)
@@ -25,11 +25,11 @@ module Kameleoon
         when Kameleoon::Targeting::Operator::EQUAL
           return value == @condition_value
         when Kameleoon::Targeting::Operator::GREATER
-          return @condition_value != nil && value > @condition_value
+          return !@condition_value.nil? && value > @condition_value
         when Kameleoon::Targeting::Operator::LOWER
-          return @condition_value != nil && value < @condition_value
+          return !@condition_value.nil? && value < @condition_value
         else
-          log "Unexpected comparing operation for #{type} condition: #{@match_type}"
+          Logging::KameleoonLogger.error("Unexpected comparing operation for '#{@type}' condition: '#{@match_type}'")
         end
         false
       end

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

@@ -6,7 +6,6 @@ require 'kameleoon/version'
 module Kameleoon
   # @api private
   module Targeting
-
     class OperatingSystemCondition < Condition
       def initialize(json_condition)
         super(json_condition)
@@ -20,7 +19,7 @@ module Kameleoon
       private
 
       def check_targeting(operating_system)
-        @os_type != nil && operating_system.os_type == @os_type
+        !@os_type.nil? && operating_system.os_type == @os_type
       end
     end
   end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'kameleoon/data/data'
+require 'kameleoon/logging/kameleoon_logger'
 require 'kameleoon/version'
 
 module Kameleoon
@@ -56,7 +57,7 @@ module Kameleoon
             (major_sdk == major_condition && minor_sdk < minor_condition) ||
             (major_sdk == major_condition && minor_sdk == minor_condition && patch_sdk < patch_condition)
         else
-          puts "Unexpected comparing operation for SdkLanguage condition: #{@operator}"
+          Logging::KameleoonLogger.error("Unexpected comparing operation for 'SdkLanguage' condition: '#{@operator}'")
           false
         end
       end

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

@@ -6,11 +6,10 @@ require 'kameleoon/version'
 module Kameleoon
   # @api private
   module Targeting
-
     class SegmentCondition < Condition
       def initialize(json_condition)
         super(json_condition)
-        @segment_id = json_condition["segmentId"]
+        @segment_id = json_condition['segmentId']
       end
 
       def check(data)
@@ -22,7 +21,8 @@ module Kameleoon
       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)})
+
+        rule.targeting_segment.check_tree(->(type) { segment_info.condition_data(type) })
       end
     end
 

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'kameleoon/logging/kameleoon_logger'
 require 'kameleoon/targeting/condition'
 
 module Kameleoon
@@ -33,7 +34,7 @@ module Kameleoon
           pattern = Regexp.new(@condition_value)
           pattern.match?(value)
         else
-          puts "Unexpected comparing operation for #{@type} condition: #{@operator}"
+          Logging::KameleoonLogger.error("Unexpected comparing operation for '#{@type}' condition: '#{@operator}'")
           false
         end
       end

data/lib/kameleoon/targeting/models.rb

@@ -10,7 +10,6 @@ module Kameleoon
       include TreeBuilder
       attr_accessor :id, :tree
       def to_s
-        print("\nSegment id: #{@id}\n")
         @tree.to_s
       end
 
@@ -49,19 +48,6 @@ module Kameleoon
     class Tree
       attr_accessor :or_operator, :left_child, :right_child, :condition
 
-      def to_s
-        print("or_operator: #{@or_operator}\n")
-        print("condition: #{@condition}")
-        unless @left_child.nil?
-          print('\nLeft child:\n    ')
-          @left_child.to_s
-        end
-        unless @right_child.nil?
-          print('\nright child:\n    ')
-          @right_child.to_s
-        end
-      end
-
       def initialize(or_operator = nil, left_child = nil, right_child = nil, condition = nil)
         @or_operator = Marshal.load(Marshal.dump(or_operator))
         @left_child = left_child

data/lib/kameleoon/targeting/targeting_manager.rb

@@ -1,25 +1,45 @@
 # frozen_string_literal: true
 
+require 'kameleoon/logging/kameleoon_logger'
 require 'kameleoon/targeting/conditions/segment_condition'
 
 module Kameleoon
   # @api private
   module Targeting
     class TargetingManager
-      def initialize(visitor_manager, data_file)
+      def initialize(data_manager, visitor_manager)
+        @data_manager = data_manager
         @visitor_manager = visitor_manager
-        @data_file = data_file
       end
 
       def check_targeting(visitor_code, campaign_id, exp_ff_rule)
+        Logging::KameleoonLogger.debug(
+          "CALL: TargetingManager.check_targeting(visitorCode: '%s', campaignId: %s, exp_ff_rule: %s)",
+          visitor_code, campaign_id, exp_ff_rule
+        )
         segment = exp_ff_rule.targeting_segment
-        return true if segment.nil?
+        if segment.nil?
+          Logging::KameleoonLogger.debug(
+            "RETURN: TargetingManager.check_targeting(visitorCode: '%s', campaignId: %s, exp_ff_rule: %s) -> " \
+              '(targeting: true)', visitor_code, campaign_id, exp_ff_rule
+          )
+          return true
+        end
 
         visitor = @visitor_manager.get_visitor(visitor_code)
-        segment.check_tree(->(type) { get_condition_data(type, visitor, visitor_code, campaign_id) })
+        targeting = segment.check_tree(->(type) { get_condition_data(type, visitor, visitor_code, campaign_id) })
+        Logging::KameleoonLogger.debug(
+          "RETURN: TargetingManager.check_targeting(visitorCode: '%s', campaignId: %s, exp_ff_rule: %s) -> " \
+            '(targeting: %s)', visitor_code, campaign_id, exp_ff_rule, targeting
+        )
+        targeting
       end
 
       def get_condition_data(type, visitor, visitor_code, campaign_id)
+        Logging::KameleoonLogger.debug(
+          "CALL: TargetingManager.get_condition_data(type: %s, visitor, visitorCode: '%s', campaignId: %s)",
+          type, visitor_code, campaign_id
+        )
         condition_data = nil
         case type
         when Kameleoon::Targeting::ConditionType::CUSTOM_DATUM
@@ -41,7 +61,7 @@ module Kameleoon
           condition_data = visitor.operating_system unless visitor.nil?
         when Kameleoon::Targeting::ConditionType::SEGMENT
           condition_data = SegmentInfo.new(
-            @data_file,
+            @data_manager.data_file,
             lambda { |type|
               get_condition_data(type, visitor, visitor_code, campaign_id)
             }
@@ -53,14 +73,22 @@ module Kameleoon
         when Kameleoon::Targeting::ConditionType::VISITOR_CODE
           condition_data = visitor_code
         when Kameleoon::Targeting::ConditionType::TARGET_FEATURE_FLAG
-          condition_data = TargetFeatureFlagInfo.new(@data_file, visitor.variations) unless visitor.nil?
+          condition_data = TargetFeatureFlagInfo.new(@data_manager.data_file, visitor.variations) unless visitor.nil?
         when Kameleoon::Targeting::ConditionType::EXCLUSIVE_FEATURE_FLAG
           condition_data = ExclusiveFeatureFlagInfo.new(campaign_id, visitor&.variations)
-        when ConditionType::FIRST_VISIT, ConditionType::LAST_VISIT, ConditionType::VISITS, ConditionType::SAME_DAY_VISITS, ConditionType::NEW_VISITORS
+        when ConditionType::FIRST_VISIT,
+          ConditionType::LAST_VISIT,
+          ConditionType::VISITS,
+          ConditionType::SAME_DAY_VISITS,
+          ConditionType::NEW_VISITORS
           condition_data = visitor.visitor_visits unless visitor.nil?
         when Kameleoon::Targeting::ConditionType::HEAT_SLICE
           condition_data = visitor&.kcs_heat
         end
+        Logging::KameleoonLogger.debug(
+          "RETURN: TargetingManager.get_condition_data(type: %s, visitor, visitor_code: '%s', campaign_id: %s) -> " \
+            '(condition_data: %s)', type, visitor_code, campaign_id, condition_data
+        )
         condition_data
       end
     end

data/lib/kameleoon/targeting/tree_builder.rb

@@ -1,4 +1,5 @@
 require 'kameleoon/targeting/condition_factory'
+require 'kameleoon/logging/kameleoon_logger'
 
 module Kameleoon
   #@api private
@@ -6,13 +7,17 @@ module Kameleoon
     module TreeBuilder
 
       def create_tree(conditions_data_json)
-        if conditions_data_json.nil?
-          return nil
-        end
+        return nil if conditions_data_json.nil?
+
+        Logging::KameleoonLogger.debug('CALL: TreeBuilder.create_tree(conditions_data_json: %s)',
+                                       conditions_data_json)
         if conditions_data_json['firstLevel'].empty?
           conditions_data_json['firstLevelOrOperators'] = []
         end
-        create_first_level(conditions_data_json)
+        tree = create_first_level(conditions_data_json)
+        Logging::KameleoonLogger.debug('RETURN: TreeBuilder.create_tree(conditions_data_json: %s) -> (tree)',
+                                       conditions_data_json)
+        tree
       end
 
       private
@@ -69,4 +74,4 @@ module Kameleoon
       end
     end
   end
-end
+end

data/lib/kameleoon/types/remote_visitor_data_filter.rb

@@ -7,6 +7,19 @@ module Kameleoon
       attr_reader :previous_visit_amount, :current_visit, :custom_data, :page_views, :geolocation, :device, :browser,
                   :operating_system, :conversions, :experiments, :kcs
 
+      def to_s
+        "RemoteVisitorDataFilter{previous_visit_amount:#{@previous_visit_amount}," \
+          "current_visit:#{@current_visit}," \
+          "custom_data:#{@custom_data}," \
+          "page_views:#{@page_views}," \
+          "geolocation:#{@geolocation}," \
+          "device:#{@device}," \
+          "browser:#{@browser}," \
+          "operating_system:#{@operating_system}," \
+          "conversions:#{@conversions}," \
+          "experiments:#{@experiments},kcs:#{@kcs}}"
+      end
+
       def initialize(
         previous_visit_amount: 1, current_visit: true, custom_data: true, page_views: false,
         geolocation: false, device: false, browser: false, operating_system: false, conversions: false,

data/lib/kameleoon/types/variable.rb

@@ -7,6 +7,10 @@ module Kameleoon
     class Variable
       attr_reader :key, :type, :value
 
+      def to_s
+        "Variable{key:'#{@key}',type:'#{@type}',value:#{@value}}"
+      end
+
       def initialize(key, type, value)
         @key = key
         @type = type

data/lib/kameleoon/types/variation.rb

@@ -7,12 +7,20 @@ module Kameleoon
     class Variation
       attr_reader :key, :id, :experiment_id, :variables
 
+      def to_s
+        "Variation{key:'#{@key}',id:#{@id},experiment_id:#{@experiment_id},variables:#{@variables}}"
+      end
+
       def initialize(key, id, experiment_id, variables)
         @key = key
         @id = id
         @experiment_id = experiment_id
         @variables = variables
       end
+
+      def active?
+        variation_key != Configuration::VariationType::VARIATION_OFF
+      end
     end
   end
 end

data/lib/kameleoon/utils.rb

@@ -4,6 +4,7 @@ require 'fiber'
 require 'bigdecimal'
 require 'kameleoon/utils'
 require 'kameleoon/exceptions'
+require 'kameleoon/logging/kameleoon_logger'
 
 module Kameleoon
   # Utils is a helper module for project
@@ -50,5 +51,53 @@ module Kameleoon
         (Digest::SHA256.hexdigest(identifier.encode('UTF-8')).to_i(16) / (BigDecimal('2')**BigDecimal('256'))).round(16)
       end
     end
+
+    module Strval
+
+      def self.secret(secret)
+        hid_ch = '*'
+        vis_count = 4
+
+        return 'nil' if secret.nil?
+
+        length = secret.length
+
+        return hid_ch * length if length <= vis_count
+
+        hidden_length = [length - vis_count, vis_count].max
+
+        secret[0, length - hidden_length] + hid_ch * hidden_length
+      end
+    end
+
+    module Domain
+      HTTP = 'http://'
+      HTTPS = 'https://'
+      REGEX_DOMAIN = /^(\.?(([a-zA-Z\d][a-zA-Z\d-]*[a-zA-Z\d])|[a-zA-Z\d]))
+(\.(([a-zA-Z\d][a-zA-Z\d-]*[a-zA-Z\d])|[a-zA-Z\d])){1,126}$/x.freeze
+
+      def self.validate_top_level_domain(top_level_domain)
+        return nil if top_level_domain.nil? || top_level_domain.empty?
+
+        top_level_domain = top_level_domain.downcase
+
+        [HTTP, HTTPS].each do |protocol|
+          next unless top_level_domain.start_with?(protocol)
+
+          top_level_domain = top_level_domain[protocol.length..]
+          Logging::KameleoonLogger.warning(
+            "The top-level domain contains '%s'. Domain after protocol trimming: '%s'", protocol, top_level_domain
+          )
+          break
+        end
+
+        unless REGEX_DOMAIN.match?(top_level_domain)
+          Logging::KameleoonLogger.error("The top-level domain '%s' is invalid.", top_level_domain)
+          return nil
+        end
+
+        top_level_domain
+      end
+    end
   end
 end

data/lib/kameleoon/version.rb

@@ -1,32 +1,6 @@
 # frozen_string_literal: true
 
 module Kameleoon
+  SDK_VERSION = '3.5.0'
   SDK_NAME = 'RUBY'
-  SDK_VERSION = '3.3.0'
-
-  # SdkManager is a helper method for fetching / obtaining version of SDK from string
-  class SdkVersion
-    def self.get_version_components(version_string)
-      versions = [0, 0, 0]
-
-      version_parts = version_string.split('.')
-      version_parts.each_with_index do |part, i|
-        versions[i] = Integer(part)
-      rescue ArgumentError
-        puts "Invalid version component, index: #{i}, value: #{part}"
-        return nil
-      end
-      versions
-    end
-
-    def self.get_float_version(version_string)
-      version_components = get_version_components(version_string)
-
-      return Float::NAN if version_components.nil?
-
-      major = version_components[0]
-      minor = version_components[1]
-      "#{major}.#{minor}".to_f
-    end
-  end
 end