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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d0c945c95a835a0f60f13a614bdae0a20978bf2d
-  data.tar.gz: 7dbe050fd70c0f5ff6805e38b715f7a571666fba
+  metadata.gz: 587fa9e98277f3a3f2551240e421d5a734ed821e
+  data.tar.gz: 9ba4dd4290b4b61e18e29c3390a901bdd9e9aebd
 SHA512:
-  metadata.gz: 5517bb32198da4696b4bee5a983d7cd2baa3af2caf2de65f2848c58817ad6664865a4437a53e87be9ef54914870a6ab31999304ce2ddc103e9442999a21bb927
-  data.tar.gz: 55983d8a45d23b1862e5e2809f468779e2f9a7c2edbe059e9beb3615885c0c1211d94554e275f530e1f871489c1952dc410189fe300cb192764308507e0c86da
+  metadata.gz: 737188f30254868feebdf799ddc9e4a54ef840db885aac1c1155b1e4bc988e112e15ec7879d89bc31911abb334b08379211b7cf93d5735124b330d2f93bf7704
+  data.tar.gz: e96eca60d3dc2c53c2667f0a4eee50ed960865af99d6108788598589f8d16cc5b2d33d61a9ae9616f2446888c9a527b8019eecd459ade92ecce66aedac9c2224

data/CHANGES.txt

@@ -1,7 +1,7 @@
 CHANGES
 
 7.1.3 (Jul 31, 2020)
-- Updated rake development dependency to ~> 12.3.3
+- Updated rake development dependency to ~> 12.3.3.
 
 7.1.2 (Jun 15, 2020)
 - Fixed uninitialized constant LocalhostSplitStore::YAML for console apps.

data/Rakefile

@@ -11,14 +11,19 @@ RSpec::Core::RakeTask.new(:spec)
 RuboCop::RakeTask.new(:rubocop)
 
 task spec: :compile
-
-if RUBY_PLATFORM == 'java'
+case RUBY_PLATFORM
+when 'java'
   require 'rake/javaextensiontask'
   Rake::JavaExtensionTask.new 'murmurhash' do |ext|
     ext.lib_dir = 'lib/murmurhash'
     ext.target_version = '1.7'
     ext.source_version = '1.7'
   end
+else
+  require 'rake/extensiontask'
+  Rake::ExtensionTask.new 'murmurhash' do |ext|
+    ext.lib_dir = 'lib/murmurhash'
+  end
 end
 
 if !ENV['APPRAISAL_INITIALIZED']

data/ext/murmurhash/MurmurHash3.java

@@ -159,4 +159,143 @@ public final class MurmurHash3 {
 
         return h1 & 0xFFFFFFFFL;
     }
