kameleoon-client-ruby 3.12.1 → 3.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 02e0aa66de89608c98d6dd7aee47b01532554c8b1e721061d6fd9cf30c486702
-  data.tar.gz: 637b3bbee24635ca8e021d86fa9ea94030f58da8d3afe181f67133b227676839
+  metadata.gz: b5566ec9ff02ebb63ff3ee337f4c26fc0c229f2de8df0893fe85dc3f83fbc0ce
+  data.tar.gz: fcd11bacbaead7a0c357a0fd4828fb6c4b7347ebf1fab728f4e00882b0224dc7
 SHA512:
-  metadata.gz: b3e214eba6a1481863758cb794ce08523e759c25fe1200c535ea82e4173c2a51a31e42f7d3ee10cd09adcb4c19cc88f968c337646c11875ecf30f7fb542e5fc7
-  data.tar.gz: 74d531f7d1d3ea7db51a0e336eef0e7f639dd95e50e3a769f8e5a226c0266cd5e1fdf631c5a4c9fe464131ef45d6c42238b430b4d4d872331cd6940321950778
+  metadata.gz: 78418ebd561b9d1fe2639751d0dae68a875a4a76f4782ac079fe2f3f3c6e2b7466c41cb762e978b4895973a97ddf4940b10171d36c2695a565ed2e1b66445f53
+  data.tar.gz: b91b577c23c13547d78c09c98a2c39bb788a314b280b50c57bf1cc25891dd74747127aec2bc14b0a5a4908a2cde2d0e2089ec13c6f5200087b7c52bd80b7a68f

data/lib/kameleoon/configuration/custom_data_info.rb

@@ -13,16 +13,18 @@ module Kameleoon
       def initialize(hashes)
         @local_only = Set[]
         @visitor_scope = Set[]
+        @custom_data_index_by_id = {}
         unless hashes.nil?
           for hash in hashes
             index = hash['index']
             @local_only.add(index) if hash['localOnly']
             @visitor_scope.add(index) if hash['scope'] == SCOPE_VISITOR
+            id = hash['id']
+            @custom_data_index_by_id[id] = index if id && index
             if hash['isMappingIdentifier']
               unless @mapping_identifier_index.nil?
                 Logging::KameleoonLogger.warning('More than one mapping identifier is set. Undefined behavior ' \
                                           'may occur on cross-device reconciliation.')
-
               end
               @mapping_identifier_index = index
             end
@@ -42,6 +44,10 @@ module Kameleoon
         @visitor_scope.include?(index)
       end
 
+      def get_custom_data_index_by_id(custom_data_id)
+        @custom_data_index_by_id[custom_data_id]
+      end
+
       def self.mapping_identifier?(custom_data_info, custom_data)
         !custom_data_info.nil? && (custom_data.id == custom_data_info.mapping_identifier_index) && \
           !(custom_data.values.empty? || custom_data.values[0].empty?)

data/lib/kameleoon/configuration/data_file.rb

@@ -6,32 +6,41 @@ require 'kameleoon/configuration/feature_flag'
 require 'kameleoon/configuration/me_group'
 require 'kameleoon/configuration/settings'
 require 'kameleoon/logging/kameleoon_logger'
+require 'kameleoon/targeting/models'
 
 module Kameleoon
   module Configuration
     class DataFile
-      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,
+      attr_reader :last_modified, :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{' \
           "environment:#{@environment}," \
+          "last_modified:#{@last_modified}," \
           "feature_flags:#{@feature_flags.size}," \
           "settings:#{@settings}" \
           '}'
       end
 
-      def initialize(environment, configuration = nil)
-        Logging::KameleoonLogger.debug('CALL: DataFile.new(environment: %s)', environment)
+      def initialize(environment, configuration = nil, last_modified = nil)
+        Logging::KameleoonLogger.debug(
+          "CALL: DataFile.new(environment: '%s', configuration, last_modified: '%s')",
+          environment, last_modified
+        )
         @environment = environment
+        @last_modified = last_modified
         if configuration.nil?
           init_default
         else
           init(configuration)
         end
         collect_indices
-        Logging::KameleoonLogger.debug('RETURN: DataFile.new(environment: %s)', environment)
+        Logging::KameleoonLogger.debug(
+          "RETURN: DataFile.new(environment: '%s', configuration, last_modified: '%s')",
+          environment, last_modified
+        )
       end
 
       def get_feature_flag(feature_key)
@@ -61,18 +70,29 @@ module Kameleoon
       def init(configuration)
         Logging::KameleoonLogger.debug('CALL: DataFile.init(configuration: %s)', configuration)
         @settings = Settings.new(configuration['configuration'])
-        @feature_flags = {}
-        configuration['featureFlags'].each do |raw|
-          ff = FeatureFlag.new(raw)
-          @feature_flags[ff.feature_key] = ff
-        end
+        segments = parse_segments(configuration)
+        @custom_data_info = CustomDataInfo.new(configuration['customData'])
+        @feature_flags = parse_feature_flags(configuration, segments, @custom_data_info)
         @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
 
+      def parse_segments(configuration)
+        configuration['segments'].to_h do |raw_seg|
+          seg = Targeting::Segment.new(raw_seg)
+          [seg.id, seg]
+        end
+      end
+
+      def parse_feature_flags(configuration, segments, cdi)
+        configuration['featureFlags'].to_h do |raw_ff|
+          ff = FeatureFlag.new(raw_ff, segments, cdi)
+          [ff.feature_key, ff]
+        end
+      end
+
       def any_targeted_delivery_rule?
         @feature_flags.any? { |_, ff| ff.environment_enabled && ff.rules.any?(&:targeted_delivery_type?) }
       end

data/lib/kameleoon/configuration/feature_flag.rb

@@ -8,7 +8,8 @@ module Kameleoon
   module Configuration
     # Class for manage all feature flags with rules
     class FeatureFlag
