splitclient-rb 8.5.0 → 8.6.0.pre.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49270eca968d09db0947f123ef98071ebf93abe96fd70cca06ae9775fc79c334
-  data.tar.gz: 7205c421419bd3ab6da82eeb00361ca008d7d936eb2cc3bf83b404967f7615eb
+  metadata.gz: a4e482ad28374447239354e09829df29adcf7b58cb2d6a9d42120463cb34b655
+  data.tar.gz: 074bb6358936a908054cea7817a0e5e441421f905346b5c458f406785d1e4297
 SHA512:
-  metadata.gz: 9e79b5ea033863981678658a28a6444caef7564d38aad5d4a3b22d60ac569d5574b6cfba0e46a71e590a89b22eabea3ab8103f23320ce2101d96b106712e6eeb
-  data.tar.gz: 2f1d582dc82f396cc50400252b38155924677dc593c0a3524c2080b3d1bb93b781ee66563b2939ac064bd080296ad4797fcb0021030fa8827c799934e8bf11a7
+  metadata.gz: 82c605432eda05966aa5164c00be845e544a1529ea909524141871710f9cccdfece1ae45390f01b64a0c82cc5bc64993874dd2b8206d470aed0d6fa7cb19a9ec
+  data.tar.gz: '098a2e908b0f7ea745efd5c0de3ba584278dbf35b517c1c0d1c407b1d2bcc7001133be72b2f4d1c3ae5907c766a3b39e36f82b3bcc2fb5d56b32e418e57ed78b'

data/CHANGES.txt

@@ -1,5 +1,9 @@
 CHANGES
 
+8.6.0 (Jun xx, 2025)
+- Added support for rule-based segments. These segments determine membership at runtime by evaluating their configured rules against the user attributes provided to the SDK.
+- Added support for feature flag prerequisites. This allows customers to define dependency conditions between flags, which are evaluated before any allowlists or targeting rules.
+
 8.5.0 (Jan 17, 2025)
 - Fixed high cpu usage when unique keys are cleared every 24 hours.
 - Added support for the new impressions tracking toggle available on feature flags, both respecting the setting and including the new field being returned on SplitView type objects. Read more in our docs.

data/lib/splitclient-rb/cache/fetchers/split_fetcher.rb

@@ -2,10 +2,11 @@ module SplitIoClient
   module Cache
     module Fetchers
       class SplitFetcher
-        attr_reader :splits_repository
+        attr_reader :splits_repository, :rule_based_segments_repository
 
-        def initialize(splits_repository, api_key, config, telemetry_runtime_producer)
+        def initialize(splits_repository, rule_based_segments_repository, api_key, config, telemetry_runtime_producer)
           @splits_repository = splits_repository
+          @rule_based_segments_repository = rule_based_segments_repository
           @api_key = api_key
           @config = config
           @semaphore = Mutex.new
@@ -23,10 +24,11 @@ module SplitIoClient
 
         def fetch_splits(fetch_options = { cache_control_headers: false, till: nil })
           @semaphore.synchronize do
-            data = splits_since(@splits_repository.get_change_number, fetch_options)
-
-            SplitIoClient::Helpers::RepositoryHelper.update_feature_flag_repository(@splits_repository, data[:splits], data[:till], @config)
+            data = splits_since(@splits_repository.get_change_number, @rule_based_segments_repository.get_change_number, fetch_options)
+            SplitIoClient::Helpers::RepositoryHelper.update_feature_flag_repository(@splits_repository, data[:ff][:d], data[:ff][:t], @config, @splits_api.clear_storage)
+            SplitIoClient::Helpers::RepositoryHelper.update_rule_based_segment_repository(@rule_based_segments_repository, data[:rbs][:d], data[:rbs][:t], @config)
             @splits_repository.set_segment_names(data[:segment_names])
+            @rule_based_segments_repository.set_segment_names(data[:segment_names])
             @config.logger.debug("segments seen(#{data[:segment_names].length}): #{data[:segment_names].to_a}") if @config.debug_enabled
 
             { segment_names: data[:segment_names], success: true }