+
+    // The following set of methods and constants are borrowed from:
+    // `This method is borrowed from `org.apache.commons.codec.digest.MurmurHash3`
+
+    // Constants for 128-bit variant
+    private static final long C1 = 0x87c37b91114253d5L;
+    private static final long C2 = 0x4cf5ad432745937fL;
+    private static final int R1 = 31;
+    private static final int R2 = 27;
+    private static final int R3 = 33;
+    private static final int M = 5;
+    private static final int N1 = 0x52dce729;
+    private static final int N2 = 0x38495ab5;
+
+    /**
+     * Gets the little-endian long from 8 bytes starting at the specified index.
+     *
+     * @param data The data
+     * @param index The index
+     * @return The little-endian long
+     */
+    private static long getLittleEndianLong(final byte[] data, final int index) {
+        return (((long) data[index    ] & 0xff)      ) |
+                (((long) data[index + 1] & 0xff) <<  8) |
+                (((long) data[index + 2] & 0xff) << 16) |
+                (((long) data[index + 3] & 0xff) << 24) |
+                (((long) data[index + 4] & 0xff) << 32) |
+                (((long) data[index + 5] & 0xff) << 40) |
+                (((long) data[index + 6] & 0xff) << 48) |
+                (((long) data[index + 7] & 0xff) << 56);
+    }
+
+    public static long[] hash128x64(final byte[] data) {
+        return hash128x64(data, 0, data.length, 0);
+    }
+
+    /**
+     * Generates 128-bit hash from the byte array with the given offset, length and seed.
+     *
+     * <p>This is an implementation of the 128-bit hash function {@code MurmurHash3_x64_128}
+     * from from Austin Applyby's original MurmurHash3 {@code c++} code in SMHasher.</p>
+     *
+     * @param data The input byte array
+     * @param offset The first element of array
+     * @param length The length of array
+     * @param seed The initial seed value
+     * @return The 128-bit hash (2 longs)
+     */
+    public static long[] hash128x64(final byte[] data, final int offset, final int length, final long seed) {
+        long h1 = seed;
+        long h2 = seed;
+        final int nblocks = length >> 4;
+
+        // body
+        for (int i = 0; i < nblocks; i++) {
+            final int index = offset + (i << 4);
+            long k1 = getLittleEndianLong(data, index);
+            long k2 = getLittleEndianLong(data, index + 8);
+
+            // mix functions for k1
+            k1 *= C1;
+            k1 = Long.rotateLeft(k1, R1);
+            k1 *= C2;
+            h1 ^= k1;
+            h1 = Long.rotateLeft(h1, R2);
+            h1 += h2;
+            h1 = h1 * M + N1;
+
+            // mix functions for k2
+            k2 *= C2;
+            k2 = Long.rotateLeft(k2, R3);
+            k2 *= C1;
+            h2 ^= k2;
+            h2 = Long.rotateLeft(h2, R1);
+            h2 += h1;
+            h2 = h2 * M + N2;
+        }
+
+        // tail
+        long k1 = 0;
+        long k2 = 0;
+        final int index = offset + (nblocks << 4);
+        switch (offset + length - index) {
+            case 15:
+                k2 ^= ((long) data[index + 14] & 0xff) << 48;
+            case 14:
+                k2 ^= ((long) data[index + 13] & 0xff) << 40;
+            case 13:
+                k2 ^= ((long) data[index + 12] & 0xff) << 32;
+            case 12:
+                k2 ^= ((long) data[index + 11] & 0xff) << 24;
+            case 11:
+                k2 ^= ((long) data[index + 10] & 0xff) << 16;
+            case 10:
+                k2 ^= ((long) data[index + 9] & 0xff) << 8;
+            case 9:
+                k2 ^= data[index + 8] & 0xff;
+                k2 *= C2;
+                k2 = Long.rotateLeft(k2, R3);
+                k2 *= C1;
+                h2 ^= k2;
+
+            case 8:
+                k1 ^= ((long) data[index + 7] & 0xff) << 56;
+            case 7:
+                k1 ^= ((long) data[index + 6] & 0xff) << 48;
+            case 6:
+                k1 ^= ((long) data[index + 5] & 0xff) << 40;
+            case 5:
+                k1 ^= ((long) data[index + 4] & 0xff) << 32;
+            case 4:
+                k1 ^= ((long) data[index + 3] & 0xff) << 24;
+            case 3:
+                k1 ^= ((long) data[index + 2] & 0xff) << 16;
+            case 2:
+                k1 ^= ((long) data[index + 1] & 0xff) << 8;
+            case 1:
+                k1 ^= data[index] & 0xff;
+                k1 *= C1;
+                k1 = Long.rotateLeft(k1, R1);
+                k1 *= C2;
+                h1 ^= k1;
+        }
+
+        // finalization
+        h1 ^= length;
+        h2 ^= length;
+
+        h1 += h2;
+        h2 += h1;
+
+        h1 = fmix64(h1);
+        h2 = fmix64(h2);
+
+        h1 += h2;
+        h2 += h1;
+
+        return new long[] { h1, h2 };
+    }
 }

data/lib/splitclient-rb.rb