-      attr_accessor :id, :feature_key, :variations, :default_variation_key, :me_group_name, :environment_enabled, :rules
+      attr_reader :id, :feature_key, :variations, :default_variation_key, :me_group_name, :environment_enabled, :rules,
+                  :bucketing_custom_data_index
 
       def self.create_from_array(array)
         array&.map { |it| FeatureFlag.new(it) }
@@ -21,18 +22,21 @@ module Kameleoon
           "environment_enabled:#{@environment_enabled}," \
           "default_variation_key:'#{@default_variation_key}'," \
           "me_group_name:'#{@me_group_name}'," \
-          "rules:#{@rules.size}" \
+          "rules:#{@rules.size}," \
+          "bucketing_custom_data_index:#{@bucketing_custom_data_index}" \
           '}'
       end
 
-      def initialize(hash)
+      def initialize(hash, segments, cdi)
         @id = hash['id']
         @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'])
+        @rules = Rule.create_from_array(hash['rules'], segments)
+        bucketing_cd_id = hash['bucketingCustomDataId']
+        @bucketing_custom_data_index = bucketing_cd_id ? cdi.get_custom_data_index_by_id(bucketing_cd_id) : nil
       end
 
       def get_variation_by_key(key)

data/lib/kameleoon/configuration/rule.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require_relative 'experiment'
-require 'kameleoon/targeting/models'
 
 module Kameleoon
   # Module which contains all internal data of SDK
@@ -32,22 +31,22 @@ module Kameleoon
       attr_reader :id, :order, :type, :exposition, :experiment, :respool_time, :segment_id
       attr_accessor :targeting_segment
 
-      def self.create_from_array(array)
-        array&.map { |it| Rule.new(it) }
+      def self.create_from_array(array, segments)
+        array&.map { |it| Rule.new(it, segments) }
       end
 
       def to_s
         "Rule{id:#{@id}}"
       end
 
-      def initialize(hash)
+      def initialize(hash, segments)
         @id = hash['id']
         @order = hash['order']
         @type = RuleType.from_literal(hash['type'])
         @exposition = hash['exposition']
         @respool_time = hash['respoolTime']
-        @targeting_segment = Kameleoon::Targeting::Segment.new((hash['segment'])) if hash['segment']
-        @segment_id = @targeting_segment != nil ? targeting_segment.id : -1
+        @segment_id = hash['segmentId'] || -1
+        @targeting_segment = segments[@segment_id] if @segment_id != -1
         @experiment = Experiment.from_json(hash)
       end
 

data/lib/kameleoon/data/cookie.rb

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

data/lib/kameleoon/data/data.rb

@@ -18,6 +18,7 @@ module Kameleoon
     FORCED_FEATURE_VARIATION = 'FORCED_FEATURE_VARIATION'
     OPERATING_SYSTEM = 'OPERATING_SYSTEM'
     GEOLOCATION = 'GEOLOCATION'
+    VISITOR_VISITS = 'VISITOR_VISITS'
   end
 
   module DataState

data/lib/kameleoon/data/device.rb

@@ -30,7 +30,7 @@ module Kameleoon
         deviceType: @device_type,
         nonce: nonce
       }
-      Kameleoon::Network::UriHelper.encode_query(params)
+      Network::UriHelper.encode_query(params)
     end
   end
 end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'concurrent'
+require 'time'
 require 'kameleoon/data/browser'
 require 'kameleoon/data/cbscores'
 require 'kameleoon/data/conversion'
@@ -42,6 +43,10 @@ module Kameleoon
         update_last_activity_time
       end
 
+      def time_started
+        @data.time_started
+      end
+
       def last_activity_time
         @data.last_activity_time
       end
@@ -263,7 +268,7 @@ module Kameleoon
             when CBScores
               @data.set_cbscores(data, overwrite)
             when VisitorVisits
-              @data.visitor_visits = data
+              @data.set_visitor_visits(data, overwrite)
             when UniqueIdentifier
               @is_unique_identifier = data.value
             else
@@ -286,12 +291,13 @@ module Kameleoon
     end
 
     class VisitorData
-      attr_reader :mutex, :device, :browser, :geolocation, :operating_system
-      attr_accessor :last_activity_time, :legal_consent, :user_agent, :cookie, :kcs_heat, :cbscores, :visitor_visits,
+      attr_reader :time_started, :mutex, :device, :browser, :geolocation, :operating_system, :visitor_visits
+      attr_accessor :last_activity_time, :legal_consent, :user_agent, :cookie, :kcs_heat, :cbscores,
                     :mapping_identifier, :forced_variations, :simulated_variations
 
       def initialize
         Logging::KameleoonLogger.debug('CALL: VisitorData.new')
+        @time_started = (Time.now.to_f * 1000).to_i
         @mutex = Concurrent::ReadWriteLock.new
         @legal_consent = false
         Logging::KameleoonLogger.debug('RETURN: VisitorData.new')
@@ -318,6 +324,7 @@ module Kameleoon
         blk.call(@browser) unless @browser.nil?
         blk.call(@operating_system) unless @operating_system.nil?
         blk.call(@geolocation) unless @geolocation.nil?
+        blk.call(@visitor_visits) unless @visitor_visits.nil?
         @mutex.with_read_lock do
           @custom_data_map&.each { |_, cd| blk.call(cd) }
           @page_view_visits&.each { |_, pvv| blk.call(pvv.page_view) }
@@ -332,8 +339,9 @@ module Kameleoon
         @mutex.with_read_lock do
           count += 1 unless @device.nil?
           count += 1 unless @browser.nil?
-          count += 1 unless @geolocation.nil?
           count += 1 unless @operating_system.nil?
+          count += 1 unless @geolocation.nil?
+          count += 1 unless @visitor_visits.nil?
           count += @custom_data_map.size unless @custom_data_map.nil?
           count += @page_view_visits.size unless @page_view_visits.nil?
           count += @conversions.size unless @conversions.nil?
