kameleoon-client-ruby 3.13.0 → 3.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 05500f77891f22fd67b10f0dec830e6673a77d8ff83b391ffbf8547893bfcf1e
-  data.tar.gz: 4c572f1464af6e5026642e4fac03dcc1e1a99715228c76982c67de5063c2235e
+  metadata.gz: 07240065fc16f98169c01fd4367321b2f633d79373f293b0bcf110f68d920d46
+  data.tar.gz: 52b83806f28aa0035eb8df2db89f84b98b774e2a53b0fd8a7c5abd71b0a59ac4
 SHA512:
-  metadata.gz: b7ac1acb43bf56661f194dacc810b064e2c4cba67010b1af49d928c190ae53c139ee0447fb7e5f5670ae1fb0c406a0efb7e2c7fe0eedac323635dc0e215de869
-  data.tar.gz: 58278744be7aaef43a0e0dcbe71bf93ee9ab9c1aec3a0b6e6f296e940f24ce943ee7c7998a550ecf1950cbcb3f36cb78858feacea6289a2b8ce1c3439b4b037e
+  metadata.gz: 88e8da4ec50eca784dd49b5861f373d84e60eaa521894d095104c10d6d469cb8e20d4fbf98416a473790fe77842411e4021beed153a4a4bb784603b90360abd0
+  data.tar.gz: 9068a2d4b8dfaff1020933c9e38e133965486ef0ddc722db19dd7eeee28a0327926d4d3beb1b17460615da176620699a2f7dcc5ada1dc63db4e6696aaa080131

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,13 +6,14 @@ 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 :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
+      attr_reader :last_modified, :settings, :segments, :audience_tracking_segments, :feature_flags, :me_groups,
+                  :has_any_targeted_delivery_rule, :feature_flag_by_id, :rule_info_by_exp_id, :variation_by_id,
+                  :custom_data_info, :experiment_ids_with_js_css_variable, :holdout
 
       def to_s
         'DataFile{' \
@@ -69,25 +70,40 @@ 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, @audience_tracking_segments = parse_segments(configuration)
+        @custom_data_info = CustomDataInfo.new(configuration['customData'])
+        @feature_flags = parse_feature_flags(configuration, @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)
+        audience_tracking_segments = []
+        segments = configuration['segments'].to_h do |raw_seg|
+          seg = Targeting::Segment.new(raw_seg)
+          audience_tracking_segments.push(seg) if seg.audience_tracking
+          [seg.id, seg]
+        end
+        segments.freeze
+        audience_tracking_segments.freeze
+        [segments, audience_tracking_segments]
+      end
+
+      def parse_feature_flags(configuration, 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
 
       def collect_indices
         @feature_flag_by_id = {}
-        @rule_by_segment_id = {}
         @rule_info_by_exp_id = {}
         @variation_by_id = {}
         @experiment_ids_with_js_css_variable = Set.new
@@ -98,7 +114,6 @@ module Kameleoon
 
           has_feature_flag_variable_js_css = feature_flag_variable_js_css?(feature_flag)
           feature_flag.rules.each do |rule|
-            @rule_by_segment_id[rule.segment_id] = rule
             @rule_info_by_exp_id[rule.experiment.id] = RuleInfo.new(feature_flag, rule)
             rule.experiment.variations_by_exposition.each do |variation|
               @variation_by_id[variation.variation_id] = variation
@@ -107,7 +122,6 @@ module Kameleoon
           end
         end
         @feature_flag_by_id.freeze
-        @rule_by_segment_id.freeze
         @variation_by_id.freeze
         @experiment_ids_with_js_css_variable.freeze
       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

@@ -19,6 +19,7 @@ module Kameleoon
     OPERATING_SYSTEM = 'OPERATING_SYSTEM'
     GEOLOCATION = 'GEOLOCATION'
     VISITOR_VISITS = 'VISITOR_VISITS'
+    TARGETED_SEGMENT = 'TARGETED_SEGMENT'
   end
 
   module DataState

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

@@ -10,6 +10,7 @@ require 'kameleoon/data/device'
 require 'kameleoon/data/kcs_heat'
 require 'kameleoon/data/page_view'
 require 'kameleoon/data/personalization'
+require 'kameleoon/data/targeted_segment'
 require 'kameleoon/data/unique_identifier'
 require 'kameleoon/data/user_agent'
 require 'kameleoon/data/manager/assigned_variation'
@@ -186,6 +187,14 @@ module Kameleoon
         personalizations
       end
 
+      def targeted_segments
+        targeted_segments = @data.targeted_segments
+        Logging::KameleoonLogger.debug(
+          'CALL/RETURN: Visitor.targeted_segments -> (targeted_segments: %s)', targeted_segments
+        )
+        targeted_segments
+      end
+
       def get_forced_feature_variation(feature_key)
         Logging::KameleoonLogger.debug("CALL: Visitor.get_forced_feature_variation(feature_key: '%s')", feature_key)
         variation = @data.get_from_map(@data.simulated_variations, feature_key)
@@ -241,6 +250,8 @@ module Kameleoon
               @data.add_variation(data, overwrite)
             when Personalization
               @data.add_personalization(data, overwrite)
+            when TargetedSegment
+              @data.add_targeted_segment(data)
             when ForcedFeatureVariation
               @data.add_forced_feature_variation(data)
             when ForcedExperimentVariation
@@ -329,6 +340,7 @@ module Kameleoon
           @custom_data_map&.each { |_, cd| blk.call(cd) }
           @page_view_visits&.each { |_, pvv| blk.call(pvv.page_view) }
           @variations&.each { |_, av| blk.call(av) }
+          @targeted_segments&.each { |_, ts| blk.call(ts) }
           @conversions&.each { |c| blk.call(c) }
         end
       end
@@ -344,8 +356,9 @@ module Kameleoon
           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?
           count += @variations.size unless @variations.nil?
+          count += @targeted_segments.size unless @targeted_segments.nil?
+          count += @conversions.size unless @conversions.nil?
         end
         Logging::KameleoonLogger.debug('RETURN: VisitorData.count_sendable_data -> (count: %s)', count)
         count
@@ -371,6 +384,10 @@ module Kameleoon
         DataMapStorage.new(@mutex, @personalizations)
       end
 
+      def targeted_segments
+        DataMapStorage.new(@mutex, @targeted_segments)
+      end
+
       def set_device(device, overwrite)
         @device = device if overwrite || @device.nil?
       end
@@ -389,6 +406,11 @@ module Kameleoon
         end
       end
 
+      def add_targeted_segment(targeted_segment)
+        @targeted_segments ||= {}
+        @targeted_segments[targeted_segment.id] = targeted_segment
+      end
+
       def set_browser(browser, overwrite)
         @browser = browser if overwrite || @browser.nil?
       end

data/lib/kameleoon/data/targeted_segment.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'kameleoon/data/data'
+require 'kameleoon/network/uri_helper'
+
+module Kameleoon
+  class TargetedSegment < DuplicationUnsafeData
+    EVENT_TYPE = 'targetingSegment'
+
+    attr_reader :id
+
+    def initialize(id)
+      super(DataType::TARGETED_SEGMENT)
+      @id = id
+    end
+
+    def obtain_full_post_text_line
+      params = {
+        eventType: EVENT_TYPE,
+        id: @id,
+        nonce: nonce
+      }
+      Network::UriHelper.encode_query(params)
+    end
+
+    def to_s
+      "TargetedSegment{id:#{@id}}"
+    end
+  end
+end

data/lib/kameleoon/kameleoon_client.rb

@@ -758,6 +758,27 @@ module Kameleoon
       )
     end
 
