splitclient-rb 8.2.0-java → 8.3.0.pre.rc1-java

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

@@ -5,6 +5,10 @@ module SplitIoClient
   GET_TREATMENTS = 'get_treatments'
   GET_TREATMENT_WITH_CONFIG = 'get_treatment_with_config'
   GET_TREATMENTS_WITH_CONFIG = 'get_treatments_with_config'
+  GET_TREATMENTS_BY_FLAG_SET = 'get_treatments_by_flag_set'
+  GET_TREATMENTS_BY_FLAG_SETS = 'get_treatments_by_flag_sets'
+  GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET = 'get_treatments_with_config_by_flag_set'
+  GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS = 'get_treatments_with_config_by_flag_sets'
   TRACK = 'track'
 
   class SplitClient
@@ -14,7 +18,7 @@ module SplitIoClient
     # @param sdk_key [String] the SDK key for your split account
     #
     # @return [SplitIoClient] split.io client instance
-    def initialize(sdk_key, repositories, status_manager, config, impressions_manager, telemetry_evaluation_producer)
+    def initialize(sdk_key, repositories, status_manager, config, impressions_manager, telemetry_evaluation_producer, evaluator, split_validator)
       @api_key = sdk_key
       @splits_repository = repositories[:splits]
       @segments_repository = repositories[:segments]
@@ -25,36 +29,29 @@ module SplitIoClient
       @config = config
       @impressions_manager = impressions_manager
       @telemetry_evaluation_producer = telemetry_evaluation_producer
+      @split_validator = split_validator
+      @evaluator = evaluator
     end
 
     def get_treatment(
         key, split_name, attributes = {}, split_data = nil, store_impressions = true,
         multiple = false, evaluator = nil
       )
-      impressions = []
-      result = treatment(key, split_name, attributes, split_data, store_impressions, multiple, evaluator, GET_TREATMENT, impressions)
-      @impressions_manager.track(impressions)
-
-      if multiple
-        result.tap { |t| t.delete(:config) }
-      else
-        result[:treatment]
-      end
+      result = treatment(key, split_name, attributes, split_data, store_impressions, GET_TREATMENT, multiple)
+      return result.tap { |t| t.delete(:config) } if multiple
+      result[:treatment]
     end
 
     def get_treatment_with_config(
         key, split_name, attributes = {}, split_data = nil, store_impressions = true,
         multiple = false, evaluator = nil
       )
-      impressions = []
-      result = treatment(key, split_name, attributes, split_data, store_impressions, multiple, evaluator, GET_TREATMENT_WITH_CONFIG, impressions)
-      @impressions_manager.track(impressions)
-
-      result
+      treatment(key, split_name, attributes, split_data, store_impressions, GET_TREATMENT_WITH_CONFIG, multiple)
     end
 
     def get_treatments(key, split_names, attributes = {})
       treatments = treatments(key, split_names, attributes)
+
       return treatments if treatments.nil?
       keys = treatments.keys
       treats = treatments.map { |_,t| t[:treatment]  }
@@ -65,6 +62,38 @@ module SplitIoClient
       treatments(key, split_names, attributes, GET_TREATMENTS_WITH_CONFIG)
     end
 
