kameleoon-client-ruby 3.8.0 → 3.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a64d8edfee07c22561b166de49f9185d89a6fbdec9b49f6fd65860125bd54eab
-  data.tar.gz: ee7ccf78d0d11dec198b930e77e496c39a220b87471d724015c78114b85368f8
+  metadata.gz: 1831531ee6a40f0fbd32f110f9a9c9c1a33f71569c8b8de842bc01c06250d6d5
+  data.tar.gz: 6e6f8f9d0ee511c2a27fc63ff040e6155b90df66925989d1d08bd473f86c071b
 SHA512:
-  metadata.gz: ccfba38b35f50d2b1dda0ef2bf31406f74fd92663276f4297ae867bc7b88b8606b345a8a4234f24ef71c71fdc3555cc9852d7324c1a6a668ed8b6cbc98cfeedb
-  data.tar.gz: 38543c67b7c8949ccba5c8e0f08eae86d2755a737bc25a5dc82e94dd92011c7678cb4b32647ffae0edb606913bff537455f2f42295fe9f421554726a57675808
+  metadata.gz: 6f575eb2b6e12302ffa5cdb067582d994ab890edcab12f174732d396adc4248fc96a9e27935c008db52f59a93b5e0c713530356acab47711727651d2a4d48e3a
+  data.tar.gz: '058e6a5284550663cf20223eca099728a9ca0985aacfcfa829e585070228a83b38b4facda77d38a7f3ae17ae8fad37cc7898e47e2519826364a46b3205b33452'

data/lib/kameleoon/configuration/data_file.rb

@@ -3,15 +3,16 @@
 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,
-                  :holdout
+      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{' \
@@ -51,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')
@@ -64,6 +66,7 @@ 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')
@@ -101,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/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/data/cbscores.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Kameleoon
+  class CBScores
+    # keys = experiment IDs / values = list of variation IDs ordered descending
+    # by score (there may be several variation ids with same score)
+    attr_reader :values
+
+    def initialize(cbs_map)
+      values = cbs_map.transform_values { |cbs_value| extract_var_ids(cbs_value) }
+      values.freeze
+      @values = values
+    end
+
+    def to_s
+      str_values = @values.transform_values { |vgs| vgs.map(&:to_s) }
+      "CBScores{values:#{str_values}}"
+    end
+
+    class ScoredVarId
+      attr_reader :variation_id, :score
+
+      def initialize(variation_id, score)
+        @variation_id = variation_id
+        @score = score
+      end
+    end
+
+    class VarGroup
+      attr_reader :ids
+
+      def initialize(ids)
+        ids.sort!
+        ids.freeze
+        @ids = ids
+      end
+
+      def to_s
+        "VarGroup{ids:#{@ids}}"
+      end
+    end
+
+    private
+
+    def extract_var_ids(scores)
+      grouped = {}
+      scores.each do |score|
+        glist = grouped[score.score]
+        if glist
+          glist.push(score.variation_id)
+        else
+          grouped[score.score] = [score.variation_id]
+        end
+      end
+      grouped.sort_by { |score, _| -score }.collect { |_, glist| VarGroup.new(glist) }
+    end
+  end
+end

data/lib/kameleoon/data/geolocation.rb

@@ -47,4 +47,3 @@ module Kameleoon
     end
   end
 end
-

data/lib/kameleoon/data/kcs_heat.rb

@@ -8,9 +8,9 @@ module Kameleoon
       @values = values
       @values.freeze
     end
-  end
 
-  def to_s
-    "KcsHeat{values:#{@values}}"
+    def to_s
+      "KcsHeat{values:#{@values}}"
+    end
   end
 end

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

@@ -2,6 +2,7 @@
 
 require 'concurrent'
 require 'kameleoon/data/browser'
+require 'kameleoon/data/cbscores'
 require 'kameleoon/data/conversion'
 require 'kameleoon/data/custom_data'
 require 'kameleoon/data/device'
