kameleoon-client-ruby 3.7.0 → 3.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e0001c490d29beefab2f33c416affe19f6ccbc05d83e0aaad70be85070986e3
-  data.tar.gz: 6959eb4d8f421b9e14e62f3c490d5e1c6f038a25d3e5cb785c1832d7908c291d
+  metadata.gz: a64d8edfee07c22561b166de49f9185d89a6fbdec9b49f6fd65860125bd54eab
+  data.tar.gz: ee7ccf78d0d11dec198b930e77e496c39a220b87471d724015c78114b85368f8
 SHA512:
-  metadata.gz: dfe9e75f3563287b6f187a38066a623145ba7ed916d12b9c7ec03dfe7173600ddd16d6a49ca304c4c46ec28794d5372bf29534f36ebaea18fa7eb8c2977dd981
-  data.tar.gz: faf2abe7ed35a211fc210a3e72f90a2bf79a8affde8a35c96af2363fabb50091b1069aaea0074458bff1d56156d80e81cd8cb427e3c772b99dc81d318093f7a9
+  metadata.gz: ccfba38b35f50d2b1dda0ef2bf31406f74fd92663276f4297ae867bc7b88b8606b345a8a4234f24ef71c71fdc3555cc9852d7324c1a6a668ed8b6cbc98cfeedb
+  data.tar.gz: 38543c67b7c8949ccba5c8e0f08eae86d2755a737bc25a5dc82e94dd92011c7678cb4b32647ffae0edb606913bff537455f2f42295fe9f421554726a57675808

data/lib/kameleoon/configuration/data_file.rb

@@ -1,15 +1,17 @@
 # frozen_string_literal: true
 
-require 'kameleoon/configuration/settings'
-require 'kameleoon/configuration/feature_flag'
 require 'kameleoon/configuration/custom_data_info'
+require 'kameleoon/configuration/experiment'
+require 'kameleoon/configuration/feature_flag'
+require 'kameleoon/configuration/settings'
 require 'kameleoon/logging/kameleoon_logger'
 
 module Kameleoon
   module Configuration
     class DataFile
       attr_reader :settings, :feature_flags, :has_any_targeted_delivery_rule, :feature_flag_by_id, :rule_by_segment_id,
-                  :rule_info_by_exp_id, :variation_by_id, :custom_data_info, :experiment_ids_with_js_css_variable
+                  :rule_info_by_exp_id, :variation_by_id, :custom_data_info, :experiment_ids_with_js_css_variable,
+                  :holdout
 
       def to_s
         'DataFile{' \
@@ -64,6 +66,7 @@ module Kameleoon
         end
         @has_any_targeted_delivery_rule = any_targeted_delivery_rule?
         @custom_data_info = CustomDataInfo.new(configuration['customData'])
+        @holdout = Experiment.from_json(configuration['holdout']) if configuration.include?('holdout')
         Logging::KameleoonLogger.debug('RETURN: DataFile.init(configuration: %s)', configuration)
       end
 
@@ -85,11 +88,11 @@ module Kameleoon
           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_info_by_exp_id[rule.experiment_id || 0] = RuleInfo.new(feature_flag, rule)
-            rule.variation_by_exposition.each do |variation|
+            @rule_info_by_exp_id[rule.experiment.id] = RuleInfo.new(feature_flag, rule)
+            rule.experiment.variations_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
+            @experiment_ids_with_js_css_variable.add(rule.experiment.id) if has_feature_flag_variable_js_css
           end
         end
         @feature_flag_by_id.freeze