+    def get_treatments_by_flag_set(key, flag_set, attributes = {})
+      valid_flag_set = @split_validator.valid_flag_sets(GET_TREATMENTS_BY_FLAG_SET, [flag_set])
+      split_names = @splits_repository.get_feature_flags_by_sets(valid_flag_set)
+      treatments = treatments(key, split_names, attributes, GET_TREATMENTS_BY_FLAG_SET)
+      return treatments if treatments.nil?
+      keys = treatments.keys
+      treats = treatments.map { |_,t| t[:treatment]  }
+      Hash[keys.zip(treats)]
+    end
+
+    def get_treatments_by_flag_sets(key, flag_sets, attributes = {})
+      valid_flag_set = @split_validator.valid_flag_sets(GET_TREATMENTS_BY_FLAG_SETS, flag_sets)
+      split_names = @splits_repository.get_feature_flags_by_sets(valid_flag_set)
+      treatments = treatments(key, split_names, attributes, GET_TREATMENTS_BY_FLAG_SETS)
+      return treatments if treatments.nil?
+      keys = treatments.keys
+      treats = treatments.map { |_,t| t[:treatment]  }
+      Hash[keys.zip(treats)]
+    end
+
+    def get_treatments_with_config_by_flag_set(key, flag_set, attributes = {})
+      valid_flag_set = @split_validator.valid_flag_sets(GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, [flag_set])
+      split_names = @splits_repository.get_feature_flags_by_sets(valid_flag_set)
+      treatments(key, split_names, attributes, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET)
+    end
+
+    def get_treatments_with_config_by_flag_sets(key, flag_sets, attributes = {})
+      valid_flag_set = @split_validator.valid_flag_sets(GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, flag_sets)
+      split_names = @splits_repository.get_feature_flags_by_sets(valid_flag_set)
+      treatments(key, split_names, attributes, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS)
+    end
+
     def destroy
       @config.logger.info('Split client shutdown started...') if @config.debug_enabled
 
@@ -117,6 +146,12 @@ module SplitIoClient
       false
     end
 
+    def block_until_ready(time = nil)
+      @status_manager.wait_until_ready(time) if @status_manager
+    end
+
+    private
+
     def keys_from_key(key)
       case key
       when Hash
@@ -126,7 +161,7 @@ module SplitIoClient
       end
     end
 
-    def parsed_treatment(multiple, treatment_data)
+    def parsed_treatment(treatment_data, multiple = false)
       if multiple
       {
         treatment: treatment_data[:treatment],
@@ -135,16 +170,20 @@ module SplitIoClient
         config: treatment_data[:config]
       }
       else
-        {
-          treatment: treatment_data[:treatment],
-          config: treatment_data[:config],
-        }
+      {
+        treatment: treatment_data[:treatment],
+        config: treatment_data[:config],
+      }
       end
     end
 
     def sanitize_split_names(calling_method, split_names)
+      return nil if !split_names.is_a?(Array)
+
       split_names.compact.uniq.select do |split_name|
-        if (split_name.is_a?(String) || split_name.is_a?(Symbol)) && !split_name.empty?
+        if split_name.nil?
+          false
+        elsif (split_name.is_a?(String) || split_name.is_a?(Symbol)) && !split_name.empty?
           true
         elsif split_name.is_a?(String) && split_name.empty?
           @config.logger.warn("#{calling_method}: you passed an empty feature_flag_name, flag name must be a non-empty String or a Symbol")
@@ -156,12 +195,6 @@ module SplitIoClient
       end
     end
 
-    def block_until_ready(time = nil)
-      @status_manager.wait_until_ready(time) if @status_manager
-    end
-
-    private
-
     def validate_properties(properties)
       properties_count = 0
       size = 0
@@ -194,39 +227,72 @@ module SplitIoClient
       @config.valid_mode
     end
 
-    def treatments(key, split_names, attributes = {}, calling_method = 'get_treatments')
-      return nil unless @config.split_validator.valid_get_treatments_parameters(calling_method, split_names)
+    def treatments(key, feature_flag_names, attributes = {}, calling_method = 'get_treatments')
+      attributes = {} if attributes.nil?
+      sanitized_feature_flag_names = sanitize_split_names(calling_method, feature_flag_names)
 
-      sanitized_split_names = sanitize_split_names(calling_method, split_names)
+      if sanitized_feature_flag_names.nil?
+        @config.logger.error("#{calling_method}: feature_flag_names must be a non-empty Array")
+        return nil
+      end
 
-      if sanitized_split_names.empty?
+      if sanitized_feature_flag_names.empty?
         @config.logger.error("#{calling_method}: feature_flag_names must be a non-empty Array")
         return {}
       end
 
       bucketing_key, matching_key = keys_from_key(key)
       bucketing_key = bucketing_key ? bucketing_key.to_s : nil