@@ -55,8 +57,8 @@ module SplitIoClient
           end
         end
 
-        def splits_since(since, fetch_options = { cache_control_headers: false, till: nil })
-          splits_api.since(since, fetch_options)
+        def splits_since(since, since_rbs, fetch_options = { cache_control_headers: false, till: nil })
+          splits_api.since(since, since_rbs, fetch_options)
         end
 
         def splits_api

data/lib/splitclient-rb/cache/repositories/rule_based_segments_repository.rb

@@ -0,0 +1,122 @@
+require 'concurrent'
+
+module SplitIoClient
+  module Cache
+    module Repositories
+      class RuleBasedSegmentsRepository < Repository
+        attr_reader :adapter
+        DEFAULT_CONDITIONS_TEMPLATE = [{
+          conditionType: "ROLLOUT",
+          matcherGroup: {
+              combiner: "AND",
+              matchers: [
+              {
+                  keySelector: nil,
+                  matcherType: "ALL_KEYS",
+                  negate: false,
+                  userDefinedSegmentMatcherData: nil,
+                  whitelistMatcherData: nil,
+                  unaryNumericMatcherData: nil,
+                  betweenMatcherData: nil,
+                  dependencyMatcherData: nil,
+                  booleanMatcherData: nil,
+                  stringMatcherData: nil
+              }]
+          }
+        }]
+        TILL_PREFIX = '.rbsegments.till'
+        RB_SEGMENTS_PREFIX = '.rbsegment.'
+        REGISTERED_PREFIX = '.segments.registered'
+
+        def initialize(config)
+          super(config)
+          @adapter = case @config.cache_adapter.class.to_s
+          when 'SplitIoClient::Cache::Adapters::RedisAdapter'
+            SplitIoClient::Cache::Adapters::CacheAdapter.new(@config)
+          else
+            @config.cache_adapter
+          end
+          unless @config.mode.equal?(:consumer)
+            @adapter.set_string(namespace_key(TILL_PREFIX), '-1')
+            @adapter.initialize_map(namespace_key(REGISTERED_PREFIX))
+          end
+        end
+
+        def update(to_add, to_delete, new_change_number)
+          to_add.each{ |rule_based_segment| add_rule_based_segment(rule_based_segment) }
+          to_delete.each{ |rule_based_segment| remove_rule_based_segment(rule_based_segment) }
+          set_change_number(new_change_number)
+        end
+
+        def get_rule_based_segment(name)
+          rule_based_segment = @adapter.string(namespace_key("#{RB_SEGMENTS_PREFIX}#{name}"))
+
+          JSON.parse(rule_based_segment, symbolize_names: true) if rule_based_segment
+        end
+
+        def rule_based_segment_names
+          @adapter.find_strings_by_prefix(namespace_key(RB_SEGMENTS_PREFIX))
+            .map { |rule_based_segment_names| rule_based_segment_names.gsub(namespace_key(RB_SEGMENTS_PREFIX), '') }
+        end
+
+        def set_change_number(since)
+          @adapter.set_string(namespace_key(TILL_PREFIX), since)
+        end
+
+        def get_change_number
+          @adapter.string(namespace_key(TILL_PREFIX))
+        end
+
+        def set_segment_names(names)
+          return if names.nil? || names.empty?
+
+          names.each do |name|
+            @adapter.add_to_set(namespace_key(REGISTERED_PREFIX), name)
+          end
+        end
+
+        def exists?(name)
+          @adapter.exists?(namespace_key("#{RB_SEGMENTS_PREFIX}#{name}"))
+        end
+
+        def clear
+          @adapter.clear(namespace_key)
+        end
+
+        def contains?(segment_names)
+          return false if rule_based_segment_names.empty?
+          return set(segment_names).subset?(rule_based_segment_names)
+        end
+
+        private
+
+        def add_rule_based_segment(rule_based_segment)
+          return unless rule_based_segment[:name]
+
+          if check_undefined_matcher(rule_based_segment)
+            @config.logger.warn("Rule based segment #{rule_based_segment[:name]} has undefined matcher, setting conditions to default template.")
+            rule_based_segment[:conditions] = RuleBasedSegmentsRepository::DEFAULT_CONDITIONS_TEMPLATE
+          end
+
+          @adapter.set_string(namespace_key("#{RB_SEGMENTS_PREFIX}#{rule_based_segment[:name]}"), rule_based_segment.to_json)
+        end
+
+        def check_undefined_matcher(rule_based_segment)
+          for condition in rule_based_segment[:conditions]
+            for matcher in condition[:matcherGroup][:matchers]
+              if !SplitIoClient::Condition.instance_methods(false).map(&:to_s).include?("matcher_#{matcher[:matcherType].downcase}")
+                @config.logger.error("Detected undefined matcher #{matcher[:matcherType].downcase} in feature flag #{rule_based_segment[:name]}")
+                return true
+              end
+            end
+          end
+          return false
+        end
+
+        def remove_rule_based_segment(rule_based_segment)
+          @adapter.delete(namespace_key("#{RB_SEGMENTS_PREFIX}#{rule_based_segment[:name]}"))
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/cache/repositories/segments_repository.rb

