kameleoon-client-ruby 3.4.0 → 3.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2fb2eefaf6fa7008e5e475044e2f3c20baa088332657f0e19e17c73abffdfa3b
-  data.tar.gz: ef078e7a9d1ac4fd2fef3a74edf4ee5328043b6989c59eafc29559f79ab535d4
+  metadata.gz: 92e73ac3d81e29ddfc093e8da1a47f42b9970ea6e8717e0752be511b759db17a
+  data.tar.gz: 710361f25b6338e35bb668bb30f116c931efddd21fdb272fa5367add4d82db22
 SHA512:
-  metadata.gz: 8df54dcee89dc21a3565948e96b330b655d780ca7cbd4955385b12c5ad64ccdbc8318b17043acb02eddcd2d8dd45191eaeb001d6957e250573e8b9cc606ffbf0
-  data.tar.gz: 3fe4dfe732310de088f45dcc2002c2504b03e45e2e101bb7199b46783cac46aed80a7e35fc0cc6995ddcb7ba0202629d367922e58d8a8e90b974679f91363086
+  metadata.gz: 24db6ec9d63c160690506060d703661f77c5b60160fc585117b91460e74185a095f0b52156b268ba18d445797a584c9bd92e824c2bbecf8533d08e09cf89dab6
+  data.tar.gz: ab2f4e530b33235f7105158414ff77ce52f5b824632e4cae53ed06425f32be6f22719dcae86d7d5660cbd09ea4c090672ee5a237828a6db0e0772e80d65032c5

data/lib/kameleoon/configuration/data_file.rb

@@ -9,7 +9,7 @@ module Kameleoon
   module Configuration
     class DataFile
       attr_reader :settings, :feature_flags, :has_any_targeted_delivery_rule, :feature_flag_by_id, :rule_by_segment_id,
-                  :variation_by_id, :custom_data_info
+                  :variation_by_id, :custom_data_info, :experiment_ids_with_js_css_variable
 
       def to_s
         'DataFile{' \
@@ -39,6 +39,10 @@ module Kameleoon
         ff
       end
 
+      def experiment_js_css_variable?(experiment_id)
+        @experiment_ids_with_js_css_variable.include?(experiment_id)
+      end
+
       private
 
       def init_default
@@ -71,21 +75,31 @@ module Kameleoon
         @feature_flag_by_id = {}
         @rule_by_segment_id = {}
         @variation_by_id = {}
+        @experiment_ids_with_js_css_variable = Set.new
 
         @feature_flags.each_value do |feature_flag|
           @feature_flag_by_id[feature_flag.id] = feature_flag
           next if feature_flag.rules.nil?
 
+          has_feature_flag_variable_js_css = feature_flag_variable_js_css?(feature_flag)
           feature_flag.rules.each do |rule|
             @rule_by_segment_id[rule.segment_id] = rule
             rule.variation_by_exposition.each do |variation|
               @variation_by_id[variation.variation_id] = variation
             end
+            @experiment_ids_with_js_css_variable.add(rule.experiment_id) if has_feature_flag_variable_js_css
           end
         end
         @feature_flag_by_id.freeze
         @rule_by_segment_id.freeze
         @variation_by_id.freeze
+        @experiment_ids_with_js_css_variable.freeze
+      end
+
+      def feature_flag_variable_js_css?(feature_flag)
+        feature_flag.variations.first&.variables&.any? do |variable|
+          %w[JS CSS].include?(variable.type)
+        end
       end
     end
   end

data/lib/kameleoon/configuration/feature_flag.rb

@@ -33,7 +33,7 @@ module Kameleoon
         @rules = Rule.create_from_array(hash['rules'])
       end
 
-      def get_variation_key(key)
+      def get_variation_by_key(key)
         variations.select { |v| v.key == key }.first
       end
     end

data/lib/kameleoon/data/manager/assigned_variation.rb

@@ -18,7 +18,9 @@ module Kameleoon
           "assignment_time:#{@assignment_time},rule_type:#{@rule_type}}"
       end
 
-      def initialize(experiment_id, variation_id, rule_type = Kameleoon::Configuration::RuleType::UNKNOWN, assignment_time: nil)
+      def initialize(
+        experiment_id, variation_id, rule_type = Kameleoon::Configuration::RuleType::UNKNOWN, assignment_time: nil
+      )
         super(DataType::ASSIGNED_VARIATION)
         @experiment_id = experiment_id
         @variation_id = variation_id

data/lib/kameleoon/data/manager/page_view_visit.rb

@@ -12,7 +12,7 @@ module Kameleoon
       def initialize(page_view, count = 1, timestamp = nil)
         @page_view = page_view
         @count = count
-        @last_timestamp = timestamp != nil ? timestamp : Time.new.to_i
+        @last_timestamp = timestamp.nil? ? Time.new.to_i : timestamp
       end
 
       # Not thread-save method, should be called in synchronized code
@@ -20,10 +20,11 @@ module Kameleoon
       def overwrite(page_view)
         @page_view = page_view
         @count += 1
+        @last_timestamp = Time.new.to_i
       end
 
       # Not thread-save method, should be called in synchronized code
-      def merge (page_view_visit)
+      def merge(page_view_visit)
         @count += page_view_visit.count
         @last_timestamp = [@last_timestamp, page_view_visit.last_timestamp].max
       end

data/lib/kameleoon/data/manager/visitor.rb

@@ -24,7 +24,7 @@ module Kameleoon
       attr_reader :data, :is_unique_identifier
 
       def to_s
-        "Visitor{}"
+        'Visitor{}'
       end
 
       def initialize(source = nil)
@@ -52,7 +52,10 @@ module Kameleoon
 
       def count_sendable_data
         count_sendable_data = @data.count_sendable_data
