splitclient-rb 4.5.1-java

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

@@ -0,0 +1,22 @@
+module SplitIoClient
+  module Cache
+    module Repositories
+      # Repository which forwards impressions interface to the selected adapter
+      class MetricsRepository < Repository
+        extend Forwardable
+        def_delegators :@adapter, :add_count, :add_latency, :add_gauge, :counts, :latencies, :gauges,
+                       :clear_counts, :clear_latencies, :clear_gauges, :clear
+
+        def initialize(adapter, config)
+          @config = config
+          @adapter = case adapter.class.to_s
+          when 'SplitIoClient::Cache::Adapters::MemoryAdapter'
+            Repositories::Metrics::MemoryRepository.new(adapter, config)
+          when 'SplitIoClient::Cache::Adapters::RedisAdapter'
+            Repositories::Metrics::RedisRepository.new(adapter, config)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module SplitIoClient
+  module Cache
+    class Repository
+      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
+
+      def impressions_metrics_key(key)
+        namespace_key("/#{@config.language}-#{@config.version}/#{@config.machine_ip}/#{key}")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+module SplitIoClient
+  module Cache
+    module Repositories
+      class SegmentsRepository < Repository
+        KEYS_SLICE = 3000
+
+        attr_reader :adapter
+
+        def initialize(adapter, config)
+          @adapter = adapter
+          @config = config
+
+          @adapter.set_bool(namespace_key('.ready'), false)
+        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])
+        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
+
+        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

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

