kameleoon-client-ruby 3.9.0 → 3.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8d0ea98aa7ca7ea1585f83f6bd231aa577a774124b4332d18ca4e2c2649bfbc2
-  data.tar.gz: ec43717ed1dd3a61828a9c062f10040a7e214e070f30f6deb2a76bec9d60fb76
+  metadata.gz: 1831531ee6a40f0fbd32f110f9a9c9c1a33f71569c8b8de842bc01c06250d6d5
+  data.tar.gz: 6e6f8f9d0ee511c2a27fc63ff040e6155b90df66925989d1d08bd473f86c071b
 SHA512:
-  metadata.gz: bec6bd1d823d247b5b1e561e621f454e4d451bec12fb1312dc2a9f348f1e2ccbcc884e6927bae254da107e6314e4d91acad9bb1ef67012d96b62a34253f2978f
-  data.tar.gz: d5f5c2c4d85b5d2f706d35fc77f3bc5ce8b6e24ce56413e5d9086fd95aae0d8adf1bbe37a6b5d041f389575db0c8c3815e005a78a7a9d45f255a9325b4f11c46
+  metadata.gz: 6f575eb2b6e12302ffa5cdb067582d994ab890edcab12f174732d396adc4248fc96a9e27935c008db52f59a93b5e0c713530356acab47711727651d2a4d48e3a
+  data.tar.gz: '058e6a5284550663cf20223eca099728a9ca0985aacfcfa829e585070228a83b38b4facda77d38a7f3ae17ae8fad37cc7898e47e2519826364a46b3205b33452'

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
@@ -1032,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)
@@ -1042,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
@@ -1055,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
@@ -1063,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
@@ -1073,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
@@ -1083,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

@@ -77,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(
@@ -100,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.9.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.9.0
+  version: 3.10.0
 platform: ruby
 authors:
 - Kameleoon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-02-26 00:00:00.000000000 Z
+date: 2025-03-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: em-http-request
@@ -87,6 +87,7 @@ files:
 - 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