splitclient-rb 1.0.2.wip → 8.11.1.pre.rc1-java

data/lib/splitclient-rb/cache/adapters/memory_adapters/queue_adapter.rb

@@ -0,0 +1,53 @@
+module SplitIoClient
+  module Cache
+    module Adapters
+      module MemoryAdapters
+        # Memory adapter implementation, which stores everything inside queue
+        class QueueAdapter
+          def initialize(max_size)
+            @max_size = max_size
+            @queue = Queue.new
+            @current_size = Concurrent::AtomicFixnum.new(0)
+          end
+
+          def clear(_ = nil)
+            @queue = Queue.new
+            @current_size.value = 0
+          end
+
+          # Adds data to queue in non-blocking mode
+          def add_to_queue(data)
+            fail ThreadError if @current_size.value >= @max_size
+
+            @queue.push(data)
+
+            @current_size.increment
+          end
+
+          def clear
+            get_batch(@current_size.value)
+          end
+
+          def get_batch(size)
+            items = []
+            size.times do
+              items << @queue.pop(true)
+              @current_size.decrement
+            end
+            items
+            rescue ThreadError
+            items
+          end
+
+          def length
+            @current_size.value
+          end
+
+          def empty?
+            @queue.empty?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/cache/adapters/redis_adapter.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module SplitIoClient
+  module Cache
+    module Adapters
+      # Redis adapter used to provide interface to Redis
+      class RedisAdapter
+        SCAN_SLICE = 5000
+
+        attr_reader :redis
+
+        def initialize(redis_url)
+          connection = redis_url.is_a?(Hash) ? redis_url : { url: redis_url }
+
+          @redis = Redis.new(connection)
+        end
+
+        def hincrby(key, field, increment)
+          @redis.hincrby(key, field, increment)
+        end
+
+        # Map
+        def initialize_map(key)
+          # No need to initialize hash/map in Redis
+        end
+
+        def add_to_map(key, field, value)
+          @redis.hset(key, field, value)
+        end
+
+        def find_in_map(key, field)
+          @redis.hget(key, field)
+        end
+
+        def delete_from_map(key, field)
+          @redis.hdel(key, field)
+        end
+
+        def in_map?(key, field)
+          @redis.hexists(key, field)
+        end
+
+        def map_keys(key)
+          @redis.hkeys(key)
+        end
+
+        def get_map(key)
+          @redis.hgetall(key)
+        end
+
+        # String
+        def string(key)
+          @redis.get(key)
+        end
+
+        def set_string(key, str)
+          @redis.set(key, str)
+        end
+
+        def find_strings_by_prefix(prefix)
+          find_strings_by_pattern("#{prefix}*")
+        end
+
+        def find_strings_by_pattern(pattern)
+          memo = { items: [], cursor: 0 }
+
+          loop do
+            memo[:cursor], items = @redis.scan(memo[:cursor], match: "#{pattern}", count: SCAN_SLICE)
+
+            memo[:items].push(*items)
+
+            break if memo[:cursor] == '0'
+          end
+
+          memo[:items]
+        end
+
+        def multiple_strings(keys)
+          Hash[keys.zip(@redis.mget(keys))]
+        end
+
+        def append_to_string(key, val)
+          @redis.append(key, val)
+        end
+
+        # Bool
+        def set_bool(key, val)
+          @redis.set(key, val.to_s)
+        end
+
+        def bool(key)
+          @redis.get(key) == 'true'
+        end
+
+        # Set
+        alias initialize_set initialize_map
+        alias find_sets_by_prefix find_strings_by_prefix
+
+        def add_to_set(key, val)
+          @redis.sadd?(key, val)
+        end
+
+        def delete_from_set(key, val)
+          @redis.srem(key, val)
+        end
+
+        def get_set(key)
+          @redis.smembers(key)
+        end
+
+        def in_set?(key, val)
+          @redis.sismember(key, val)
+        end
+
+        def get_all_from_set(key)
+          @redis.smembers(key)
+        end
+
+        def union_sets(set_keys)
+          return [] if set_keys == []
+
+          @redis.sunion(set_keys)
+        end
+
+        def random_set_elements(key, count)
+          @redis.srandmember(key, count)
+        end
+
+        # Queue
+        def add_to_queue(key, val)
+          @redis.rpush(key, val)
+        end
+
+        # count = 0 will result in lrange(0,-1), fetching all items
+        def get_from_queue(key, count)
+          items = @redis.lrange(key, 0, count - 1)
+          fetched_count = items.size
+          items_to_remove = fetched_count == count ? count : fetched_count
+
+          @redis.ltrim(key, items_to_remove, -1)
+
+          items
+        end
+
+        # General
+        def exists?(key)
+          @redis.exists?(key)
+        end
+
+        def delete(key)
+          return nil if key == []
+
+          @redis.del(key)
+        end
+
+        def inc(key, inc = 1)
+          @redis.incrby(key, inc)
+        end
+
+        def pipelined
+          @redis.pipelined do |pipeline|
+            yield
+          end
+        end
+
+        def clear(prefix)
+          # noop
+        end
+
+        def expire(key, seconds)
+          @redis.expire(key, seconds)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+module SplitIoClient
+  module Cache
+    module Fetchers
+      class SegmentFetcher
+        attr_reader :segments_repository
+
+        def initialize(segments_repository, api_key, config, telemetry_runtime_producer)
+          @segments_repository = 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_segments
+            return
+          end
+          
+          segments_thread
+        end
+
+        def fetch_segments_if_not_exists(names, cache_control_headers = false)
+          names.each do |name|
+            change_number = @segments_repository.get_change_number(name)
+            
+            if change_number == -1
+              fetch_options = { cache_control_headers: cache_control_headers, till: nil }
+              fetch_segment(name, fetch_options) if change_number == -1
+            end
+          end
+        rescue StandardError => e
+          @config.log_found_exception(__method__.to_s, e)
+        end
+
+        def fetch_segment(name, fetch_options = { cache_control_headers: false, till: nil })
+          @semaphore.synchronize do
+            segments_api.fetch_segments_by_names([name], fetch_options)
+          end
+        rescue StandardError => e
+          @config.log_found_exception(__method__.to_s, e)
+        end
+
+        def fetch_segments
+          @semaphore.synchronize do
+            segments_api.fetch_segments_by_names(@segments_repository.used_segment_names)
+
+            true
+          end
+        rescue StandardError => e
+          @config.log_found_exception(__method__.to_s, e)
+          false
+        end
+
+        def stop_segments_thread
+          SplitIoClient::Helpers::ThreadHelper.stop(:segment_fetcher, @config)
+        end
+
+        private
+
+        def segments_thread
+          @config.threads[:segment_fetcher] = Thread.new do
+            @config.logger.info('Starting segments fetcher service') if @config.debug_enabled
+
+            loop do
+              fetch_segments
+              @config.logger.debug("Segment names: #{@segments_repository.used_segment_names.to_a}") if @config.debug_enabled
+
+              sleep_for = SplitIoClient::Cache::Stores::StoreUtils.random_interval(@config.segments_refresh_rate)
+              @config.logger.debug("Segments fetcher is sleeping for: #{sleep_for} seconds") if @config.debug_enabled
+              sleep(sleep_for)
+            end
+          end
+        end
+
+        def segments_api
+          @segments_api ||= SplitIoClient::Api::Segments.new(@api_key, @segments_repository, @config, @telemetry_runtime_producer)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module SplitIoClient
+  module Cache
+    module Repositories
+      module Events
+        class MemoryRepository < EventsRepository
+          EVENTS_MAX_SIZE_BYTES = 5242880
+
+          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, properties, event_size)
+            @adapter.add_to_queue(m: metadata, e: event(key, traffic_type, event_type, time, value, properties))
+            @size += event_size
+
+            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
+  end
+end

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

@@ -0,0 +1,35 @@
+module SplitIoClient
+  module Cache
+    module Repositories
+      module Events
+        class RedisRepository < EventsRepository
+
+          def initialize(config)
+            @config = config
+            @adapter = @config.events_adapter
+          end
+
+          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, properties) }.to_json
+            )
+          end
+
+          def clear
+            @adapter.get_from_queue(namespace_key('.events'), 0).map do |e|
+              JSON.parse(e, symbolize_names: true)
+            end
+          rescue StandardError => e
+            @config.logger.error("Exception while clearing events cache: #{e}")
+            []
+          end
+
+          def batch
+            clear()
+          end
+        end
+      end
+    end
+  end
+end