-      matching_key = matching_key ? matching_key.to_s : nil     
+      matching_key = matching_key ? matching_key.to_s : nil
 
-      evaluator = Engine::Parser::Evaluator.new(@segments_repository, @splits_repository, @config, true)
-      start = Time.now
-      impressions = []
-      treatments_labels_change_numbers =
-        @splits_repository.get_splits(sanitized_split_names).each_with_object({}) do |(name, data), memo|
-          memo.merge!(name => treatment(key, name, attributes, data, false, true, evaluator, calling_method, impressions))
-        end
+      if !@config.split_validator.valid_get_treatments_parameters(calling_method, key, sanitized_feature_flag_names, matching_key, bucketing_key, attributes)
+        to_return = Hash.new
+        sanitized_feature_flag_names.each {|name|
+          to_return[name.to_sym] = control_treatment_with_config
+        }
+        return to_return
+      end
 
-      record_latency(calling_method, start)
-      @impressions_manager.track(impressions)
+      if !ready?
+        impressions = []
+        to_return = Hash.new
+        sanitized_feature_flag_names.each {|name|
+          to_return[name.to_sym] = control_treatment_with_config
+          impressions << @impressions_manager.build_impression(matching_key, bucketing_key, name.to_sym, control_treatment_with_config.merge({ label: Engine::Models::Label::NOT_READY }), { attributes: attributes, time: nil })
+        }
+        @impressions_manager.track(impressions)
+        return to_return
+      end
 
-      split_names_keys = treatments_labels_change_numbers.keys
-      treatments = treatments_labels_change_numbers.values.map do |v|
+      valid_feature_flag_names = []
+      sanitized_feature_flag_names.each { |feature_flag_name|
+        valid_feature_flag_names << feature_flag_name unless feature_flag_name.nil?
+      }
+      start = Time.now
+      impressions_total = []
+
+      feature_flags = @splits_repository.splits(valid_feature_flag_names)
+      treatments = Hash.new
+      invalid_treatments = Hash.new
+      feature_flags.each do |key, feature_flag|
+        if feature_flag.nil?
+          @config.logger.warn("#{calling_method}: you passed #{key} that " \
+            'does not exist in this environment, please double check what feature flags exist in the Split user interface')
+            invalid_treatments[key] = control_treatment_with_config
+          next
+        end
+        treatments_labels_change_numbers, impressions = evaluate_treatment(feature_flag, key, bucketing_key, matching_key, attributes, calling_method)
+        impressions_total.concat(impressions) unless impressions.nil?
+        treatments[key] =
         {
-          treatment: v[:treatment],
-          config: v[:config]
+          treatment: treatments_labels_change_numbers[:treatment],
+          config: treatments_labels_change_numbers[:config]
         }
       end
-      Hash[split_names_keys.zip(treatments)]
+      record_latency(calling_method, start)
+      @impressions_manager.track(impressions_total) unless impressions_total.empty?
+
+      treatments.merge(invalid_treatments)
     end
 
     #
@@ -237,72 +303,74 @@ module SplitIoClient
     # @param attributes [Hash] attributes to pass to the treatment class
     # @param split_data [Hash] split data, when provided this method doesn't fetch splits_repository for the data
     # @param store_impressions [Boolean] impressions aren't stored if this flag is false
-    # @param multiple [Hash] internal flag to signal if method is called by get_treatments
-    # @param evaluator [Evaluator] Evaluator class instance, used to cache treatments
-    #
     # @return [String/Hash] Treatment as String or Hash of treatments in case of array of features
-    def treatment(
-        key, split_name, attributes = {}, split_data = nil, store_impressions = true,
-        multiple = false, evaluator = nil, calling_method = 'get_treatment', impressions = []
-      )
-      control_treatment = { treatment: Engine::Models::Treatment::CONTROL }
-
+    def treatment(key, feature_flag_name, attributes = {}, split_data = nil, store_impressions = true,
+                   calling_method = 'get_treatment', multiple = false)
+      impressions = []
       bucketing_key, matching_key = keys_from_key(key)
 
       attributes = parsed_attributes(attributes)
 