-        Logging::KameleoonLogger.debug('CALL/RETURN: Visitor.count_sendable_data -> (count_sendable_data: %s)', count_sendable_data)
+        Logging::KameleoonLogger.debug(
+          'CALL/RETURN: Visitor.count_sendable_data -> (count_sendable_data: %s)',
+          count_sendable_data
+        )
         count_sendable_data
       end
 
@@ -82,7 +85,10 @@ module Kameleoon
 
       def operating_system
         operating_system = @data.operating_system
-        Logging::KameleoonLogger.debug('CALL/RETURN: Visitor.operating_system -> (operating_system: %s)', operating_system)
+        Logging::KameleoonLogger.debug(
+          'CALL/RETURN: Visitor.operating_system -> (operating_system: %s)',
+          operating_system
+        )
         operating_system
       end
 
@@ -122,7 +128,14 @@ module Kameleoon
       end
 
       def mapping_identifier=(value)
-        @data.mapping_identifier = value
+        return unless @data.mapping_identifier.nil?
+
+        @data.mutex.with_write_lock do
+          if @data.mapping_identifier.nil?
+            @data.mapping_identifier = value
+            Logging::KameleoonLogger.debug('CALL/RETURN: Visitor.mapping_identifier = %s', value)
+          end
+        end
       end
 
       def custom_data

data/lib/kameleoon/hybrid/manager.rb

@@ -5,8 +5,8 @@ require 'kameleoon/logging/kameleoon_logger'
 module Kameleoon
   module Hybrid
     TC_INIT = 'window.kameleoonQueue=window.kameleoonQueue||[];'
-    TC_ASSIGN_VARIATION_FORMAT = "window.kameleoonQueue.push(['Experiments.assignVariation',%d,%d]);"
-    TC_TRIGGER_FORMAT = "window.kameleoonQueue.push(['Experiments.trigger',%d,true]);"
+    TC_ASSIGN_VARIATION_FORMAT = "window.kameleoonQueue.push(['Experiments.assignVariation',%d,%d,true]);"
+    TC_TRIGGER_FORMAT = "window.kameleoonQueue.push(['Experiments.trigger',%d,%s]);"
     TC_ASSIGN_VARIATION_TRIGGER_FORMAT = TC_ASSIGN_VARIATION_FORMAT + TC_TRIGGER_FORMAT
 
     # Will be useful for Ruby 3.0
@@ -19,10 +19,11 @@ module Kameleoon
 
     # Implementation of Cache with auto cleaning feature
     class ManagerImpl < Manager
-      def initialize(expiration_time)
+      def initialize(expiration_time, data_manager)
         super()
         Logging::KameleoonLogger.debug('CALL: HybridManager.new(expiration_time: %s)', expiration_time)
         @expiration_time = expiration_time
+        @data_manager = data_manager
         Logging::KameleoonLogger.debug('RETURN: HybridManager.new(expiration_time: %s)', expiration_time)
       end
 
@@ -34,7 +35,9 @@ module Kameleoon
           expired_time = (Time.now - @expiration_time).to_i
           visitor_variations.enumerate do |v|
             if v.assignment_time > expired_time
-              v_code = format(TC_ASSIGN_VARIATION_TRIGGER_FORMAT, v.experiment_id, v.variation_id, v.experiment_id)
+              tracking_only = !@data_manager.data_file.experiment_js_css_variable?(v.experiment_id)
+              v_code = format(TC_ASSIGN_VARIATION_TRIGGER_FORMAT, v.experiment_id, v.variation_id, v.experiment_id,
+                              tracking_only)
               tracking_code.push(v_code)
             end
           end

data/lib/kameleoon/kameleoon_client.rb

@@ -24,6 +24,8 @@ require 'kameleoon/real_time/real_time_configuration_service'
 require 'kameleoon/storage/cache_factory'
 require 'kameleoon/targeting/models'
 require 'kameleoon/targeting/targeting_manager'
+require 'kameleoon/types/variable'
+require 'kameleoon/types/variation'
 require 'rufus/scheduler'
 require 'yaml'
 require 'json'
@@ -59,7 +61,7 @@ module Kameleoon
       @visitor_manager = Kameleoon::DataManager::VisitorManager.new(
         @data_manager, config.session_duration_second, @scheduler
       )