data/lib/kameleoon/configuration/experiment.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative 'variation_exposition'
+require 'kameleoon/exceptions'
+
+module Kameleoon
+  module Configuration
+    class Experiment
+      attr_reader :id, :variations_by_exposition
+
+      def initialize(id, variations_by_exposition)
+        @id = id
+        @variations_by_exposition = variations_by_exposition
+      end
+
+      def self.from_json(hash)
+        id = hash['experimentId'] || 0
+        variations_by_exposition = VariationByExposition.create_from_array(hash['variationByExposition'])
+        variations_by_exposition.freeze
+        Experiment.new(id, variations_by_exposition)
+      end
+
+      def to_s
+        "Experiment{id:#{@id}}"
+      end
+
+      def get_variation(hash_double)
+        total = 0.0
+        @variations_by_exposition.each do |var_by_exp|
+          total += var_by_exp.exposition
+          return var_by_exp if total >= hash_double
+        end
+        nil
+      end
+
+      def get_variation_by_key(variation_key)
+        var_by_exp = @variations_by_exposition.find { |v| v.variation_key == variation_key }
+        unless var_by_exp
+          raise Exception::FeatureVariationNotFound.new(variation_key),
+                "#{self} does not contain variation '#{variation_key}'"
+        end
+        var_by_exp
+      end
+    end
+  end
+end

data/lib/kameleoon/configuration/rule.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'variation_exposition'
-require 'kameleoon/exceptions'
+require_relative 'experiment'
 require 'kameleoon/targeting/models'
 
 module Kameleoon
@@ -30,8 +29,7 @@ module Kameleoon
 
     # Rule is a class for new rules of feature flags
     class Rule
-      attr_reader :id, :order, :type, :exposition, :experiment_id, :variation_by_exposition, :respool_time, :segment_id,
-                  :first_variation
+      attr_reader :id, :order, :type, :exposition, :experiment, :respool_time, :segment_id
       attr_accessor :targeting_segment
 
       def self.create_from_array(array)
@@ -47,35 +45,10 @@ module Kameleoon
         @order = hash['order']
         @type = RuleType.from_literal(hash['type'])
         @exposition = hash['exposition']
-        @experiment_id = hash['experimentId']
         @respool_time = hash['respoolTime']
-        @variation_by_exposition = VariationByExposition.create_from_array(hash['variationByExposition'])
-        @variation_by_exposition.freeze
-        @first_variation = @variation_by_exposition.first
         @targeting_segment = Kameleoon::Targeting::Segment.new((hash['segment'])) if hash['segment']
         @segment_id = @targeting_segment != nil ? targeting_segment.id : -1
-      end
-
-      def get_variation(hash_double)
-        total = 0.0
-        variation_by_exposition.each do |var_by_exp|
-          total += var_by_exp.exposition
-          return var_by_exp if total >= hash_double
-        end
-        nil
-      end
-
-      def get_variation_by_key(variation_key)
-        var_by_exp = variation_by_exposition.find { |v| v.variation_key == variation_key }
-        unless var_by_exp
-          raise Exception::FeatureVariationNotFound.new(variation_key),
-                "#{self} does not contain variation '#{variation_key}'"
-        end
-        var_by_exp
-      end
-
-      def get_variation_id_by_key(key)
-        variation_by_exposition.select { |v| v.variation_key == key }.first&.variation_id
+        @experiment = Experiment.from_json(hash)
       end
 
       def experimentation_type?

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

@@ -405,7 +405,7 @@ module Kameleoon
 
       def add_forced_experiment_variation(forced_variation)
         @forced_variations ||= {}
-        @forced_variations[forced_variation.rule.experiment_id || 0] = forced_variation
+        @forced_variations[forced_variation.rule.experiment.id] = forced_variation
       end
     end
   end

data/lib/kameleoon/kameleoon_client.rb

@@ -321,9 +321,9 @@ module Kameleoon
       )
       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_key, eval_exp = 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)
+      external_variation = create_external_variation(variation, eval_exp)
       @tracking_manager.add_visitor_code(visitor_code) if track
       Logging::KameleoonLogger.info(
         "RETURN: KameleoonClient.get_variation(visitor_code: '%s', feature_key: '%s', track: %s)" \
@@ -358,12 +358,11 @@ module Kameleoon
       @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)
+        variation_key, eval_exp = 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)
+        variations[feature_flag.feature_key] = create_external_variation(variation, eval_exp)
       end
       variations.freeze
       @tracking_manager.add_visitor_code(visitor_code) if track