+    ##
+    # Evaluates the visitor against all available Audiences Explorer segments and tracks those that match.
+    # A detailed analysis of segment performance can then be performed directly in Audiences Explorer.
+    #
+    # @param [String] visitor_code The unique visitor code identifying the visitor.
+    #
+    # @raise [Kameleoon::Exception::VisitorCodeInvalid] The provided **visitor code** is invalid.
+    def evaluate_audiences(visitor_code)
+      Logging::KameleoonLogger.info("CALL: KameleoonClient.evaluate_audiences(visitor_code: '%s')", visitor_code)
+      Utils::VisitorCode.validate(visitor_code)
+      segments = @data_manager.data_file.audience_tracking_segments.select do |seg|
+        check_targeting(visitor_code, nil, seg)
+      end
+      unless segments.empty?
+        segments.map! { |seg| TargetedSegment.new(seg.id) }
+        @visitor_manager.add_data(visitor_code, *segments)
+      end
+      @tracking_manager.add_visitor_code(visitor_code)
+      Logging::KameleoonLogger.info("RETURN: KameleoonClient.evaluate_audiences(visitor_code: '%s')", visitor_code)
+    end
+
     private
 
     HYBRID_EXPIRATION_TIME = 5
@@ -904,8 +925,8 @@ module Kameleoon
     #   nil
     # end
 
-    def check_targeting(visitor_code, campaign_id, exp_ff_rule)
-      @targeting_manager.check_targeting(visitor_code, campaign_id, exp_ff_rule)
+    def check_targeting(visitor_code, campaign_id, segment)
+      @targeting_manager.check_targeting(visitor_code, campaign_id, segment)
     end
 
     def get_variation_info(visitor_code, feature_flag, track)
@@ -933,7 +954,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
@@ -955,7 +976,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'",
@@ -970,17 +991,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)
@@ -992,9 +1013,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
@@ -1038,16 +1059,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]
@@ -1062,7 +1091,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
@@ -1073,8 +1102,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
@@ -1087,7 +1116,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|
@@ -1098,7 +1127,7 @@ module Kameleoon
           break
         end
         # check if visitor is targeted for rule, else next rule
-        next unless check_targeting(visitor_code, rule.experiment.id, rule)
+        next unless check_targeting(visitor_code, rule.experiment.id, rule.targeting_segment)
 
         unless forced_variation.nil?
           # Forcing experiment variation in targeting-only mode
@@ -1110,7 +1139,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/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/network_manager.rb

