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

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

@@ -0,0 +1,296 @@
+require 'concurrent'
+
+module SplitIoClient
+  module Cache
+    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(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(@config)
+          else
+            @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 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)
+
+          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)
+          split = @adapter.string(namespace_key(".split.#{name}"))
+
+          JSON.parse(split, symbolize_names: true) if split
+        end
+
+        def splits(filtered_names=nil)
+          symbolize = true
+          if filtered_names.nil?
+            filtered_names = split_names
+            symbolize = false
+          end
+          get_splits(filtered_names, symbolize)
+        end
+
+        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_PREFIX))
+            .map { |split| split.gsub(namespace_key(SPLIT_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('.segments.registered'), name)
+          end
+        end
+
+        def exists?(name)
+          @adapter.exists?(namespace_key(".split.#{name}"))
+        end
+
+        def ready?
+          @adapter.string(namespace_key(READY_PREFIX)).to_i != -1
+        end
+
+        def not_ready!
+          @adapter.set_string(namespace_key(READY_PREFIX), -1)
+        end
+
+        def ready!
+          @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
+  end
+end

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

@@ -0,0 +1,60 @@
+module SplitIoClient
+  class ImpressionRouter
+    attr_reader :router_thread
+
+    def initialize(config)
+      @config = config
+      @listener = @config.impression_listener
+
+      return unless @listener
+
+      @queue = Queue.new
+      router_thread
+
+      if defined?(PhusionPassenger)
+        PhusionPassenger.on_event(:starting_worker_process) do |forked|
+          router_thread if forked
+        end
+      end
+    end
+
+    def add_bulk(impressions)
+      impressions.each do |impression|
+        enqueue(impression)
+      end
+    end
+
+    private
+
+    def enqueue(impression)
+      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
+      @config.threads[:impression_router] = Thread.new do
+        loop do
+          begin
+            @listener.log(@queue.pop)
+          rescue StandardError => e
+            @config.log_found_exception(__method__.to_s, e)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/cache/senders/events_sender.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Cache
+    module Senders
+      class EventsSender
+        def initialize(events_repository, config)
+          @events_repository = events_repository
+          @config = config
+        end
+
+        def call          
+          events_thread
+        end
+
+        private
+
+        def events_thread
+          @config.threads[:events_sender] = Thread.new do
+            begin
+              @config.logger.info('Starting events service')
+
+              loop do
+                post_events
+
+                sleep(SplitIoClient::Utilities.randomize_interval(@config.events_push_rate))
+              end
+            rescue SplitIoClient::SDKShutdownException
+              post_events
+
+              @config.logger.info('Posting events due to shutdown')
+            end
+          end
+        end
+
+        def post_events
+          @events_repository.post_events
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/cache/senders/impressions_adapter/memory_sender.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Cache
+    module Senders
+      class MemoryImpressionsSender < ImpressionsSenderAdapter
+        def initialize(config, telemetry_api, impressions_api)
+          @config = config
+          @telemetry_api = telemetry_api
+          @impressions_api = impressions_api
+        end
+
+        def record_uniques_key(uniques)
+          uniques_keys = uniques_formatter(uniques)
+
+          @telemetry_api.record_unique_keys(uniques_keys) unless uniques_keys.nil?
+        rescue StandardError => e
+          @config.log_found_exception(__method__.to_s, e)
+        end
+
+        def record_impressions_count(impressions_count)
+          counts = impressions_count_formatter(impressions_count)
+
+          @impressions_api.post_count(counts) unless counts.nil?
+        rescue StandardError => e
+          @config.log_found_exception(__method__.to_s, e)
+        end
+
+        private 
+
+        def uniques_formatter(uniques)
+          return if uniques.nil? || uniques.empty?
+
+          to_return = { keys: [] }
+          uniques.each do |key, value|
+            to_return[:keys] << {
+              f: key,
+              ks: value.to_a
+            }
+          end
+
+          to_return
+        rescue StandardError => e
+          @config.log_found_exception(__method__.to_s, e)
+          nil
+        end
+
+        def impressions_count_formatter(counts)
+          return if counts.nil? || counts.empty?
+
+          formated_counts = {pf: []}
+
+          counts.each do |key, value|              
+            key_splited = key.split('::')
+            
+            formated_counts[:pf] << {
+              f: key_splited[0].to_s, # feature name
+              m: key_splited[1].to_i, # time frame
+              rc: value # count
+            }
+          end
+
+          formated_counts
+        rescue StandardError => e
+          @config.log_found_exception(__method__.to_s, e)
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/cache/senders/impressions_adapter/redis_sender.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Cache
+    module Senders
+      class RedisImpressionsSender < ImpressionsSenderAdapter
+        EXPIRE_SECONDS = 3600
+
+        def initialize(config)
+          @config = config
+          @adapter = @config.impressions_adapter
+        end
+
+        def record_uniques_key(uniques)
+          return if uniques.nil? || uniques.empty?
+
+          size = @adapter.add_to_queue(unique_keys_key, uniques_formatter(uniques))
+
+          @adapter.expire(unique_keys_key, EXPIRE_SECONDS) if uniques.length == size
+        rescue StandardError => e
+          @config.log_found_exception(__method__.to_s, e)
+        end
+
+        def record_impressions_count(impressions_count)
+          return if impressions_count.nil? || impressions_count.empty?
+
+          result = @adapter.redis.pipelined do |pipeline|
+            impressions_count.each do |key, value|
+              pipeline.hincrby(impressions_count_key, key, value)
+            end
+          end
+
+          expire_impressions_count_key(impressions_count, result)
+        rescue StandardError => e
+          @config.log_found_exception(__method__.to_s, e)
+        end
+
+        private
+
+        def expire_impressions_count_key(impressions_count, pipeline_result)
+          total_count = impressions_count.sum { |_, value| value }
+          hlen = pipeline_result.last
+
+          @adapter.expire(impressions_count_key, EXPIRE_SECONDS) if impressions_count.size == hlen && (pipeline_result.sum - hlen) == total_count
+        end
+
+        def uniques_formatter(uniques)
+          to_return = []
+          uniques.each do |key, value|
+            to_return << {
+              f: key,
+              ks: value.to_a
+            }.to_json
+          end
+
+          to_return
+        end
+
+        def impressions_count_key
+          "#{@config.redis_namespace}.impressions.count"
+        end
+
+        def unique_keys_key
+          "#{@config.redis_namespace}.uniquekeys"
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/cache/senders/impressions_count_sender.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Cache
+    module Senders
+      class ImpressionsCountSender
+        def initialize(config, impression_counter, impressions_sender_adapter)
+          @config = config
+          @impression_counter = impression_counter
+          @impressions_sender_adapter = impressions_sender_adapter
+        end
+
+        def call
+          impressions_count_thread
+        end
+
+        private
+
+        def impressions_count_thread
+          @config.threads[:impressions_count_sender] = Thread.new do
+            begin
+              @config.logger.info('Starting impressions count service')
+              loop do
+                sleep(@config.counter_refresh_rate)
+                post_impressions_count                
+              end
+            rescue SplitIoClient::SDKShutdownException
+              post_impressions_count
+
+              @config.logger.info('Posting impressions count due to shutdown')
+            end
+          end
+        end
+
+        def post_impressions_count
+          @impressions_sender_adapter.record_impressions_count(@impression_counter.pop_all)
+        rescue StandardError => e
+          @config.log_found_exception(__method__.to_s, e)
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/cache/senders/impressions_formatter.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Cache
+    module Senders
+      class ImpressionsFormatter
+        def initialize(impressions_repository)
+          @impressions_repository = impressions_repository
+        end
+
+        def call(fetch_all_impressions, raw_impressions = nil)
+          impressions = raw_impressions || (fetch_all_impressions ? @impressions_repository.clear : @impressions_repository.batch)
+          
+          filtered_impressions = filter_impressions(impressions)
+
+          return [] if impressions.empty? || filtered_impressions.empty?
+
+          formatted_impressions = unique_features(filtered_impressions).each_with_object([]) do |feature, memo|
+            feature_impressions = feature_impressions(filtered_impressions, feature)
+            current_impressions = current_impressions(feature_impressions)
+            memo << {
+              f: feature.to_sym,
+              i: current_impressions
+            }
+          end
+
+          formatted_impressions
+        end
+
+        private
+
+        def feature_impressions(filtered_impressions, feature)
+          filtered_impressions.select do |impression|
+            impression[:i][:f] == feature
+          end
+        end
+
+        def current_impressions(feature_impressions)
+          feature_impressions.map do |impression|
+            if impression[:i][:properties].nil?
+              impression = {
+                k: impression[:i][:k],
+                t: impression[:i][:t],
+                m: impression[:i][:m],
+                b: impression[:i][:b],
+                r: impression[:i][:r],
+                c: impression[:i][:c],
+                pt: impression[:i][:pt]
+              }
+            else
+              impression = {
+                k: impression[:i][:k],
+                t: impression[:i][:t],
+                m: impression[:i][:m],
+                b: impression[:i][:b],
+                r: impression[:i][:r],
+                c: impression[:i][:c],
+                pt: impression[:i][:pt],
+                properties: impression[:i][:properties].to_json.to_s
+              }
+            end
+          end
+        end
+
+        def unique_features(impressions)
+          impressions.map { |impression| impression[:i][:f] }.uniq
+        end
+
+        # Filter seen impressions by impression_hash
+        def filter_impressions(unfiltered_impressions)
+          impressions_seen = []
+
+          unfiltered_impressions.each_with_object([]) do |impression, impressions|
+            impression_hash = impression_hash(impression)
+
+            next if impressions_seen.include?(impression_hash)
+
+            impressions_seen << impression_hash
+            impressions << impression
+          end
+        end
+
+        def impression_hash(impression)
+          "#{impression[:i][:f]}:" \
+          "#{impression[:i][:k]}:" \
+          "#{impression[:i][:b]}:" \
+          "#{impression[:i][:c]}:" \
+          "#{impression[:i][:t]}:" \
+          "#{impression[:i][:pt]}" \
+          "#{impression[:i][:properties]}" \
+        end
+      end
+    end
+  end
+end