splitclient-rb 6.3.0 → 8.11.0

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

@@ -0,0 +1,70 @@
+module SplitIoClient
+  module Cache
+    module Fetchers
+      class SplitFetcher
+        attr_reader :splits_repository, :rule_based_segments_repository
+
+        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
+          @telemetry_runtime_producer = telemetry_runtime_producer
+        end
+
+        def call
+          if ENV['SPLITCLIENT_ENV'] == 'test'
+            fetch_splits
+            return
+          end
+
+          splits_thread
+        end
+
+        def fetch_splits(fetch_options = { cache_control_headers: false, till: nil })
+          @semaphore.synchronize do
+            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 }
+          end
+        rescue StandardError => e
+          @config.log_found_exception(__method__.to_s, e)
+          { segment_names: [], success: false }
+        end
+
+        def stop_splits_thread
+          SplitIoClient::Helpers::ThreadHelper.stop(:split_fetcher, @config)
+        end
+
+        private
+
+        def splits_thread
+          @config.threads[:split_fetcher] = Thread.new do
+            @config.logger.info('Starting feature flags fetcher service') if @config.debug_enabled
+            loop do
+              fetch_splits
+
+              sleep_for = SplitIoClient::Cache::Stores::StoreUtils.random_interval(@config.features_refresh_rate)
+              @config.logger.debug("Feature flags fetcher is sleeping for: #{sleep_for} seconds") if @config.debug_enabled
+              sleep(sleep_for)
+            end
+          end
+        end
+
+        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
+          @splits_api ||= SplitIoClient::Api::Splits.new(@api_key, @config, @telemetry_runtime_producer)
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/cache/filter/bloom_filter.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'bitarray'
+
+module SplitIoClient
+  module Cache
+    module Filter
+      class BloomFilter
+        def initialize(capacity, false_positive_probability = 0.001)
+          @capacity = capacity.round
+          @m = best_m(capacity, false_positive_probability)
+          reset_filter
+          @k = best_k(capacity)
+        end
+
+        def add(string)
+          return false if contains?(string)
+
+          positions = hashes(string)
+          positions.each { |position| @ba[position] = 1 }
+
+          true
+        end
+
+        def contains?(string)
+          !hashes(string).any? { |ea| @ba[ea] == 0 }
+        end
+
+        def clear
+          @ba = nil
+          reset_filter
+        end
+
+        private
+
+        def reset_filter
+          @ba = BitArray.new(@m.round)
+        end
+
+        # m is the required number of bits in the array
+        def best_m(capacity, false_positive_probability)
+          -(capacity * Math.log(false_positive_probability)) / (Math.log(2) ** 2)
+        end
+
+        # k is the number of hash functions that minimizes the probability of false positives
+        def best_k(capacity)
+          (Math.log(2) * (@ba.size / capacity)).round
+        end
+
+        def hashes(data)
+          m = @ba.size
+          h = Digest::MD5.hexdigest(data.to_s).to_i(16)
+          x = h % m
+          h /= m
+          y = h % m
+          h /= m
+          z = h % m
+          [x] + 1.upto(@k - 1).collect do |i|
+            x = (x + y) % m
+            y = (y + z) % m
+            x
+          end
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/cache/filter/filter_adapter.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Cache
+    module Filter
+      class FilterAdapter
+        def initialize(config, filter)
+          @config = config
+          @filter = filter
+        end
+
+        def add(feature_name, key)
+          @filter.add("#{feature_name}#{key}")
+        rescue StandardError => e
+          @config.log_found_exception(__method__.to_s, e)
+        end
+
+        def contains?(feature_name, key)
+          @filter.contains?("#{feature_name}#{key}")
+        rescue StandardError => e
+          @config.log_found_exception(__method__.to_s, e)
+        end
+
+        def clear
+          @filter.clear
+        rescue StandardError => e
+          @config.log_found_exception(__method__.to_s, e)
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/cache/filter/flag_set_filter.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module SplitIoClient
+  module Cache
+    module Filter
+      class FlagSetsFilter
+        def initialize(flag_sets = [])
+          @flag_sets = Set.new(flag_sets)
+          @should_filter = @flag_sets.any?
+        end
+
+        def should_filter?
+          @should_filter
+        end
+
+        def flag_set_exist?(flag_set)
+          return true unless @should_filter
+
+          if not flag_set.is_a?(String) or flag_set.empty?
+            return false
+          end
+
+          @flag_sets.intersection([flag_set]).any?
+        end
+
+        def intersect?(flag_sets)
+          return true unless @should_filter
+
+          if not flag_sets.is_a?(Array) or flag_sets.empty?
+            return false
+          end
+
+          @flag_sets.intersection(Set.new(flag_sets)).any?
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/cache/hashers/impression_hasher.rb

