splitclient-rb 6.3.0 → 8.11.0

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

@@ -6,42 +6,17 @@ module SplitIoClient
       # Repository which forwards impressions interface to the selected adapter
       class ImpressionsRepository < Repository
         extend Forwardable
-        def_delegators :@adapter, :add, :add_bulk, :batch, :clear, :empty?
+        def_delegators :@repository, :add_bulk, :batch, :clear, :empty?
 
-        def initialize(adapter)
-          @adapter = case adapter.class.to_s
+        def initialize(config)
+          super(config)
+          @repository = case @config.impressions_adapter.class.to_s
                      when 'SplitIoClient::Cache::Adapters::MemoryAdapter'
-                       Repositories::Impressions::MemoryRepository.new(adapter)
+                       Repositories::Impressions::MemoryRepository.new(@config)
                      when 'SplitIoClient::Cache::Adapters::RedisAdapter'
-                       Repositories::Impressions::RedisRepository.new(adapter)
+                       Repositories::Impressions::RedisRepository.new(@config)
                      end
         end
-
-        protected
-
-        def impression_data(matching_key, bucketing_key, split_name, treatment, timestamp)
-          {
-            k: matching_key,
-            b: bucketing_key,
-            f: split_name,
-            t: treatment[:treatment],
-            r: applied_rule(treatment[:label]),
-            c: treatment[:change_number],
-            m: timestamp
-          }
-        end
-
-        def metadata
-          {
-            s: "#{SplitIoClient.configuration.language}-#{SplitIoClient.configuration.version}",
-            i: SplitIoClient.configuration.machine_ip,
-            n: SplitIoClient.configuration.machine_name
-          }
-        end
-
-        def applied_rule(label)
-          SplitIoClient.configuration.labels_enabled ? label : nil
-        end
       end
     end
   end

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

@@ -1,6 +1,11 @@
 module SplitIoClient
   module Cache
     class Repository
+
+      def initialize(config)
+        @config = config
+      end
+
       def set_string(key, str)
         @adapter.set_string(namespace_key(key), str)
       end
@@ -12,11 +17,7 @@ module SplitIoClient
       protected
 
       def namespace_key(key = '')
-        "#{SplitIoClient.configuration.redis_namespace}#{key}"
-      end
-
-      def impressions_metrics_key(key)
-        namespace_key("/#{SplitIoClient.configuration.language}-#{SplitIoClient.configuration.version}/#{SplitIoClient.configuration.machine_ip}/#{key}")
+        "#{@config.redis_namespace}#{key}"
       end
     end
   end

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

@@ -0,0 +1,136 @@
+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, internal_events_queue)
+          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
+          @internal_events_queue = internal_events_queue
+        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)
+
+          if to_add.length > 0 || to_delete.length > 0
+            @internal_events_queue.push(
+              SplitIoClient::Engine::Models::SdkInternalEventNotification.new(
+                SplitIoClient::Engine::Models::SdkInternalEvent::RB_SEGMENTS_UPDATED, 
+                SplitIoClient::Engine::Models::EventsMetadata.new(
+                  SplitIoClient::Engine::Models::SdkEventType::SEGMENTS_UPDATE,
+                  []
+                )
+              )
+            )
+          end
+        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 segment_names.to_set.subset?(rule_based_segment_names.to_set)
+        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

@@ -6,14 +6,16 @@ module SplitIoClient
 
         attr_reader :adapter
 
-        def initialize(adapter)
-          @adapter = case adapter.class.to_s
+        def initialize(config, internal_events_queue)
+          super(config)
+          @adapter = case @config.cache_adapter.class.to_s
           when 'SplitIoClient::Cache::Adapters::RedisAdapter'
-            SplitIoClient::Cache::Adapters::CacheAdapter.new(adapter)
+            SplitIoClient::Cache::Adapters::CacheAdapter.new(@config)
           else
-            adapter
+            @config.cache_adapter
           end
-          @adapter.set_bool(namespace_key('.ready'), false) unless SplitIoClient.configuration.mode.equal?(:consumer)
+          @adapter.set_bool(namespace_key('.ready'), false) unless @config.mode.equal?(:consumer)
+          @internal_events_queue = internal_events_queue
         end
 
         # Receives segment data, adds and removes segements from the store