@@ -0,0 +1,106 @@
+require 'concurrent'
+
+module SplitIoClient
+  module Cache
+    module Repositories
+      class SplitsRepository < Repository
+        SPLITS_SLICE = 10
+
+        attr_reader :adapter
+
+        def initialize(adapter, config)
+          @adapter = adapter
+          @config = config
+
+          @adapter.set_string(namespace_key('.splits.till'), '-1')
+          @adapter.initialize_map(namespace_key('.segments.registered'))
+        end
+
+        def add_split(split)
+          return unless split[:name]
+
+          @adapter.set_string(namespace_key(".split.#{split[:name]}"), split.to_json)
+        end
+
+        def remove_split(name)
+          @adapter.delete(namespace_key(".split.#{name}"))
+        end
+
+        def get_splits(names, slice = SPLITS_SLICE)
+          splits = {}
+
+          names.each_slice(slice) do |splits_slice|
+            splits.merge!(
+              @adapter
+                .multiple_strings(splits_slice.map { |name| namespace_key(".split.#{name}") })
+                .map { |name, data| [name.gsub(namespace_key('.split.'), ''), data] }.to_h
+            )
+          end
+
+          splits.map do |name, data|
+            parsed_data = data ? JSON.parse(data, symbolize_names: true) : nil
+            [name.to_sym, parsed_data]
+          end.to_h
+        end
+
+        def get_split(name)
+          split = @adapter.string(namespace_key(".split.#{name}"))
+
+          JSON.parse(split, symbolize_names: true) if split
+        end
+
+        def splits
+          splits_hash = {}
+
+          split_names.each do |name|
+            splits_hash[name] = get_split(name)
+          end
+
+          splits_hash
+        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.'), '') }
+        end
+
+        def set_change_number(since)
+          @adapter.set_string(namespace_key('.splits.till'), since)
+        end
+
+        def get_change_number
+          @adapter.string(namespace_key('.splits.till'))
+        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('.splits.ready')).to_i != -1
+        end
+
+        def not_ready!
+          @adapter.set_string(namespace_key('.splits.ready'), -1)
+        end
+
+        def ready!
+          @adapter.set_string(namespace_key('.splits.ready'), Time.now.utc.to_i)
+        end
+
+        def clear
+          @adapter.clear(namespace_key)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module SplitIoClient
+  class ImpressionRouter
+    attr_reader :router_thread
+
+    def initialize(config)
+      @config = config
+      @listener = config.impression_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(impression)
+      @queue.push(impression)
+    end
+
+    def add_bulk(impressions)
+      impressions[:split_names].each do |split_name|
+        @queue.push(
+          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]
+        )
+      end
+    end
+
+    private
+
+    def router_thread
+      @config.threads[:impression_router] = Thread.new do
+        loop do
+          begin
+            @listener.log(@queue.pop)
+          rescue StandardError => error
+            @config.log_found_exception(__method__.to_s, error)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module SplitIoClient
+  module Cache
+    module Senders
+      class EventsSender
+        def initialize(events_repository, config, api_key)
+          @events_repository = events_repository
+          @config = config
+          @api_key = api_key
+        end
+
+        def call
+          if ENV['SPLITCLIENT_ENV'] == 'test'
+            post_events
+          else
+            events_thread
+
+            if defined?(PhusionPassenger)
+              PhusionPassenger.on_event(:starting_worker_process) do |forked|
+                events_thread if forked
+              end
+            end
+          end
+        end
+
+        private
+
+        def events_thread
+          @config.threads[:events_sender] = Thread.new do
+            @config.logger.info('Starting events service')
+
+            loop do
+              post_events
+
+              sleep(SplitIoClient::Utilities.randomize_interval(@config.events_push_rate))
+            end
+          end
+        end
+
+        def post_events
+          SplitIoClient::Api::Events.new(@api_key, @config, @events_repository.clear).post
+        rescue StandardError => error
+          @config.log_found_exception(__method__.to_s, error)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+module SplitIoClient
+  module Cache
+    module Senders
+      class ImpressionsFormatter
+        def initialize(impressions_repository)
+          @impressions_repository = impressions_repository
+        end
+
+        def call(raw_impressions)
+          impressions = raw_impressions ? raw_impressions : @impressions_repository.clear
+          formatted_impressions = []
+          filtered_impressions = filter_impressions(impressions)
+
+          return [] if impressions.empty? || filtered_impressions.empty?
+
+          formatted_impressions = unique_features(filtered_impressions).each_with_object([]) do |feature, memo|
+            ip = nil
+            current_impressions =
+              filtered_impressions
+                .select { |impression| impression[:feature] == feature }
+                .map do |impression|
+                  ip = impression[:ip]
+                  {
+                    keyName: impression[:impressions]['keyName'] || impression[:impressions]['key_name'],
+                    treatment: impression[:impressions]['treatment'],
+                    time: impression[:impressions]['time'],
+                    bucketingKey: impression[:impressions]['bucketingKey'] || impression[:impressions]['bucketing_key'],
+                    label: impression[:impressions]['label'],
+                    changeNumber: impression[:impressions]['changeNumber'] || impression[:impressions]['change_number'],
+                  }
+                end
+
+            memo << {
+              testName: feature.to_sym,
+              keyImpressions: current_impressions,
+              ip: ip
+            }
+          end
+
+          formatted_impressions
+        end
+
+        private
+
+        def unique_features(impressions)
+          impressions.map { |impression| impression[:feature] }.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[:feature]}:" \
+          "#{impression[:impressions]['keyName']}:" \
+          "#{impression[:impressions]['bucketingKey']}:" \
+          "#{impression[:impressions]['changeNumber']}:" \
+          "#{impression[:impressions]['treatment']}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+module SplitIoClient
+  module Cache
+    module Senders
+      class ImpressionsSender
+        def initialize(impressions_repository, config, api_key)
+          @impressions_repository = impressions_repository
+          @config = config
+          @api_key = api_key
+        end
+
+        def call
+          # Disable impressions if @config.impressions_queue_size == -1
+          if @config.impressions_queue_size < 0
+            @config.logger.info('Disabling impressions service by config')
+            return
+          end
+
+          if ENV['SPLITCLIENT_ENV'] == 'test'
+            post_impressions
+          else
+            impressions_thread
+
+            if defined?(PhusionPassenger)
+              PhusionPassenger.on_event(:starting_worker_process) do |forked|
+                impressions_thread if forked
+              end
+            end
+          end
+        end
+
+        private
+
+        def impressions_thread
+          @config.threads[:impressions_sender] = Thread.new do
+            begin
+              @config.logger.info('Starting impressions service')
+
+              loop do
+                post_impressions
+
+                sleep(SplitIoClient::Utilities.randomize_interval(@config.impressions_refresh_rate))
+              end
+            rescue SplitIoClient::ImpressionShutdownException
+              post_impressions
+
+              @impressions_repository.clear
+            end
+          end
+        end
+
+        def post_impressions
+          impressions_client.post
+        rescue StandardError => error
+          @config.log_found_exception(__method__.to_s, error)
+        end
+
+        def formatted_impressions(raw_impressions = nil)
+          ImpressionsFormatter.new(@impressions_repository).call(raw_impressions)
+        end
+
+        def impressions_client
+          SplitIoClient::Api::Impressions.new(@api_key, @config, formatted_impressions)
+        end
+      end
+    end
+  end
+end