@@ -12,6 +12,8 @@ require 'splitclient-rb/cache/adapters/memory_adapter'
 require 'splitclient-rb/cache/adapters/redis_adapter'
 require 'splitclient-rb/cache/fetchers/segment_fetcher'
 require 'splitclient-rb/cache/fetchers/split_fetcher'
+require 'splitclient-rb/cache/hashers/impression_hasher'
+require 'splitclient-rb/cache/observers/impression_observer'
 require 'splitclient-rb/cache/repositories/repository'
 require 'splitclient-rb/cache/repositories/segments_repository'
 require 'splitclient-rb/cache/repositories/splits_repository'
@@ -28,6 +30,7 @@ require 'splitclient-rb/cache/senders/impressions_formatter'
 require 'splitclient-rb/cache/senders/impressions_sender'
 require 'splitclient-rb/cache/senders/metrics_sender'
 require 'splitclient-rb/cache/senders/events_sender'
+require 'splitclient-rb/cache/senders/impressions_count_sender'
 require 'splitclient-rb/cache/senders/localhost_repo_cleaner'
 require 'splitclient-rb/cache/stores/store_utils'
 require 'splitclient-rb/cache/stores/localhost_split_builder'
@@ -52,6 +55,8 @@ require 'splitclient-rb/engine/api/metrics'
 require 'splitclient-rb/engine/api/segments'
 require 'splitclient-rb/engine/api/splits'
 require 'splitclient-rb/engine/api/events'
+require 'splitclient-rb/engine/common/impressions_counter'
+require 'splitclient-rb/engine/common/impressions_manager'
 require 'splitclient-rb/engine/parser/condition'
 require 'splitclient-rb/engine/parser/partition'
 require 'splitclient-rb/engine/parser/evaluator'
@@ -105,7 +110,7 @@ require 'splitclient-rb/sse/notification_processor'
 require 'splitclient-rb/sse/sse_handler'
 
 # C extension
-#require 'murmurhash/murmurhash_mri'
+require 'murmurhash/murmurhash_mri'
 
 module SplitIoClient
   def self.root

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/repositories/impressions/memory_repository.rb

@@ -10,18 +10,10 @@ module SplitIoClient
             @adapter = @config.impressions_adapter
           end
 
-          # Store impression data in the selected adapter
-          def add(matching_key, bucketing_key, split_name, treatment, time)
-            @adapter.add_to_queue(
-              m: metadata,
-              i: impression_data(
-                matching_key,
-                bucketing_key,
-                split_name,
-                treatment,
-                time
-              )
-            )
+          def add_bulk(impressions)
+            impressions.each do |impression|
+              @adapter.add_to_queue(impression)
+            end
           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 \
@@ -30,12 +22,6 @@ module SplitIoClient
             end
           end
 
-          def add_bulk(key, bucketing_key, treatments, time)
-            treatments.each do |split_name, treatment|
-              add(key, bucketing_key, split_name, treatment, time)
-            end
-          end
-
           def batch
             return [] if @config.impressions_bulk_size.zero?
 

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

@@ -12,28 +12,17 @@ module SplitIoClient
             @adapter = @config.impressions_adapter
           end
 
-          def add(matching_key, bucketing_key, split_name, treatment, time)
-            add_bulk(matching_key, bucketing_key, { split_name => treatment }, time)
-          end
-
-          def add_bulk(matching_key, bucketing_key, treatments, time)
-            impressions = treatments.map do |split_name, treatment|
-              {
-                m: metadata,
-                i: impression_data(
-                  matching_key,
-                  bucketing_key,
-                  split_name,
-                  treatment,
-                  time
-                )
-              }.to_json
+          def add_bulk(impressions)
+            impressions_json = impressions.map do |impression|
+              impression.to_json
             end
 
-            impressions_list_size = @adapter.add_to_queue(key, impressions)
+            impressions_list_size = @adapter.add_to_queue(key, impressions_json)
 
             # Synchronizer might not be running