@@ -21,9 +23,20 @@ module SplitIoClient
           name = segment[:name]
 
           @adapter.initialize_set(segment_data(name)) unless @adapter.exists?(segment_data(name))
-
+          @config.logger.debug(segment)
           add_keys(name, segment[:added])
           remove_keys(name, segment[:removed])
+          if segment[:added].length > 0 || segment[:removed].length > 0
+            @internal_events_queue.push(
+              SplitIoClient::Engine::Models::SdkInternalEventNotification.new(
+                SplitIoClient::Engine::Models::SdkInternalEvent::SEGMENTS_UPDATED, 
+                SplitIoClient::Engine::Models::EventsMetadata.new(
+                  SplitIoClient::Engine::Models::SdkEventType::SEGMENTS_UPDATE,
+                  []
+                )
+              )
+            )
+          end
         end
 
         def get_segment_keys(name)
@@ -62,6 +75,33 @@ module SplitIoClient
           @adapter.clear(namespace_key)
         end
 
+        def segments_count
+          used_segment_names.length
+        end
+
+        def segment_keys_count
+          names = used_segment_names
+
+          keys = 0
+
+          names.each do |name|
+            segment_keys = get_segment_keys(name)            
+            keys += segment_keys.length
+          end
+          
+          keys
+        rescue StandardError => e
+          @config.log_found_exception(__method__.to_s, e)
+          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

@@ -5,43 +5,67 @@ module SplitIoClient
     module Repositories
       class SplitsRepository < 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
+              }]
+          },
+          partitions: [
+              {
+              treatment: "control",
+              size: 100
+              }
+          ],
+          label: "targeting rule type unsupported by sdk"
+        }]
+        TILL_PREFIX = '.splits.till'
+        SPLIT_PREFIX = '.split.'
+        READY_PREFIX = '.splits.ready'
 
-        def initialize(adapter)
-          @adapter = case adapter.class.to_s
+        def initialize(config, flag_sets_repository, flag_set_filter, internal_events_queue)
+          super(config)
+          @tt_cache = {}
+          @adapter = case @config.cache_adapter.class.to_s
           when 'SplitIoClient::Cache::Adapters::RedisAdapter'
-            SplitIoClient::Cache::Adapters::CacheAdapter.new(adapter)
+            SplitIoClient::Cache::Adapters::CacheAdapter.new(@config)
           else
-            adapter
-          end
-          unless SplitIoClient.configuration.mode.equal?(:consumer)
-            @adapter.set_string(namespace_key('.splits.till'), '-1')
-            @adapter.initialize_map(namespace_key('.segments.registered'))
+            @config.cache_adapter
           end
+          @flag_sets = flag_sets_repository
+          @flag_set_filter = flag_set_filter
+          @internal_events_queue = internal_events_queue
+          initialize_keys
         end
 
-        def add_split(split)
-          return unless split[:name]
-
-          @adapter.set_string(namespace_key(".split.#{split[:name]}"), split.to_json)
-        end
+        def update(to_add, to_delete, new_change_number)
+          to_add.each{ |feature_flag| add_feature_flag(feature_flag) }
+          to_delete.each{ |feature_flag| remove_feature_flag(feature_flag) }
+          set_change_number(new_change_number)
 
-        def remove_split(name)
-          @adapter.delete(namespace_key(".split.#{name}"))
-        end
-
-        def get_splits(names)
-          splits = {}
-          split_names = names.map { |name| namespace_key(".split.#{name}") }
-          splits.merge!(
-            @adapter
-              .multiple_strings(split_names)
-              .map { |name, data| [name.gsub(namespace_key('.split.'), ''), data] }.to_h
-          )
-
-          splits.map do |name, data|
-            parsed_data = data ? JSON.parse(data, symbolize_names: true) : nil
-            [name.to_sym, parsed_data]
-          end.to_h
+          if to_add.length > 0 || to_delete.length > 0
+            @internal_events_queue.push(
+              SplitIoClient::Engine::Models::SdkInternalEventNotification.new(
+                SplitIoClient::Engine::Models::SdkInternalEvent::FLAGS_UPDATED, 
+                SplitIoClient::Engine::Models::EventsMetadata.new(
+                  SplitIoClient::Engine::Models::SdkEventType::FLAG_UPDATE,
+                  to_add.map {|flag| flag[:name]} | to_delete.map {|flag| flag[:name]}
+                )
+              )
+            )
+          end
         end
 
         def get_split(name)