@@ -0,0 +1,34 @@
+module SplitIoClient
+  module Hashers
+    class ImpressionHasher
+      def initialize
+        @murmur_hash_128_64 = case RUBY_PLATFORM
+        when 'java' 
+          Proc.new { |key, seed| Java::MurmurHash3.hash128x64(key, seed) }
+        else
+          Proc.new { |key, seed| Digest::MurmurHashMRI3_x64_128.rawdigest(key, [seed].pack('L')) }
+        end
+      end
+
+      def process(impression)
+        impression_data = "#{unknown_if_null(impression[:k])}"
+        impression_data << ":#{unknown_if_null(impression[:f])}"
+        impression_data << ":#{unknown_if_null(impression[:t])}"
+        impression_data << ":#{unknown_if_null(impression[:r])}"
+        impression_data << ":#{zero_if_null(impression[:c])}"
+        
+        @murmur_hash_128_64.call(impression_data, 0)[0];
+      end
+
+      private
+
+      def unknown_if_null(value)
+        value == nil ? "UNKNOWN" : value
+      end
+
+      def zero_if_null(value)
+        value == nil ? 0 : value
+      end
+    end
+  end
+end

data/lib/splitclient-rb/cache/observers/impression_observer.rb

@@ -0,0 +1,22 @@
+module SplitIoClient
+  module Observers
+    class ImpressionObserver
+      LAST_SEEN_CACHE_SIZE = 500000
+
+      def initialize
+        @cache = LruRedux::TTL::ThreadSafeCache.new(LAST_SEEN_CACHE_SIZE)
+        @impression_hasher = Hashers::ImpressionHasher.new
+      end
+
+      def test_and_set(impression)
+        return if impression.nil?
+        
+        hash = @impression_hasher.process(impression)
+        previous = @cache[hash]
+        @cache[hash] = impression[:m]
+
+        previous.nil? ? nil : [previous, impression[:m]].min
+      end
+    end
+  end
+end

data/lib/splitclient-rb/cache/observers/noop_impression_observer.rb

@@ -0,0 +1,10 @@
+module SplitIoClient
+  module Observers
+    class NoopImpressionObserver
+      def test_and_set(impression)
+        # no-op
+      end
+    end
+  end
+end
+  

data/lib/splitclient-rb/cache/repositories/events/memory_repository.rb

@@ -3,29 +3,41 @@ module SplitIoClient
     module Repositories
       module Events
         class MemoryRepository < EventsRepository
-          EVENTS_SLICE = 100
+          EVENTS_MAX_SIZE_BYTES = 5242880
 
-          def initialize(adapter)
-            @adapter = adapter
+          def initialize(config, telemetry_runtime_producer)
+            @config = config
+            @adapter = @config.events_adapter
+            @size = 0
+            @telemetry_runtime_producer = telemetry_runtime_producer
           end
 
-          def add(key, traffic_type, event_type, time, value)
-            @adapter.add_to_queue(m: metadata, e: event(key, traffic_type, event_type, time, value))
-          rescue ThreadError # queue is full
-            if SplitIoClient.configuration.debug_enabled
-              SplitIoClient.configuration.logger.warn("Dropping events. Current size is #{SplitIoClient.configuration.events_queue_size}. " \
-                                  "Consider increasing events_queue_size")
-            end
-            @adapter.clear
-          end
+          def add(key, traffic_type, event_type, time, value, properties, event_size)
+            @adapter.add_to_queue(m: metadata, e: event(key, traffic_type, event_type, time, value, properties))
+            @size += event_size
 
