kameleoon-client-ruby 3.7.0 → 3.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e0001c490d29beefab2f33c416affe19f6ccbc05d83e0aaad70be85070986e3
-  data.tar.gz: 6959eb4d8f421b9e14e62f3c490d5e1c6f038a25d3e5cb785c1832d7908c291d
+  metadata.gz: 8d0ea98aa7ca7ea1585f83f6bd231aa577a774124b4332d18ca4e2c2649bfbc2
+  data.tar.gz: ec43717ed1dd3a61828a9c062f10040a7e214e070f30f6deb2a76bec9d60fb76
 SHA512:
-  metadata.gz: dfe9e75f3563287b6f187a38066a623145ba7ed916d12b9c7ec03dfe7173600ddd16d6a49ca304c4c46ec28794d5372bf29534f36ebaea18fa7eb8c2977dd981
-  data.tar.gz: faf2abe7ed35a211fc210a3e72f90a2bf79a8affde8a35c96af2363fabb50091b1069aaea0074458bff1d56156d80e81cd8cb427e3c772b99dc81d318093f7a9
+  metadata.gz: bec6bd1d823d247b5b1e561e621f454e4d451bec12fb1312dc2a9f348f1e2ccbcc884e6927bae254da107e6314e4d91acad9bb1ef67012d96b62a34253f2978f
+  data.tar.gz: d5f5c2c4d85b5d2f706d35fc77f3bc5ce8b6e24ce56413e5d9086fd95aae0d8adf1bbe37a6b5d041f389575db0c8c3815e005a78a7a9d45f255a9325b4f11c46

data/lib/kameleoon/configuration/data_file.rb

@@ -1,15 +1,18 @@
 # 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/me_group'
+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
+      attr_reader :settings, :feature_flags, :me_groups, :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, :holdout
 
       def to_s
         'DataFile{' \
@@ -49,6 +52,7 @@ module Kameleoon
         Logging::KameleoonLogger.debug('CALL: DataFile.init_default')
         @settings = Settings.new
         @feature_flags = {}
+        @me_groups = {}
         @has_any_targeted_delivery_rule = false
         @custom_data_info = Kameleoon::Configuration::CustomDataInfo.new(nil)
         Logging::KameleoonLogger.debug('RETURN: DataFile.init_default')
@@ -62,8 +66,10 @@ module Kameleoon
           ff = FeatureFlag.new(raw)
           @feature_flags[ff.feature_key] = ff
         end
+        @me_groups = make_me_groups(@feature_flags)
         @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 +91,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
@@ -98,6 +104,21 @@ module Kameleoon
         @experiment_ids_with_js_css_variable.freeze
       end
 
+      def make_me_groups(feature_flags)
+        me_group_lists = {}
+        feature_flags.each_value do |feature_flag|
+          next if feature_flag.me_group_name.nil?
+
+          me_group_list = me_group_lists[feature_flag.me_group_name]
+          if me_group_list
+            me_group_list.push(feature_flag)
+          else
+            me_group_lists[feature_flag.me_group_name] = [feature_flag]
+          end
+        end
+        me_group_lists.transform_values { |me_group_list| MEGroup.new(me_group_list) }
+      end
+
       def feature_flag_variable_js_css?(feature_flag)
         feature_flag.variations.first&.variables&.any? do |variable|
           %w[JS CSS].include?(variable.type)

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/feature_flag.rb

@@ -8,7 +8,7 @@ module Kameleoon
   module Configuration
     # Class for manage all feature flags with rules
     class FeatureFlag
-      attr_accessor :id, :feature_key, :variations, :default_variation_key, :environment_enabled, :rules
+      attr_accessor :id, :feature_key, :variations, :default_variation_key, :me_group_name, :environment_enabled, :rules
 
       def self.create_from_array(array)
         array&.map { |it| FeatureFlag.new(it) }
@@ -16,10 +16,11 @@ module Kameleoon
 
       def to_s
         'FeatureFlag{' \