@@ -433,6 +441,10 @@ module Kameleoon
         @cbscores = cbs if overwrite || @cbscores.nil?
       end
 
+      def set_visitor_visits(visitor_visits, overwrite)
+        @visitor_visits = visitor_visits.localize(@time_started) if overwrite || @visitor_visits.nil?
+      end
+
       def add_forced_feature_variation(forced_variation)
         @simulated_variations ||= {}
         @simulated_variations[forced_variation.feature_key] = forced_variation

data/lib/kameleoon/data/visitor_visits.rb

@@ -1,24 +1,77 @@
 # frozen_string_literal: true
 
+require 'kameleoon/data/data'
+require 'kameleoon/network/uri_helper'
+
 module Kameleoon
-  class VisitorVisits
-    attr_reader :previous_visit_timestamps
+  class VisitorVisits < DuplicationUnsafeData
+    attr_reader :visit_number, :prev_visits, :time_started, :time_since_previous_visit
 
-    def to_s
-      "VisitorVisits{previous_visit_timestamps:#{@previous_visit_timestamps}}"
+    def initialize(prev_visits, visit_number = 0, time_started: 0, time_since_previous_visit: 0)
+      super(DataType::VISITOR_VISITS)
+      @visit_number = visit_number >= prev_visits.size ? visit_number : prev_visits.size
+      @prev_visits = prev_visits
+      @prev_visits.freeze
+      @time_started = time_started
+      @time_since_previous_visit = time_since_previous_visit
+    end
+
+    def localize(time_started)
+      time_since_previous_visit = 0
+      @prev_visits.each do |visit|
+        time_delta = time_started - visit.time_last_activity
+        unless time_delta.negative?
+          time_since_previous_visit = time_delta
+          break
+        end
+      end
+      VisitorVisits.new(
+        @prev_visits,
+        @visit_number,
+        time_started: time_started,
+        time_since_previous_visit: time_since_previous_visit
+      )
+    end
+
+    def obtain_full_post_text_line
+      params = {
+        eventType: 'staticData',
+        visitNumber: @visit_number,
+        timeSincePreviousVisit: @time_since_previous_visit,
+        nonce: nonce
+      }
+      Network::UriHelper.encode_query(params)
     end
 
-    def initialize(previous_visit_timestamps = [])
-      @previous_visit_timestamps = previous_visit_timestamps
-      @previous_visit_timestamps.freeze
+    def to_s
+      'VisitorVisits{' \
+      "visit_number:#{@visit_number}," \
+      "prev_visits:#{@prev_visits.map(&:to_s)}," \
+      "time_started:#{@time_started}," \
+      "time_since_previous_visit:#{@time_since_previous_visit}" \
+      '}'
     end
 
-    def self.get_previous_visit_timestamps(visitor_visits)
-      visitor_visits.is_a?(VisitorVisits) ? visitor_visits.previous_visit_timestamps : []
+    def ==(other)
+      other.is_a?(VisitorVisits) && (@visit_number == other.visit_number) && (@prev_visits == other.prev_visits) &&
+        (@time_started == other.time_started) && (@time_since_previous_visit == other.time_since_previous_visit)
     end
 
-    def self.visitor_visits?(obj)
-      obj.nil? || obj.is_a?(VisitorVisits)
+    class Visit
+      attr_reader :time_started, :time_last_activity
+
+      def initialize(time_started, time_last_activity = nil)
+        @time_started = time_started
+        @time_last_activity = time_last_activity || time_started
+      end
+
+      def to_s
+        "Visit{time_started:#{@time_started},time_last_activity:#{time_last_activity}}"
+      end
+
+      def ==(other)
+        other.is_a?(Visit) && (@time_started == other.time_started) && (@time_last_activity == other.time_last_activity)
+      end
     end
   end
 end

data/lib/kameleoon/kameleoon_client.rb

@@ -852,14 +852,17 @@ module Kameleoon
 
     def obtain_configuration(time_stamp = nil)
       Logging::KameleoonLogger.info('Fetching configuration from Client-Config service')
-      response = @network_manager.fetch_configuration(time_stamp)
+      last_modified = @data_manager.data_file.last_modified
+      response = @network_manager.fetch_configuration(time_stamp, if_modified_since: last_modified)
       return false unless response
 
-      configuration = JSON.parse(response)
-      data_file = Configuration::DataFile.new(@config.environment, configuration)
-      apply_new_configuration(data_file)
-      call_update_handler_if_needed(!time_stamp.nil?)
-      Logging::KameleoonLogger.info('Feature flags are fetched: %s', response.inspect)
+      if response.configuration
+        configuration = JSON.parse(response.configuration)
+        data_file = Configuration::DataFile.new(@config.environment, configuration, response.last_modified)
+        apply_new_configuration(data_file)
+        call_update_handler_if_needed(!time_stamp.nil?)
+        Logging::KameleoonLogger.info('Feature flags are fetched: %s', response.inspect)
+      end
       true
     end
 
@@ -871,7 +874,7 @@ module Kameleoon
     end
 
     ##
-    # Call the handler when configuraiton was updated with new time stamp.
+    # Call the handler when configuration was updated with new time stamp.
     #
     # @param need_call [Bool] Indicates if we need to call handler or not.
     def call_update_handler_if_needed(need_call)
@@ -930,7 +933,7 @@ 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, feature_flag.bucketing_custom_data_index) && \
             ff_unrestricted_by_me_group?(visitor, visitor_code, feature_flag)
         eval_exp = _calculate_variation_key_for_feature(visitor_code, feature_flag)
       end
@@ -952,7 +955,7 @@ module Kameleoon
       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)
+        code_for_hash = get_code_for_hash(visitor, visitor_code, feature_flag.bucketing_custom_data_index)
         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'",
@@ -967,17 +970,17 @@ module Kameleoon
       unrestricted
     end
 