-          def batch
-            @adapter.get_batch(EVENTS_SLICE)
+            post_events if @size >= EVENTS_MAX_SIZE_BYTES || @adapter.length == @config.events_queue_size
+
+            @telemetry_runtime_producer.record_events_stats(Telemetry::Domain::Constants::EVENTS_QUEUED, 1)
+          rescue StandardError => e
+            @config.log_found_exception(__method__.to_s, e)
+            @telemetry_runtime_producer.record_events_stats(Telemetry::Domain::Constants::EVENTS_DROPPED, 1)
           end
 
           def clear
+            @size = 0
             @adapter.clear
           end
+
+          def empty?
+            @adapter.empty?
+          end
+
+          def batch
+            return [] if @config.events_queue_size.zero?
+
+            @adapter.get_batch(@config.events_queue_size)
+          end
         end
       end
     end

data/lib/splitclient-rb/cache/repositories/events/redis_repository.rb

@@ -3,36 +3,31 @@ module SplitIoClient
     module Repositories
       module Events
         class RedisRepository < EventsRepository
-          EVENTS_SLICE = 100
 
-          def initialize(adapter)
-            @adapter = adapter
+          def initialize(config)
+            @config = config
+            @adapter = @config.events_adapter
           end
 
-          def add(key, traffic_type, event_type, time, value)
+          def add(key, traffic_type, event_type, time, value, properties, size)
             @adapter.add_to_queue(
               namespace_key('.events'),
-              { m: metadata, e: event(key, traffic_type, event_type, time, value) }.to_json,
+              { m: metadata, e: event(key, traffic_type, event_type, time, value, properties) }.to_json
             )
           end
 
-          def get_events(number_of_events = 0)
-            @adapter.get_from_queue(namespace_key('.events'), number_of_events).map do |e|
+          def clear
+            @adapter.get_from_queue(namespace_key('.events'), 0).map do |e|
               JSON.parse(e, symbolize_names: true)
             end
           rescue StandardError => e
-            SplitIoClient.configuration.logger.error("Exception while clearing events cache: #{e}")
+            @config.logger.error("Exception while clearing events cache: #{e}")
             []
           end
 
           def batch
-            get_events(EVENTS_SLICE)
+            clear()
           end
-
-          def clear
-            get_events
-          end
-
         end
       end
     end

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

@@ -4,36 +4,57 @@ module SplitIoClient
       # Repository which forwards events interface to the selected adapter
       class EventsRepository < Repository
         extend Forwardable
-        def_delegators :@adapter, :add, :clear, :batch
+        def_delegators :@repository, :add, :clear, :batch
 
-        def initialize(adapter)
-          @adapter = case adapter.class.to_s
+        def initialize(config, api_key, telemetry_runtime_producer)
+          super(config)
+          @repository = case @config.events_adapter.class.to_s
           when 'SplitIoClient::Cache::Adapters::MemoryAdapter'
-            Repositories::Events::MemoryRepository.new(adapter)
+            Repositories::Events::MemoryRepository.new(@config, telemetry_runtime_producer)
           when 'SplitIoClient::Cache::Adapters::RedisAdapter'
-            Repositories::Events::RedisRepository.new(adapter)
+            Repositories::Events::RedisRepository.new(@config)
           end
+
+          @api_key = api_key
+          @telemetry_runtime_producer = telemetry_runtime_producer
+        end
+
+        def post_events
+          events_api.post(self.clear)
+        rescue StandardError => e
+          @config.log_found_exception(__method__.to_s, e)
         end
 