-      return parsed_treatment(multiple, control_treatment) unless valid_client && @config.split_validator.valid_get_treatment_parameters(calling_method, key, split_name, matching_key, bucketing_key, attributes)
+      return parsed_treatment(control_treatment, multiple) unless valid_client && @config.split_validator.valid_get_treatment_parameters(calling_method, key, feature_flag_name, matching_key, bucketing_key, attributes)
 
       bucketing_key = bucketing_key ? bucketing_key.to_s : nil
       matching_key = matching_key.to_s
-      sanitized_split_name = split_name.to_s.strip
+      sanitized_feature_flag_name = feature_flag_name.to_s.strip
 
-      if split_name.to_s != sanitized_split_name
-        @config.logger.warn("#{calling_method}: feature_flag_name #{split_name} has extra whitespace, trimming")
-        split_name = sanitized_split_name
+      if feature_flag_name.to_s != sanitized_feature_flag_name
+        @config.logger.warn("#{calling_method}: feature_flag_name #{feature_flag_name} has extra whitespace, trimming")
+        feature_flag_name = sanitized_feature_flag_name
       end
 
-      evaluator ||= Engine::Parser::Evaluator.new(@segments_repository, @splits_repository, @config)
+      feature_flag = @splits_repository.get_split(feature_flag_name)
+      treatments, impressions = evaluate_treatment(feature_flag, feature_flag_name, bucketing_key, matching_key, attributes, calling_method, multiple)
 
+      @impressions_manager.track(impressions) unless impressions.nil?
+      treatments
+    end
+
+    def evaluate_treatment(feature_flag, feature_flag_name, bucketing_key, matching_key, attributes, calling_method, multiple = false)
+      impressions = []
       begin
         start = Time.now