@@ -106,6 +107,12 @@ module Kameleoon
         kcs_heat
       end
 
+      def cbscores
+        cbs = @data.cbscores
+        Logging::KameleoonLogger.debug('CALL/RETURN: Visitor.cbscores -> (cbs: %s)', cbs)
+        cbs
+      end
+
       def visitor_visits
         visitor_visits = @data.visitor_visits
         Logging::KameleoonLogger.debug('CALL/RETURN: Visitor.visitor_visits -> (visitor_visits: %s)', visitor_visits)
@@ -242,6 +249,8 @@ module Kameleoon
               @data.set_geolocation(data, overwrite)
             when KcsHeat
               @data.kcs_heat = data
+            when CBScores
+              @data.set_cbscores(data, overwrite)
             when VisitorVisits
               @data.visitor_visits = data
             when UniqueIdentifier
@@ -267,7 +276,7 @@ module Kameleoon
 
     class VisitorData
       attr_reader :mutex, :device, :browser, :geolocation, :operating_system
-      attr_accessor :last_activity_time, :legal_consent, :user_agent, :cookie, :kcs_heat, :visitor_visits,
+      attr_accessor :last_activity_time, :legal_consent, :user_agent, :cookie, :kcs_heat, :cbscores, :visitor_visits,
                     :mapping_identifier, :forced_variations, :simulated_variations
 
       def initialize
@@ -398,6 +407,10 @@ module Kameleoon
         @operating_system = operating_system if overwrite || @operating_system.nil?
       end
 
+      def set_cbscores(cbs, overwrite)
+        @cbscores = cbs if overwrite || @cbscores.nil?
+      end
+
       def add_forced_feature_variation(forced_variation)
         @simulated_variations ||= {}
         @simulated_variations[forced_variation.feature_key] = forced_variation

data/lib/kameleoon/kameleoon_client.rb

@@ -67,7 +67,7 @@ module Kameleoon
         config.environment,
         config.default_timeout_millisecond,
         Network::AccessTokenSourceFactory.new(config.client_id, config.client_secret),
-        Network::UrlProvider.new(site_code)
+        Network::UrlProvider.new(site_code, config.network_domain)
       )
       @tracking_manager = Managers::Tracking::TrackingManager.new(
         @data_manager, @network_manager, @visitor_manager, config.tracking_interval_second, @scheduler
@@ -922,37 +922,62 @@ module Kameleoon
       forced_variation = visitor&.get_forced_feature_variation(feature_flag.feature_key)
       if forced_variation
         eval_exp = EvaluatedExperiment.from_forced_variation(forced_variation)
-      elsif visitor_not_in_holdout?(visitor, visitor_code, track, save)
+      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
       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: %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
+      Logging::KameleoonLogger.debug(
+        "RETURN: KameleoonClient.ff_unrestricted_by_me_group?(visitor, visitor_code: '%s', feature_flag: %s)" \
+        ' -> (unrestricted: %s)', visitor_code, feature_flag, unrestricted
+      )
+      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
       )
