splitclient-rb 7.1.4.pre.rc7 → 7.1.4.pre.rc8

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

@@ -4,10 +4,10 @@ module SplitIoClient
   module Cache
     module Senders
       class ImpressionsSender
-        def initialize(impressions_repository, api_key, config)
+        def initialize(impressions_repository, config, impressions_api)
           @impressions_repository = impressions_repository
-          @api_key = api_key
           @config = config
+          @impressions_api = impressions_api
         end
 
         def call
@@ -50,7 +50,7 @@ module SplitIoClient
         end
 
         def impressions_api
-          @impressions_api ||= SplitIoClient::Api::Impressions.new(@api_key, @config)
+          @impressions_api
         end
       end
     end

data/lib/splitclient-rb/clients/split_client.rb

@@ -9,7 +9,7 @@ module SplitIoClient
     # @param api_key [String] the API key for your split account
     #
     # @return [SplitIoClient] split.io client instance
-    def initialize(api_key, metrics, splits_repository, segments_repository, impressions_repository, metrics_repository, events_repository, sdk_blocker, config)
+    def initialize(api_key, metrics, splits_repository, segments_repository, impressions_repository, metrics_repository, events_repository, sdk_blocker, config, impressions_manager)
       @api_key = api_key
       @metrics = metrics
       @splits_repository = splits_repository
@@ -20,17 +20,21 @@ module SplitIoClient
       @sdk_blocker = sdk_blocker
       @destroyed = false
       @config = config
+      @impressions_manager = impressions_manager
     end
 
     def get_treatment(
         key, split_name, attributes = {}, split_data = nil, store_impressions = true,
         multiple = false, evaluator = nil
       )
-      treatment = treatment(key, split_name, attributes, split_data, store_impressions, multiple, evaluator)
+      impressions = []
+      result = treatment(key, split_name, attributes, split_data, store_impressions, multiple, evaluator, 'get_treatment', impressions)
+      @impressions_manager.track(impressions)
+
       if multiple
-         treatment.tap { |t| t.delete(:config) }
+        result.tap { |t| t.delete(:config) }
       else
-        treatment[:treatment]
+        result[:treatment]
       end
     end
 
@@ -38,7 +42,11 @@ module SplitIoClient
         key, split_name, attributes = {}, split_data = nil, store_impressions = true,
         multiple = false, evaluator = nil
       )
-      treatment(key, split_name, attributes, split_data, store_impressions, multiple, evaluator, 'get_treatment_with_config')
+      impressions = []
+      result = treatment(key, split_name, attributes, split_data, store_impressions, multiple, evaluator, 'get_treatment_with_config', impressions)
+      @impressions_manager.track(impressions)
+
+      result
     end
 
     def get_treatments(key, split_names, attributes = {})
@@ -74,53 +82,6 @@ module SplitIoClient
       @destroyed = true
     end
 
-    def store_impression(split_name, matching_key, bucketing_key, treatment, attributes)
-      time = (Time.now.to_f * 1000.0).to_i
-
-      @impressions_repository.add(
-        matching_key,
-        bucketing_key,
-        split_name,
-        treatment,
-        time
-      )
-
-      route_impression(split_name, matching_key, bucketing_key, time, treatment, attributes)
-
-    rescue StandardError => error
-      @config.log_found_exception(__method__.to_s, error)
-    end
-
-    def route_impression(split_name, matching_key, bucketing_key, time, treatment, attributes)
-      impression_router.add(
-        split_name: split_name,
-        matching_key: matching_key,
-        bucketing_key: bucketing_key,
-        time: time,
-        treatment: {
-          label: treatment[:label],
-          treatment: treatment[:treatment],
-          change_number: treatment[:change_number]
-        },
-        attributes: attributes
-      )
-    end
-
-    def route_impressions(split_names, matching_key, bucketing_key, time, treatments_labels_change_numbers, attributes)
-      impression_router.add_bulk(
-        split_names: split_names,
-        matching_key: matching_key,
-        bucketing_key: bucketing_key,
-        time: time,
-        treatments_labels_change_numbers: treatments_labels_change_numbers,
-        attributes: attributes
-      )
-    end
-
-    def impression_router
-      @impression_router ||= SplitIoClient::ImpressionRouter.new(@config)
-    end
-
     def track(key, traffic_type_name, event_type, value = nil, properties = nil)
       return false unless valid_client && @config.split_validator.valid_track_parameters(key, traffic_type_name, event_type, value, properties)
 