@@ -83,6 +83,13 @@ module SplitIoClient
           0
         end
 
+        def contains?(segment_names)
+          if segment_names.empty?
+            return false
+          end
+          return segment_names.to_set.subset?(used_segment_names.to_set)
+        end
+
         private
 
         def segment_data(name)

data/lib/splitclient-rb/cache/repositories/splits_repository.rb

@@ -31,6 +31,9 @@ module SplitIoClient
           ],
           label: "targeting rule type unsupported by sdk"
         }]
+        TILL_PREFIX = '.splits.till'
+        SPLIT_PREFIX = '.split.'
+        READY_PREFIX = '.splits.ready'
 
         def initialize(config, flag_sets_repository, flag_set_filter)
           super(config)
@@ -43,10 +46,7 @@ module SplitIoClient
           end
           @flag_sets = flag_sets_repository
           @flag_set_filter = flag_set_filter
-          unless @config.mode.equal?(:consumer)
-            @adapter.set_string(namespace_key('.splits.till'), '-1')
-            @adapter.initialize_map(namespace_key('.segments.registered'))
-          end
+          initialize_keys
         end
 
         def update(to_add, to_delete, new_change_number)
@@ -87,16 +87,16 @@ module SplitIoClient
 
         # Return an array of Split Names excluding control keys like splits.till
         def split_names
-          @adapter.find_strings_by_prefix(namespace_key('.split.'))
-            .map { |split| split.gsub(namespace_key('.split.'), '') }
+          @adapter.find_strings_by_prefix(namespace_key(SPLIT_PREFIX))
+            .map { |split| split.gsub(namespace_key(SPLIT_PREFIX), '') }
         end
 
         def set_change_number(since)
-          @adapter.set_string(namespace_key('.splits.till'), since)
+          @adapter.set_string(namespace_key(TILL_PREFIX), since)
         end
 
         def get_change_number
-          @adapter.string(namespace_key('.splits.till'))
+          @adapter.string(namespace_key(TILL_PREFIX))
         end
 
         def set_segment_names(names)
@@ -112,21 +112,22 @@ module SplitIoClient
         end
 
         def ready?
-          @adapter.string(namespace_key('.splits.ready')).to_i != -1
+          @adapter.string(namespace_key(READY_PREFIX)).to_i != -1
         end
 
         def not_ready!
-          @adapter.set_string(namespace_key('.splits.ready'), -1)
+          @adapter.set_string(namespace_key(READY_PREFIX), -1)
         end
 
         def ready!
-          @adapter.set_string(namespace_key('.splits.ready'), Time.now.utc.to_i)
+          @adapter.set_string(namespace_key(READY_PREFIX), Time.now.utc.to_i)
         end
 
         def clear
           @tt_cache.clear
 
           @adapter.clear(namespace_key)
+          initialize_keys
         end
 
         def kill(change_number, split_name, default_treatment)
@@ -167,6 +168,13 @@ module SplitIoClient
 
         private
 