-      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
+      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(
@@ -1007,6 +1032,42 @@ module Kameleoon
       visitor&.mapping_identifier || visitor_code
     end
 
+    def evaluate_cbscores(visitor, visitor_code, rule)
+      return nil if visitor&.cbscores.nil?
+
+      Logging::KameleoonLogger.debug(
+        "CALL: KameleoonClient.evaluate_cbscores(visitor, visitor_code: '%s', rule: %s)", visitor_code, rule
+      )
+      eval_exp = nil
+      var_id_group_by_scores = visitor.cbscores.values[rule.experiment.id]
+      if var_id_group_by_scores
+        var_by_exp_in_cbs = nil
+        var_id_group_by_scores.each do |var_group|
+          var_by_exp_in_cbs = rule.experiment.variations_by_exposition.filter do |var_by_exp|
+            var_group.ids.include?(var_by_exp.variation_id)
+          end
+          break unless var_by_exp_in_cbs.empty?
+        end
+        if (var_by_exp_in_cbs&.size || 0).positive?
+          size = var_by_exp_in_cbs.size
+          if size > 1
+            code_for_hash = get_code_for_hash(visitor, visitor_code)
+            variation_hash = Utils::Hasher.obtain(code_for_hash, rule.experiment.id, rule.respool_time)
+            Logging::KameleoonLogger.debug("Calculated CBS hash %s for code '%s'", variation_hash, code_for_hash)
+            idx = [(variation_hash * size).to_i, size - 1].min
+          else
+            idx = 0
+          end
+          eval_exp = EvaluatedExperiment.from_var_by_exp_rule(var_by_exp_in_cbs[idx], rule)
+        end
+      end
+      Logging::KameleoonLogger.debug(
+        "RETURN: KameleoonClient.evaluate_cbscores(visitor, visitor_code: '%s', rule: %s) -> (eval_exp: %s)",
+        visitor_code, rule, eval_exp
+      )
+      eval_exp
+    end
+
     ##
     # helper method for calculate variation key for feature flag
     def _calculate_variation_key_for_feature(visitor_code, feature_flag)
@@ -1017,12 +1078,12 @@ module Kameleoon
       visitor = @visitor_manager.get_visitor(visitor_code)
       code_for_hash = get_code_for_hash(visitor, visitor_code)
       # no rules -> return default_variation_key
-      selected = nil
+      eval_exp = nil
       feature_flag.rules.each do |rule|
         forced_variation = visitor&.get_forced_experiment_variation(rule.experiment.id)
         if forced_variation&.force_targeting
           # Forcing experiment variation in force-targeting mode
-          selected = EvaluatedExperiment.from_var_by_exp_rule(forced_variation.var_by_exp, rule)
+          eval_exp = EvaluatedExperiment.from_var_by_exp_rule(forced_variation.var_by_exp, rule)
           break
         end
         # check if visitor is targeted for rule, else next rule
@@ -1030,7 +1091,7 @@ module Kameleoon
 
         unless forced_variation.nil?
           # Forcing experiment variation in targeting-only mode
-          selected = EvaluatedExperiment.from_var_by_exp_rule(forced_variation.var_by_exp, rule)
+          eval_exp = EvaluatedExperiment.from_var_by_exp_rule(forced_variation.var_by_exp, rule)
           break
         end
         # uses for rule exposition
@@ -1038,8 +1099,11 @@ module Kameleoon
         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
+          eval_exp = evaluate_cbscores(visitor, visitor_code, rule)
+          break unless eval_exp.nil?
+
           if rule.targeted_delivery_type?
-            selected = EvaluatedExperiment.from_var_by_exp_rule(rule.experiment.variations_by_exposition.first, rule)
+            eval_exp = EvaluatedExperiment.from_var_by_exp_rule(rule.experiment.variations_by_exposition.first, rule)
             break
           end
           # uses for variation's expositions
@@ -1048,7 +1112,7 @@ module Kameleoon
           # get variation key with new hashVariation
           variation = rule.experiment.get_variation(hash_variation)
           unless variation.nil?
-            selected = EvaluatedExperiment.from_var_by_exp_rule(variation, rule)
+            eval_exp = EvaluatedExperiment.from_var_by_exp_rule(variation, rule)
             break
           end
         # if visitor is targeted for targeted rule then break cycle -> return default
@@ -1058,9 +1122,9 @@ module Kameleoon
       end
       Logging::KameleoonLogger.debug(
         "RETURN: KameleoonClient._calculate_variation_key_for_feature(visitor_code: '%s', feature_flag: %s) " \
-          '-> (eval_exp: %s)', visitor_code, feature_flag, selected
+          '-> (eval_exp: %s)', visitor_code, feature_flag, eval_exp
       )
-      selected
+      eval_exp
     end
 
     def calculate_variation_key(eval_exp, default_value)

data/lib/kameleoon/kameleoon_client_config.rb

@@ -14,7 +14,7 @@ module Kameleoon
 
     attr_reader :client_id, :client_secret, :refresh_interval_second, :session_duration_second,
                 :default_timeout_millisecond, :tracking_interval_second, :environment, :top_level_domain,
-                :verbose_mode
+                :verbose_mode, :network_domain
 
     def to_s
       'KameleoonClientConfig{' \
@@ -25,7 +25,8 @@ module Kameleoon
         "environment:'#{@environment}'," \
         "default_timeout_millisecond:#{@default_timeout_millisecond}," \
         "top_level_domain:'#{@top_level_domain}'," \
-        "verbose_mode:#{verbose_mode}" \
+        "verbose_mode:#{verbose_mode}," \
+        "network_domain:'#{@network_domain}'" \
         '}'
     end
 
@@ -39,7 +40,8 @@ module Kameleoon
       tracking_interval_millisecond: DEFAULT_TRACKING_INTERVAL_MILLISECONDS,
       environment: nil,
       top_level_domain: nil,
-      verbose_mode: nil
+      verbose_mode: nil,
+      network_domain: nil
     )
       raise Exception::ConfigCredentialsInvalid, 'Client ID is not specified' if client_id&.empty? != false
       raise Exception::ConfigCredentialsInvalid, 'Client secret is not specified' if client_secret&.empty? != false