-    def visitor_not_in_holdout?(visitor, visitor_code, track, save)
+    def visitor_not_in_holdout?(visitor, visitor_code, track, save, bucketing_custom_data_index)
       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
+        "CALL: KameleoonClient.visitor_not_in_holdout?(visitor, visitor_code: '%s', track: %s, save: %s, " \
+        'bucketing_custom_data_index: %s)', visitor_code, track, save, bucketing_custom_data_index
       )
       is_not_in_holdout = true
-      code_for_hash = get_code_for_hash(visitor, visitor_code)
+      code_for_hash = get_code_for_hash(visitor, visitor_code, bucketing_custom_data_index)
       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)
@@ -989,9 +992,9 @@ module Kameleoon
         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
+        "RETURN: KameleoonClient.visitor_not_in_holdout?(visitor, visitor_code: '%s', track: %s, save: %s, " \
+        'bucketing_custom_data_index: %s) -> (is_not_in_holdout: %s)',
+        visitor_code, track, save, bucketing_custom_data_index, is_not_in_holdout
       )
       is_not_in_holdout
     end
@@ -1035,16 +1038,24 @@ module Kameleoon
       )
     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
+    def get_code_for_hash(visitor, visitor_code, bucketing_custom_data_index)
+      return visitor_code if visitor.nil?
+
+      # 1. Try to use the bucketing custom data's value if bucketingCustomDataId is defined
+      if bucketing_custom_data_index
+        bucketing_custom_data = visitor.custom_data.get(bucketing_custom_data_index)
+        return bucketing_custom_data.values[0] if bucketing_custom_data && !bucketing_custom_data.values.empty?
+      end
+      # 2. Use mappingIdentifier instead of visitorCode if it was set up
+      visitor.mapping_identifier || visitor_code
     end
 
-    def evaluate_cbscores(visitor, visitor_code, rule)
+    def evaluate_cbscores(visitor, visitor_code, rule, bucketing_custom_data_index)
       return nil if visitor&.cbscores.nil?
 
       Logging::KameleoonLogger.debug(
-        "CALL: KameleoonClient.evaluate_cbscores(visitor, visitor_code: '%s', rule: %s)", visitor_code, rule
+        "CALL: KameleoonClient.evaluate_cbscores(visitor, visitor_code: '%s', rule: %s, " \
+        'bucketing_custom_data_index: %s)', visitor_code, rule, bucketing_custom_data_index
       )
       eval_exp = nil
       var_id_group_by_scores = visitor.cbscores.values[rule.experiment.id]
@@ -1059,7 +1070,7 @@ module Kameleoon
         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)
+            code_for_hash = get_code_for_hash(visitor, visitor_code, bucketing_custom_data_index)
             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
@@ -1070,8 +1081,8 @@ module Kameleoon
         end
       end
       Logging::KameleoonLogger.debug(
-        "RETURN: KameleoonClient.evaluate_cbscores(visitor, visitor_code: '%s', rule: %s) -> (eval_exp: %s)",
-        visitor_code, rule, eval_exp
+        "RETURN: KameleoonClient.evaluate_cbscores(visitor, visitor_code: '%s', rule: %s," \
+        'bucketing_custom_data_index: %s) -> (eval_exp: %s)', visitor_code, rule, bucketing_custom_data_index, eval_exp
       )
       eval_exp
     end
@@ -1084,7 +1095,7 @@ module Kameleoon
         visitor_code, feature_flag
       )
       visitor = @visitor_manager.get_visitor(visitor_code)
-      code_for_hash = get_code_for_hash(visitor, visitor_code)
+      code_for_hash = get_code_for_hash(visitor, visitor_code, feature_flag.bucketing_custom_data_index)
       # no rules -> return default_variation_key
       eval_exp = nil
       feature_flag.rules.each do |rule|
@@ -1107,7 +1118,7 @@ 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)
+          eval_exp = evaluate_cbscores(visitor, visitor_code, rule, feature_flag.bucketing_custom_data_index)
           break unless eval_exp.nil?
 
           if rule.targeted_delivery_type?

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

@@ -42,7 +42,7 @@ module Kameleoon
           filter = Types::RemoteVisitorDataFilter.new unless filter.is_a?(Types::RemoteVisitorDataFilter)
           is_unique_identifier = @visitor_manger.get_visitor(visitor_code)&.is_unique_identifier || false
           response = @network_manager.get_remote_visitor_data(visitor_code, filter, is_unique_identifier, timeout)
-          remote_visitor_data = parse_custom_data_array(visitor_code, response)
+          remote_visitor_data = parse_custom_data_array(visitor_code, response, filter)
           remote_visitor_data.mark_data_as_sent(@data_manager.data_file.custom_data_info)
           data_to_add = remote_visitor_data.collect_data_to_add
           if add_data && !data_to_add.empty?
@@ -66,8 +66,8 @@ module Kameleoon
 
         ##
         # helper method used by `get_remote_visitor_data`
-        def parse_custom_data_array(visitor_code, response)
-          RemoteVisitorData.new(JSON.parse(response))
+        def parse_custom_data_array(visitor_code, response, filter)
+          RemoteVisitorData.new(JSON.parse(response), filter)
         rescue StandardError => e
           Logging::KameleoonLogger.error("Parsing of remote visitor data of '#{visitor_code}' failed: #{e}")
           raise

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

@@ -18,21 +18,23 @@ module Kameleoon
     module RemoteData
       class RemoteVisitorData
         attr_reader :custom_data_dict, :page_view_visits, :conversions, :experiments, :personalizations, :device,
-                    :browser, :operating_system, :geolocation, :previous_visitor_visits, :kcs_heat, :cbs, :visitor_code
+                    :browser, :operating_system, :geolocation, :visitor_visits, :kcs_heat, :cbs, :visitor_code
 
-        def initialize(hash)
+        def initialize(hash, filter)
+          @filter = filter
+          @visit_number = 0
           current_visit = hash['currentVisit']