@@ -239,26 +200,20 @@ module SplitIoClient
 
       bucketing_key, matching_key = keys_from_key(key)
       bucketing_key = bucketing_key ? bucketing_key.to_s : nil
-      matching_key = matching_key ? matching_key.to_s : nil
+      matching_key = matching_key ? matching_key.to_s : nil     
 
       evaluator = Engine::Parser::Evaluator.new(@segments_repository, @splits_repository, @config, true)
       start = Time.now
+      impressions = []
       treatments_labels_change_numbers =
         @splits_repository.get_splits(sanitized_split_names).each_with_object({}) do |(name, data), memo|
-          memo.merge!(name => treatment(key, name, attributes, data, false, true, evaluator))
+          memo.merge!(name => treatment(key, name, attributes, data, false, true, evaluator, calling_method, impressions))
         end
       latency = (Time.now - start) * 1000.0
       # Measure
       @metrics.time('sdk.' + calling_method, latency)
 
-      treatments_for_impressions = get_treatment_for_impressions(treatments_labels_change_numbers)
-
-      time = (Time.now.to_f * 1000.0).to_i
-      @impressions_repository.add_bulk(
-        matching_key, bucketing_key, treatments_for_impressions, time
-      ) unless treatments_for_impressions == {}
-
-      route_impressions(sanitized_split_names, matching_key, bucketing_key, time, treatments_for_impressions, attributes)
+      @impressions_manager.track(impressions)
 
       split_names_keys = treatments_labels_change_numbers.keys
       treatments = treatments_labels_change_numbers.values.map do |v|
@@ -284,7 +239,7 @@ module SplitIoClient
     # @return [String/Hash] Treatment as String or Hash of treatments in case of array of features
     def treatment(
         key, split_name, attributes = {}, split_data = nil, store_impressions = true,
-        multiple = false, evaluator = nil, calling_method = 'get_treatment'
+        multiple = false, evaluator = nil, calling_method = 'get_treatment', impressions = []
       )
       control_treatment = { treatment: Engine::Models::Treatment::CONTROL }
 
@@ -329,15 +284,18 @@ module SplitIoClient
         end
 
         latency = (Time.now - start) * 1000.0
-
-        store_impression(split_name, matching_key, bucketing_key, treatment_data, attributes) if store_impressions
+        
+        impression = @impressions_manager.build_impression(matching_key, bucketing_key, split_name, treatment_data, { attributes: attributes, time: nil })
+        impressions << impression unless impression.nil?
 
         # Measure
         @metrics.time('sdk.' + calling_method, latency) unless multiple
       rescue StandardError => error
+        p error
         @config.log_found_exception(__method__.to_s, error)
 
-        store_impression(split_name, matching_key, bucketing_key, control_treatment, attributes) if store_impressions
+        impression = @impressions_manager.build_impression(matching_key, bucketing_key, split_name, control_treatment, { attributes: attributes, time: nil })
+        impressions << impression unless impression.nil?
 
         return parsed_treatment(multiple, control_treatment.merge({ label: Engine::Models::Label::EXCEPTION }))
       end
@@ -357,12 +315,5 @@ module SplitIoClient
     def parsed_attributes(attributes)
       return attributes || attributes.to_h
     end
-
-    def get_treatment_for_impressions(treatments_labels_change_numbers)
-      return treatments_labels_change_numbers.select{|imp| 
-        treatments_labels_change_numbers[imp][:label] != Engine::Models::Label::NOT_FOUND && 
-        !treatments_labels_change_numbers[imp][:label].nil?
-      }
-    end
   end
 end

data/lib/splitclient-rb/engine/api/impressions.rb

@@ -14,16 +14,31 @@ module SplitIoClient
           return
         end
 
-        impressions_by_ip(impressions).each do |ip, impressions_ip|
-          response = post_api("#{@config.events_uri}/testImpressions/bulk", @api_key, impressions_ip)
-
-          if response.success?
-            @config.split_logger.log_if_debug("Impressions reported: #{total_impressions(impressions)}")
-          else
-            @config.logger.error("Unexpected status code while posting impressions: #{response.status}." \
-            ' - Check your API key and base URI')
-            raise 'Split SDK failed to connect to backend to post impressions'
-          end
+        response = post_api("#{@config.events_uri}/testImpressions/bulk", @api_key, impressions, impressions_headers)
+
+        if response.success?
+          @config.split_logger.log_if_debug("Impressions reported: #{total_impressions(impressions)}")
+        else
+          @config.logger.error("Unexpected status code while posting impressions: #{response.status}." \
+          ' - Check your API key and base URI')
+          raise 'Split SDK failed to connect to backend to post impressions'
+        end
+      end
+
+      def post_count(impressions_count)
+        if impressions_count.nil? || impressions_count[:pf].empty?
+          @config.split_logger.log_if_debug('No impressions count to send')
+          return
+        end
+
+        response = post_api("#{@config.events_uri}/testImpressions/count", @api_key, impressions_count)
+
+        if response.success?
+          @config.split_logger.log_if_debug("Impressions count sent: #{impressions_count[:pf].length}")
+        else
+          @config.logger.error("Unexpected status code while posting impressions count: #{response.status}." \
+          ' - Check your API key and base URI')
+          raise 'Split SDK failed to connect to backend to post impressions'
         end
       end
 