@@ -624,14 +623,8 @@ module Kameleoon
       @data_manager.data_file.feature_flags.each do |feature_key, feature_flag|
         next unless feature_flag.environment_enabled
 
-        forced_variation = visitor&.get_forced_feature_variation(feature_key)
-        if forced_variation
-          variation = forced_variation.var_by_exp
-          rule = forced_variation.rule
-        else
-          variation, rule = _calculate_variation_key_for_feature(visitor_code, feature_flag)
-        end
-        variation_key = _get_variation_key(variation, rule, feature_flag)
+        eval_exp = evaluate(visitor, visitor_code, feature_flag, false, false)
+        variation_key = calculate_variation_key(eval_exp, feature_flag.default_variation_key)
         list_keys.push(feature_key) if variation_key != Kameleoon::Configuration::VariationType::VARIATION_OFF
       end
       Logging::KameleoonLogger.info(
@@ -665,20 +658,13 @@ module Kameleoon
       @data_manager.data_file.feature_flags.each_value do |feature_flag|
         next unless feature_flag.environment_enabled
 
-        forced_variation = visitor&.get_forced_feature_variation(feature_flag.feature_key)
-        if forced_variation
-          var_by_exp = forced_variation.var_by_exp
-          rule = forced_variation.rule
-        else
-          var_by_exp, rule = _calculate_variation_key_for_feature(visitor_code, feature_flag)
-        end
-        variation_key = _get_variation_key(var_by_exp, rule, feature_flag)
+        eval_exp = evaluate(visitor, visitor_code, feature_flag, false, false)
+        variation_key = calculate_variation_key(eval_exp, feature_flag.default_variation_key)
 
         next if variation_key == Configuration::VariationType::VARIATION_OFF
 
         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)
+        map_active_features[feature_flag.feature_key] = create_external_variation(variation, eval_exp)
       end
 
       map_active_features.freeze
@@ -753,7 +739,7 @@ module Kameleoon
           raise Exception::FeatureExperimentNotFound.new(experiment_id), "Experiment #{experiment_id} is not found"
         end
 
-        var_by_exp = rule_info.rule.get_variation_by_key(variation_key)
+        var_by_exp = rule_info.rule.experiment.get_variation_by_key(variation_key)
         forced_variation = DataManager::ForcedExperimentVariation.new(rule_info.rule, var_by_exp, force_targeting)
         @visitor_manager.add_data(visitor_code, forced_variation)
       end
@@ -917,23 +903,64 @@ module Kameleoon
         visitor_code, feature_flag, track
       )
       visitor = @visitor_manager.get_visitor(visitor_code)
+      eval_exp = evaluate(visitor, visitor_code, feature_flag, track, true)
+      variation_key = calculate_variation_key(eval_exp, feature_flag.default_variation_key)
+      Logging::KameleoonLogger.debug(
+        "RETURN: KameleoonClient.get_variation_info(visitor_code: '%s', feature_flag: %s, track: %s)" \
+        ' -> (variation_key: %s, eval_exp: %s)',
+        visitor_code, feature_flag, track, variation_key, eval_exp
+      )
+      [variation_key, eval_exp]
+    end
+
+    def evaluate(visitor, visitor_code, feature_flag, track, save)
+      Logging::KameleoonLogger.debug(
+        "CALL: KameleoonClient.evaluate(visitor, visitor_code: '%s', feature_flag: %s, track: %s, save: %s)",
+        visitor_code, feature_flag, track, save
+      )
+      eval_exp = nil
       forced_variation = visitor&.get_forced_feature_variation(feature_flag.feature_key)
       if forced_variation
-        var_by_exp = forced_variation.var_by_exp
-        rule = forced_variation.rule
-      else
-        var_by_exp, rule = _calculate_variation_key_for_feature(visitor_code, feature_flag)
+        eval_exp = EvaluatedExperiment.from_forced_variation(forced_variation)
+      elsif visitor_not_in_holdout?(visitor, visitor_code, track, save)
+        eval_exp = _calculate_variation_key_for_feature(visitor_code, feature_flag)
       end