-          parse_visit(current_visit) unless current_visit.nil?
+          parse_visit(current_visit, false) unless current_visit.nil?
           previous_visits = hash['previousVisits']
           previous_visits = [] if previous_visits.nil?
 
           if previous_visits.size.positive?
-            times_started = []
+            prev_visits = []
             previous_visits.each do |visit|
-              times_started.push(visit['timeStarted'])
-              parse_visit(visit)
+              prev_visits.push(VisitorVisits::Visit.new(visit['timeStarted'] || 0, visit['timeLastEvent']))
+              parse_visit(visit, true)
             end
-            @previous_visitor_visits = VisitorVisits.new(times_started)
+            @visitor_visits = VisitorVisits.new(prev_visits, @visit_number)
           end
           @kcs_heat = parse_kcs_heat(hash['kcs'])
           @cbs = parse_cbscores(hash['cbs'])
@@ -41,7 +43,7 @@ module Kameleoon
         def collect_data_to_add
           data_to_add = []
           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(@visitor_visits) unless @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?
@@ -72,7 +74,7 @@ module Kameleoon
 
         private
 
-        def parse_visit(hash)
+        def parse_visit(hash, is_prev_visit)
           @visitor_code = hash['visitorCode'] if @visitor_code.nil?
           custom_data_events = hash['customDataEvents']
           parse_custom_data(custom_data_events) if !custom_data_events.nil? && custom_data_events.size.positive?
@@ -86,7 +88,7 @@ module Kameleoon
           @geolocation = parse_geolocation(geolocation_events) if @geolocation.nil? && !geolocation_events.nil? && \
                                                                   geolocation_events.size.positive?
           static_data_events = hash['staticDataEvent']
-          parse_static_data(static_data_events) unless static_data_events.nil?
+          parse_static_data(static_data_events, is_prev_visit) unless static_data_events.nil?
           personalization_events = hash['personalizationEvents']
           parse_personalizations(personalization_events) unless personalization_events.nil?
         end
@@ -144,17 +146,21 @@ module Kameleoon
           Geolocation.new(data['country'], data['region'], data['city'])
         end
 
-        def parse_static_data(static_data_event)
+        def parse_static_data(static_data_event, is_prev_visit)
           data = static_data_event['data']
-          if @device.nil?
+          if @visit_number.zero?
+            @visit_number = data['visitNumber'] || 0
+            @visit_number += 1 if is_prev_visit && @visit_number.positive?
+          end
+          if @filter.device && @device.nil?
             device_type = data['deviceType']
             @device = Device.new(device_type) unless device_type.nil?
           end
-          if @browser.nil?
+          if @filter.browser && @browser.nil?
             browser_type = BrowserType.from_name(data['browser'])
             @browser = Browser.new(browser_type, data['browserVersion']) unless browser_type.nil?
           end
-          if @operating_system.nil?
+          if @filter.operating_system && @operating_system.nil?
             operating_system_type = OperatingSystemType.from_name(data['os'])
             @operating_system = OperatingSystem.new(operating_system_type) unless operating_system_type.nil?
           end

data/lib/kameleoon/network/content_type.rb

@@ -3,6 +3,7 @@
 module Kameleoon
   module Network
     module ContentType
+      WILDCARD = '*/*'
       TEXT = 'text/plain'
       JSON = 'application/json'
       FORM = 'application/x-www-form-urlencoded'

data/lib/kameleoon/network/fetched_configuration.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Kameleoon
+  module Network
+    class FetchedConfiguration
+      attr_reader :configuration, :last_modified
+
+      def initialize(configuration, last_modified)
+        @configuration = configuration
+        @last_modified = last_modified
+      end
+    end
+  end
+end

data/lib/kameleoon/network/net_provider.rb

@@ -22,7 +22,7 @@ module Kameleoon
       end
 
       def unknown_method_response(method, request)
-        Response.new("Unknown request method '#{method}'", nil, nil, request)
+        Response.new("Unknown request method '#{method}'", nil, nil, nil, request)
       end
     end
 
@@ -48,9 +48,10 @@ module Kameleoon
         end
         body = resp.body
         body = nil if body&.empty?
-        Response.new(nil, resp.code.to_i, body, request)
+        headers = resp.to_hash
+        Response.new(nil, resp.code.to_i, body, headers, request)
       rescue StandardError => e
-        Response.new(e, nil, nil, request)
+        Response.new(e, nil, nil, nil, request)
       end
     end
   end

data/lib/kameleoon/network/network_manager.rb

@@ -2,6 +2,7 @@
 
 require 'kameleoon/logging/kameleoon_logger'
 require 'kameleoon/network/content_type'
+require 'kameleoon/network/fetched_configuration'
 require 'kameleoon/network/method'
 require 'kameleoon/network/request'
 require 'kameleoon/network/net_provider'
@@ -19,6 +20,8 @@ module Kameleoon
       SDK_TYPE_HEADER = 'X-Kameleoon-SDK-Type'
       SDK_VERSION_HEADER = 'X-Kameleoon-SDK-Version'
       ACCESS_TOKEN_GRANT_TYPE = 'client_credentials'
+      HEADER_IF_MODIFIED_SINCE = 'If-Modified-Since'
+      HEADER_LAST_MODIFIED = 'last-modified' # in lower case because the network lib casts response headers to lower
 
       attr_reader :environment, :default_timeout, :access_token_source, :url_provider
 
@@ -30,26 +33,32 @@ module Kameleoon
         @sync_net_provider = SyncNetProvider.new
       end
 
-      def fetch_configuration(timestamp = nil, timeout = nil)
+      def fetch_configuration(timestamp = nil, timeout = nil, if_modified_since: nil)
         url = @url_provider.make_configuration_url(@environment, timestamp)
         timeout = ensure_timeout(timeout)