@@ -114,6 +116,7 @@ module Kameleoon
         )
       end
       @top_level_domain = Utils::Domain.validate_top_level_domain(top_level_domain)
+      @network_domain = Utils::Domain.validate_network_domain(network_domain)
     end
 
     def self.read_from_yaml(path)
@@ -131,7 +134,8 @@ module Kameleoon
         tracking_interval_millisecond: yaml['tracking_interval_millisecond'],
         environment: yaml['environment'],
         top_level_domain: yaml['top_level_domain'],
-        verbose_mode: yaml['verbose_mode']
+        verbose_mode: yaml['verbose_mode'],
+        network_domain: yaml['network_domain']
       )
     end
   end

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

@@ -1,22 +1,23 @@
 # frozen_string_literal: true
 
-require 'kameleoon/data/manager/page_view_visit'
-require 'kameleoon/data/manager/assigned_variation'
-require 'kameleoon/data/visitor_visits'
 require 'kameleoon/data/browser'
-require 'kameleoon/data/device'
+require 'kameleoon/data/cbscores'
 require 'kameleoon/data/conversion'
 require 'kameleoon/data/custom_data'
+require 'kameleoon/data/device'
 require 'kameleoon/data/geolocation'
 require 'kameleoon/data/kcs_heat'
 require 'kameleoon/data/page_view'
+require 'kameleoon/data/visitor_visits'
+require 'kameleoon/data/manager/page_view_visit'
+require 'kameleoon/data/manager/assigned_variation'
 
 module Kameleoon
   module Managers
     module RemoteData
       class RemoteVisitorData
         attr_reader :custom_data_dict, :page_view_visits, :conversions, :experiments, :device, :browser,
-                    :operating_system, :geolocation, :previous_visitor_visits, :kcs_heat, :visitor_code
+                    :operating_system, :geolocation, :previous_visitor_visits, :kcs_heat, :cbs, :visitor_code
 
         def initialize(hash)
           current_visit = hash['currentVisit']
@@ -33,6 +34,7 @@ module Kameleoon
             @previous_visitor_visits = VisitorVisits.new(times_started)
           end
           @kcs_heat = parse_kcs_heat(hash['kcs'])
+          @cbs = parse_cbscores(hash['cbs'])
         end
 
         def collect_data_to_add
@@ -40,6 +42,7 @@ module Kameleoon
           data_to_add.concat(@custom_data_dict.values) unless @custom_data_dict.nil?
           data_to_add.push(@previous_visitor_visits) unless @previous_visitor_visits.nil?
           data_to_add.push(@kcs_heat) unless @kcs_heat.nil?