-      unless forced_variation&.simulated
-        save_variation(visitor_code, rule, var_by_exp, track: track)
+      save_variation(visitor_code, eval_exp, track: track) if save && !forced_variation&.simulated
+      Logging::KameleoonLogger.debug(
+        "RETURN: KameleoonClient.evaluate(visitor, visitor_code: '%s', feature_flag: %s, track: %s, save: %s)" \
+        ' -> (eval_exp: %s)',
+        visitor_code, feature_flag, track, save, eval_exp
+      )
+      eval_exp
+    end
+
+    def visitor_not_in_holdout?(visitor, visitor_code, track, save)
+      in_holdout_variation_key = 'in-holdout'
+      Logging::KameleoonLogger.debug(
+        "CALL: KameleoonClient.visitor_not_in_holdout?(visitor, visitor_code: '%s', track: %s, save: %s)",
+        visitor_code, track, save
+      )
+      holdout = @data_manager.data_file.holdout
+      is_not_in_holdout = true
+      unless holdout.nil?
+        code_for_hash = get_code_for_hash(visitor, visitor_code)
+        variation_hash = Utils::Hasher.obtain(code_for_hash, holdout.id)
+        Logging::KameleoonLogger.debug("Calculated holdout hash %s for code '%s'", variation_hash, code_for_hash)
+        var_by_exp = holdout.get_variation(variation_hash)
+        unless var_by_exp.nil?
+          is_not_in_holdout = var_by_exp.variation_key != in_holdout_variation_key
+          if save
+            eval_exp = EvaluatedExperiment.new(var_by_exp, holdout, Configuration::RuleType::EXPERIMENTATION)
+            save_variation(visitor_code, eval_exp, track: track)
+          end
+        end
       end
-      variation_key = _get_variation_key(var_by_exp, rule, feature_flag)
       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
+        "RETURN: KameleoonClient.visitor_not_in_holdout?(visitor, visitor_code: '%s', track: %s, save: %s)" \
+        ' -> (is_not_in_holdout: %s)',
+        visitor_code, track, save, is_not_in_holdout
       )
-      [variation_key, var_by_exp, rule]
+      is_not_in_holdout
     end
 
     ##
@@ -945,15 +972,8 @@ module Kameleoon
       )
       feature_flag = @data_manager.data_file.get_feature_flag(feature_key)
       visitor = @visitor_manager.get_visitor(visitor_code)
-      forced_variation = visitor&.get_forced_feature_variation(feature_flag.feature_key)
-      if forced_variation
-        variation = forced_variation.var_by_exp
-        rule = forced_variation.rule
-      else
-        variation, rule = _calculate_variation_key_for_feature(visitor_code, feature_flag)
-      end
-      save_variation(visitor_code, rule, variation) unless forced_variation&.simulated
-      variation_key = _get_variation_key(variation, rule, feature_flag)
+      eval_exp = evaluate(visitor, visitor_code, feature_flag, true, true)
+      variation_key = calculate_variation_key(eval_exp, feature_flag.default_variation_key)
       @tracking_manager.add_visitor_code(visitor_code)
       Logging::KameleoonLogger.debug(
         "RETURN: KameleoonClient._get_feature_variation_key(visitor_code: '%s', feature_key: '%s')" \
@@ -963,25 +983,30 @@ 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?
+    def save_variation(visitor_code, eval_exp, track: true)
+      return if eval_exp.nil? || eval_exp.experiment.id.zero? || eval_exp.var_by_exp.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
+        "CALL: KameleoonClient.save_variation(visitor_code: '%s', eval_exp: %s, track: %s)",
+        visitor_code, eval_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 = Kameleoon::DataManager::AssignedVariation.new(
+        eval_exp.experiment.id, eval_exp.var_by_exp.variation_id, eval_exp.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
+        "RETURN: KameleoonClient.save_variation(visitor_code: '%s', eval_exp: %s, track: %s)",
+        visitor_code, eval_exp, track
       )
     end
 
+    def get_code_for_hash(visitor, visitor_code)
+      # use mappingIdentifier instead of visitor_code if it was set up
+      visitor&.mapping_identifier || visitor_code
+    end
+
     ##
     # helper method for calculate variation key for feature flag
     def _calculate_variation_key_for_feature(visitor_code, feature_flag)
@@ -990,48 +1015,40 @@ module Kameleoon
         visitor_code, feature_flag
       )
       visitor = @visitor_manager.get_visitor(visitor_code)