-        sdk_headers = { SDK_TYPE_HEADER => SDK_NAME, SDK_VERSION_HEADER => SDK_VERSION }
-        request = Request.new(Method::GET, url, ContentType::JSON, timeout, extra_headers: sdk_headers)
-        make_call(request, false, FETCH_CONFIGURATION_ATTEMPT_NUMBER - 1)
+        headers = { SDK_TYPE_HEADER => SDK_NAME, SDK_VERSION_HEADER => SDK_VERSION }
+        headers[HEADER_IF_MODIFIED_SINCE] = if_modified_since if if_modified_since
+        request = Request.new(Method::GET, url, ContentType::JSON, timeout, extra_headers: headers)
+        response, success = make_call(request, false, FETCH_CONFIGURATION_ATTEMPT_NUMBER - 1)
+        return nil unless success
+        return FetchedConfiguration.new(nil, nil) if response.code == 304
+
+        last_modified = response.headers&.[](HEADER_LAST_MODIFIED)&.first
+        FetchedConfiguration.new(response.body, last_modified)
       end
 
       def get_remote_data(key, timeout = nil)
         url = @url_provider.make_api_data_get_request_url(key)
         timeout = ensure_timeout(timeout)
         request = Request.new(Method::GET, url, ContentType::JSON, timeout)
-        make_call(request, true)
+        unwrap_response(*make_call(request, true))
       end
 
       def get_remote_visitor_data(visitor_code, filter, is_unique_identifier, timeout = nil)
         url = @url_provider.make_visitor_data_get_url(visitor_code, filter, is_unique_identifier)
         timeout = ensure_timeout(timeout)
         request = Request.new(Method::GET, url, ContentType::JSON, timeout)
-        make_call(request, true)
+        unwrap_response(*make_call(request, true))
       end
 
       def send_tracking_data(lines, timeout = nil)
@@ -57,8 +66,8 @@ module Kameleoon
 
         url = @url_provider.make_tracking_url
         timeout = ensure_timeout(timeout)
-        request = Request.new(Method::POST, url, ContentType::TEXT, timeout, data: lines)
-        make_call(request, true, TRACKING_CALL_ATTEMPT_NUMBER - 1, TRACKING_CALL_RETRY_DELAY)
+        request = Request.new(Method::POST, url, ContentType::WILDCARD, timeout, data: lines)
+        unwrap_response(*make_call(request, true, TRACKING_CALL_ATTEMPT_NUMBER - 1, TRACKING_CALL_RETRY_DELAY))
       end
 
       def fetch_access_jwtoken(client_id, client_secret, timeout = nil)
@@ -71,7 +80,7 @@ module Kameleoon
         }
         data = UriHelper.encode_query(data_map).encode('UTF-8')
         request = Request.new(Method::POST, url, ContentType::FORM, timeout, data: data)
-        make_call(request, false)
+        unwrap_response(*make_call(request, false))
       end
 
       private
@@ -81,6 +90,7 @@ module Kameleoon
                                        request, try_access_token_auth, retry_limit, retry_delay)
         attempt = 0
         success = false
+        response = nil
         while !success && (attempt <= retry_limit)
           delay(retry_delay) if attempt.positive? && retry_delay.positive?
           try_authorize(request) if try_access_token_auth
@@ -110,11 +120,11 @@ module Kameleoon
           attempt += 1
         end
         Logging::KameleoonLogger.debug('Fetched response %s for request %s', response, request)
-        success ? response.body : false
+        [response, success]
       end
 
       def get_log_level(attempt, attempt_count)
-        return log_level = attempt < attempt_count ? Logging::LogLevel::WARNING : Logging::LogLevel::ERROR
+        attempt < attempt_count ? Logging::LogLevel::WARNING : Logging::LogLevel::ERROR
       end
 
       def delay(period)
@@ -129,6 +139,10 @@ module Kameleoon
         token = @access_token_source.get_token(request.timeout)
         request.authorize(token)
       end
+
+      def unwrap_response(response, success)
+        success ? response.body : false
+      end
     end
   end
 end

data/lib/kameleoon/network/request.rb

@@ -16,7 +16,7 @@ module Kameleoon
             body = @data
           end
         end
-        "HttpRequest{Method:'#{@method}',Url:'#{@url}',Headers:#{@extra_headers},Body:'#{body}'}"
+        "Request{method:'#{@method}',url:'#{@url}',headers:#{@extra_headers},body:'#{body}'}"
       end
 
       def initialize(method, url, content_type, timeout, extra_headers: nil, data: nil)

data/lib/kameleoon/network/response.rb

@@ -5,21 +5,22 @@ module Kameleoon
     ##
     # Response represents HTTP response.
     class Response
-      attr_reader :error, :code, :body, :request
+      attr_reader :error, :code, :body, :headers, :request
 
       def to_s
-        "HttpResponse{Code:'#{@code}',Reason:'#{@error}',Body:#{@body}}"
+        "Response{code:'#{@code}',error:'#{@error}',body:#{@body}}"
       end
 
-      def initialize(error, code, body, request)
+      def initialize(error, code, body, headers, request)
         @error = error
         @code = code
         @body = body
+        @headers = headers
         @request = request
       end
 
       def success?
-        @error.nil? && ((@code / 100 == 2) || (@code == 403))
+        @error.nil? && ((@code / 100 == 2) || (@code == 403) || (@code == 304))
       end
     end
   end

data/lib/kameleoon/network/url_provider.rb

@@ -19,7 +19,7 @@ module Kameleoon
       DEFAULT_ACCESS_TOKEN_DOMAIN = 'api.kameleoon.com'
       DEFAULT_DATA_API_DOMAIN = 'data.kameleoon.io'
 
-      CONFIGURATION_API_URL_FORMAT = 'https://%s/%s'
+      CONFIGURATION_API_URL_FORMAT = 'https://%s/v3/%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'
@@ -68,6 +68,7 @@ module Kameleoon
         params[is_unique_identifier ? :mappingValue : :visitorCode] = visitor_code
         params[:maxNumberPreviousVisits] = filter.previous_visit_amount
         params[:version] = 0