-          "id:#{@id}, " \
-          "feature_key:#{@feature_key}, " \
-          "environment_enabled:#{@environment_enabled}, " \
-          "default_variation_key:#{@default_variation_key}, " \
+          "id:#{@id}," \
+          "feature_key:'#{@feature_key}'," \
+          "environment_enabled:#{@environment_enabled}," \
+          "default_variation_key:'#{@default_variation_key}'," \
+          "me_group_name:'#{@me_group_name}'," \
           "rules:#{@rules.size}" \
           '}'
       end
@@ -29,6 +30,7 @@ module Kameleoon
         @feature_key = hash['featureKey']
         @variations = Variation.create_from_array(hash['variations'])
         @default_variation_key = hash['defaultVariationKey']
+        @me_group_name = hash['mutuallyExclusiveGroup']
         @environment_enabled = hash['environmentEnabled']
         @rules = Rule.create_from_array(hash['rules'])
       end

data/lib/kameleoon/configuration/me_group.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Kameleoon
+  module Configuration
+    class MEGroup
+      attr_reader :feature_flags
+
+      def initialize(feature_flags)
+        @feature_flags = feature_flags.sort { |a, b| a.id <=> b.id }
+      end
+
+      def get_feature_flag_by_hash(hash)
+        idx = (hash * @feature_flags.size).to_i
+        idx = @feature_flags.size - 1 if idx >= @feature_flags.size
+        @feature_flags[idx]
+      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,89 @@ 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) && \
+            ff_unrestricted_by_me_group?(visitor, visitor_code, feature_flag)
+        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 ff_unrestricted_by_me_group?(visitor, visitor_code, feature_flag)
+      return true if feature_flag.me_group_name.nil?
+
+      Logging::KameleoonLogger.debug(
+        "CALL: KameleoonClient.ff_unrestricted_by_me_group?(visitor, visitor_code: '%s', feature_flag: %s)",
+        visitor_code, feature_flag
+      )
+      unrestricted = true
+      me_group = @data_manager.data_file.me_groups[feature_flag.me_group_name]
+      if me_group
+        code_for_hash = get_code_for_hash(visitor, visitor_code)
+        me_group_hash = Utils::Hasher.obtain_hash_for_me_group(code_for_hash, feature_flag.me_group_name)
+        Logging::KameleoonLogger.debug(
+          "Calculated ME group hash %s for code: '%s', meGroup: '%s'",
+          me_group_hash, code_for_hash, feature_flag.me_group_name
+        )
+        unrestricted = me_group.get_feature_flag_by_hash(me_group_hash) == feature_flag
       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.ff_unrestricted_by_me_group?(visitor, visitor_code: '%s', feature_flag: %s)" \
+        ' -> (unrestricted: %s)', visitor_code, feature_flag, unrestricted
       )
-      [variation_key, var_by_exp, rule]
+      unrestricted
+    end
+
+    def visitor_not_in_holdout?(visitor, visitor_code, track, save)
+      holdout = @data_manager.data_file.holdout
+      return true if holdout.nil?
+
+      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
+      )
+      is_not_in_holdout = true
+      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
+      Logging::KameleoonLogger.debug(
+        "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
+      )
+      is_not_in_holdout
     end
 
     ##
@@ -945,15 +997,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 +1008,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 +1040,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 +1083,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 +1143,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,19 @@ 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)
+      def self.obtain_hash_for_me_group(visitor_code, me_group_name)
+        calculate("#{visitor_code}#{me_group_name}")
       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.9.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.9.0
 platform: ruby
 authors:
 - Kameleoon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-12-16 00:00:00.000000000 Z
+date: 2025-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: em-http-request
@@ -78,7 +78,9 @@ 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/me_group.rb
 - lib/kameleoon/configuration/rule.rb
 - lib/kameleoon/configuration/settings.rb
 - lib/kameleoon/configuration/variable.rb