+      code_for_hash = get_code_for_hash(visitor, visitor_code)
       # no rules -> return default_variation_key
-      selected_variation = nil
-      selected_rule = nil
+      selected = nil
       feature_flag.rules.each do |rule|
-        forced_variation = visitor&.get_forced_experiment_variation(rule.experiment_id || 0)
+        forced_variation = visitor&.get_forced_experiment_variation(rule.experiment.id)
         if forced_variation&.force_targeting
           # Forcing experiment variation in force-targeting mode
-          selected_variation = forced_variation.var_by_exp
-          selected_rule = rule
+          selected = EvaluatedExperiment.from_var_by_exp_rule(forced_variation.var_by_exp, rule)
           break
         end
         # check if visitor is targeted for rule, else next rule
-        next unless check_targeting(visitor_code, rule.experiment_id, rule)
+        next unless check_targeting(visitor_code, rule.experiment.id, rule)
 
         unless forced_variation.nil?
           # Forcing experiment variation in targeting-only mode
-          selected_variation = forced_variation.var_by_exp
-          selected_rule = rule
+          selected = EvaluatedExperiment.from_var_by_exp_rule(forced_variation.var_by_exp, rule)
           break
         end
-        # use mappingIdentifier instead of visitorCode if it was set up
-        code_for_hash = visitor&.mapping_identifier || visitor_code
         # uses for rule exposition
-        hash_rule = Utils::HashDouble.obtain_rule(code_for_hash, rule.id, rule.respool_time)
-        Logging::KameleoonLogger.debug("Calculated hash_rule: %s for visitor_code: '%s'", hash_rule, code_for_hash)
+        hash_rule = Utils::Hasher.obtain(code_for_hash, rule.id, rule.respool_time)
+        Logging::KameleoonLogger.debug("Calculated rule hash %s for code '%s'", hash_rule, code_for_hash)
         # check main expostion for rule with hashRule
         if hash_rule <= rule.exposition
           if rule.targeted_delivery_type?
-            selected_variation = rule.first_variation
-            selected_rule = rule
+            selected = EvaluatedExperiment.from_var_by_exp_rule(rule.experiment.variations_by_exposition.first, rule)
             break
           end
           # uses for variation's expositions
-          hash_variation = Utils::HashDouble.obtain_rule(code_for_hash, rule.experiment_id, rule.respool_time)
-          Logging::KameleoonLogger.debug(
-            "Calculated hash_variation: %s for visitor_code: '%s'", hash_variation, code_for_hash
-          )
+          hash_variation = Utils::Hasher.obtain(code_for_hash, rule.experiment.id, rule.respool_time)
+          Logging::KameleoonLogger.debug("Calculated variation hash %s for code '%s'", hash_variation, code_for_hash)
           # get variation key with new hashVariation
-          variation = rule.get_variation(hash_variation)
+          variation = rule.experiment.get_variation(hash_variation)
           unless variation.nil?
-            selected_variation = variation
-            selected_rule = rule
+            selected = EvaluatedExperiment.from_var_by_exp_rule(variation, rule)
             break
           end
         # if visitor is targeted for targeted rule then break cycle -> return default
@@ -1041,39 +1058,44 @@ module Kameleoon
       end
       Logging::KameleoonLogger.debug(
         "RETURN: KameleoonClient._calculate_variation_key_for_feature(visitor_code: '%s', feature_flag: %s) " \
-          '-> (variation: %s, rule: %s)', visitor_code, feature_flag, selected_variation, selected_rule
+          '-> (eval_exp: %s)', visitor_code, feature_flag, selected
       )
-      [selected_variation, selected_rule]
+      selected
     end
 
