kameleoon-client-ruby 3.4.0 → 3.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2fb2eefaf6fa7008e5e475044e2f3c20baa088332657f0e19e17c73abffdfa3b
-  data.tar.gz: ef078e7a9d1ac4fd2fef3a74edf4ee5328043b6989c59eafc29559f79ab535d4
+  metadata.gz: 283250365ae9bf4087ebffeb7a4de0e31cca91f06a865cdd4ad2cae1f88c692c
+  data.tar.gz: 31ab8ddbd1ef7524b41019a0afe442a47ee5b5e9e1d50649ed04aab625d7c3a3
 SHA512:
-  metadata.gz: 8df54dcee89dc21a3565948e96b330b655d780ca7cbd4955385b12c5ad64ccdbc8318b17043acb02eddcd2d8dd45191eaeb001d6957e250573e8b9cc606ffbf0
-  data.tar.gz: 3fe4dfe732310de088f45dcc2002c2504b03e45e2e101bb7199b46783cac46aed80a7e35fc0cc6995ddcb7ba0202629d367922e58d8a8e90b974679f91363086
+  metadata.gz: 23f61dd193ad1bb7477ee44e0e2eb5c16bec625748b9ebdde37a9a6b9e71a4610a98c218a4e76addb66a5a55ecf2bcae1764f2aac8d9f9f8ebb6bbc3be86e318
+  data.tar.gz: d27d91e39fb5bc968ba414016642de07baef8ef7888f1d93969ae5fb67f07b903ba60b981de9387fa5c6eb20e99bd647d965fea0123841348f67a8aa66840f99

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/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,
@@ -263,22 +265,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 +297,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 +392,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 +431,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 +444,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 +473,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 +610,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 +639,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 +658,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 +847,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 +873,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 +883,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 +964,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/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/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.5.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.5.0
 platform: ruby
 authors:
 - Kameleoon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-08-15 00:00:00.000000000 Z
+date: 2024-10-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: em-http-request