-            @adapter.expire(key, EXPIRE_SECONDS) if impressions.size == impressions_list_size
+            @adapter.expire(key, EXPIRE_SECONDS) if impressions_json.size == impressions_list_size
+          rescue StandardError => e
+            @config.logger.error("Exception while add_bulk_v2: #{e}")
           end
 
           def get_impressions(number_of_impressions = 0)

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

@@ -6,7 +6,7 @@ module SplitIoClient
       # Repository which forwards impressions interface to the selected adapter
       class ImpressionsRepository < Repository
         extend Forwardable
-        def_delegators :@repository, :add, :add_bulk, :batch, :clear, :empty?
+        def_delegators :@repository, :add_bulk, :batch, :clear, :empty?
 
         def initialize(config)
           super(config)
@@ -17,32 +17,6 @@ module SplitIoClient
                        Repositories::Impressions::RedisRepository.new(@config)
                      end
         end
-
-        protected
-
-        def impression_data(matching_key, bucketing_key, split_name, treatment, timestamp)
-          {
-            k: matching_key,
-            b: bucketing_key,
-            f: split_name,
-            t: treatment[:treatment],
-            r: applied_rule(treatment[:label]),
-            c: treatment[:change_number],
-            m: timestamp
-          }
-        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
       end
     end
   end

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

@@ -18,24 +18,22 @@ module SplitIoClient
       end
     end
 
-    def add(impression)
-      enqueue(impression)
-    end
-
     def add_bulk(impressions)
-      impressions[:split_names].each do |split_name|
+      return unless @listener
+      impressions.each do |impression|
         enqueue(
-          split_name: split_name.to_s,
-          matching_key: impressions[:matching_key],
-          bucketing_key: impressions[:bucketing_key],
-          time: impressions[:time],
+          split_name: impression[:i][:f],
+          matching_key: impression[:i][:k],
+          bucketing_key: impression[:i][:b],
+          time: impression[:i][:m],
           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]
+            label: impression[:i][:r],
+            treatment: impression[:i][:t],
+            change_number: impression[:i][:c]
           },
-          attributes: impressions[:attributes]
-        ) unless impressions[:treatments_labels_change_numbers][split_name.to_sym].nil?
+          previous_time: impression[:i][:pt],
+          attributes: impression[:attributes]
+        ) unless impression.nil?
       end
     end
 

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Cache
+    module Senders
+      class ImpressionsCountSender
+        COUNTER_REFRESH_RATE_SECONDS = 1800
+
+        def initialize(config, impression_counter, impressions_api)
+          @config = config
+          @impression_counter = impression_counter
+          @impressions_api = impressions_api
+        end
+
+        def call
+          impressions_count_thread
+
+          if defined?(PhusionPassenger)
+            PhusionPassenger.on_event(:starting_worker_process) do |forked|
+              impressions_count_thread if forked
+            end
+          end
+        end
+
+        private
+
+        def impressions_count_thread
+          @config.threads[:impressions_count_sender] = Thread.new do
+            begin
+              @config.logger.info('Starting impressions count service')
+
+              loop do
+                post_impressions_count
+
+                sleep(COUNTER_REFRESH_RATE_SECONDS)
+              end
+            rescue SplitIoClient::SDKShutdownException
+              post_impressions_count
+
+              @config.logger.info('Posting impressions count due to shutdown')
+            end
+          end
+
+          def post_impressions_count
+            @impressions_api.post_count(formatter(@impression_counter.pop_all))
+          rescue StandardError => error
+            @config.log_found_exception(__method__.to_s, error)
+          end
+
+          def formatter(counts)
+            return if 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 => error
+            @config.log_found_exception(__method__.to_s, error)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -17,12 +17,10 @@ module SplitIoClient
 
           formatted_impressions = unique_features(filtered_impressions).each_with_object([]) do |feature, memo|
             feature_impressions = feature_impressions(filtered_impressions, feature)