-    def _get_variation_key(var_by_exp, rule, feature_flag)
-      return var_by_exp.variation_key unless var_by_exp.nil?
-      return Kameleoon::Configuration::VariationType::VARIATION_OFF if !rule.nil? && rule.experimentation_type?
-
-      feature_flag.default_variation_key
+    def calculate_variation_key(eval_exp, default_value)
+      Logging::KameleoonLogger.debug(
+        "CALL: KameleoonClient.calculate_variation_key(eval_exp: %s, default_value: '%s') ", eval_exp, default_value
+      )
+      variation_key = eval_exp ? eval_exp.var_by_exp.variation_key : default_value
+      Logging::KameleoonLogger.debug(
+        "RETURN: KameleoonClient.calculate_variation_key(eval_exp: %s, default_value: '%s') -> (variation_key: '%s')",
+        eval_exp, default_value, variation_key
+      )
+      variation_key
     end
 
-    def make_external_variation(internal_variation, variation_id, experiment_id)
+    def create_external_variation(variation, eval_exp)
       Logging::KameleoonLogger.debug(
-        'CALL: KameleoonClient.make_external_variation(internal_variation: %s, variation_id: %s, experiment_id: %s)',
-        internal_variation, variation_id, experiment_id
+        'CALL: KameleoonClient.create_external_variation(variation: %s, eval_exp: %s)', variation, eval_exp
       )
-      variables = {}
-      internal_variation&.variables&.each do |variable|
-        variables[variable.key] = Types::Variable.new(
+      ext_variables = {}
+      variation&.variables&.each do |variable|
+        ext_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)
+      ext_variables.freeze
+      ext_variation = Types::Variation.new(
+        variation&.key, eval_exp&.var_by_exp&.variation_id, eval_exp&.experiment&.id, ext_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
+        'RETURN: KameleoonClient.create_external_variation(variation: %s, eval_exp: %s) -> (ext_variation: %s)',
+        variation, eval_exp, ext_variation
       )
-      variation
+      ext_variation
     end
 
     ##
@@ -1096,5 +1118,31 @@ module Kameleoon
       )
       @visitor_manager.add_data(visitor_code, UniqueIdentifier.new(is_unique_identifier))
     end
+
+    class EvaluatedExperiment
+      attr_reader :var_by_exp, :experiment, :rule_type
+
+      def initialize(var_by_exp, experiment, rule_type)
+        @var_by_exp = var_by_exp
+        @experiment = experiment
+        @rule_type = rule_type
+      end
+
+      def self.from_var_by_exp_rule(var_by_exp, rule)
+        EvaluatedExperiment.new(var_by_exp, rule.experiment, rule.type)
+      end
+
+      def self.from_forced_variation(forced_variation)
+        if forced_variation.var_by_exp.nil? || forced_variation.rule.nil?
+          nil
+        else
+          EvaluatedExperiment.from_var_by_exp_rule(forced_variation.var_by_exp, forced_variation.rule)
+        end
+      end
+
+      def self.from_forced_experiment_variation(forced_variation)
+        EvaluatedExperiment.from_var_by_exp_rule(forced_variation.var_by_exp, forced_variation.rule)
+      end
+    end
   end
 end

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

@@ -163,12 +163,12 @@ module Kameleoon
           end
           return DataManager::ForcedFeatureVariation.new(feature_key, nil, nil, true) if experiment_id.zero?
 
-          rule = feature_flag.rules.find { |r| r.experiment_id == experiment_id }
+          rule = feature_flag.rules.find { |r| r.experiment.id == experiment_id }
           unless rule
             Logging::KameleoonLogger.error('Simulated experiment %d is not found', experiment_id)
             return nil
           end
-          var_by_exp = rule.variation_by_exposition.find { |v| v.variation_id == variation_id }
+          var_by_exp = rule.experiment.variations_by_exposition.find { |v| v.variation_id == variation_id }
           unless var_by_exp
             Logging::KameleoonLogger.error('Simulated variation %d is not found', variation_id)
             return nil

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

@@ -25,11 +25,10 @@ module Kameleoon
       end
 
       private def check_rule(data, rule)