+        params[:staticData] = true
         params[:kcs] = true if filter.kcs
         params[:currentVisit] = true if filter.current_visit
         params[:customData] = true if filter.custom_data
@@ -75,7 +76,6 @@ module Kameleoon
         params[:geolocation] = true if filter.geolocation
         params[:experiment] = true if filter.experiments
         params[:page] = true if filter.page_views
-        params[:staticData] = true if filter.device || filter.browser || filter.operating_system
         params[:personalization] = true if filter.personalization
         params[:cbs] = true if filter.cbs
         format(DATA_API_URL_FORMAT, @data_api_domain, VISITOR_DATA_PATH, UriHelper.encode_query(params))

data/lib/kameleoon/targeting/condition.rb

@@ -11,7 +11,6 @@ module Kameleoon
       TARGET_FEATURE_FLAG = 'TARGET_FEATURE_FLAG'
       TARGET_EXPERIMENT = 'TARGET_EXPERIMENT'
       TARGET_PERSONALIZATION = 'TARGET_PERSONALIZATION'
-      EXCLUSIVE_FEATURE_FLAG = 'EXCLUSIVE_FEATURE_FLAG'
       EXCLUSIVE_EXPERIMENT = 'EXCLUSIVE_EXPERIMENT'
       PAGE_URL = 'PAGE_URL'
       PAGE_VIEWS = 'PAGE_VIEWS'

data/lib/kameleoon/targeting/condition_factory.rb

@@ -3,7 +3,6 @@ require_relative 'conditions/target_experiment_condition'
 require_relative 'conditions/target_feature_flag_condition'
 require_relative 'conditions/target_personalization_condition'
 require_relative 'conditions/exclusive_experiment_condition'
-require_relative 'conditions/exclusive_feature_flag_condition'
 require_relative 'conditions/page_title_condition'
 require_relative 'conditions/page_url_condition'
 require_relative 'conditions/page_view_number_condition'
@@ -39,8 +38,6 @@ module Kameleoon
           TargetExperimentCondition.new(condition_json)
         when ConditionType::TARGET_PERSONALIZATION
           TargetPersonalizationCondition.new(condition_json)
-        when ConditionType::EXCLUSIVE_FEATURE_FLAG
-          ExclusiveFeatureFlagCondition.new(condition_json)
         when ConditionType::EXCLUSIVE_EXPERIMENT
           ExclusiveExperimentCondition.new(condition_json)
         when ConditionType::PAGE_URL

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

@@ -10,16 +10,17 @@ module Kameleoon
       def initialize(json_condition)
         count_in_millis = json_condition['countInMillis']
         super(json_condition, count_in_millis)
-        @is_first_visit = @type == Kameleoon::Targeting::ConditionType::FIRST_VISIT
+        @is_first_visit = @type == ConditionType::FIRST_VISIT
       end
 
       def check(data)
-        return false unless data.is_a?(Kameleoon::VisitorVisits) && !@condition_value.nil?
+        data ||= VisitorVisits.new([])
+        return false unless data.is_a?(VisitorVisits) && !@condition_value.nil?
 
-        previous_visits_count = data.previous_visit_timestamps.count
-        if previous_visits_count >= 1
+        prev_visits = data.prev_visits
+        if prev_visits.size >= 1
           now = (Time.now.to_f * 1000).to_i # ... * 1000 for convert seconds to milliseconds
-          visit_time = data.previous_visit_timestamps[@is_first_visit ? previous_visits_count - 1 : 0]
+          visit_time = prev_visits[@is_first_visit ? prev_visits.size - 1 : 0].time_started
           return check_targeting(now - visit_time)
         end
         false

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

@@ -13,15 +13,27 @@ module Kameleoon
       end
 
       def check(data)
-        return false unless VisitorVisits.visitor_visits?(data) && !@condition_value.nil?
+        return false unless data.is_a?(TargetingData) && !@condition_value.nil?
 
         number_of_visits_today = 0
         start_of_day = (Time.new.to_date.to_time.to_f * 1000).to_i # ... * 1000 to convert seconds to milliseconds
-        for timestamp in VisitorVisits.get_previous_visit_timestamps(data)
-          break if timestamp < start_of_day
+        data.visitor_visits.prev_visits.each do |visit|
+          break if visit.time_started < start_of_day
+
           number_of_visits_today += 1
         end
-        check_targeting(number_of_visits_today + 1) # +1 for current visit
+        number_of_visits_today += 1 if data.current_visit_time_started >= start_of_day
+        check_targeting(number_of_visits_today)
+      end
+
+      class TargetingData
+        attr_reader :current_visit_time_started, :visitor_visits
+
+        def initialize(current_visit_time_started, visitor_visits)
+          @current_visit_time_started =
+            current_visit_time_started.is_a?(Integer) ? current_visit_time_started : (Time.new.to_f * 1000).to_i
+          @visitor_visits = visitor_visits.is_a?(VisitorVisits) ? visitor_visits : VisitorVisits.new([])
+        end
       end
     end
   end

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

@@ -13,10 +13,11 @@ module Kameleoon
       end
 
       def check(data)
-        return false unless VisitorVisits.visitor_visits?(data) && !@condition_value.nil?
+        data ||= VisitorVisits.new([])
+        return false unless data.is_a?(VisitorVisits) && !@condition_value.nil?
 
-        previous_visit_timestamps = VisitorVisits.get_previous_visit_timestamps(data)
-        check_targeting(previous_visit_timestamps.size + 1) # +1 for current visit
+        prev_visits = data.prev_visits
+        check_targeting(prev_visits.size + 1) # +1 for current visit
       end
     end
   end

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

@@ -17,14 +17,15 @@ module Kameleoon
       end
 
       def check(data)