+        def initialize_keys
+          unless @config.mode.equal?(:consumer)
+            @adapter.set_string(namespace_key(TILL_PREFIX), '-1')
+            @adapter.initialize_map(namespace_key('.segments.registered'))
+          end
+        end
+
         def add_feature_flag(split)
           return unless split[:name]
           existing_split = get_split(split[:name])

data/lib/splitclient-rb/cache/stores/localhost_split_builder.rb

@@ -22,7 +22,8 @@ module SplitIoClient
               seed: 2_089_907_429,
               defaultTreatment: 'control_treatment',
               configurations: build_configurations(treatments),
-              conditions: build_conditions(treatments)
+              conditions: build_conditions(treatments),
+              prerequisites: []
             }
           end
 

data/lib/splitclient-rb/clients/split_client.rb

@@ -22,6 +22,7 @@ module SplitIoClient
       @api_key = sdk_key
       @splits_repository = repositories[:splits]
       @segments_repository = repositories[:segments]
+      @rule_based_segments_repository = repositories[:rule_based_segments]
       @impressions_repository = repositories[:impressions]
       @events_repository = repositories[:events]
       @status_manager = status_manager
@@ -115,6 +116,7 @@ module SplitIoClient
 
       @splits_repository.clear
       @segments_repository.clear
+      @rule_based_segments_repository.clear
 
       SplitIoClient.load_factory_registry
       SplitIoClient.split_factory_registry.remove(@api_key)

data/lib/splitclient-rb/engine/api/client.rb

@@ -20,6 +20,11 @@ module SplitIoClient
 
           @config.split_logger.log_if_debug("GET #{url} proxy: #{api_client.proxy}")
         end
+      
+      rescue Zlib::GzipFile::Error => e
+        @config.logger.warn("Incorrect formatted response exception: #{e}\n")
+        SplitIoClient::Engine::Models::SplitHttpResponse.new(400, '', true)
+
       rescue StandardError => e
         @config.logger.warn("#{e}\nURL:#{url}\nparams:#{params}")
         raise e, 'Split SDK failed to connect to backend to retrieve information', e.backtrace
@@ -50,6 +55,9 @@ module SplitIoClient
         raise e, 'Split SDK failed to connect to backend to post information', e.backtrace
       end
 
+      def sdk_url_overriden?
+        @config.sdk_url_overriden?
+      end
       private
 
       def api_client

data/lib/splitclient-rb/engine/api/splits.rb

@@ -5,17 +5,40 @@ module SplitIoClient
     # Retrieves split definitions from the Split Backend
     class Splits < Client
 
+      PROXY_CHECK_INTERVAL_SECONDS = 24 * 60 * 60
+      SPEC_1_1 = "1.1"
+
       def initialize(api_key, config, telemetry_runtime_producer)
         super(config)
         @api_key = api_key
         @telemetry_runtime_producer = telemetry_runtime_producer
         @flag_sets_filter = @config.flag_sets_filter
+        @spec_version = SplitIoClient::Spec::FeatureFlags::SPEC_VERSION
+        @last_proxy_check_timestamp = 0
+        @clear_storage = false
+        @old_spec_since = nil
       end
 
-      def since(since, fetch_options = { cache_control_headers: false, till: nil, sets: nil})
+      def since(since, since_rbs, fetch_options = { cache_control_headers: false, till: nil, sets: nil})
         start = Time.now
+        
+        if check_last_proxy_check_timestamp
+            @spec_version = SplitIoClient::Spec::FeatureFlags::SPEC_VERSION
+            @config.logger.debug("Switching to new Feature flag spec #{@spec_version} and fetching.")
+            @old_spec_since = since
+            since = -1
+            since_rbs = -1
+            fetch_options = { cache_control_headers: false, till: nil, sets: nil}
+        end
+
+        if @spec_version == Splits::SPEC_1_1
+          since = @old_spec_since unless @old_spec_since.nil?
+          params = { s: @spec_version, since: since }
+          @old_spec_since = nil
+        else
+          params = { s: @spec_version, since: since, rbSince: since_rbs }
+        end
 