-        return false if !rule.is_a?(Kameleoon::Configuration::Rule) || rule.experiment_id.nil?
-
+        return false unless rule.is_a?(Kameleoon::Configuration::Rule)
         return false if !@condition_rule_id.nil? && (@condition_rule_id != rule.id)
 
-        variation = data.variations_storage.get(rule.experiment_id)
+        variation = data.variations_storage.get(rule.experiment.id)
         return false if variation.nil?
 
         return true if @condition_variation_key.nil?

data/lib/kameleoon/targeting/targeting_manager.rb

@@ -14,13 +14,13 @@ module Kameleoon
 
       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)",
+          "CALL: TargetingManager.check_targeting(visitor_code: '%s', campaign_id: %s, exp_ff_rule: %s)",
           visitor_code, campaign_id, exp_ff_rule
         )
         segment = exp_ff_rule.targeting_segment
         if segment.nil?
           Logging::KameleoonLogger.debug(
-            "RETURN: TargetingManager.check_targeting(visitorCode: '%s', campaignId: %s, exp_ff_rule: %s) -> " \
+            "RETURN: TargetingManager.check_targeting(visitor_code: '%s', campaign_id: %s, exp_ff_rule: %s) -> " \
               '(targeting: true)', visitor_code, campaign_id, exp_ff_rule
           )
           return true
@@ -29,7 +29,7 @@ module Kameleoon
         visitor = @visitor_manager.get_visitor(visitor_code)
         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) -> " \
+          "RETURN: TargetingManager.check_targeting(visitor_code: '%s', campaign_id: %s, exp_ff_rule: %s) -> " \
             '(targeting: %s)', visitor_code, campaign_id, exp_ff_rule, targeting
         )
         targeting

data/lib/kameleoon/utils.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-require 'fiber'
 require 'bigdecimal'
+require 'digest'
+require 'fiber'
 require 'kameleoon/utils'
 require 'kameleoon/exceptions'
 require 'kameleoon/logging/kameleoon_logger'
@@ -32,23 +33,15 @@ module Kameleoon
       end
     end
 
-    module HashDouble
-      def self.obtain(visitor_code, respool_times = {}, container_id = '')
-        obtain_helper(visitor_code, respool_times, container_id, '')
+    module Hasher
+      def self.obtain(visitor_code, container_id, suffix = nil)
+        calculate("#{visitor_code}#{container_id}#{suffix}")
       end
 
-      def self.obtain_rule(visitor_code, container_id = '', suffix = '')
-        obtain_helper(visitor_code, {}, container_id, suffix)
-      end
-
-      private
-
-      def self.obtain_helper(visitor_code, respool_times, container_id, suffix)
-        identifier = visitor_code.to_s
-        identifier += container_id.to_s
-        identifier += suffix.to_s
-        identifier += respool_times.sort.to_h.values.join.to_s if !respool_times.nil? && !respool_times.empty?
-        (Digest::SHA256.hexdigest(identifier.encode('UTF-8')).to_i(16) / (BigDecimal('2')**BigDecimal('256'))).round(16)
+      def self.calculate(string_to_hash)
+        parsed_value = Digest::SHA256.hexdigest(string_to_hash.encode('UTF-8')).to_i(16)
+        max_value = BigDecimal('2')**BigDecimal('256')
+        (parsed_value / max_value).round(16)
       end
     end
 

data/lib/kameleoon/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Kameleoon
-  SDK_VERSION = '3.7.0'
+  SDK_VERSION = '3.8.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.7.0
+  version: 3.8.0
 platform: ruby
 authors:
 - Kameleoon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-12-16 00:00:00.000000000 Z
+date: 2025-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: em-http-request
@@ -78,6 +78,7 @@ files:
 - lib/kameleoon/client_readiness.rb
 - lib/kameleoon/configuration/custom_data_info.rb
 - lib/kameleoon/configuration/data_file.rb
+- lib/kameleoon/configuration/experiment.rb
 - lib/kameleoon/configuration/feature_flag.rb
 - lib/kameleoon/configuration/rule.rb
 - lib/kameleoon/configuration/settings.rb