-            ip = feature_impressions.first[:m][:i]
             current_impressions = current_impressions(feature_impressions)
             memo << {
-              testName: feature.to_sym,
-              keyImpressions: current_impressions,
-              ip: ip
+              f: feature.to_sym,
+              i: current_impressions
             }
           end
 
@@ -40,12 +38,13 @@ module SplitIoClient
         def current_impressions(feature_impressions)
           feature_impressions.map do |impression|
             {
-              keyName: impression[:i][:k],
-              treatment: impression[:i][:t],
-              time: impression[:i][:m],
-              bucketingKey: impression[:i][:b],
-              label: impression[:i][:r],
-              changeNumber: impression[:i][:c]
+              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]
             }
           end
         end
@@ -73,7 +72,8 @@ module SplitIoClient
           "#{impression[:i][:k]}:" \
           "#{impression[:i][:b]}:" \
           "#{impression[:i][:c]}:" \
-          "#{impression[:i][:t]}"
+          "#{impression[:i][:t]}:" \
+          "#{impression[:i][:pt]}"
         end
       end
     end

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

data/lib/splitclient-rb/split_config.rb

@@ -53,7 +53,9 @@ module SplitIoClient
       @segments_refresh_rate = opts[:segments_refresh_rate] || SplitConfig.default_segments_refresh_rate
       @metrics_refresh_rate = opts[:metrics_refresh_rate] || SplitConfig.default_metrics_refresh_rate
 
-      @impressions_refresh_rate = opts[:impressions_refresh_rate] || SplitConfig.default_impressions_refresh_rate
+      @impressions_mode = init_impressions_mode(opts[:impressions_mode])
+
+      @impressions_refresh_rate = SplitConfig.init_impressions_refresh_rate(@impressions_mode, opts[:impressions_refresh_rate], SplitConfig.default_impressions_refresh_rate)
       @impressions_queue_size = opts[:impressions_queue_size] || SplitConfig.default_impressions_queue_size
       @impressions_adapter = SplitConfig.init_cache_adapter(
         opts[:cache_adapter] || SplitConfig.default_cache_adapter, :queue_adapter, @impressions_queue_size, @redis_url
@@ -270,6 +272,30 @@ module SplitIoClient
 
     attr_accessor :streaming_enabled
 
+    attr_accessor :impressions_mode
+
+    def self.default_impressions_mode
+      :optimized
+    end
+
+    def init_impressions_mode(impressions_mode)
+      impressions_mode ||= SplitConfig.default_impressions_mode
+
+      case impressions_mode
+      when :debug
+        return :debug
+      else
+        @logger.error('You passed an invalid impressions_mode, impressions_mode should be one of the following values: :debug or :optimized. Defaulting to :optimized mode') unless impressions_mode == :optimized
+        return :optimized
+      end
+    end
+
+    def self.init_impressions_refresh_rate(impressions_mode, refresh_rate, default_rate)      
+      return (refresh_rate.nil? || refresh_rate <= 0 ? default_rate : refresh_rate) if impressions_mode == :debug
+      
+      return refresh_rate.nil? || refresh_rate <= 0 ? SplitConfig.default_impressions_refresh_rate_optimized : [default_rate, refresh_rate].max
+    end
+
     def self.default_streaming_enabled
       true
     end
@@ -387,6 +413,10 @@ module SplitIoClient
       60
     end
 
+    def self.default_impressions_refresh_rate_optimized
+      300
+    end
+
     def self.default_impression_listener_refresh_rate
       0
     end

data/lib/splitclient-rb/split_factory.rb

@@ -34,10 +34,12 @@ module SplitIoClient
       @metrics_repository = MetricsRepository.new(@config)
       @sdk_blocker = SDKBlocker.new(@splits_repository, @segments_repository, @config)
       @metrics = Metrics.new(100, @metrics_repository)
+      @impression_counter = SplitIoClient::Engine::Common::ImpressionCounter.new
+      @impressions_manager = SplitIoClient::Engine::Common::ImpressionManager.new(@config, @impressions_repository, @impression_counter)
 
       start!
 
-      @client = SplitClient.new(@api_key, @metrics, @splits_repository, @segments_repository, @impressions_repository, @metrics_repository, @events_repository, @sdk_blocker, @config)
+      @client = SplitClient.new(@api_key, @metrics, @splits_repository, @segments_repository, @impressions_repository, @metrics_repository, @events_repository, @sdk_blocker, @config, @impressions_manager)
       @manager = SplitManager.new(@splits_repository, @sdk_blocker, @config)
 
       validate_api_key
@@ -51,7 +53,8 @@ module SplitIoClient
       if @config.localhost_mode
         start_localhost_components
       else
-        SplitIoClient::Engine::SyncManager.new(repositories, @api_key, @config, @sdk_blocker, @metrics).start
+        params = { sdk_blocker: @sdk_blocker, metrics: @metrics, impression_counter: @impression_counter }
+        SplitIoClient::Engine::SyncManager.new(repositories, @api_key, @config, params).start
       end
     end
 

data/lib/splitclient-rb/version.rb

@@ -1,3 +1,3 @@
 module SplitIoClient
-  VERSION = '7.1.4.pre.rc7'
+  VERSION = '7.1.4.pre.rc8'
 end

data/splitclient-rb.gemspec

@@ -26,7 +26,14 @@ Gem::Specification.new do |spec|
          lib/murmurhash/murmurhash.jar]
     )
   else