-        params = { s: SplitIoClient::Spec::FeatureFlags::SPEC_VERSION, since: since }
         params[:sets] = @flag_sets_filter.join(",") unless @flag_sets_filter.empty?
         params[:till] = fetch_options[:till] unless fetch_options[:till].nil?
         @config.logger.debug("Fetching from splitChanges with #{params}: ")
@@ -24,39 +47,92 @@ module SplitIoClient
           @config.logger.error("Error fetching feature flags; the amount of flag sets provided are too big, causing uri length error.")
           raise ApiException.new response.body, 414
         end
+
+        if response.status == 400 and sdk_url_overriden? and @spec_version == SplitIoClient::Spec::FeatureFlags::SPEC_VERSION
+            @config.logger.warn("Detected proxy response error, changing spec version from #{@spec_version} to #{Splits::SPEC_1_1} and re-fetching.")
+            @spec_version = Splits::SPEC_1_1
+            @last_proxy_check_timestamp = Time.now
+            return since(since, 0, fetch_options = {cache_control_headers: fetch_options[:cache_control_headers], till: fetch_options[:till],
+                sets: fetch_options[:sets]})          
+        end
         if response.success?
-          result = splits_with_segment_names(response.body)
-          unless result[:splits].empty?
-            @config.split_logger.log_if_debug("#{result[:splits].length} feature flags retrieved. since=#{since}")
-          end
-          @config.split_logger.log_if_transport("Feature flag changes response: #{result.to_s}")
+          result = JSON.parse(response.body, symbolize_names: true)
 
-          bucket = BinarySearchLatencyTracker.get_bucket((Time.now - start) * 1000.0)
-          @telemetry_runtime_producer.record_sync_latency(Telemetry::Domain::Constants::SPLIT_SYNC, bucket)
-          @telemetry_runtime_producer.record_successful_sync(Telemetry::Domain::Constants::SPLIT_SYNC, (Time.now.to_f * 1000.0).to_i)
+          return process_result(result, since, since_rbs, start)
+        end
+        @telemetry_runtime_producer.record_sync_error(Telemetry::Domain::Constants::SPLIT_SYNC, response.status)
 
-          result
-        else
-          @telemetry_runtime_producer.record_sync_error(Telemetry::Domain::Constants::SPLIT_SYNC, response.status)
+        @config.logger.error("Unexpected status code while fetching feature flags: #{response.status}. " \
+        'Check your API key and base URI')
 
-          @config.logger.error("Unexpected status code while fetching feature flags: #{response.status}. " \
-          'Check your API key and base URI')
+        raise 'Split SDK failed to connect to backend to fetch feature flags definitions'
+      end
 
-          raise 'Split SDK failed to connect to backend to fetch feature flags definitions'
-        end
+      def clear_storage
+        @clear_storage
       end
 
       private
 
-      def splits_with_segment_names(splits_json)
-        parsed_splits = JSON.parse(splits_json, symbolize_names: true)
+      def process_result(result, since, since_rbs, start)
+        if @spec_version == Splits::SPEC_1_1
+          result = convert_to_new_spec(result)
+        end
+        
+        result[:rbs][:d] = check_rbs_data(result[:rbs][:d])
+        result = objects_with_segment_names(result)
+        
+        if @spec_version == SplitIoClient::Spec::FeatureFlags::SPEC_VERSION
+          @clear_storage = @last_proxy_check_timestamp != 0
+          @last_proxy_check_timestamp = 0
+        end
+
+        unless result[:ff][:d].empty?
+          @config.split_logger.log_if_debug("#{result[:ff][:d].length} feature flags retrieved. since=#{since}")
+        end
+        @config.split_logger.log_if_transport("Feature flag changes response: #{result[:ff].to_s}")
+
+        unless result[:rbs][:d].empty?
+          @config.split_logger.log_if_debug("#{result[:rbs][:d].length} rule based segments retrieved. since=#{since_rbs}")
+        end
+        @config.split_logger.log_if_transport("rule based segments changes response: #{result[:rbs].to_s}")
+
+        bucket = BinarySearchLatencyTracker.get_bucket((Time.now - start) * 1000.0)
+        @telemetry_runtime_producer.record_sync_latency(Telemetry::Domain::Constants::SPLIT_SYNC, bucket)
+        @telemetry_runtime_producer.record_successful_sync(Telemetry::Domain::Constants::SPLIT_SYNC, (Time.now.to_f * 1000.0).to_i)
+
+        result
+      end
+
+      def check_rbs_data(rbs_data)
+        rbs_data.each do |rb_segment|
+          rb_segment[:excluded] = {:keys => [], :segments => []} if rb_segment[:excluded].nil?
+          rb_segment[:excluded][:keys] = [] if rb_segment[:excluded][:keys].nil?
+          rb_segment[:excluded][:segments] = [] if rb_segment[:excluded][:segments].nil?
+        end
+        rbs_data
+      end
 