@@ -66,7 +66,7 @@ module Kameleoon
 
         url = @url_provider.make_tracking_url
         timeout = ensure_timeout(timeout)
-        request = Request.new(Method::POST, url, ContentType::TEXT, timeout, data: lines)
+        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
 

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'

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

@@ -19,10 +19,10 @@ module Kameleoon
       private
 
       def check_targeting(segment_info)
-        rule = segment_info.data_file.rule_by_segment_id[@segment_id]
-        return false unless rule.is_a?(Kameleoon::Configuration::Rule)
+        segment = segment_info.data_file.segments[@segment_id]
+        return false if segment.nil?
 
-        rule.targeting_segment.check_tree(->(type) { segment_info.condition_data(type) })
+        segment.check_tree(->(type) { segment_info.condition_data(type) })
       end
     end
 

data/lib/kameleoon/targeting/models.rb

@@ -8,9 +8,10 @@ module Kameleoon
   module Targeting
     class Segment
       include TreeBuilder
-      attr_accessor :id, :tree
+      attr_accessor :id, :tree, :audience_tracking
+
       def to_s
-        @tree.to_s
+        "Segment{id:#{@id},audience_tracking:#{@audience_tracking}}"
       end
 
       def initialize(*args)
@@ -27,6 +28,7 @@ module Kameleoon
             if hash['conditionsData'].nil?
               raise Kameleoon::Exception::NotFound.new(hash['conditionsData']), 'hash[\'conditionsData\']'
             end
+            @audience_tracking = hash['audienceTracking'] || false
             @tree = create_tree(hash['conditionsData'])
           elsif args.length == 2
             @id = args[0]
@@ -84,13 +86,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 +104,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

@@ -19,25 +19,19 @@ module Kameleoon
         @visitor_manager = visitor_manager
       end
 
-      def check_targeting(visitor_code, campaign_id, exp_ff_rule)
+      def check_targeting(visitor_code, campaign_id, segment)
         Logging::KameleoonLogger.debug(
-          "CALL: TargetingManager.check_targeting(visitor_code: '%s', campaign_id: %s, exp_ff_rule: %s)",
-          visitor_code, campaign_id, exp_ff_rule
+          "CALL: TargetingManager.check_targeting(visitor_code: '%s', campaign_id: %s, segment: %s)",
+          visitor_code, campaign_id, segment
         )
-        segment = exp_ff_rule.targeting_segment
-        if segment.nil?
-          Logging::KameleoonLogger.debug(
-            "RETURN: TargetingManager.check_targeting(visitor_code: '%s', campaign_id: %s, exp_ff_rule: %s) -> " \
-              '(targeting: true)', visitor_code, campaign_id, exp_ff_rule
-          )
-          return true
+        targeting = true
+        unless segment.nil?
+          visitor = @visitor_manager.get_visitor(visitor_code)
+          targeting = segment.check_tree(->(type) { get_condition_data(type, visitor, visitor_code, campaign_id) })
         end
-
-        visitor = @visitor_manager.get_visitor(visitor_code)
-        targeting = segment.check_tree(->(type) { get_condition_data(type, visitor, visitor_code, campaign_id) })
         Logging::KameleoonLogger.debug(
-          "RETURN: TargetingManager.check_targeting(visitor_code: '%s', campaign_id: %s, exp_ff_rule: %s) -> " \
-            '(targeting: %s)', visitor_code, campaign_id, exp_ff_rule, targeting
+          "RETURN: TargetingManager.check_targeting(visitor_code: '%s', campaign_id: %s, segment: %s) -> " \
+            '(targeting: %s)', visitor_code, campaign_id, segment, targeting
         )
         targeting
       end
@@ -86,7 +80,9 @@ module Kameleoon
         when ConditionType::TARGET_PERSONALIZATION
           condition_data = TargetPersonalizationInfo.new(visitor&.personalizations)
         when ConditionType::EXCLUSIVE_EXPERIMENT
-          condition_data = ExclusiveExperimentInfo.new(campaign_id, visitor&.variations, visitor&.personalizations)
+          unless campaign_id.nil?
+            condition_data = ExclusiveExperimentInfo.new(campaign_id, visitor&.variations, visitor&.personalizations)
+          end
         when ConditionType::FIRST_VISIT,
           ConditionType::LAST_VISIT,
           ConditionType::VISITS,

data/lib/kameleoon/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Kameleoon
-  SDK_VERSION = '3.13.0'
+  SDK_VERSION = '3.15.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.13.0
+  version: 3.15.0
 platform: ruby
 authors:
 - Kameleoon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-05-26 00:00:00.000000000 Z
+date: 2025-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: em-http-request
@@ -108,6 +108,7 @@ files:
 - lib/kameleoon/data/operating_system.rb
 - lib/kameleoon/data/page_view.rb
 - lib/kameleoon/data/personalization.rb
+- lib/kameleoon/data/targeted_segment.rb
 - lib/kameleoon/data/unique_identifier.rb
 - lib/kameleoon/data/user_agent.rb
 - lib/kameleoon/data/visitor_visits.rb