-      @hybrid_manager = Hybrid::ManagerImpl.new(HYBRID_EXPIRATION_TIME)
+      @hybrid_manager = Hybrid::ManagerImpl.new(HYBRID_EXPIRATION_TIME, @data_manager)
       @network_manager = Network::NetworkManager.new(
         config.environment,
         config.default_timeout_millisecond,
@@ -81,6 +83,7 @@ module Kameleoon
         Logging::KameleoonLogger.log_level = Logging::LogLevel::INFO
       end
 
+      ObjectSpace.define_finalizer(self, method(:dispose))
       Logging::KameleoonLogger.info("RETURN: KameleoonClient.new(site_code: '%s', config: %s)",
                                     site_code, config)
     end
@@ -263,22 +266,31 @@ module Kameleoon
     # @param [String] feature_key Key of the feature flag you want to expose to a user. This field is mandatory.
     # @param [Bool] is_unique_identifier(DEPRECATED) Parameter that specifies whether the visitorCode is a unique
     # identifier. This field is optional.
+    # @param [Bool] track Optional flag indicating whether tracking of the feature evaluation is enabled
+    # (`true`) or disabled (`false`); the default value is `true`.
+    #
+    # @return [Bool] If the user has not been associated with your feature flag before, the SDK returns
+    # a random boolean value (`true` if the user should have this feature or `false` if not).
     #
     # @raise [Kameleoon::Exception::FeatureNotFound] Feature Flag isn't found in this configuration
     # @raise [Kameleoon::Exception::VisitorCodeInvalid] If the visitor code is empty or longer than 255 chars
     #
-    def feature_active?(visitor_code, feature_key, is_unique_identifier: nil)
+    def feature_active?(visitor_code, feature_key, is_unique_identifier: nil, track: true)
       Logging::KameleoonLogger.info(
-        "CALL: KameleoonClient.feature_active?(visitor_code: '%s', feature_key: '%s', is_unique_identifier: %s)",
-        visitor_code, feature_key, is_unique_identifier
+        "CALL: KameleoonClient.feature_active?(visitor_code: '%s', feature_key: '%s', " \
+        'is_unique_identifier: %s, track: %s)',
+        visitor_code, feature_key, is_unique_identifier, track
       )
       Utils::VisitorCode.validate(visitor_code)
       set_unique_identifier(visitor_code, is_unique_identifier) unless is_unique_identifier.nil?
-      _, variation_key = _get_feature_variation_key(visitor_code, feature_key)
+      feature_flag = @data_manager.data_file.get_feature_flag(feature_key)
+      variation_key, = get_variation_info(visitor_code, feature_flag, track)
       feature_active = variation_key != Kameleoon::Configuration::VariationType::VARIATION_OFF
+      @tracking_manager.add_visitor_code(visitor_code) if track
       Logging::KameleoonLogger.info(
-        "RETURN: KameleoonClient.feature_active?(visitor_code: '%s', feature_key: '%s', is_unique_identifier: %s) " \
-          '-> (feature_active: false)', visitor_code, feature_key, is_unique_identifier
+        "RETURN: KameleoonClient.feature_active?(visitor_code: '%s', feature_key: '%s', " \
+        'is_unique_identifier: %s, track: %s) -> (feature_active: %s)',
+        visitor_code, feature_key, is_unique_identifier, track, feature_active
       )
       feature_active
     rescue Exception::FeatureEnvironmentDisabled
@@ -286,6 +298,82 @@ module Kameleoon
       false
     end
 
+    ##
+    # Retrieves the variation assigned to the given visitor for a specific feature flag.
+    #
+    # @param [String] visitor_code The unique identifier of the visitor.
+    # @param [String] feature_key The unique identifier of the feature flag.
+    # @param [Bool] track Optional flag indicating whether tracking of the feature evaluation is enabled
+    # (`true`) or disabled (`false`); the default value is `true`.
+    #
+    # @return [Kameleoon::Types::Variation] The variation assigned to the visitor if the visitor is associated with some
+    # rule of the feature flag, otherwise the method returns the default variation of the feature flag.
+    #
+    # @raise [Kameleoon::Exception::VisitorCodeInvalid] If the visitor code is empty or longer than 255 chars.
+    # @raise [Kameleoon::Exception::FeatureNotFound] Feature Flag isn't found in this configuration.
+    # @raise [Kameleoon::Exception::FeatureEnvironmentDisabled] If the requested feature flag is disabled for
+    # the current environment.
+    def get_variation(visitor_code, feature_key, track: true)
+      Logging::KameleoonLogger.info(
+        "CALL: KameleoonClient.get_variation(visitor_code: '%s', feature_key: '%s', track: %s)",
+        visitor_code, feature_key, track
+      )
+      Utils::VisitorCode.validate(visitor_code)
+      feature_flag = @data_manager.data_file.get_feature_flag(feature_key)
+      variation_key, var_by_exp, rule = get_variation_info(visitor_code, feature_flag, track)
+      variation = feature_flag.get_variation_by_key(variation_key)
+      external_variation = make_external_variation(variation, var_by_exp&.variation_id, rule&.experiment_id)
+      @tracking_manager.add_visitor_code(visitor_code) if track
+      Logging::KameleoonLogger.info(
+        "RETURN: KameleoonClient.get_variation(visitor_code: '%s', feature_key: '%s', track: %s)" \
+        ' -> (variation: %s)',
+        visitor_code, feature_key, track, external_variation
+      )
+      external_variation
+    end
+
+    ##
+    # Forms a dictionary of variations assigned to a given visitor across all feature flags.
+    # This method iterates over all available feature flags and returns the assigned variation for each flag
+    # associated with the specified visitor.
+    #
+    # @param [String] visitor_code The unique identifier of the visitor.
+    # @param [Bool] only_active Optional flag indicating whether to return only variations for active feature
+    # flags (`true`) or for any feature flags (`false`); the default value is `false`.
+    # @param [Bool] track Optional flag indicating whether tracking of the feature evaluation is enabled
+    # (`true`) or disabled (`false`); the default value is `true`.
+    #
+    # @return [Hash] A hash consisting of feature flag keys as keys (`String`) and their corresponding
+    # variations (or the default variation of that feature flag) as values (`Kameleoon::Types::Variation`).
+    #
+    # @raise [Kameleoon::Exception::VisitorCodeInvalid] If the visitor code is empty or longer than 255 chars.
+    def get_variations(visitor_code, only_active: false, track: true)
+      Logging::KameleoonLogger.info(
+        "CALL: KameleoonClient.get_variations(visitor_code: '%s', only_active: %s, track: %s)",
+        visitor_code, only_active, track
+      )
+      Utils::VisitorCode.validate(visitor_code)
+      variations = {}
+      @data_manager.data_file.feature_flags.each_value do |feature_flag|
+        next unless feature_flag.environment_enabled
+
+        variation_key, var_by_exp, rule = get_variation_info(visitor_code, feature_flag, track)
+        next if only_active && (variation_key == Configuration::VariationType::VARIATION_OFF)
+
+        variation = feature_flag.get_variation_by_key(variation_key)
+        variations[feature_flag.feature_key] =
+          make_external_variation(variation, var_by_exp&.variation_id, rule&.experiment_id)
+      end
+      variations.freeze
+      @tracking_manager.add_visitor_code(visitor_code) if track
+      Logging::KameleoonLogger.info(
+        "RETURN: KameleoonClient.get_variations(visitor_code: '%s', only_active: %s, track: %s)" \
+        ' -> (variations: %s)',
+        visitor_code, only_active, track, variations
+      )
+      variations
+    end
+
     ##
     # get_feature_variation_key returns a variation key for visitor code
     #
@@ -305,7 +393,12 @@ module Kameleoon
     # @raise [Kameleoon::Exception::FeatureEnvironmentDisabled] If the requested feature flag is disabled for
     # the current environment
     #
+    # DEPRECATED. Please use `get_variation(visitor_code, feature_key, track: true)` instead.
     def get_feature_variation_key(visitor_code, feature_key, is_unique_identifier: nil)
+      Logging::KameleoonLogger.info(
+        '[DEPRECATION] `get_feature_variation_key` is deprecated. ' \
+        'Please use `get_variation(visitor_code, feature_key, track: true)` instead.'
+      )
       Logging::KameleoonLogger.info(
         "CALL: KameleoonClient.get_feature_variation_key(visitor_code: '%s', feature_key: '%s', " \
           'is_unique_identifier: %s)',
@@ -339,7 +432,12 @@ module Kameleoon
     # @raise [Kameleoon::Exception::FeatureEnvironmentDisabled] If the requested feature flag is disabled for
     # the current environment
     #
+    # DEPRECATED. Please use `get_variation(visitor_code, feature_key, track: true)` instead.
     def get_feature_variable(visitor_code, feature_key, variable_name, is_unique_identifier: nil)
+      Logging::KameleoonLogger.info(
+        '[DEPRECATION] `get_feature_variable` is deprecated. ' \
+        'Please use `get_variation(visitor_code, feature_key, track: true)` instead.'
+      )
       Logging::KameleoonLogger.info(
         "CALL: KameleoonClient.get_feature_variable(visitor_code: '%s', feature_key: '%s', variable_name: '%s', " \
           'is_unique_identifier: %s)', visitor_code, feature_key, variable_name, is_unique_identifier
@@ -347,7 +445,7 @@ module Kameleoon
       Utils::VisitorCode.validate(visitor_code)
       set_unique_identifier(visitor_code, is_unique_identifier) unless is_unique_identifier.nil?
       feature_flag, variation_key = _get_feature_variation_key(visitor_code, feature_key)
-      variation = feature_flag.get_variation_key(variation_key)
+      variation = feature_flag.get_variation_by_key(variation_key)
       variable = variation&.get_variable_by_key(variable_name)
       if variable.nil?
         raise Exception::FeatureVariableNotFound.new(variable_name),
@@ -376,13 +474,18 @@ module Kameleoon
     # @raise [Kameleoon::Exception::FeatureVariationNotFound]
     # @raise [Kameleoon::Exception::FeatureEnvironmentDisabled]
     #
+    # DEPRECATED. Please use `get_variation(visitor_code, feature_key, track: false)` instead.
     def get_feature_variation_variables(feature_key, variation_key)
+      Logging::KameleoonLogger.info(
+        '[DEPRECATION] `get_feature_variation_variables` is deprecated. ' \
+        'Please use `get_variation(visitor_code, feature_key, track: false)` instead.'
+      )
       Logging::KameleoonLogger.info(
         "CALL: KameleoonClient.get_feature_variation_variables(feature_key: '%s', variation_key: '%s')",
         feature_key, variation_key
       )
       feature_flag = @data_manager.data_file.get_feature_flag(feature_key)
-      variation = feature_flag.get_variation_key(variation_key)
+      variation = feature_flag.get_variation_by_key(variation_key)
       if variation.nil?
         raise Exception::FeatureVariationNotFound.new(variation_key),
               "Variation key #{variation_key} not found"
@@ -508,7 +611,7 @@ module Kameleoon
     #
     # DEPRECATED. Please use `get_active_features` instead.
     def get_active_feature_list_for_visitor(visitor_code)
-      Logging::KameleoonLogger.warning('[DEPRECATION] `get_active_feature_list_for_visitor` is deprecated.' \
+      Logging::KameleoonLogger.info('[DEPRECATION] `get_active_feature_list_for_visitor` is deprecated.' \
                                          ' Please use `get_active_features` instead.')
       Logging::KameleoonLogger.info("CALL: KameleoonClient.get_active_feature_list_for_visitor(visitor_code: '%s')",
                                     visitor_code)
@@ -537,7 +640,13 @@ module Kameleoon
     # @raise [Kameleoon::Exception::VisitorCodeInvalid] If the visitor code is empty or longer than 255 chars or is nil
     #
     # @return [Hash] Hash of active features for a visitor
+    #
+    # DEPRECATED. Please use `get_variations(visitor_code, only_active: true, track: false)` instead.
     def get_active_features(visitor_code)
+      Logging::KameleoonLogger.info(
+        '[DEPRECATION] `get_active_features` is deprecated. ' \
+        'Please use `get_variations(visitor_code, only_active: true, track: false)` instead.'
+      )
       Logging::KameleoonLogger.info("CALL: KameleoonClient.get_active_features(visitor_code: '%s')", visitor_code)
       Utils::VisitorCode.validate(visitor_code)
       map_active_features = {}
@@ -550,24 +659,9 @@ module Kameleoon
 
         next if variation_key == Configuration::VariationType::VARIATION_OFF
 
-        variation = feature_flag.get_variation_key(variation_key)
-        variables = {}
-
-        variation&.variables&.each do |variable|
-          variables[variable.key] = Kameleoon::Types::Variable.new(
-            variable.key,
-            variable.type,
-            _parse_feature_variable(variable)
-          )
-        end
-
-        variables.freeze
-        map_active_features[feature_flag.feature_key] = Kameleoon::Types::Variation.new(
-          variation_key,
-          var_by_exp ? var_by_exp.variation_id : nil,
-          rule ? rule.experiment_id : nil,
-          variables
-        )
+        variation = feature_flag.get_variation_by_key(variation_key)
+        map_active_features[feature_flag.feature_key] =
+          make_external_variation(variation, var_by_exp&.variation_id, rule&.experiment_id)
       end
 
       map_active_features.freeze
@@ -754,6 +848,22 @@ module Kameleoon
       @targeting_manager.check_targeting(visitor_code, campaign_id, exp_ff_rule)
     end
 
+    def get_variation_info(visitor_code, feature_flag, track)
+      Logging::KameleoonLogger.debug(
+        "CALL: KameleoonClient.get_variation_info(visitor_code: '%s', feature_flag: %s, track: %s)",
+        visitor_code, feature_flag, track
+      )
+      var_by_exp, rule = _calculate_variation_key_for_feature(visitor_code, feature_flag)
+      variation_key = _get_variation_key(var_by_exp, rule, feature_flag)
+      save_variation(visitor_code, rule, var_by_exp, track: track)
+      Logging::KameleoonLogger.debug(
+        "RETURN: KameleoonClient.get_variation_info(visitor_code: '%s', feature_flag: %s, track: %s)" \
+        ' -> (variation_key: %s, variation_by_exposition: %s, rule: %s)',
+        visitor_code, feature_flag, track, variation_key, var_by_exp, rule
+      )
+      [variation_key, var_by_exp, rule]
+    end
+
     ##
     # helper method for getting variation key for feature flag
     def _get_feature_variation_key(visitor_code, feature_key)
@@ -764,16 +874,7 @@ module Kameleoon
       feature_flag = @data_manager.data_file.get_feature_flag(feature_key)
       variation, rule = _calculate_variation_key_for_feature(visitor_code, feature_flag)
       variation_key = _get_variation_key(variation, rule, feature_flag)
-      visitor = nil
-      unless rule.nil?
-        experiment_id = rule.experiment_id
-        variation_id = variation.variation_id unless variation.nil?
-        visitor = @visitor_manager.get_or_create_visitor(visitor_code)
-        unless experiment_id.nil? || variation_id.nil?
-          as_variation = Kameleoon::DataManager::AssignedVariation.new(experiment_id, variation_id, rule.type)
-          visitor.assign_variation(as_variation)
-        end
-      end
+      save_variation(visitor_code, rule, variation)
       @tracking_manager.add_visitor_code(visitor_code)
       Logging::KameleoonLogger.debug(
         "RETURN: KameleoonClient._get_feature_variation_key(visitor_code: '%s', feature_key: '%s')" \
@@ -783,6 +884,25 @@ module Kameleoon
       [feature_flag, variation_key]
     end
 
+    def save_variation(visitor_code, rule, var_by_exp, track: true)
+      experiment_id = rule&.experiment_id
+      variation_id = var_by_exp&.variation_id
+      return if experiment_id.nil? || variation_id.nil?
+
+      Logging::KameleoonLogger.debug(
+        "CALL: KameleoonClient.save_variation(visitor_code: '%s', rule: %s, var_by_exp: %s, track: %s)",
+        visitor_code, rule, var_by_exp, track
+      )
+      visitor = @visitor_manager.get_or_create_visitor(visitor_code)
+      as_variation = Kameleoon::DataManager::AssignedVariation.new(experiment_id, variation_id, rule.type)
+      as_variation.mark_as_sent unless track
+      visitor.assign_variation(as_variation)
+      Logging::KameleoonLogger.debug(
+        "RETURN: KameleoonClient.save_variation(visitor_code: '%s', rule: %s, var_by_exp: %s, track: %s)",
+        visitor_code, rule, var_by_exp, track
+      )
+    end
+
     ##
     # helper method for calculate variation key for feature flag
     def _calculate_variation_key_for_feature(visitor_code, feature_flag)
@@ -845,22 +965,47 @@ module Kameleoon
       feature_flag.default_variation_key
     end
 
+    def make_external_variation(internal_variation, variation_id, experiment_id)
+      Logging::KameleoonLogger.debug(
+        'CALL: KameleoonClient.make_external_variation(internal_variation: %s, variation_id: %s, experiment_id: %s)',
+        internal_variation, variation_id, experiment_id
+      )
+      variables = {}
+      internal_variation&.variables&.each do |variable|
+        variables[variable.key] = Types::Variable.new(
+          variable.key,
+          variable.type,
+          _parse_feature_variable(variable)
+        )
+      end
+      variables.freeze
+      variation = Types::Variation.new(internal_variation&.key, variation_id, experiment_id, variables)
+      Logging::KameleoonLogger.debug(
+        'RETURN: KameleoonClient.make_external_variation(internal_variation: %s, variation_id: %s, experiment_id: %s)' \
+        ' -> (variation: %s)',
+        internal_variation, variation_id, experiment_id, variation
+      )
+      variation
+    end
+
     ##
     # helper method for fetching values from a Variable
     def _parse_feature_variable(variable)
       case variable.type
-      when 'BOOLEAN', 'STRING', 'NUMBER'
+      when 'BOOLEAN', 'STRING', 'NUMBER', 'JS', 'CSS'
         variable.value
       when 'JSON'
         JSON.parse(variable.value)
       else
-        raise TypeError.new('Unknown type for feature variable'),
-              'Unknown type for feature variable'
+        Logging::KameleoonLogger.error("Unknown type '#{variable.type}' for feature variable")
+        variable.value
       end
     end
 
     def set_unique_identifier(visitor_code, is_unique_identifier)
-      Logging::KameleoonLogger.warning("The 'isUniqueIdentifier' parameter is deprecated. Please, add 'UniqueIdentifier' to a visitor instead.")
+      Logging::KameleoonLogger.info(
+        "The 'isUniqueIdentifier' parameter is deprecated. Please, add 'UniqueIdentifier' to a visitor instead."
+      )
       @visitor_manager.add_data(visitor_code, UniqueIdentifier.new(is_unique_identifier))
     end
   end

data/lib/kameleoon/kameleoon_client_config.rb

@@ -113,7 +113,7 @@ module Kameleoon
           'Setting top level domain is strictly recommended, otherwise you may have problems when using subdomains.'
         )
       end
-      @top_level_domain = top_level_domain
+      @top_level_domain = Utils::Domain.validate_top_level_domain(top_level_domain)
     end
 
     def self.read_from_yaml(path)

data/lib/kameleoon/managers/data/data_manager.rb

@@ -16,18 +16,18 @@ module Kameleoon
           @container = Container.new(value)
         end
 
-        def consent_required?
-          @container.is_consent_required
+        def visitor_code_managed?
+          @container.visitor_code_managed
         end
 
         class Container
-          attr_reader :data_file, :is_consent_required
+          attr_reader :data_file, :visitor_code_managed
 
           def initialize(data_file)
             @data_file = data_file
             # Regarding GDPR policy we should set visitorCode if legal consent isn't required or we have at
             # least one Targeted Delivery rule in datafile
-            @is_consent_required = data_file.settings.is_consent_required && !data_file.has_any_targeted_delivery_rule
+            @visitor_code_managed = data_file.settings.is_consent_required && !data_file.has_any_targeted_delivery_rule
           end
         end
       end

data/lib/kameleoon/managers/remote_data/remote_data_manager.rb

@@ -42,12 +42,20 @@ module Kameleoon
           filter = Types::RemoteVisitorDataFilter.new unless filter.is_a?(Types::RemoteVisitorDataFilter)
           is_unique_identifier = @visitor_manger.get_visitor(visitor_code)&.is_unique_identifier || false
           response = @network_manager.get_remote_visitor_data(visitor_code, filter, is_unique_identifier, timeout)
-          (data_to_add, data_to_return) = parse_custom_data_array(visitor_code, response)
+          remote_visitor_data = parse_custom_data_array(visitor_code, response)
+          remote_visitor_data.mark_data_as_sent(@data_manager.data_file.custom_data_info)
+          data_to_add = remote_visitor_data.collect_data_to_add
           if add_data && !data_to_add.empty?
             # Cannot use `VisitorManager.add_data` because it could use remote visitor data for mapping.
             visitor = @visitor_manger.get_or_create_visitor(visitor_code)
             visitor.add_data(*data_to_add, overwrite: false)
           end
+          if filter.visitor_code && !remote_visitor_data.visitor_code.nil?
+            # We apply visitor code from the latest visit fetched from Data API
+            visitor = @visitor_manger.get_or_create_visitor(visitor_code)
+            visitor.mapping_identifier = remote_visitor_data.visitor_code
+          end
+          data_to_return = remote_visitor_data.collect_data_to_return
           Logging::KameleoonLogger.debug(
             "RETURN: RemoteDataManager.get_visitor_data(visitor_code: '%s', add_data: %s, filter: %s," \
               ' timeout: %s) -> (visitor_data: %s)',
@@ -59,9 +67,7 @@ module Kameleoon
         ##
         # helper method used by `get_remote_visitor_data`
         def parse_custom_data_array(visitor_code, response)
-          remote_visitor_data = RemoteVisitorData.new(JSON.parse(response))
-          remote_visitor_data.mark_data_as_sent(@data_manager.data_file.custom_data_info)
-          [remote_visitor_data.collect_data_to_add, remote_visitor_data.collect_data_to_return]
+          RemoteVisitorData.new(JSON.parse(response))
         rescue StandardError => e
           Logging::KameleoonLogger.error("Parsing of remote visitor data of '#{visitor_code}' failed: #{e}")
           raise

data/lib/kameleoon/managers/remote_data/remote_visitor_data.rb

@@ -16,7 +16,7 @@ module Kameleoon
     module RemoteData
       class RemoteVisitorData
         attr_reader :custom_data_dict, :page_view_visits, :conversions, :experiments, :device, :browser,
-                    :operating_system, :geolocation, :previous_visitor_visits, :kcs_heat
+                    :operating_system, :geolocation, :previous_visitor_visits, :kcs_heat, :visitor_code
 
         def initialize(hash)
           current_visit = hash['currentVisit']
@@ -68,18 +68,20 @@ module Kameleoon
         private
 
         def parse_visit(hash)
+          @visitor_code = hash['visitorCode'] if @visitor_code.nil?
           custom_data_events = hash['customDataEvents']
-          parse_custom_data(custom_data_events) if custom_data_events != nil && custom_data_events.size.positive?
+          parse_custom_data(custom_data_events) if !custom_data_events.nil? && custom_data_events.size.positive?
           page_events = hash['pageEvents']
-          parse_pages(page_events) if page_events != nil && page_events.size.positive?
+          parse_pages(page_events) if !page_events.nil? && page_events.size.positive?
           experiment_events = hash['experimentEvents']
-          parse_experiments(experiment_events) if experiment_events != nil && experiment_events.size.positive?
+          parse_experiments(experiment_events) if !experiment_events.nil? && experiment_events.size.positive?
           conversion_events = hash['conversionEvents']
-          parse_conversions(conversion_events) if conversion_events != nil && conversion_events.size.positive?
+          parse_conversions(conversion_events) if !conversion_events.nil? && conversion_events.size.positive?
           geolocation_events = hash['geolocationEvents']
-          @geolocation = parse_geolocation(geolocation_events) if @geolocation.nil? && geolocation_events != nil && geolocation_events.size.positive?
+          @geolocation = parse_geolocation(geolocation_events) if @geolocation.nil? && !geolocation_events.nil? && \
+                                                                  geolocation_events.size.positive?
           static_data_events = hash['staticDataEvent']
-          parse_static_data(static_data_events) if static_data_events != nil
+          parse_static_data(static_data_events) unless static_data_events.nil?
         end
 
         def parse_custom_data(custom_data_events)

data/lib/kameleoon/managers/tracking/tracking_manager.rb

@@ -80,12 +80,13 @@ module Kameleoon
           Thread.new do
             result = @network_manager.send_tracking_data(lines)
             if result != false
-              Logging::KameleoonLogger.debug('Successful request for tracking visitors: %s, data: %s',
-                                             visitor_codes, visitor_data)
+              Logging::KameleoonLogger.info('Successful request for tracking visitors: %s, data: %s',
+                                            visitor_codes, visitor_data)
               visitor_data.each { |d| d.mark_as_sent if d.is_a?(Kameleoon::Data) }
             else
-              Logging::KameleoonLogger.debug('Failed request for tracking visitors: %s, data: %s',
-                                             visitor_codes, visitor_data)
+              Logging::KameleoonLogger.error('Tracking request failed')
+              Logging::KameleoonLogger.info('Failed request for tracking visitors: %s, data: %s',
+                                            visitor_codes, visitor_data)
               visitor_data.each { |d| d.mark_as_unsent if d.is_a?(Kameleoon::Data) }
               @tracking_visitors.add_all(visitor_codes)
             end

data/lib/kameleoon/network/cookie/cookie_manager.rb

@@ -31,7 +31,7 @@ module Kameleoon
             Utils::VisitorCode.validate(visitor_code)
             Logging::KameleoonLogger.debug("Read visitor code '%s' from cookies %s", visitor_code, cookies)
             # Remove adding cookies when we will be sure that it doesn't break anything
-            add(visitor_code, cookies) unless @data_manager.consent_required?
+            add(visitor_code, cookies) unless @data_manager.visitor_code_managed?
             Logging::KameleoonLogger.debug(
               "RETURN: CookieManager.get_or_add(cookies: %s, default_visitor_code: '%s') -> (visitor_code: '%s')",
               cookies, default_visitor_code, visitor_code
@@ -42,7 +42,7 @@ module Kameleoon
           if default_visitor_code.nil?
             visitor_code = Utils::VisitorCode.generate
             Logging::KameleoonLogger.debug("Generated new visitor code '%s'", visitor_code)
-            add(visitor_code, cookies) unless @data_manager.consent_required?
+            add(visitor_code, cookies) unless @data_manager.visitor_code_managed?
             Logging::KameleoonLogger.debug(
               "RETURN: CookieManager.get_or_add(cookies: %s, default_visitor_code: '%s') -> (visitor_code: '%s')",
               cookies, default_visitor_code, visitor_code
@@ -56,7 +56,8 @@ module Kameleoon
           add(visitor_code, cookies)
           Logging::KameleoonLogger.debug(
             "RETURN: CookieManager.get_or_add(cookies: %s, default_visitor_code: '%s') -> (visitor_code: '%s')",
-            cookies, default_visitor_code, visitor_code)
+            cookies, default_visitor_code, visitor_code
+          )
           visitor_code
         end
 
@@ -72,7 +73,7 @@ module Kameleoon
             remove(cookies)
           end
           Logging::KameleoonLogger.debug("RETURN: CookieManager.update(visitor_code: '%s', consent: %s, cookies: %s)",
-                                visitor_code, consent, cookies)
+                                         visitor_code, consent, cookies)
         end
 
         private
@@ -88,13 +89,13 @@ module Kameleoon
           }
           cookies[VISITOR_CODE_COOKIE] = cookie
           Logging::KameleoonLogger.debug("RETURN: CookieManager.add(visitor_code: '%s', cookies: %s)",
-                                visitor_code, cookies)
+                                         visitor_code, cookies)
           cookies
         end
 
         def remove(cookies)
           Logging::KameleoonLogger.debug('CALL: CookieManager.remove(cookies: %s)', cookies)
-          cookies[VISITOR_CODE_COOKIE] = nil if @data_manager.consent_required?
+          cookies[VISITOR_CODE_COOKIE] = nil if @data_manager.visitor_code_managed?
           Logging::KameleoonLogger.debug('RETURN: CookieManager.remove(cookies: %s)', cookies)
           cookies
         end

data/lib/kameleoon/network/network_manager.rb

@@ -88,11 +88,13 @@ module Kameleoon
           if response.success?
             success = true
           elsif !response.error.nil?
-            Logging::KameleoonLogger.warning("%s call '%s' failed: Error occurred during request: %s",
-                                             request.method, request.url, response.error)
+            log_level = attempt < retry_limit ? Logging::LogLevel::WARNING : Logging::LogLevel::ERROR
+            Logging::KameleoonLogger.log(log_level, "%s call '%s' failed: Error occurred during request: %s",
+                                         request.method, request.url, response.error)
           else
-            Logging::KameleoonLogger.warning("%s call '%s' failed: Received unexpected status code '%s'",
-                                             request.method, request.url, response.code)
+            log_level = attempt < retry_limit ? Logging::LogLevel::WARNING : Logging::LogLevel::ERROR
+            Logging::KameleoonLogger.log(log_level, "%s call '%s' failed: Received unexpected status code '%s'",
+                                         request.method, request.url, response.code)
             if response.code == 401 && request.access_token
               Logging::KameleoonLogger.warning("Unexpected rejection of access token '#{request.access_token}'")
               @access_token_source.discard_token(request.access_token)
@@ -108,7 +110,6 @@ module Kameleoon
           attempt += 1
         end
         Logging::KameleoonLogger.debug('Fetched response %s for request %s', response, request)
-        Logging::KameleoonLogger.error("Failed %s request '%s'", request.method, request.url) unless success
         success ? response.body : false
       end
 

data/lib/kameleoon/network/url_provider.rb

@@ -19,7 +19,7 @@ module Kameleoon
       DEFAULT_DATA_API_DOMAIN = 'data.kameleoon.io'
       TEST_DATA_API_DOMAIN = 'data.kameleoon.net'
       DEFAULT_AUTOMATION_API_DOMAIN = 'api.kameleoon.com'
-      TEST_AUTOMATION_API_DOMAIN = 'api.master.preview.kameleoon.net'
+      TEST_AUTOMATION_API_DOMAIN = 'api.kameleoon.net'
 
       attr_reader :site_code, :data_api_domain, :automation_api_domain
 

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

@@ -13,15 +13,17 @@ module Kameleoon
         super(json_condition, json_condition['title'])
       end
 
-      def check(page_view_visit_storage)
-        return false unless page_view_visit_storage.is_a?(Kameleoon::DataManager::DataMapStorage)
+      def check(page_view_visits)
+        return false unless page_view_visits.is_a?(Kameleoon::DataManager::DataMapStorage)
 
-        is_targeted = false
-        page_view_visit_storage.enumerate do |visit|
-          is_targeted = visit.is_a?(Kameleoon::DataManager::PageViewVisit) && check_targeting(visit.page_view.title)
-          break if is_targeted
+        latest = nil
+        page_view_visits.enumerate do |visit|
+          if visit.is_a?(Kameleoon::DataManager::PageViewVisit) \
+            && (latest.nil? || visit.last_timestamp > latest.last_timestamp)
+            latest = visit
+          end
         end
-        is_targeted
+        !latest.nil? && latest.is_a?(Kameleoon::DataManager::PageViewVisit) && check_targeting(latest.page_view.title)
       end
     end
   end

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

@@ -13,22 +13,17 @@ module Kameleoon
         super(json_condition, json_condition['url'])
       end
 
-      def check(page_view_visit_storage)
-        return false unless page_view_visit_storage.is_a?(Kameleoon::DataManager::DataMapStorage)
-        return !page_view_visit_storage.get(condition_value).nil? if operator == Operator::EXACT
+      def check(page_view_visits)
+        return false unless page_view_visits.is_a?(Kameleoon::DataManager::DataMapStorage)
 
-        is_targeted = false
-        page_view_visit_storage.enumerate do |visit|
-          is_targeted = check_page_view_visit(visit)
-          break if is_targeted
+        latest = nil
+        page_view_visits.enumerate do |visit|
+          if visit.is_a?(Kameleoon::DataManager::PageViewVisit) \
+            && (latest.nil? || visit.last_timestamp > latest.last_timestamp)
+            latest = visit
+          end
         end
-        is_targeted
-      end
-
-      private
-
-      def check_page_view_visit(visit)
-        visit.is_a?(Kameleoon::DataManager::PageViewVisit) && check_targeting(visit.page_view.url)
+        !latest.nil? && latest.is_a?(Kameleoon::DataManager::PageViewVisit) && check_targeting(latest.page_view.url)
       end
     end
   end

data/lib/kameleoon/types/remote_visitor_data_filter.rb

@@ -5,7 +5,7 @@ module Kameleoon
   module Types
     class RemoteVisitorDataFilter
       attr_reader :previous_visit_amount, :current_visit, :custom_data, :page_views, :geolocation, :device, :browser,
-                  :operating_system, :conversions, :experiments, :kcs
+                  :operating_system, :conversions, :experiments, :kcs, :visitor_code
 
       def to_s
         "RemoteVisitorDataFilter{previous_visit_amount:#{@previous_visit_amount}," \
@@ -17,13 +17,15 @@ module Kameleoon
           "browser:#{@browser}," \
           "operating_system:#{@operating_system}," \
           "conversions:#{@conversions}," \
-          "experiments:#{@experiments},kcs:#{@kcs}}"
+          "experiments:#{@experiments}," \
+          "kcs:#{@kcs}," \
+          "visitor_code:#{@visitor_code}}"
       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,
-        experiments: false, kcs: false
+        experiments: false, kcs: false, visitor_code: true
       )
         @previous_visit_amount = previous_visit_amount
         @current_visit = current_visit
@@ -36,6 +38,7 @@ module Kameleoon
         @conversions = conversions
         @experiments = experiments
         @kcs = kcs
+        @visitor_code = visitor_code
       end
     end
   end

data/lib/kameleoon/types/variation.rb

@@ -17,6 +17,10 @@ module Kameleoon
         @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
@@ -68,5 +69,35 @@ module Kameleoon
         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,6 +1,6 @@
 # frozen_string_literal: true
 
 module Kameleoon
-  SDK_VERSION = '3.4.0'
+  SDK_VERSION = '3.6.0'
   SDK_NAME = 'RUBY'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kameleoon-client-ruby
 version: !ruby/object:Gem::Version
-  version: 3.4.0
+  version: 3.6.0
 platform: ruby
 authors:
 - Kameleoon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-08-15 00:00:00.000000000 Z
+date: 2024-11-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: em-http-request