-        return false unless VisitorVisits.visitor_visits?(data)
+        data ||= VisitorVisits.new([])
+        return false unless data.is_a?(VisitorVisits)
 
-        previous_visit_timestamps = VisitorVisits.get_previous_visit_timestamps(data)
+        prev_visits = data.prev_visits
         case @visitor_type
         when VisitorType::NEW
-          previous_visit_timestamps.empty?
+          prev_visits.empty?
         when VisitorType::RETURNING
-          !previous_visit_timestamps.empty?
+          !prev_visits.empty?
         else
           false
         end

data/lib/kameleoon/targeting/models.rb

@@ -9,6 +9,7 @@ module Kameleoon
     class Segment
       include TreeBuilder
       attr_accessor :id, :tree
+
       def to_s
         @tree.to_s
       end
@@ -84,13 +85,13 @@ module Kameleoon
           # Computing results
           if is_left_child_targeted.nil?
             if is_right_child_targeted == @or_operator
-              is_targeted = Marshal.load(Marshal.dump(@or_operator)) #Deep copy
+              is_targeted = Marshal.load(Marshal.dump(@or_operator)) # Deep copy
             else
               is_targeted = nil
             end
           else
             if is_left_child_targeted == @or_operator
-              is_targeted = Marshal.load(Marshal.dump(@or_operator)) #Deep copy
+              is_targeted = Marshal.load(Marshal.dump(@or_operator)) # Deep copy
             else
               if is_right_child_targeted == true
                 is_targeted = true
@@ -102,7 +103,7 @@ module Kameleoon
             end
           end
         end
-        Marshal.load(Marshal.dump(is_targeted)) #Deep copy
+        Marshal.load(Marshal.dump(is_targeted)) # Deep copy
       end
 
       def check_condition(datas, condition = @condition)

data/lib/kameleoon/targeting/targeting_manager.rb

@@ -3,12 +3,12 @@
 require 'kameleoon/logging/kameleoon_logger'
 require 'kameleoon/targeting/condition'
 require 'kameleoon/targeting/conditions/exclusive_experiment_condition'
-require 'kameleoon/targeting/conditions/exclusive_feature_flag_condition'
 require 'kameleoon/targeting/conditions/sdk_language_condition'
 require 'kameleoon/targeting/conditions/segment_condition'
 require 'kameleoon/targeting/conditions/target_experiment_condition'
 require 'kameleoon/targeting/conditions/target_feature_flag_condition'
 require 'kameleoon/targeting/conditions/target_personalization_condition'
+require 'kameleoon/targeting/conditions/visit_number_today_condition'
 
 module Kameleoon
   # @api private
@@ -85,16 +85,15 @@ module Kameleoon
           condition_data = TargetExperimentInfo.new(visitor&.variations)
         when ConditionType::TARGET_PERSONALIZATION
           condition_data = TargetPersonalizationInfo.new(visitor&.personalizations)
-        when ConditionType::EXCLUSIVE_FEATURE_FLAG
-          condition_data = ExclusiveFeatureFlagInfo.new(campaign_id, visitor&.variations)
         when ConditionType::EXCLUSIVE_EXPERIMENT
           condition_data = ExclusiveExperimentInfo.new(campaign_id, visitor&.variations, visitor&.personalizations)
         when ConditionType::FIRST_VISIT,
           ConditionType::LAST_VISIT,
           ConditionType::VISITS,
-          ConditionType::SAME_DAY_VISITS,
           ConditionType::NEW_VISITORS
           condition_data = visitor.visitor_visits unless visitor.nil?
+        when ConditionType::SAME_DAY_VISITS
+          condition_data = VisitNumberTodayCondition::TargetingData.new(visitor&.time_started, visitor&.visitor_visits)
         when ConditionType::HEAT_SLICE
           condition_data = visitor&.kcs_heat
         end

data/lib/kameleoon/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Kameleoon
-  SDK_VERSION = '3.12.1'
+  SDK_VERSION = '3.14.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.12.1
+  version: 3.14.0
 platform: ruby
 authors:
 - Kameleoon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-04-08 00:00:00.000000000 Z
+date: 2025-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: em-http-request
@@ -130,6 +130,7 @@ files:
 - lib/kameleoon/network/activity_event.rb
 - lib/kameleoon/network/content_type.rb
 - lib/kameleoon/network/cookie/cookie_manager.rb
+- lib/kameleoon/network/fetched_configuration.rb
 - lib/kameleoon/network/method.rb
 - lib/kameleoon/network/net_provider.rb
 - lib/kameleoon/network/network_manager.rb
@@ -153,7 +154,6 @@ files:
 - lib/kameleoon/targeting/conditions/custom_datum.rb
 - lib/kameleoon/targeting/conditions/device_condition.rb
 - lib/kameleoon/targeting/conditions/exclusive_experiment_condition.rb
-- lib/kameleoon/targeting/conditions/exclusive_feature_flag_condition.rb
 - lib/kameleoon/targeting/conditions/geolocation_condition.rb
 - lib/kameleoon/targeting/conditions/kcs_heat_range_condition.rb
 - lib/kameleoon/targeting/conditions/number_condition.rb

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

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require 'kameleoon/targeting/condition'
-
-module Kameleoon
-  # @api private
-  module Targeting
-    # ExclusiveFeatureFlag represents an instance of Exclusive FeatureFlag condition in user account
-    class ExclusiveFeatureFlagCondition < Condition
-      def check(data)
-        return false unless data.is_a?(ExclusiveFeatureFlagInfo)
-
-        size = data.variations_storage&.size || 0
-        size.zero? || (size == 1 && !data.variations_storage.get(data.current_experiment_id).nil?)
-      end
-    end
-
-    class ExclusiveFeatureFlagInfo
-      attr_reader :current_experiment_id, :variations_storage
-
-      def initialize(current_experiment_id, variations_storage)
-        @current_experiment_id = current_experiment_id
-        @variations_storage = variations_storage
-      end
-    end
-  end
-end