+        def empty?
+          @repository.empty?
+         end
+
         protected
 
         def metadata
           {
-            s: "#{SplitIoClient.configuration.language}-#{SplitIoClient.configuration.version}",
-            i: SplitIoClient.configuration.machine_ip,
-            n: SplitIoClient.configuration.machine_name
+            s: "#{@config.language}-#{@config.version}",
+            i: @config.machine_ip,
+            n: @config.machine_name
           }
         end
 
-        def event(key, traffic_type, event_type, time, value)
+        def event(key, traffic_type, event_type, time, value, properties)
           {
             key: key,
             trafficTypeName: traffic_type,
             eventTypeId: event_type,
             value: value,
-            timestamp: time
+            timestamp: time,
+            properties: properties
           }.reject { |_, v| v.nil? }
         end
+
+        private
+
+        def events_api
+          @events_api ||= SplitIoClient::Api::Events.new(@api_key, @config, @telemetry_runtime_producer)
+        end
       end
     end
   end

data/lib/splitclient-rb/cache/repositories/flag_sets/memory_repository.rb

@@ -0,0 +1,40 @@
+require 'concurrent'
+
+module SplitIoClient
+  module Cache
+    module Repositories
+      class MemoryFlagSetsRepository
+        def initialize(flag_sets = [])
+          @sets_feature_flag_map = {}
+          flag_sets.each{ |flag_set| @sets_feature_flag_map[flag_set] = Set[] }
+        end
+
+        def flag_set_exist?(flag_set)
+          @sets_feature_flag_map.key?(flag_set)
+        end
+
+        def get_flag_sets(flag_sets)
+          to_return = Array.new
+          flag_sets.each { |flag_set| to_return.concat(@sets_feature_flag_map[flag_set].to_a)}
+          to_return.uniq
+        end
+
+        def add_flag_set(flag_set)
+          @sets_feature_flag_map[flag_set] = Set[] if !flag_set_exist?(flag_set)
+        end
+
+        def remove_flag_set(flag_set)
+          @sets_feature_flag_map.delete(flag_set) if flag_set_exist?(flag_set)
+        end
+
+        def add_feature_flag_to_flag_set(flag_set, feature_flag)
+          @sets_feature_flag_map[flag_set].add(feature_flag) if flag_set_exist?(flag_set)
+        end
+
+        def remove_feature_flag_from_flag_set(flag_set, feature_flag)
+          @sets_feature_flag_map[flag_set].delete(feature_flag) if flag_set_exist?(flag_set)
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/cache/repositories/flag_sets/redis_repository.rb

@@ -0,0 +1,49 @@
+require 'concurrent'
+
+module SplitIoClient
+  module Cache
+    module Repositories
+      class RedisFlagSetsRepository < Repository
+
+        def initialize(config)
+          super(config)
+          @adapter = SplitIoClient::Cache::Adapters::RedisAdapter.new(@config.redis_url)
+        end
+
+        def flag_set_exist?(flag_set)
+          @adapter.exists?(namespace_key(".flagSet.#{flag_set}"))
+        end
+
+        def get_flag_sets(flag_sets)
+          result = @adapter.redis.pipelined do |pipeline|
+            flag_sets.each do |flag_set|
+               pipeline.smembers(namespace_key(".flagSet.#{flag_set}"))
+            end
+          end
+          to_return = Array.new
+          result.each do |flag_set|
+            flag_set.each { |feature_flag_name| to_return.push(feature_flag_name.to_s)}
+          end
+          to_return.uniq
+        end
+
+        def add_flag_set(flag_set)
+          # not implemented
+        end
+
+        def remove_flag_set(flag_set)
+          # not implemented
+        end
+
+        def add_feature_flag_to_flag_set(flag_set, feature_flag)
+          # not implemented
+        end
+
+        def remove_feature_flag_from_flag_set(flag_set, feature_flag)
+          # not implemented
+        end
+
+      end
+    end
+  end
+end

data/lib/splitclient-rb/cache/repositories/impressions/memory_repository.rb

@@ -5,46 +5,45 @@ module SplitIoClient
     module Repositories
       module Impressions
         class MemoryRepository < ImpressionsRepository