@@ -31,14 +46,16 @@ module SplitIoClient
         return 0 if impressions.nil?
 
         impressions.reduce(0) do |impressions_count, impression|
-          impressions_count += impression[:keyImpressions].length
+          impressions_count += impression[:i].length
         end
       end
 
       private
 
-      def impressions_by_ip(impressions)
-        impressions.group_by { |impression| impression[:ip] }
+      def impressions_headers
+        {
+          'SplitSDKImpressionsMode' => @config.impressions_mode.to_s
+        }
       end
     end
   end

data/lib/splitclient-rb/engine/common/impressions_counter.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'concurrent'
+
+module SplitIoClient
+  module Engine
+    module Common
+      TIME_INTERVAL_MS = 3600 * 1000
+
+      class ImpressionCounter
+        DEFAULT_AMOUNT = 1
+
+        def initialize
+          @cache = Concurrent::Hash.new
+        end
+
+        def inc(split_name, time_frame)
+          key = make_key(split_name, time_frame)
+
+          current_amount = @cache[key]
+          @cache[key] = current_amount.nil? ? DEFAULT_AMOUNT : (current_amount + DEFAULT_AMOUNT)
+        end
+
+        def pop_all
+          to_return = Concurrent::Hash.new
+
+          @cache.each do |key, value|
+            to_return[key] = value
+          end
+          @cache.clear
+
+          to_return
+        end
+
+        def truncate_time_frame(timestamp_ms)
+          timestamp_ms - (timestamp_ms % TIME_INTERVAL_MS)
+        end
+
+        def make_key(split_name, time_frame)
+          "#{split_name}::#{truncate_time_frame(time_frame)}"
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/engine/common/impressions_manager.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Engine
+    module Common
+      class ImpressionManager
+        def initialize(config, impressions_repository, impression_counter)
+          @config = config
+          @impressions_repository = impressions_repository
+          @impression_counter = impression_counter
+          @impression_router = SplitIoClient::ImpressionRouter.new(@config)
+          @impression_observer = SplitIoClient::Observers::ImpressionObserver.new
+        end
+
+        # added param time for test
+        def build_impression(matching_key, bucketing_key, split_name, treatment, params = {})
+          impression_data = impression_data(matching_key, bucketing_key, split_name, treatment, params[:time])
+
+          impression_data[:pt] = @impression_observer.test_and_set(impression_data) unless redis?
+
+          return impression_optimized(split_name, impression_data, params[:attributes]) if optimized? && !redis?
+
+          impression(impression_data, params[:attributes])
+        rescue StandardError => error
+          @config.log_found_exception(__method__.to_s, error)
+        end
+
+        def track(impressions)
+          @impressions_repository.add_bulk(impressions)
+          @impression_router.add_bulk(impressions)
+        rescue StandardError => error
+          @config.log_found_exception(__method__.to_s, error)
+        end
+
+        private
+
+        # added param time for test
+        def impression_data(matching_key, bucketing_key, split_name, treatment, time = nil)
+          {
+            k: matching_key,
+            b: bucketing_key,
+            f: split_name,
+            t: treatment[:treatment],
+            r: applied_rule(treatment[:label]),
+            c: treatment[:change_number],
+            m: time || (Time.now.to_f * 1000.0).to_i,
+            pt: nil
+          }
+        end
+
+        def metadata
+          {
+            s: "#{@config.language}-#{@config.version}",
+            i: @config.machine_ip,
+            n: @config.machine_name
+          }
+        end
+
+        def applied_rule(label)
+          @config.labels_enabled ? label : nil
+        end
+
+        def optimized?
+          @config.impressions_mode == :optimized
+        end
+
+        def impression_optimized(split_name, impression_data, attributes)
+          @impression_counter.inc(split_name, impression_data[:m])
+
+          impression(impression_data, attributes) if should_queue_impression?(impression_data)
+        end
+
+        def should_queue_impression?(impression)
+          impression[:pt].nil? || (impression[:pt] < ((Time.now.to_f * 1000.0).to_i - Common::TIME_INTERVAL_MS))
+        end
+
+        def impression(impression_data, attributes)
+          { m: metadata, i: impression_data, attributes: attributes }
+        end
+
+        def redis?
+          @config.impressions_adapter.class.to_s == 'SplitIoClient::Cache::Adapters::RedisAdapter'
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/engine/evaluator/splitter.rb