+          data_to_add.push(@cbs) unless @cbs.nil?
           data_to_add.concat(@page_view_visits.values) unless @page_view_visits.nil?
           data_to_add.concat(@experiments.values) unless @experiments.nil?
           data_to_add.concat(conversions_single_objects)
@@ -184,6 +187,26 @@ module Kameleoon
           end
           KcsHeat.new(value_map)
         end
+
+        def parse_cbscores(cbs)
+          return nil if cbs.nil?
+
+          cbs_map = {}
+          cbs.each do |str_exp_id, scored_var_entries|
+            next unless str_exp_id.is_a?(String) && scored_var_entries.is_a?(Hash)
+
+            entries = []
+            scored_var_entries.each do |str_var_id, score|
+              next unless str_var_id.is_a?(String) && (score.is_a?(Float) || score.is_a?(Integer))
+
+              var_id = str_var_id.to_i
+              entries.push(CBScores::ScoredVarId.new(var_id, score))
+            end
+            exp_id = str_exp_id.to_i
+            cbs_map[exp_id] = entries
+          end
+          CBScores.new(cbs_map)
+        end
       end
     end
   end

data/lib/kameleoon/network/network_manager.rb

@@ -88,13 +88,13 @@ module Kameleoon
           if response.success?
             success = true
           elsif !response.error.nil?
-            log_level = attempt < retry_limit ? Logging::LogLevel::WARNING : Logging::LogLevel::ERROR
+            log_level = get_log_level(attempt, retry_limit)
             Logging::KameleoonLogger.log(log_level, "%s call '%s' failed: Error occurred during request: %s",
                                          request.method, request.url, response.error)
           else
-            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)
+            log_level = get_log_level(attempt, retry_limit)
+            Logging::KameleoonLogger.log(log_level, "%s call '%s' failed: Received unexpected status code: %s, body: %s",
+                                         request.method, request.url, response.code, response.body)
             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)
@@ -113,6 +113,10 @@ module Kameleoon
         success ? response.body : false
       end
 
+      def get_log_level(attempt, attempt_count)
+        return log_level = attempt < attempt_count ? Logging::LogLevel::WARNING : Logging::LogLevel::ERROR
+      end
+
       def delay(period)
         sleep(period)
       end

data/lib/kameleoon/network/url_provider.rb

@@ -14,27 +14,43 @@ module Kameleoon
       POST_DATA_PATH = '/map/maps'
       ACCESS_TOKEN_PATH = '/oauth/token'
 
-      CONFIGURATION_API_URL_FORMAT = 'https://sdk-config.kameleoon.eu/%s'
-      RT_CONFIGURATION_URL = 'https://events.kameleoon.com:8110/sse'
+      DEFAULT_EVENTS_DOMAIN = 'events.kameleoon.eu'
+      DEFAULT_CONFIGURATION_DOMAIN = 'sdk-config.kameleoon.eu'
+      DEFAULT_ACCESS_TOKEN_DOMAIN = 'api.kameleoon.com'
       DEFAULT_DATA_API_DOMAIN = 'data.kameleoon.io'
+
+      CONFIGURATION_API_URL_FORMAT = 'https://%s/%s'
+      DATA_API_URL_FORMAT = 'https://%s%s?%s'
+      RT_CONFIGURATION_URL_FORMAT = 'https://%s:8110/sse?%s'
+      ACCESS_TOKEN_URL_FORMAT = 'https://%s/oauth/token'
+
       TEST_DATA_API_DOMAIN = 'data.kameleoon.net'
-      DEFAULT_AUTOMATION_API_DOMAIN = 'api.kameleoon.com'
       TEST_AUTOMATION_API_DOMAIN = 'api.kameleoon.net'
 
-      attr_reader :site_code, :data_api_domain, :automation_api_domain
+      attr_reader :site_code, :data_api_domain, :events_domain, :configuration_domain, :access_token_domain
 
       def initialize(
         site_code,
-        data_api_domain = DEFAULT_DATA_API_DOMAIN,
-        automation_api_domain = DEFAULT_AUTOMATION_API_DOMAIN
+        network_domain = nil
       )
         @site_code = site_code