@@ -50,28 +74,42 @@ module SplitIoClient
           JSON.parse(split, symbolize_names: true) if split
         end
 
-        def splits
-          splits_hash = {}
-
-          split_names.each do |name|
-            splits_hash[name] = get_split(name)
+        def splits(filtered_names=nil)
+          symbolize = true
+          if filtered_names.nil?
+            filtered_names = split_names
+            symbolize = false
           end
+          get_splits(filtered_names, symbolize)
+        end
 
-          splits_hash
+        def traffic_type_exists(tt_name)
+          case @adapter
+          when SplitIoClient::Cache::Adapters::CacheAdapter
+            tt_count = @adapter.string(namespace_key(".trafficType.#{tt_name}"))
+            begin
+              !tt_count.nil? && Integer(tt_count, 10) > 0
+            rescue StandardError => e
+              @config.logger.error("Error while parsing Traffic Type count: #{e.message}")
+              false
+            end
+          else
+            @tt_cache.key?(tt_name) && @tt_cache[tt_name] > 0
+          end
         end
 
         # 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)
@@ -87,19 +125,170 @@ 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)
+          split = get_split(split_name)
+
+          return if split.nil?
+
+          split[:killed] = true
+          split[:defaultTreatment] = default_treatment
+          split[:changeNumber] = change_number
+
+          @adapter.set_string(namespace_key(".split.#{split_name}"), split.to_json)
+          @internal_events_queue.push(
+            SplitIoClient::Engine::Models::SdkInternalEventNotification.new(
+              SplitIoClient::Engine::Models::SdkInternalEvent::FLAG_KILLED_NOTIFICATION, 
+              SplitIoClient::Engine::Models::EventsMetadata.new(
+                SplitIoClient::Engine::Models::SdkEventType::FLAG_UPDATE,
+                [split_name]
+              )
+            )
+          )
+        end
+
+        def splits_count
+          split_names.length
+        end
+
+        def get_feature_flags_by_sets(flag_sets)
+          sets_to_fetch = Array.new
+          flag_sets.each do |flag_set|
+            unless @flag_sets.flag_set_exist?(flag_set)
+              @config.logger.warn("Flag set #{flag_set} is not part of the configured flag set list, ignoring it.")
+              next
+            end
+            sets_to_fetch.push(flag_set)
+          end
+          @flag_sets.get_flag_sets(flag_sets)
+        end
+
+        def is_flag_set_exist(flag_set)
+          @flag_sets.flag_set_exist?(flag_set)
+        end
+
+        def flag_set_filter
+          @flag_set_filter
+        end
+
+        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])
+
+          if(!existing_split)
+            increase_tt_name_count(split[:trafficTypeName])
+          elsif(existing_split[:trafficTypeName] != split[:trafficTypeName])
+            increase_tt_name_count(split[:trafficTypeName])
+            decrease_tt_name_count(existing_split[:trafficTypeName])
+            remove_from_flag_sets(existing_split)
+          elsif(existing_split[:sets] != split[:sets])
+            remove_from_flag_sets(existing_split)
+          end
+
+          if check_undefined_matcher(split)
+            @config.logger.warn("Feature Flag #{split[:name]} has undefined matcher, setting conditions to default template.")
+            split[:conditions] = SplitsRepository::DEFAULT_CONDITIONS_TEMPLATE
+          end
+          if !split[:sets].nil?
+            for flag_set in split[:sets]
+              if !@flag_sets.flag_set_exist?(flag_set)
+                if @flag_set_filter.should_filter?
+                  next
+                end
+                @flag_sets.add_flag_set(flag_set)
+              end
+              @flag_sets.add_feature_flag_to_flag_set(flag_set, split[:name])
+            end
+          end
+
+          @adapter.set_string(namespace_key(".split.#{split[:name]}"), split.to_json)
+        end
+
+        def check_undefined_matcher(split)
+          for condition in split[: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 #{split[:name]}")
+                return true
+              end
+            end
+          end
+          return false
+        end
+
+        def remove_feature_flag(split)
+          decrease_tt_name_count(split[:trafficTypeName])
+          remove_from_flag_sets(split)
+          @adapter.delete(namespace_key(".split.#{split[:name]}"))
+        end
+
+        def get_splits(names, symbolize_names = true)
+          splits = {}
+          split_names = names.map { |name| namespace_key(".split.#{name}") }
+          splits.merge!(
+            @adapter
+              .multiple_strings(split_names)
+              .map { |name, data| [name.gsub(namespace_key('.split.'), ''), data] }.to_h
+          )
+
+          splits.map do |name, data|
+            parsed_data = data ? JSON.parse(data, symbolize_names: true) : nil
+            split_name = symbolize_names ? name.to_sym : name
+            [split_name, parsed_data]
+          end.to_h
+        end
+
+        def remove_from_flag_sets(feature_flag)
+          name = feature_flag[:name]
+          flag_sets = get_split(name)[:sets] if exists?(name)
+          if !flag_sets.nil?
+            for flag_set in flag_sets
+              @flag_sets.remove_feature_flag_from_flag_set(flag_set, feature_flag[:name])
+              if is_flag_set_exist(flag_set) && @flag_sets.get_flag_sets([flag_set]).length == 0 && !@flag_set_filter.should_filter?
+                  @flag_sets.remove_flag_set(flag_set)
+              end
+            end
+          end
+        end
+
+        def increase_tt_name_count(tt_name)
+          return unless tt_name
+
+          @tt_cache[tt_name] = 0 unless @tt_cache[tt_name]
+          @tt_cache[tt_name] += 1
+        end
+
+        def decrease_tt_name_count(tt_name)
+          return unless tt_name
+
+          @tt_cache[tt_name] -= 1 if @tt_cache[tt_name]
+          @tt_cache.delete(tt_name) if @tt_cache[tt_name] == 0
         end
       end
     end

data/lib/splitclient-rb/cache/routers/impression_router.rb

@@ -2,8 +2,9 @@ module SplitIoClient
   class ImpressionRouter
     attr_reader :router_thread
 
-    def initialize
-      @listener = SplitIoClient.configuration.impression_listener
+    def initialize(config)
+      @config = config
+      @listener = @config.impression_listener
 
       return unless @listener
 
@@ -17,39 +18,40 @@ module SplitIoClient
       end
     end
 
-    def add(impression)
-      enqueue(impression)
-    end
-
     def add_bulk(impressions)
-      impressions[:split_names].each do |split_name|
-        enqueue(
-          split_name: split_name.to_s,
-          matching_key: impressions[:matching_key],
-          bucketing_key: impressions[:bucketing_key],
-          treatment: {
-            label: impressions[:treatments_labels_change_numbers][split_name.to_sym][:label],
-            treatment: impressions[:treatments_labels_change_numbers][split_name.to_sym][:treatment],
-            change_number: impressions[:treatments_labels_change_numbers][split_name.to_sym][:change_number]
-          },
-          attributes: impressions[:attributes]
-        )
+      impressions.each do |impression|
+        enqueue(impression)
       end
     end
 
     private
 
     def enqueue(impression)
-      @queue.push(impression) if @listener
+      imp = {
+        split_name: impression[:i][:f],
+        matching_key: impression[:i][:k],
+        bucketing_key: impression[:i][:b],
+        time: impression[:i][:m],
+        treatment: {
+          label: impression[:i][:r],
+          treatment: impression[:i][:t],
+          change_number: impression[:i][:c]
+        },
+        previous_time: impression[:i][:pt],
+        attributes: impression[:attributes]
+      }
+      @queue.push(imp) if @listener
+    rescue StandardError => e
+      @config.log_found_exception(__method__.to_s, e)
     end
 
     def router_thread
-      SplitIoClient.configuration.threads[:impression_router] = Thread.new do
+      @config.threads[:impression_router] = Thread.new do
         loop do
           begin
             @listener.log(@queue.pop)
-          rescue StandardError => error
-            SplitIoClient.configuration.log_found_exception(__method__.to_s, error)
+          rescue StandardError => e
+            @config.log_found_exception(__method__.to_s, e)
           end
         end
       end