-        parsed_splits[:segment_names] =
-          parsed_splits[:splits].each_with_object(Set.new) do |split, splits|
-            splits << Helpers::Util.segment_names_by_feature_flag(split)
+      def objects_with_segment_names(parsed_objects)
+        parsed_objects[:segment_names] = Set.new
+        parsed_objects[:segment_names] =
+          parsed_objects[:ff][:d].each_with_object(Set.new) do |split, splits|
+            splits << Helpers::Util.segment_names_by_object(split, "IN_SEGMENT")
           end.flatten
 
-        parsed_splits
+        parsed_objects[:rbs][:d].each do |rule_based_segment|
+          parsed_objects[:segment_names].merge Helpers::Util.segment_names_in_rb_segment(rule_based_segment, "IN_SEGMENT")
+        end
+        
+        parsed_objects
+      end
+
+      def check_last_proxy_check_timestamp
+        @spec_version == Splits::SPEC_1_1 and ((Time.now - @last_proxy_check_timestamp) >= Splits::PROXY_CHECK_INTERVAL_SECONDS)
+      end
+
+      def convert_to_new_spec(body)
+        {:ff => {:d => body[:splits], :s => body[:since], :t => body[:till]}, :rbs => {:d => [], :s => -1, :t => -1}}
       end
     end
   end

data/lib/splitclient-rb/engine/matchers/combining_matcher.rb

@@ -56,7 +56,9 @@ module SplitIoClient
 
       @matchers.all? do |matcher|
         if match_with_key?(matcher)
-          matcher.match?(value: args[:matching_key])
+          key = args[:value]
+          key = args[:matching_key] unless args[:matching_key].nil?
+          matcher.match?(value: key)
         else
           matcher.match?(args)
         end

data/lib/splitclient-rb/engine/matchers/prerequisites_matcher.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  class PrerequisitesMatcher
+    def initialize(prerequisites, logger)
+      @prerequisites = prerequisites
+      @logger = logger
+    end
+
+    def match?(args)
+      keys = { matching_key: args[:matching_key], bucketing_key: args[:bucketing_key] }
+
+      match = true
+      @prerequisites.each do |prerequisite|
+        evaluate = args[:evaluator].evaluate_feature_flag(keys, prerequisite[:n], args[:attributes])
+        next if prerequisite[:ts].include?(evaluate[:treatment])
+
+        @logger.log_if_debug("[PrerequisitesMatcher] feature flag #{prerequisite[:n]} evaluated to #{evaluate[:treatment]} \
+          that does not exist in prerequisited treatments.")
+        match = false
+        break
+      end
+
+      match
+    end
+
+    def string_type?
+      false
+    end
+  end
+end

