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

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

@@ -0,0 +1,61 @@
+module SplitIoClient
+  module Cache
+    module Repositories
+      # Repository which forwards events interface to the selected adapter
+      class EventsRepository < Repository
+        extend Forwardable
+        def_delegators :@repository, :add, :clear, :batch
+
+        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(@config, telemetry_runtime_producer)
+          when 'SplitIoClient::Cache::Adapters::RedisAdapter'
+            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: "#{@config.language}-#{@config.version}",
+            i: @config.machine_ip,
+            n: @config.machine_name
+          }
+        end
+
+        def event(key, traffic_type, event_type, time, value, properties)
+          {
+            key: key,
+            trafficTypeName: traffic_type,
+            eventTypeId: event_type,
+            value: value,
+            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
+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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Cache
+    module Repositories
+      module Impressions
+        class MemoryRepository < ImpressionsRepository
+          def initialize(config)
+            @config = config
+            @adapter = @config.impressions_adapter
+          end
+
+          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
+              @config.logger.warn("Dropping impressions. Current size is \
+                #{@config.impressions_queue_size}. " \
+                'Consider increasing impressions_queue_size')
+            end
+
+            impressions.length - count
+          end
+
+          def batch
+            return [] if @config.impressions_bulk_size.zero?
+
+            @adapter.get_batch(@config.impressions_bulk_size)
+          end
+
+          def clear
+            @adapter.clear
+          end
+
+          def empty?
+            @adapter.empty?
+          end
+
+          private
+
+          def random_sampler
+            @random_sampler ||= Random.new
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Cache
+    module Repositories
+      module Impressions
+        class RedisRepository < ImpressionsRepository
+          EXPIRE_SECONDS = 3600
+
+          def initialize(config)
+            @config = config
+            @adapter = @config.impressions_adapter
+          end
+
+          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_json)
+
+            # Synchronizer might not be running
+            @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)
+            @adapter.get_from_queue(key, number_of_impressions).map do |e|
+              impression = JSON.parse(e, symbolize_names: true)
+              impression[:i][:f] = impression[:i][:f].to_sym
+              impression
+            end
+          rescue StandardError => e
+            @config.logger.error("Exception while clearing impressions cache: #{e}")
+            []
+          end
+
+          def batch
+            get_impressions(@config.impressions_bulk_size)
+          end
+
+          def clear
+            get_impressions
+          end
+
+          def key
+            @key ||= namespace_key('.impressions')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Cache
+    module Repositories
+      # Repository which forwards impressions interface to the selected adapter
+      class ImpressionsRepository < Repository
+        extend Forwardable
+        def_delegators :@repository, :add_bulk, :batch, :clear, :empty?
+
+        def initialize(config)
+          super(config)
+          @repository = case @config.impressions_adapter.class.to_s
+                     when 'SplitIoClient::Cache::Adapters::MemoryAdapter'
+                       Repositories::Impressions::MemoryRepository.new(@config)
+                     when 'SplitIoClient::Cache::Adapters::RedisAdapter'
+                       Repositories::Impressions::RedisRepository.new(@config)
+                     end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+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
+
+      def string(key)
+        @adapter.string(namespace_key(key))
+      end
+
+      protected
+
+      def namespace_key(key = '')
+        "#{@config.redis_namespace}#{key}"
+      end
+    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

@@ -0,0 +1,124 @@
+module SplitIoClient
+  module Cache
+    module Repositories
+      class SegmentsRepository < Repository
+        KEYS_SLICE = 3000
+
+        attr_reader :adapter
+
+        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
+          @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
+        def add_to_segment(segment)
+          name = segment[:name]
+
+          @adapter.initialize_set(segment_data(name)) unless @adapter.exists?(segment_data(name))
+          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)
+          @adapter.get_set(segment_data(name))
+        end
+
+        def in_segment?(name, key)
+          @adapter.in_set?(segment_data(name), key)
+        end
+
+        def used_segment_names
+          @adapter.get_set(namespace_key('.segments.registered'))
+        end
+
+        def set_change_number(name, last_change)
+          @adapter.set_string(namespace_key(".segment.#{name}.till"), last_change)
+        end
+
+        def get_change_number(name)
+          @adapter.string(namespace_key(".segment.#{name}.till")) || -1
+        end
+
+        def ready?
+          @adapter.string(namespace_key('.segments.ready')).to_i != -1
+        end
+
+        def not_ready!
+          @adapter.set_string(namespace_key('.segments.ready'), -1)
+        end
+
+        def ready!
+          @adapter.set_string(namespace_key('.segments.ready'), Time.now.utc.to_i)
+        end
+
+        def clear
+          @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)
+          namespace_key(".segment.#{name}")
+        end
+
+        def add_keys(name, keys)
+          keys.each_slice(KEYS_SLICE) do |keys_slice|
+            @adapter.add_to_set(segment_data(name), keys_slice)
+          end
+        end
+
+        def remove_keys(name, keys)
+          keys.each_slice(KEYS_SLICE) do |keys_slice|
+            @adapter.delete_from_set(segment_data(name), keys_slice)
+          end
+        end
+      end
+    end
+  end
+end