-        @data_api_domain = data_api_domain
-        @automation_api_domain = automation_api_domain
+        @data_api_domain = DEFAULT_DATA_API_DOMAIN
+        @events_domain = DEFAULT_EVENTS_DOMAIN
+        @configuration_domain = DEFAULT_CONFIGURATION_DOMAIN
+        @access_token_domain = DEFAULT_ACCESS_TOKEN_DOMAIN
+        @is_custom_domain = false
+        update_domains(network_domain)
       end
 
       def apply_data_api_domain(domain)
-        @data_api_domain = domain if domain.is_a?(String)
+        return if domain.nil? || domain.empty?
+
+        if @is_custom_domain
+          sub_domain = domain.split('.').first
+          @data_api_domain = @data_api_domain.sub(/^[^.]+/, sub_domain)
+        else
+          @data_api_domain = domain
+        end
       end
 
       def make_tracking_url
@@ -44,7 +60,7 @@ module Kameleoon
           siteCode: @site_code,
           bodyUa: true
         }
-        "https://#{@data_api_domain}#{TRACKING_PATH}?#{UriHelper.encode_query(params)}"
+        format(DATA_API_URL_FORMAT, @data_api_domain, TRACKING_PATH, UriHelper.encode_query(params))
       end
 
       def make_visitor_data_get_url(visitor_code, filter, is_unique_identifier = false)
@@ -60,7 +76,8 @@ module Kameleoon
         params[:experiment] = true if filter.experiments
         params[:page] = true if filter.page_views
         params[:staticData] = true if filter.device || filter.browser || filter.operating_system
-        "https://#{@data_api_domain}#{VISITOR_DATA_PATH}?#{UriHelper.encode_query(params)}"
+        params[:cbs] = true if filter.cbs
+        format(DATA_API_URL_FORMAT, @data_api_domain, VISITOR_DATA_PATH, UriHelper.encode_query(params))
       end
 
       def make_api_data_get_request_url(key)
@@ -68,11 +85,11 @@ module Kameleoon
           siteCode: @site_code,
           key: key
         }
-        "https://#{@data_api_domain}#{GET_DATA_PATH}?#{UriHelper.encode_query(params)}"
+        format(DATA_API_URL_FORMAT, @data_api_domain, GET_DATA_PATH, UriHelper.encode_query(params))
       end
 
       def make_configuration_url(environment = nil, timestamp = nil)
-        url = format(CONFIGURATION_API_URL_FORMAT, @site_code)
+        url = format(CONFIGURATION_API_URL_FORMAT, @configuration_domain, @site_code)
         params = {}
         params[:environment] = environment unless environment.nil?
         params[:ts] = timestamp unless timestamp.nil?
@@ -82,11 +99,24 @@ module Kameleoon
 
       def make_real_time_url
         params = { siteCode: @site_code }
-        "#{RT_CONFIGURATION_URL}?#{UriHelper.encode_query(params)}"
+        format(RT_CONFIGURATION_URL_FORMAT, @events_domain, UriHelper.encode_query(params))
       end
 
       def make_access_token_url
-        "https://#{@automation_api_domain}#{ACCESS_TOKEN_PATH}"
+        format(ACCESS_TOKEN_URL_FORMAT, @access_token_domain)
+      end
+
+      private
+
+      def update_domains(network_domain)
+        return if network_domain.nil? || network_domain.empty?
+
+        @is_custom_domain = true
+
+        @data_api_domain = "data.#{network_domain}"
+        @events_domain = "events.#{network_domain}"
+        @configuration_domain = "sdk-config.#{network_domain}"
+        @access_token_domain = "api.#{network_domain}"
       end
     end
   end

data/lib/kameleoon/types/remote_visitor_data_filter.rb