@@ -1,7 +1,3 @@
-unless defined?(JRUBY_VERSION)
-  require 'digest/murmurhash'
-end
-
 module SplitIoClient
   # Misc class in charge of providing hash functions and
   # determination of treatment based on concept of buckets
@@ -13,7 +9,7 @@ module SplitIoClient
       when 'java' 
         Proc.new { |key, seed| Java::MurmurHash3.murmurhash3_x86_32(key, seed) }
       else
-        Proc.new { |key, seed| Digest::MurmurHash3_x86_32.rawdigest(key, [seed].pack('L')) }
+        Proc.new { |key, seed| Digest::MurmurHashMRI3_x86_32.rawdigest(key, [seed].pack('L')) }
       end
     end
     

data/lib/splitclient-rb/engine/parser/evaluator.rb

@@ -1,7 +1,3 @@
-unless defined?(JRUBY_VERSION)
-  require 'digest/murmurhash'
-end
-
 module SplitIoClient
   module Engine
     module Parser

data/lib/splitclient-rb/engine/sync_manager.rb

@@ -9,14 +9,13 @@ module SplitIoClient
         repositories,
         api_key,
         config,
-        sdk_blocker,
-        metrics
+        params
       )
-        split_fetcher = SplitFetcher.new(repositories[:splits], api_key, metrics, config, sdk_blocker)
-        segment_fetcher = SegmentFetcher.new(repositories[:segments], api_key, metrics, config, sdk_blocker)
-        sync_params = { split_fetcher: split_fetcher, segment_fetcher: segment_fetcher }
+        split_fetcher = SplitFetcher.new(repositories[:splits], api_key, params[:metrics], config, params[:sdk_blocker])
+        segment_fetcher = SegmentFetcher.new(repositories[:segments], api_key, params[:metrics], config, params[:sdk_blocker])
+        sync_params = { split_fetcher: split_fetcher, segment_fetcher: segment_fetcher, imp_counter: params[:impression_counter] }
 
-        @synchronizer = Synchronizer.new(repositories, api_key, config, sdk_blocker, sync_params)
+        @synchronizer = Synchronizer.new(repositories, api_key, config, params[:sdk_blocker], sync_params)
         notification_manager_keeper = SplitIoClient::SSE::NotificationManagerKeeper.new(config) do |manager|
           manager.on_occupancy { |publisher_available| process_occupancy(publisher_available) }
           manager.on_push_shutdown { process_push_shutdown }

data/lib/splitclient-rb/engine/synchronizer.rb

@@ -23,6 +23,8 @@ module SplitIoClient
         @sdk_blocker = sdk_blocker
         @split_fetcher = params[:split_fetcher]
         @segment_fetcher = params[:segment_fetcher]
+        @impressions_api = SplitIoClient::Api::Impressions.new(@api_key, @config)
+        @impression_counter = params[:imp_counter]
       end
 
       def sync_all
@@ -35,6 +37,7 @@ module SplitIoClient
         impressions_sender
         metrics_sender
         events_sender
+        impressions_count_sender
       end
 
       def start_periodic_fetch
@@ -73,7 +76,7 @@ module SplitIoClient
 
       # Starts thread which loops constantly and sends impressions to the Split API
       def impressions_sender
-        ImpressionsSender.new(@impressions_repository, @api_key, @config).call
+        ImpressionsSender.new(@impressions_repository, @config, @impressions_api).call
       end
 
       # Starts thread which loops constantly and sends metrics to the Split API
@@ -85,6 +88,11 @@ module SplitIoClient
       def events_sender
         EventsSender.new(@events_repository, @config).call
       end
+
+      # Starts thread which loops constantly and sends impressions count to the Split API
+      def impressions_count_sender
+        ImpressionsCountSender.new(@config, @impression_counter, @impressions_api).call
+      end
     end
   end
 end