data/lib/splitclient-rb/engine/matchers/rule_based_segment_matcher.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  #
+  # class to implement the user defined matcher
+  #
+  class RuleBasedSegmentMatcher < Matcher
+    MATCHER_TYPE = 'IN_RULE_BASED_SEGMENT'
+
+    def initialize(segments_repository, rule_based_segments_repository, segment_name, config)
+      super(config.logger)
+      @rule_based_segments_repository = rule_based_segments_repository
+      @segments_repository = segments_repository
+      @segment_name = segment_name
+      @config = config
+    end
+
+    #
+    # evaluates if the key matches the matcher
+    #
+    # @param key [string] key value to be matched
+    #
+    # @return [boolean] evaluation of the key against the segment
+    def match?(args)
+      rule_based_segment = @rule_based_segments_repository.get_rule_based_segment(@segment_name)
+      return false if rule_based_segment.nil?
+
+      key = update_key(args)
+      return false if rule_based_segment[:excluded][:keys].include?(key)
+
+      return false unless check_excluded_segments(rule_based_segment, key, args)
+
+      matches = false
+      rule_based_segment[:conditions].each do |c|
+        condition = SplitIoClient::Condition.new(c, @config)
+        next if condition.empty?
+
+        matches = Helpers::EvaluatorHelper.matcher_type(condition, @segments_repository, @rule_based_segments_repository).match?(args)
+      end
+      @logger.debug("[InRuleSegmentMatcher] #{@segment_name} is in rule based segment -> #{matches}")
+      matches
+    end
+
+    private
+
+    def check_excluded_segments(rule_based_segment, key, args)
+      rule_based_segment[:excluded][:segments].each do |segment|
+        if segment[:type] == SplitIoClient::Engine::Models::SegmentType::STANDARD &&
+           @segments_repository.in_segment?(segment[:name], key)
+          return false
+        end
+        return false if segment[:type] == SplitIoClient::Engine::Models::SegmentType::RULE_BASED_SEGMENT && match_rbs(
+          @rule_based_segments_repository.get_rule_based_segment(segment[:name]), args
+        )
+      end
+      true
+    end
+
+    def update_key(args)
+      if args[:value].nil? || args[:value].empty?
+        args[:matching_key]
+      else
+        args[:value]
+      end
+    end
+
+    def match_rbs(rule_based_segment, args)
+      rbs_matcher = RuleBasedSegmentMatcher.new(@segments_repository, @rule_based_segments_repository,
+                                                rule_based_segment[:name], @config)
+      rbs_matcher.match?(matching_key: args[:matching_key],
+                         bucketing_key: args[:value],
+                         attributes: args[:attributes])
+    end
+  end
+end

data/lib/splitclient-rb/engine/models/label.rb

@@ -6,4 +6,5 @@ class SplitIoClient::Engine::Models::Label
   NOT_IN_SPLIT = 'not in split'.freeze
   NOT_READY = 'not ready'.freeze
   NOT_FOUND = 'definition not found'.freeze
+  PREREQUISITES_NOT_MET = 'prerequisites not met'.freeze
 end

data/lib/splitclient-rb/engine/models/segment_type.rb

@@ -0,0 +1,4 @@
+class SplitIoClient::Engine::Models::SegmentType
+  STANDARD = 'standard'
+  RULE_BASED_SEGMENT = 'rule-based'
+end

data/lib/splitclient-rb/engine/models/split_http_response.rb

@@ -0,0 +1,19 @@
+module SplitIoClient
+  module Engine
+    module Models
+      class SplitHttpResponse
+        attr_accessor :status, :body
+
+        def initialize(status, body, success)
+          @status = status
+          @body = body
+          @success = success
+        end
+
+        def success?
+          @success
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/engine/parser/condition.rb

@@ -230,6 +230,13 @@ module SplitIoClient
       )
     end
 
+    def matcher_in_rule_based_segment(params)
+      matcher = params[:matcher]
+      segment_name = matcher[:userDefinedSegmentMatcherData] && matcher[:userDefinedSegmentMatcherData][:segmentName]
+
+      RuleBasedSegmentMatcher.new(params[:segments_repository], params[:rule_based_segments_repository], segment_name, @config)
+    end
+
     #
     # @return [object] the negate value for this condition
     def negate
@@ -246,6 +253,8 @@ module SplitIoClient
     # @return [void]
     def set_partitions
       partitions_list = []
+      return partitions_list unless @data.key?(:partitions) or @data.key?('partitions')
+      
       @data[:partitions].each do |p|
         partition = SplitIoClient::Partition.new(p)
         partitions_list << partition