-
-        split = multiple ? split_data : @splits_repository.get_split(split_name)
-
-        if split.nil? && ready?
-          @config.logger.warn("#{calling_method}: you passed #{split_name} that " \
+        if feature_flag.nil? && ready?
+          @config.logger.warn("#{calling_method}: you passed #{feature_flag_name} that " \
             'does not exist in this environment, please double check what feature flags exist in the Split user interface')
-
-          return parsed_treatment(multiple, control_treatment.merge({ label: Engine::Models::Label::NOT_FOUND }))
+          return parsed_treatment(control_treatment.merge({ label: Engine::Models::Label::NOT_FOUND }), multiple), nil
         end
-
         treatment_data =
-        if !split.nil? && ready?
-          evaluator.call(
-            { bucketing_key: bucketing_key, matching_key: matching_key }, split, attributes
+        if !feature_flag.nil? && ready?
+          @evaluator.evaluate_feature_flag(
+            { bucketing_key: bucketing_key, matching_key: matching_key }, feature_flag, attributes
           )
         else
           @config.logger.error("#{calling_method}: the SDK is not ready, the operation cannot be executed")
-
           control_treatment.merge({ label: Engine::Models::Label::NOT_READY })
         end
 
-        record_latency(calling_method, start) unless multiple
-        
-        impression = @impressions_manager.build_impression(matching_key, bucketing_key, split_name, treatment_data, { attributes: attributes, time: nil })
+        record_latency(calling_method, start)
+        impression = @impressions_manager.build_impression(matching_key, bucketing_key, feature_flag_name, treatment_data, { attributes: attributes, time: nil })
         impressions << impression unless impression.nil?
       rescue StandardError => e
         @config.log_found_exception(__method__.to_s, e)
 
         record_exception(calling_method)
 
-        impression = @impressions_manager.build_impression(matching_key, bucketing_key, split_name, control_treatment, { attributes: attributes, time: nil })
+        impression = @impressions_manager.build_impression(matching_key, bucketing_key, feature_flag_name, control_treatment, { attributes: attributes, time: nil })
         impressions << impression unless impression.nil?
 
-        return parsed_treatment(multiple, control_treatment.merge({ label: Engine::Models::Label::EXCEPTION }))
+        return parsed_treatment(control_treatment.merge({ label: Engine::Models::Label::EXCEPTION }), multiple), impressions
       end
 
-      parsed_treatment(multiple, treatment_data)
+      return parsed_treatment(treatment_data, multiple), impressions
+    end
+
+    def control_treatment
+      { treatment: Engine::Models::Treatment::CONTROL }
+    end
+
+    def control_treatment_with_config
+      {:treatment => Engine::Models::Treatment::CONTROL, :config => nil}
     end
 
     def variable_size(value)
@@ -320,7 +388,7 @@ module SplitIoClient
 
     def record_latency(method, start)
       bucket = BinarySearchLatencyTracker.get_bucket((Time.now - start) * 1000.0)
-      
+
       case method
       when GET_TREATMENT
         @telemetry_evaluation_producer.record_latency(Telemetry::Domain::Constants::TREATMENT, bucket)
@@ -330,9 +398,17 @@ module SplitIoClient
         @telemetry_evaluation_producer.record_latency(Telemetry::Domain::Constants::TREATMENT_WITH_CONFIG, bucket)
       when GET_TREATMENTS_WITH_CONFIG
         @telemetry_evaluation_producer.record_latency(Telemetry::Domain::Constants::TREATMENTS_WITH_CONFIG, bucket)
+      when GET_TREATMENTS_BY_FLAG_SET
+        @telemetry_evaluation_producer.record_latency(Telemetry::Domain::Constants::TREATMENTS_BY_FLAG_SET, bucket)
+      when GET_TREATMENTS_BY_FLAG_SETS
+        @telemetry_evaluation_producer.record_latency(Telemetry::Domain::Constants::TREATMENTS_BY_FLAG_SETS, bucket)
+      when GET_TREATMENT_WITH_CONFIG
+        @telemetry_evaluation_producer.record_latency(Telemetry::Domain::Constants::TREATMENT_WITH_CONFIG, bucket)
+      when GET_TREATMENTS_WITH_CONFIG
+        @telemetry_evaluation_producer.record_latency(Telemetry::Domain::Constants::TREATMENTS_WITH_CONFIG, bucket)
       when TRACK
         @telemetry_evaluation_producer.record_latency(Telemetry::Domain::Constants::TRACK, bucket)
-      end      
+      end
     end
 
     def record_exception(method)
@@ -345,6 +421,14 @@ module SplitIoClient
         @telemetry_evaluation_producer.record_exception(Telemetry::Domain::Constants::TREATMENT_WITH_CONFIG)
       when GET_TREATMENTS_WITH_CONFIG
         @telemetry_evaluation_producer.record_exception(Telemetry::Domain::Constants::TREATMENTS_WITH_CONFIG)
+      when GET_TREATMENTS_BY_FLAG_SET
+        @telemetry_evaluation_producer.record_exception(Telemetry::Domain::Constants::TREATMENTS_BY_FLAG_SET)
+      when GET_TREATMENTS_BY_FLAG_SETS
+        @telemetry_evaluation_producer.record_exception(Telemetry::Domain::Constants::TREATMENTS_BY_FLAG_SETS)
+      when GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET
+        @telemetry_evaluation_producer.record_exception(Telemetry::Domain::Constants::TREATMENTS_WITH_CONFIG_BY_FLAG_SET)
+      when GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS
+        @telemetry_evaluation_producer.record_exception(Telemetry::Domain::Constants::TREATMENTS_WITH_CONFIG_BY_FLAG_SETS)
       when TRACK
         @telemetry_evaluation_producer.record_exception(Telemetry::Domain::Constants::TRACK)
       end

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

@@ -8,17 +8,22 @@ module SplitIoClient
         super(config)
         @api_key = api_key
         @telemetry_runtime_producer = telemetry_runtime_producer
+        @flag_sets_filter = @config.flag_sets_filter
       end
 
-      def since(since, fetch_options = { cache_control_headers: false, till: nil })
+      def since(since, fetch_options = { cache_control_headers: false, till: nil, sets: nil })
         start = Time.now
-        
+
         params = { since: since }
         params[:till] = fetch_options[:till] unless fetch_options[:till].nil?
+        params[:sets] = @flag_sets_filter.join(",") unless @flag_sets_filter.empty?
         response = get_api("#{@config.base_uri}/splitChanges", @api_key, params, fetch_options[:cache_control_headers])
+        if response.status == 414
+          @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.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

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

@@ -12,7 +12,7 @@ module SplitIoClient
 
     def match?(args)
       keys = { matching_key: args[:matching_key], bucketing_key: args[:bucketing_key] }
-      evaluate = args[:evaluator].call(keys, @feature_flag, args[:attributes])
+      evaluate = args[:evaluator].evaluate_feature_flag(keys, @feature_flag, args[:attributes])
       matches = @treatments.include?(evaluate[:treatment])
       @logger.log_if_debug("[dependencyMatcher] Parent feature flag #{@feature_flag} evaluated to #{evaluate[:treatment]} \
         with label #{evaluate[:label]}. #{@feature_flag} evaluated treatment is part of [#{@treatments}] ? #{matches}.")

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

@@ -2,41 +2,35 @@ module SplitIoClient
   module Engine
     module Parser
       class Evaluator
-        def initialize(segments_repository, splits_repository, config, multiple = false)
+        def initialize(segments_repository, splits_repository, config)
           @splits_repository = splits_repository
           @segments_repository = segments_repository
-          @multiple = multiple
           @config = config
-          @cache = {}
         end
 
-        def call(keys, split, attributes = nil)
+        def evaluate_feature_flag(keys, feature_flag, attributes = nil)
           # DependencyMatcher here, split is actually a split_name in this case
-          cache_result = split.is_a? String
-          split = @splits_repository.get_split(split) if cache_result
-          digest = Digest::MD5.hexdigest("#{{matching_key: keys[:matching_key]}}#{split}#{attributes}")
+          cache_result = feature_flag.is_a? String
+          feature_flag = @splits_repository.get_split(feature_flag) if cache_result
+          evaluate_treatment(keys, feature_flag, attributes)
+        end
 
-          if Models::Split.archived?(split)
-            return treatment_hash(Models::Label::ARCHIVED, Models::Treatment::CONTROL, split[:changeNumber])
-          end
+        private
 
-          treatment = if Models::Split.matchable?(split)
-            if @multiple && @cache[digest]
-              @cache[digest]
-            else
-              match(split, keys, attributes)
-            end
-          else
-            treatment_hash(Models::Label::KILLED, split[:defaultTreatment], split[:changeNumber], split_configurations(split[:defaultTreatment], split))
+        def evaluate_treatment(keys, feature_flag, attributes)
+          if Models::Split.archived?(feature_flag)
+            return treatment_hash(Models::Label::ARCHIVED, Models::Treatment::CONTROL, feature_flag[:changeNumber])
           end
 
-          @cache[digest] = treatment if cache_result
+          treatment = if Models::Split.matchable?(feature_flag)
+                        match(feature_flag, keys, attributes)
+                      else
+                        treatment_hash(Models::Label::KILLED, feature_flag[:defaultTreatment], feature_flag[:changeNumber], split_configurations(feature_flag[:defaultTreatment], feature_flag))
+                      end
 
           treatment
         end
 
-        private
-
         def split_configurations(treatment, split)
           return nil if split[:configurations].nil?
           split[:configurations][treatment.to_sym]

data/lib/splitclient-rb/exceptions.rb

@@ -12,4 +12,15 @@ module SplitIoClient
       @event = event
     end
   end
+
+  class ApiException < SplitIoError
+    def initialize(msg, exception_code)
+      @@exception_code = exception_code
+      super(msg)
+    end
+    def exception_code
+      @@exception_code
+    end
+  end
+
 end

data/lib/splitclient-rb/helpers/repository_helper.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Helpers
+    class RepositoryHelper
+      def self.update_feature_flag_repository(feature_flag_repository, feature_flags, change_number, config)
+        to_add = []
+        to_delete = []
+        feature_flags.each do |feature_flag|
+          if Engine::Models::Split.archived?(feature_flag) || !feature_flag_repository.flag_set_filter.intersect?(feature_flag[:sets])
+            config.logger.debug("removing feature flag from store(#{feature_flag})") if config.debug_enabled
+            to_delete.push(feature_flag)
+            next
+          end
+
+          config.logger.debug("storing feature flag (#{feature_flag[:name]})") if config.debug_enabled
+          to_add.push(feature_flag)
+        end
+        feature_flag_repository.update(to_add, to_delete, change_number)
+      end
+    end
+  end
+end

data/lib/splitclient-rb/split_config.rb

@@ -122,6 +122,7 @@ module SplitIoClient
       @on_demand_fetch_retry_delay_seconds = SplitConfig.default_on_demand_fetch_retry_delay_seconds
       @on_demand_fetch_max_retries = SplitConfig.default_on_demand_fetch_max_retries
 
+      @flag_sets_filter = SplitConfig.sanitize_flag_set_filter(opts[:flag_sets_filter], @split_validator, opts[:cache_adapter], @logger)
       startup_log
     end
 
@@ -287,7 +288,7 @@ module SplitIoClient
 
     attr_accessor :sdk_start_time
 
-    attr_accessor :on_demand_fetch_retry_delay_seconds    
+    attr_accessor :on_demand_fetch_retry_delay_seconds
     attr_accessor :on_demand_fetch_max_retries
 
     attr_accessor :unique_keys_refresh_rate
@@ -296,6 +297,12 @@ module SplitIoClient
 
     attr_accessor :counter_refresh_rate
 
+    #
+    # Flagsets filter
+    #
+    # @return [Array]
+    attr_accessor :flag_sets_filter
+
     def self.default_counter_refresh_rate(adapter)
       return 300 if adapter == :redis # Send bulk impressions count - Refresh rate: 5 min.
 
@@ -325,9 +332,9 @@ module SplitIoClient
       end
     end
 
-    def self.init_impressions_refresh_rate(impressions_mode, refresh_rate, default_rate)      
+    def self.init_impressions_refresh_rate(impressions_mode, refresh_rate, default_rate)
       return (refresh_rate.nil? || refresh_rate <= 0 ? default_rate : refresh_rate) if impressions_mode == :debug
-      
+
       return refresh_rate.nil? || refresh_rate <= 0 ? SplitConfig.default_impressions_refresh_rate_optimized : [default_rate, refresh_rate].max
     end
 
@@ -482,7 +489,7 @@ module SplitIoClient
     end
 
     def self.default_telemetry_refresh_rate
-      3600      
+      3600
     end
 
     def self.default_unique_keys_refresh_rate(adapter)
@@ -513,6 +520,15 @@ module SplitIoClient
       5
     end
 
+    def self.sanitize_flag_set_filter(flag_sets, validator, adapter, logger)
+      return [] if flag_sets.nil?
+      if adapter == :redis
+        logger.warn("config: : flag_sets_filter is not applicable for Consumer modes where the SDK does not keep rollout data in sync. FlagSet filter was discarded")
+        return []
+      end
+      return validator.valid_flag_sets(:config, flag_sets)
+    end
+
     #
     # The default logger object
     #
@@ -646,7 +662,7 @@ module SplitIoClient
           return 'NA'.freeze
         end
       end
-      
+
       return ''.freeze
     end
 
@@ -656,7 +672,7 @@ module SplitIoClient
     # @return [string]
     def self.machine_ip(ip_addresses_enabled, ip, adapter)
       if ip_addresses_enabled
-        begin          
+        begin
           return ip unless ip.nil? || ip.to_s.empty?
 
           loopback_ip = Socket.ip_address_list.find { |ip| ip.ipv4_loopback? }