@@ -5,7 +5,7 @@ module Kameleoon
   module Types
     class RemoteVisitorDataFilter
       attr_reader :previous_visit_amount, :current_visit, :custom_data, :page_views, :geolocation, :device, :browser,
-                  :operating_system, :conversions, :experiments, :kcs, :visitor_code
+                  :operating_system, :conversions, :experiments, :kcs, :visitor_code, :cbs
 
       def to_s
         "RemoteVisitorDataFilter{previous_visit_amount:#{@previous_visit_amount}," \
@@ -19,13 +19,14 @@ module Kameleoon
           "conversions:#{@conversions}," \
           "experiments:#{@experiments}," \
           "kcs:#{@kcs}," \
-          "visitor_code:#{@visitor_code}}"
+          "visitor_code:#{@visitor_code}}" \
+          "cbs:#{@cbs}}"
       end
 
       def initialize(
         previous_visit_amount: 1, current_visit: true, custom_data: true, page_views: false,
         geolocation: false, device: false, browser: false, operating_system: false, conversions: false,
-        experiments: false, kcs: false, visitor_code: true
+        experiments: false, kcs: false, visitor_code: true, cbs: false
       )
         @previous_visit_amount = previous_visit_amount
         @current_visit = current_visit
@@ -39,6 +40,7 @@ module Kameleoon
         @experiments = experiments
         @kcs = kcs
         @visitor_code = visitor_code
+        @cbs = cbs
       end
     end
   end

data/lib/kameleoon/utils.rb

@@ -38,6 +38,10 @@ module Kameleoon
         calculate("#{visitor_code}#{container_id}#{suffix}")
       end
 
+      def self.obtain_hash_for_me_group(visitor_code, me_group_name)
+        calculate("#{visitor_code}#{me_group_name}")
+      end
+
       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')
@@ -73,17 +77,7 @@ module Kameleoon
       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
+        top_level_domain = check_and_trim_protocol(top_level_domain.downcase)
 
         if !REGEX_DOMAIN.match?(top_level_domain) && top_level_domain != LOCALHOST
           Logging::KameleoonLogger.error(
@@ -96,6 +90,41 @@ module Kameleoon
 
         top_level_domain
       end
+
+      def self.validate_network_domain(network_domain)
+        return nil if network_domain.nil? || network_domain.empty?
+
+        network_domain = check_and_trim_protocol(network_domain.downcase)
+
+        # remove first and last dot
+        network_domain = network_domain.gsub(/^\.+|\.+$/, '')
+
+        if !REGEX_DOMAIN.match?(network_domain) && network_domain != LOCALHOST
+          Logging::KameleoonLogger.error(
+            "The network domain '%s' is invalid.",
+            network_domain
+          )
+          return nil
+        end
+
+        network_domain
+      end
+
+      private
+
+      def self.check_and_trim_protocol(domain)
+        [HTTP, HTTPS].each do |protocol|
+          next unless domain.start_with?(protocol)
+
+          domain = domain[protocol.length..]
+          Logging::KameleoonLogger.warning(
+            "The domain contains '%s'. Domain after protocol trimming: '%s'", protocol, domain
+          )
+          break
+        end
+
+        domain
+      end
     end
   end
 end

data/lib/kameleoon/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Kameleoon
-  SDK_VERSION = '3.8.0'
+  SDK_VERSION = '3.10.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.8.0
+  version: 3.10.0
 platform: ruby
 authors:
 - Kameleoon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-02-10 00:00:00.000000000 Z
+date: 2025-03-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: em-http-request
@@ -80,12 +80,14 @@ files:
 - 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
 - lib/kameleoon/configuration/variation.rb
 - lib/kameleoon/configuration/variation_exposition.rb
 - lib/kameleoon/data/browser.rb
+- lib/kameleoon/data/cbscores.rb
 - lib/kameleoon/data/conversion.rb
 - lib/kameleoon/data/cookie.rb
 - lib/kameleoon/data/custom_data.rb