-          def initialize(adapter)
-            @adapter = adapter
+          def initialize(config)
+            @config = config
+            @adapter = @config.impressions_adapter
           end
 
-          # Store impression data in the selected adapter
-          def add(matching_key, bucketing_key, split_name, treatment, time)
-            @adapter.add_to_queue(
-              m: metadata,
-              i: impression_data(
-                matching_key,
-                bucketing_key,
-                split_name,
-                treatment,
-                time
-              )
-            )
+          def add_bulk(impressions)
+            return 0 if impressions.nil?
+
+            count = 0
+            impressions.each do |impression|
+              @adapter.add_to_queue(impression)
+              count += 1
+            end
+
+            0
           rescue ThreadError # queue is full
             if random_sampler.rand(1..1000) <= 2 # log only 0.2 % of the time
-              SplitIoClient.configuration.logger.warn("Dropping impressions. Current size is \
-                #{SplitIoClient.configuration.impressions_queue_size}. " \
+              @config.logger.warn("Dropping impressions. Current size is \
+                #{@config.impressions_queue_size}. " \
                 'Consider increasing impressions_queue_size')
             end
-          end
 
-          def add_bulk(key, bucketing_key, treatments, time)
-            treatments.each do |split_name, treatment|
-              add(key, bucketing_key, split_name, treatment, time)
-            end
+            impressions.length - count
           end
 
           def batch
-            return [] if SplitIoClient.configuration.impressions_bulk_size.zero?
+            return [] if @config.impressions_bulk_size.zero?
 
-            @adapter.get_batch(SplitIoClient.configuration.impressions_bulk_size)
+            @adapter.get_batch(@config.impressions_bulk_size)
           end
 
           def clear
             @adapter.clear
           end
 
+          def empty?
+            @adapter.empty?
+          end
+
           private
 
           def random_sampler

data/lib/splitclient-rb/cache/repositories/impressions/redis_repository.rb

@@ -7,32 +7,25 @@ module SplitIoClient
         class RedisRepository < ImpressionsRepository
           EXPIRE_SECONDS = 3600
 
-          def initialize(adapter)
-            @adapter = adapter
+          def initialize(config)
+            @config = config
+            @adapter = @config.impressions_adapter
           end
 
-          def add(matching_key, bucketing_key, split_name, treatment, time)
-            add_bulk(matching_key, bucketing_key, { split_name => treatment }, time)
-          end
-
-          def add_bulk(matching_key, bucketing_key, treatments, time)
-            impressions = treatments.map do |split_name, treatment|
-              {
-                m: metadata,
-                i: impression_data(
-                  matching_key,
-                  bucketing_key,
-                  split_name,
-                  treatment,
-                  time
-                )
-              }.to_json
+          def add_bulk(impressions)
+            impressions_json = impressions.map do |impression|
+              impression[:i][:properties] = impression[:i][:properties].to_json.to_s unless impression[:i][:properties].nil?
+              impression.to_json
             end
 
-            impressions_list_size = @adapter.add_to_queue(key, impressions)
+            impressions_list_size = @adapter.add_to_queue(key, impressions_json)
 
             # Synchronizer might not be running
-            @adapter.expire(key, EXPIRE_SECONDS) if impressions.size == impressions_list_size
+            @adapter.expire(key, EXPIRE_SECONDS) if impressions_json.size == impressions_list_size
+            0
+          rescue StandardError => e
+            @config.logger.error("Exception while add_bulk: #{e}")
+            0
           end
 
           def get_impressions(number_of_impressions = 0)
@@ -42,12 +35,12 @@ module SplitIoClient
               impression
             end
           rescue StandardError => e
-            SplitIoClient.configuration.logger.error("Exception while clearing impressions cache: #{e}")
+            @config.logger.error("Exception while clearing impressions cache: #{e}")
             []
           end
 
           def batch
-            get_impressions(SplitIoClient.configuration.impressions_bulk_size)
+            get_impressions(@config.impressions_bulk_size)
           end
 
           def clear