-    spec.add_runtime_dependency 'digest-murmurhash', '>= 1.1.1'
+    spec.files.concat(
+      %w[ext/murmurhash/3_x86_32.c
+         ext/murmurhash/3_x64_128.c
+         ext/murmurhash/extconf.rb
+         ext/murmurhash/murmurhash.c
+         ext/murmurhash/murmurhash.h]
+    )
+    spec.extensions = ['ext/murmurhash/extconf.rb']
   end
 
   spec.add_development_dependency 'allocation_stats'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: splitclient-rb
 version: !ruby/object:Gem::Version
-  version: 7.1.4.pre.rc7
+  version: 7.1.4.pre.rc8
 platform: java
 authors:
 - Split Software
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-08-26 00:00:00.000000000 Z
+date: 2020-09-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -337,6 +337,8 @@ files:
 - lib/splitclient-rb/cache/adapters/redis_adapter.rb
 - lib/splitclient-rb/cache/fetchers/segment_fetcher.rb
 - lib/splitclient-rb/cache/fetchers/split_fetcher.rb
+- lib/splitclient-rb/cache/hashers/impression_hasher.rb
+- lib/splitclient-rb/cache/observers/impression_observer.rb
 - lib/splitclient-rb/cache/repositories/events/memory_repository.rb
 - lib/splitclient-rb/cache/repositories/events/redis_repository.rb
 - lib/splitclient-rb/cache/repositories/events_repository.rb
@@ -351,6 +353,7 @@ files:
 - lib/splitclient-rb/cache/repositories/splits_repository.rb
 - lib/splitclient-rb/cache/routers/impression_router.rb
 - lib/splitclient-rb/cache/senders/events_sender.rb
+- lib/splitclient-rb/cache/senders/impressions_count_sender.rb
 - lib/splitclient-rb/cache/senders/impressions_formatter.rb
 - lib/splitclient-rb/cache/senders/impressions_sender.rb
 - lib/splitclient-rb/cache/senders/localhost_repo_cleaner.rb
@@ -370,6 +373,8 @@ files:
 - lib/splitclient-rb/engine/api/segments.rb
 - lib/splitclient-rb/engine/api/splits.rb
 - lib/splitclient-rb/engine/auth_api_client.rb
+- lib/splitclient-rb/engine/common/impressions_counter.rb
+- lib/splitclient-rb/engine/common/impressions_manager.rb
 - lib/splitclient-rb/engine/evaluator/splitter.rb
 - lib/splitclient-rb/engine/matchers/all_keys_matcher.rb
 - lib/splitclient-rb/engine/matchers/between_matcher.rb