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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 466e08e89ced1060fc54b61943291949d592de14
-  data.tar.gz: d3dc48c5aadb358a573cec5d7774d173edcf0673
+  metadata.gz: b1309484de3281c553d149dedc90df953df886f6
+  data.tar.gz: 3f4cc3a188da4d9c3167465b4d3e9886bc92320f
 SHA512:
-  metadata.gz: 929793f1ddf099968d42c1ff6397b127cf5e11791e66f702b44304374baed4b16600e5a2185941b71e8e4416999175f6530cfdd7d85dc33523dc17331c4ddd55
-  data.tar.gz: e992dcbac1d607b045da85132bdb913e72cd8b4d4cf98e12a002f97d3a2275488a96cb544b2497451515ffe1d63414b229b4810e1c38ad09ed2370fe92ce448a
+  metadata.gz: 9d28027d4c955132b5064c331fb2d7a50104a8e04b5d7abc86bd102731324050572b021b02a4d5e384d2101e6c37351f158c50660706d26125d8c8619b45cb5c
+  data.tar.gz: fe822d1c1f3395e0f8c48fed3dbee881dd8d7a9b15964bc5340d300c0cf2494fdba7406b6fe79c8f409955cc8fc02793374e26026cdd3ee34795c8aecb3a4f42

data/README.md

@@ -104,7 +104,7 @@ The following values can be customized:
 
 **impressions_refresh_rate** : The SDK sends information on who got what treatment at what time back to Split servers to power analytics. This parameter controls how often this data is sent to Split servers in seconds
 
-**impressions_queue_size** : The size of the impressions queue. -1 to disable impressions.
+**impressions_queue_size** : The size of the impressions queue in case of `cache_adapter == :memory` and the size impressions batch to be fetched from Redis in case of `cache_adapter == :redis`. Use `-1` to disable impressions.
 
 *default value* = `60`
 
@@ -130,7 +130,7 @@ The following values can be customized:
 
 #### Cache adapter
 
-The SDK needs some container to store fetched data, i.e. splits/segments. By default it will store everything in the application's memory, but you can also use Redis.
+The SDK needs some container to store data, i.e. splits/segments/impressions. By default it will store everything in the application's memory, but you can also use Redis.
 
 To use Redis, you have to include `redis-rb` in your app's Gemfile.
 
@@ -163,7 +163,7 @@ options = {
   logger: Logger.new('logfile.log'),
   block_until_ready: 5,
   cache_adapter: :redis,
-  mode: :consumer,
+  mode: :standalone,
   redis_url: 'redis://127.0.0.1:6379/0'
 }
 begin
@@ -172,6 +172,10 @@ rescue SplitIoClient::SDKBlockerTimeoutExpiredException
   # Some arbitrary actions
 end
 ```
+
+#### IMPORTANT
+For now, SDK does not support both `producer` mode and `block_until_ready`. You must either run SDK in `standalone` mode, or do not use `block_until_ready` option.
+
 This begin-rescue-end block is optional, you might want to use it to catch timeout expired exception and apply some logic.
 
 ### Execution
@@ -230,28 +234,28 @@ And you should get something like this:
 
 ```ruby
 [
-	{ 
+	{
 		name: 'some_feature',
 		traffic_type_name: nil,
 		killed: false,
 		treatments: nil,
 		change_number: 1469134003507
 	},
-	{ 
+	{
 		name: 'another_feature',
 		traffic_type_name: nil,
 		killed: false,
 		treatments: nil,
 		change_number: 1469134003414
 	},
-	{ 
+	{
 		name: 'even_more_features',
 		traffic_type_name: nil,
 		killed: false,
 		treatments: nil,
 		change_number: 1469133991063
 	},
-	{ 
+	{
 		name: 'yet_another_feature',
 		traffic_type_name: nil,
 		killed: false,
@@ -297,7 +301,7 @@ SDK can be ran in `producer` mode both in the scope of the application (e.g. as
 bundle binstubs splitclient-rb
 ```
 
-- Run the executable provided by the SDK: 
+- Run the executable provided by the SDK:
 ```ruby
 bundle exec bin/splitio -c ~/path/to/config/file.yml
 ```

data/lib/cache/adapters/memory_adapter.rb

@@ -3,98 +3,9 @@ require 'concurrent'
 module SplitIoClient
   module Cache
     module Adapters
-      class MemoryAdapter
-        def initialize
-          @map = Concurrent::Map.new
-        end
-
-        # Map
-        def initialize_map(key)
-          @map[key] = Concurrent::Map.new
-        end
-
-        def add_to_map(key, field, value)
-          @map[key].put(field, value)
-        end
-
-        def find_in_map(key, field)
-          return nil if @map[key].nil?
-
-          @map[key].get(field)
-        end
-
-        def delete_from_map(key, fields)
-          if fields.is_a? Array
-            fields.each { |field| @map[key].delete(field) }
-          else
-            @map[key].delete(field)
-          end
-        end
-
-        def in_map?(key, field)
-          return false if @map[key].nil?
-
-          @map[key].key?(field)
-        end
-
-        def map_keys(key)
-          @map[key].keys
-        end
-
-        def get_map(key)
-          @map[key]
-        end
-
-        # String
-        def string(key)
-          @map[key]
-        end
-
-        def set_string(key, str)
-          @map[key] = str
-        end
-
-        def find_strings_by_prefix(prefix)
-          @map.keys.select { |str| str.start_with? prefix }
-        end
-
-        def multiple_strings(keys)
-          keys.each_with_object({}) do |key, memo|
-            memo[key] = string(key)
-          end
-        end
-
-        # Bool
-        def set_bool(key, val)
-          @map[key] = val
-        end
-
-        def bool(key)
-          @map[key]
-        end
-
-        # Set
-        alias_method :initialize_set, :initialize_map
-        alias_method :get_set, :map_keys
-        alias_method :delete_from_set, :delete_from_map
-        alias_method :in_set?, :in_map?
-
-        def add_to_set(key, values)
-          if values.is_a? Array
-            values.each { |value| add_to_map(key, value, 1) }
-          else
-            add_to_map(key, values, 1)
-          end
-        end
-
-        # General
-        def exists?(key)
-          !@map[key].nil?
-        end
-
-        def delete(key)
-          @map.delete(key)
-        end
+      # Memory adapter can have different implementations, this class is used as a delegator to
+      # this implementations
+      class MemoryAdapter < SimpleDelegator
       end
     end
   end

data/lib/cache/adapters/memory_adapters/map_adapter.rb

@@ -0,0 +1,121 @@
+require 'concurrent'
+
+module SplitIoClient
+  module Cache
+    module Adapters
+      module MemoryAdapters
+        # Memory adapter implementation, which stores everything inside thread-safe Map
+        class MapAdapter
+          def initialize(_ = nil)
+            @map = Concurrent::Map.new
+          end
+
+          # Map
+          def initialize_map(key)
+            @map[key] = Concurrent::Map.new
+          end
+
+          def add_to_map(key, field, value)
+            initialize_map(key) unless @map[key]
+
+            @map[key].put(field, value)
+          end
+
+          def find_in_map(key, field)
+            return nil if @map[key].nil?
+
+            @map[key].get(field)
+          end
+
+          def delete_from_map(key, fields)
+            if fields.is_a? Array
+              fields.each { |field| @map[key].delete(field) }
+            else
+              @map[key].delete(field)
+            end
+          end
+
+          def in_map?(key, field)
+            return false if @map[key].nil?
+
+            @map[key].key?(field)
+          end
+
+          def map_keys(key)
+            @map[key].keys
+          end
+
+          def get_map(key)
+            @map[key]
+          end
+
+          # String
+          def string(key)
+            @map[key]
+          end
+
+          def set_string(key, str)
+            @map[key] = str
+          end
+
+          def find_strings_by_prefix(prefix)
+            @map.keys.select { |str| str.start_with? prefix }
+          end
+
+          def multiple_strings(keys)
+            keys.each_with_object({}) do |key, memo|
+              memo[key] = string(key)
+            end
+          end
+
+          # Bool
+          def set_bool(key, val)
+            @map[key] = val
+          end
+
+          def bool(key)
+            @map[key]
+          end
+
+          # Set
+          alias_method :initialize_set, :initialize_map
+          alias_method :get_set, :map_keys
+          alias_method :delete_from_set, :delete_from_map
+          alias_method :in_set?, :in_map?
+          alias_method :find_sets_by_prefix, :find_strings_by_prefix
+
+          def add_to_set(key, values)
+            if values.is_a? Array
+              values.each { |value| add_to_map(key, value, 1) }
+            else
+              add_to_map(key, values, 1)
+            end
+          end
+
+          def get_all_from_set(key)
+            @map[key].keys
+          end
+
+          def union_sets(set_keys)
+            set_keys.each_with_object([]) do |key, memo|
+              memo << get_set(key)
+            end.flatten
+          end
+
+          # General
+          def exists?(key)
+            !@map[key].nil?
+          end
+
+          def delete(key)
+            if key.is_a? Array
+              key.each { |k| @map.delete(k) }
+            else
+              @map.delete(key)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cache/adapters/memory_adapters/sized_queue_adapter.rb

@@ -0,0 +1,38 @@
+module SplitIoClient
+  module Cache
+    module Adapters
+      module MemoryAdapters
+        # Memory adapter implementation, which stores everything inside sized queue
+        class SizedQueueAdapter
+          def initialize(size)
+            @size = size
+            @queue = SizedQueue.new(queue_size)
+          end
+
+          # Adds data to queue in non-blocking mode
+          def add_to_queue(data)
+            # IMPORTANT: this requires Ruby >= 2.2, consider changing implementation
+            @queue.push(data, true)
+          end
+
+          # Get all items from the queue
+          def clear
+            items = []
+
+            loop { items << @queue.pop(true) }
+          rescue ThreadError
+            # Last queue item reached
+            items
+          end
+
+          private
+
+          # Return 1 to prevent an exception
+          def queue_size
+            @size <= 0 ? 1 : @size
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cache/adapters/redis_adapter.rb

@@ -4,6 +4,7 @@ require 'json'
 module SplitIoClient
   module Cache
     module Adapters
+      # Redis adapter used to provide interface to Redis
       class RedisAdapter
         def initialize(redis_url)
           connection = redis_url.is_a?(Hash) ? redis_url : { url: redis_url }
@@ -68,6 +69,7 @@ module SplitIoClient
 
         # Set
         alias_method :initialize_set, :initialize_map
+        alias_method :find_sets_by_prefix, :find_strings_by_prefix
 
         def add_to_set(key, val)
           @redis.sadd(key, val)
@@ -85,12 +87,28 @@ module SplitIoClient
           @redis.sismember(key, val)
         end
 
+        def get_all_from_set(key)
+          @redis.smembers(key)
+        end
+
+        def union_sets(set_keys)
+          return [] if set_keys == []
+
+          @redis.sunion(set_keys)
+        end
+
+        def random_set_elements(key, count)
+          @redis.srandmember(key, count)
+        end
+
         # General
         def exists?(key)
           @redis.exists(key)
         end
 
         def delete(key)
+          return nil if key == []
+
           @redis.del(key)
         end
       end

data/lib/cache/repositories/impressions/memory_repository.rb

@@ -0,0 +1,35 @@
+module SplitIoClient
+  module Cache
+    module Repositories
+      module Impressions
+        class MemoryRepository
+          def initialize(adapter, config)
+            @adapter = adapter
+            @config = config
+          end
+
+          # Store impression data in the selected adapter
+          def add(split_name, data)
+            @adapter.add_to_queue(feature: split_name, impressions: data)
+          rescue ThreadError # queue is full
+            if random_sampler.rand(1..1000) <= 2 # log only 0.2 % of the time
+              @config.logger.warn("Dropping impressions. Current size is #{@config.impressions_queue_size}. " \
+                                  "Consider increasing impressions_queue_size")
+            end
+          end
+
+          # Get everything from the queue and leave it empty
+          def clear
+            @adapter.clear
+          end
+
+          private
+
+          def random_sampler
+            @random_sampler ||= Random.new
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module SplitIoClient
+  module Cache
+    module Repositories
+      module Impressions
+        class RedisRepository < Repository
+          def initialize(adapter, config)
+            @adapter = adapter
+            @config = config
+          end
+
+          # Store impression data in Redis
+          def add(split_name, data)
+            @adapter.add_to_set(
+              namespace_key("impressions.#{split_name}"), data.merge(split_name: split_name).to_json
+            )
+          end
+
+          # Get random impressions from redis in batches of size @config.impressions_queue_size,
+          # delete fetched impressions afterwards
+          def clear
+            impressions = impression_keys.each_with_object([]) do |key, memo|
+              @adapter.random_set_elements(key, @config.impressions_queue_size).each do |impression|
+                parsed_impression = JSON.parse(impression)
+
+                memo << {
+                  feature: parsed_impression['split_name'],
+                  impressions: parsed_impression.reject { |k, _| k == 'split_name' }
+                }
+
+                @adapter.delete_from_set(key, impression)
+              end
+            end
+
+            impressions
+          end
+
+          private
+
+          # Get all sets by prefix
+          def impression_keys
+            @adapter.find_sets_by_prefix(namespace_key('impressions.'))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cache/repositories/impressions_repository.rb

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

data/lib/cache/repositories/segments_repository.rb

@@ -10,6 +10,7 @@ module SplitIoClient
           @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]
 

data/lib/engine/parser/split_adapter.rb

@@ -13,10 +13,6 @@ module SplitIoClient
   # also, uses safe threads to execute fetches and post give the time execution values from the config
   #
   class SplitAdapter < NoMethodError
-    #
-    # handler for impressions
-    attr_reader :impressions
-
     #
     # handler for metrics
     attr_reader :metrics
@@ -31,7 +27,7 @@ module SplitIoClient
 
     attr_reader :impressions_producer
 
-    attr_reader :splits_repository, :segments_repository
+    attr_reader :splits_repository, :segments_repository, :impressions_repository
 
     #
     # Creates a new split api adapter instance that consumes split api endpoints
@@ -39,14 +35,14 @@ module SplitIoClient
     # @param api_key [String] the API key for your split account
     #
     # @return [SplitIoClient] split.io client instance
-    def initialize(api_key, config, splits_repository, segments_repository, sdk_blocker)
+    def initialize(api_key, config, splits_repository, segments_repository, impressions_repository, sdk_blocker)
       @api_key = api_key
       @config = config
-      @impressions = Impressions.new(@config)
       @metrics = Metrics.new(100)
 
       @splits_repository = splits_repository
       @segments_repository = segments_repository
+      @impressions_repository = impressions_repository
 
       @sdk_blocker = sdk_blocker
 
@@ -67,10 +63,10 @@ module SplitIoClient
         impressions_sender
       when :consumer
         metrics_sender
-        impressions_sender
       when :producer
         split_store
         segment_store
+        impressions_sender
 
         sleep unless ENV['SPLITCLIENT_ENV'] == 'test'
       end
@@ -107,7 +103,13 @@ module SplitIoClient
         req.body = param.to_json
         req.options.timeout = @config.read_timeout
         req.options.open_timeout = @config.connection_timeout
-        @config.logger.debug("POST #{@config.events_uri + path} #{req.body}") if @config.debug_enabled
+
+        if @config.transport_debug_enabled
+          @config.logger.debug("POST #{@config.events_uri + path} #{req.body}")
+        elsif @config.debug_enabled
+          @config.logger.debug("POST #{@config.events_uri + path}")
+        end
+
       end
     end
 
@@ -145,6 +147,14 @@ module SplitIoClient
     end
 
     def impressions_sender
+      # Disable impressions if @config.impressions_queue_size == -1
+      if @config.impressions_queue_size < 0
+        @config.logger.info("Disabling impressions service by config.")
+        return
+      end
+
+      @config.logger.info("Starting impressions service...")
+
       Thread.new do
         loop do
           begin
@@ -157,6 +167,7 @@ module SplitIoClient
           end
         end
       end
+      @config.logger.info("Started impressions service")
     end
 
     #
@@ -165,46 +176,69 @@ module SplitIoClient
     #
     # @return [void]
     def post_impressions
-      if @impressions.queue.empty?
-        @config.logger.debug('No impressions to report.') if @config.debug_enabled
+      impressions = impressions_array
+
+      if impressions.empty?
+        @config.logger.debug('No impressions to report') if @config.debug_enabled
+        return
+      end
+
+      res = post_api('/testImpressions/bulk', impressions)
+      if res.status / 100 != 2
+        @config.logger.error("Unexpected status code while posting impressions: #{res.status}")
       else
-        popped_impressions = @impressions.clear
-        test_impression_array = []
-        popped_impressions.each do |i|
-          filtered = []
-          keys_treatments_seen = []
-
-          impressions = i[:impressions]
-          impressions.each do |imp|
-            if keys_treatments_seen.include?("#{imp.key}:#{imp.treatment}")
-              next
-            end
-            keys_treatments_seen << "#{imp.key}:#{imp.treatment}"
-            filtered << imp
-          end
+        @config.logger.debug("Impressions reported: #{calculate_tot_impressions(impressions)}") if @config.debug_enabled
+      end
+    end
 
-          if filtered.empty?
-            @config.logger.debug('No impressions to report post filtering.') if @config.debug_enabled
-          else
-            test_impression = {}
-            key_impressions = []
+    def calculate_tot_impressions(impressions = nil)
+      tot = 0
+      return tot if impressions.nil?
+      impressions.each do |test_impression|
+        tot += test_impression[:keyImpressions].length
+      end
+      tot
+    end
 
-            filtered.each do |f|
-              key_impressions << {keyName: f.key, treatment: f.treatment, time: f.time.to_i}
-            end
+    # REFACTOR
+    def impressions_array(impressions = nil)
+      impressions_data = impressions || @impressions_repository
+      popped_impressions = impressions_data.clear
+      test_impression_array = []
+      filtered_impressions = []
+      keys_treatments_seen = []
 
-            test_impression = {testName: i[:feature], keyImpressions: key_impressions}
-            test_impression_array << test_impression
-          end
+      if !popped_impressions.empty?
+        popped_impressions.each do |item|
+          item_hash = "#{item[:impressions]['key_name']}:#{item[:impressions]['treatment']}"
+
+          next if keys_treatments_seen.include?(item_hash)
+
+          keys_treatments_seen << item_hash
+          filtered_impressions << item
         end
 
-        res = post_api('/testImpressions/bulk', test_impression_array)
-        if res.status / 100 != 2
-          @config.logger.error("Unexpected status code while posting impressions: #{res.status}")
-        else
-          @config.logger.debug("Impressions reported: #{test_impression_array}") if @config.debug_enabled
+        return [] unless filtered_impressions
+
+        features = filtered_impressions.map { |i| i[:feature] }.uniq
+        test_impression_array = features.each_with_object([]) do |feature, memo|
+          current_impressions = filtered_impressions.select { |i| i[:feature] == feature }
+          current_impressions.map! do |i|
+            {
+              keyName: i[:impressions]['key_name'],
+              treatment: i[:impressions]['treatment'],
+              time: i[:impressions]['time']
+            }
+          end
+
+          memo << {
+            testName: feature,
+            keyImpressions: current_impressions
+          }
         end
       end
+
+      test_impression_array
     end
 
     #
@@ -224,7 +258,7 @@ module SplitIoClient
           if res.status / 100 != 2
             @config.logger.error("Unexpected status code while posting time metrics: #{res.status}")
           else
-            @config.logger.debug("Metric time reported: #{metrics_time}") if @config.debug_enabled
+            @config.logger.debug("Metric time reported: #{metrics_time.size()}") if @config.debug_enabled
           end
         end
       end
@@ -240,7 +274,7 @@ module SplitIoClient
           if res.status / 100 != 2
             @config.logger.error("Unexpected status code while posting count metrics: #{res.status}")
           else
-            @config.logger.debug("Metric counts reported: #{metrics_count}") if @config.debug_enabled
+            @config.logger.debug("Metric counts reported: #{metrics_count.size()}") if @config.debug_enabled
           end
         end
       end
@@ -256,7 +290,7 @@ module SplitIoClient
           if res.status / 100 != 2
             @config.logger.error("Unexpected status code while posting gauge metrics: #{res.status}")
           else
-            @config.logger.debug("Metric gauge reported: #{metrics_gauge}") if @config.debug_enabled
+            @config.logger.debug("Metric gauge reported: #{metrics_gauge.size()}") if @config.debug_enabled
           end
         end
       end

data/lib/splitclient-rb.rb

@@ -5,11 +5,16 @@ require 'splitclient-rb/localhost_split_factory_builder'
 require 'splitclient-rb/localhost_split_factory'
 require 'splitclient-rb/split_config'
 require 'exceptions/sdk_blocker_timeout_expired_exception'
+require 'cache/adapters/memory_adapters/map_adapter'
+require 'cache/adapters/memory_adapters/sized_queue_adapter'
 require 'cache/adapters/memory_adapter'
 require 'cache/adapters/redis_adapter'
 require 'cache/repositories/repository'
 require 'cache/repositories/segments_repository'
 require 'cache/repositories/splits_repository'
+require 'cache/repositories/impressions_repository'
+require 'cache/repositories/impressions/memory_repository'
+require 'cache/repositories/impressions/redis_repository'
 require 'cache/stores/sdk_blocker'
 require 'cache/stores/segment_store'
 require 'cache/stores/split_store'
@@ -32,7 +37,6 @@ require 'engine/matchers/greater_than_or_equal_to_matcher'
 require 'engine/matchers/less_than_or_equal_to_matcher'
 require 'engine/matchers/between_matcher'
 require 'engine/evaluator/splitter'
-require 'engine/impressions/impressions'
 require 'engine/metrics/metrics'
 require 'engine/metrics/binary_search_latency_tracker'
 require 'engine/models/split'

data/lib/splitclient-rb/split_config.rb

@@ -29,14 +29,21 @@ module SplitIoClient
       @events_uri = (opts[:events_uri] || SplitConfig.default_events_uri).chomp('/')
       @mode = opts[:mode] || SplitConfig.default_mode
       @redis_url = opts[:redis_url] || SplitConfig.default_redis_url
-      @cache_adapter = SplitConfig.init_cache_adapter(opts[:cache_adapter] || SplitConfig.default_cache_adapter, @redis_url)
+      @cache_adapter = SplitConfig.init_cache_adapter(
+        opts[:cache_adapter] || SplitConfig.default_cache_adapter, :map_adapter, @redis_url, false
+      )
       @connection_timeout = opts[:connection_timeout] || SplitConfig.default_connection_timeout
       @read_timeout = opts[:read_timeout] || SplitConfig.default_read_timeout
       @features_refresh_rate = opts[:features_refresh_rate] || SplitConfig.default_features_refresh_rate
       @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_queue_size = opts[:impressions_queue_size] || SplitConfig.default_impressions_queue_size
+      @impressions_adapter = SplitConfig.init_cache_adapter(
+        opts[:cache_adapter] || SplitConfig.default_cache_adapter, :sized_queue_adapter, @redis_url, @impressions_queue_size
+      )
+
       @logger = opts[:logger] || SplitConfig.default_logger
       @debug_enabled = opts[:debug_enabled] || SplitConfig.default_debug
       @transport_debug_enabled = opts[:transport_debug_enabled] || SplitConfig.default_debug
@@ -76,6 +83,12 @@ module SplitIoClient
     # @return [Object] Cache adapter instance
     attr_reader :cache_adapter
 
+    #
+    # The cache adapter to store impressions in
+    #
+    # @return [Object] Impressions adapter instance
+    attr_reader :impressions_adapter
+
     #
     # The connection timeout for network connections in seconds.
     #
@@ -143,10 +156,15 @@ module SplitIoClient
       'https://events.split.io/api/'
     end
 
-    def self.init_cache_adapter(adapter, redis_url)
+    def self.init_cache_adapter(adapter, data_structure, redis_url = nil, impressions_queue_size = nil)
       case adapter
       when :memory
-        SplitIoClient::Cache::Adapters::MemoryAdapter.new
+        # takes :memory_adapter (symbol) and returns MemoryAdapter (string)
+        adapter = SplitIoClient::Cache::Adapters::MemoryAdapters.const_get(
+          data_structure.to_s.split('_').collect(&:capitalize).join
+        ).new(impressions_queue_size)
+
+        SplitIoClient::Cache::Adapters::MemoryAdapter.new(adapter)
       when :redis
         SplitIoClient::Cache::Adapters::RedisAdapter.new(redis_url)
       end

data/lib/splitclient-rb/split_factory.rb

@@ -131,7 +131,7 @@ module SplitIoClient
       # @param api_key [String] the API key for your split account
       #
       # @return [SplitIoClient] split.io client instance
-      def initialize(api_key, config = {}, adapter = nil, localhost_mode = false, splits_repository, segments_repository)
+      def initialize(api_key, config = {}, adapter = nil, localhost_mode = false, splits_repository, segments_repository, impressions_repository)
         @localhost_mode = localhost_mode
         @localhost_mode_features = []
 
@@ -139,6 +139,7 @@ module SplitIoClient
 
         @splits_repository = splits_repository
         @segments_repository = segments_repository
+        @impressions_repository = impressions_repository
 
         if api_key == LOCALHOST_MODE
           @localhost_mode = true
@@ -198,8 +199,11 @@ module SplitIoClient
           result = result.nil? ? Treatments::CONTROL : result
 
           begin
-            @adapter.impressions.log(matching_key, split_name, result, (Time.now.to_f * 1000.0))
             latency = (Time.now - start) * 1000.0
+            if @config.impressions_queue_size > 0
+              # Disable impressions if @config.impressions_queue_size == -1
+              @impressions_repository.add(split_name, 'key_name' => matching_key, 'treatment' => result, 'time' => (Time.now.to_f * 1000.0).to_i)
+            end
 
             # Measure
             @adapter.metrics.time("sdk.get_treatment", latency)
@@ -226,7 +230,7 @@ module SplitIoClient
       #
       # @return [string] version value for this sdk
       def self.sdk_version
-        'RubyClientSDK-'+SplitIoClient::VERSION
+        'ruby-'+SplitIoClient::VERSION
       end
 
       private
@@ -275,9 +279,10 @@ module SplitIoClient
       @cache_adapter = @config.cache_adapter
       @splits_repository = SplitIoClient::Cache::Repositories::SplitsRepository.new(@cache_adapter)
       @segments_repository = SplitIoClient::Cache::Repositories::SegmentsRepository.new(@cache_adapter)
+      @impressions_repository = SplitIoClient::Cache::Repositories::ImpressionsRepository.new(@config.impressions_adapter, @config)
       @sdk_blocker = SplitIoClient::Cache::Stores::SDKBlocker.new(@config)
       @adapter = api_key != 'localhost' \
-      ? SplitAdapter.new(api_key, @config, @splits_repository, @segments_repository, @sdk_blocker)
+      ? SplitAdapter.new(api_key, @config, @splits_repository, @segments_repository, @impressions_repository, @sdk_blocker)
       : nil
       @localhost_mode = api_key == 'localhost'
 
@@ -304,7 +309,7 @@ module SplitIoClient
       attr_reader :adapter
 
     def init_client
-      SplitClient.new(@api_key, @config, @adapter, @localhost_mode, @splits_repository, @segments_repository)
+      SplitClient.new(@api_key, @config, @adapter, @localhost_mode, @splits_repository, @segments_repository, @impressions_repository)
     end
 
     def init_manager

data/lib/splitclient-rb/version.rb

@@ -1,3 +1,3 @@
 module SplitIoClient
-  VERSION = '3.1.0-rc7'
+  VERSION = '3.1.0-rc8'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: splitclient-rb
 version: !ruby/object:Gem::Version
-  version: 3.1.0.pre.rc7
+  version: 3.1.0.pre.rc8
 platform: ruby
 authors:
 - Split Software
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-11-02 00:00:00.000000000 Z
+date: 2016-11-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -251,7 +251,12 @@ files:
 - Rakefile
 - exe/splitio
 - lib/cache/adapters/memory_adapter.rb
+- lib/cache/adapters/memory_adapters/map_adapter.rb
+- lib/cache/adapters/memory_adapters/sized_queue_adapter.rb
 - lib/cache/adapters/redis_adapter.rb
+- lib/cache/repositories/impressions/memory_repository.rb
+- lib/cache/repositories/impressions/redis_repository.rb
+- lib/cache/repositories/impressions_repository.rb
 - lib/cache/repositories/repository.rb
 - lib/cache/repositories/segments_repository.rb
 - lib/cache/repositories/splits_repository.rb
@@ -262,7 +267,6 @@ files:
 - lib/engine/api/segments.rb
 - lib/engine/api/splits.rb
 - lib/engine/evaluator/splitter.rb
-- lib/engine/impressions/impressions.rb
 - lib/engine/matchers/all_keys_matcher.rb
 - lib/engine/matchers/between_matcher.rb
 - lib/engine/matchers/combiners.rb

data/lib/engine/impressions/impressions.rb

@@ -1,88 +0,0 @@
-module SplitIoClient
-
-  #
-  # class to manage cached impressions
-  #
-  class Impressions < NoMethodError
-
-    # the queue of cached impression values
-    #
-    # @return [object] array of impressions
-    attr_accessor :queue
-
-    # max number of cached entries for impressions
-    #
-    # @return [int] max numbre of entries
-    attr_accessor :max_number_of_keys
-
-    #
-    # initializes the class
-    #
-    # @param config [SplitConfig] the config object
-    def initialize(config)
-      @config = config
-      @queue = SizedQueue.new(config.impressions_queue_size <= 0? 1 : config.impressions_queue_size)
-      @max_number_of_keys = config.impressions_queue_size
-    end
-
-    #
-    # generates a new entry for impressions list
-    #
-    # @param id [string] user key
-    # @param feature [string] feature name
-    # @param treatment [string] treatment value
-    # @param time [time] time value in milisenconds
-    #
-    # @return void
-    def log(id, feature, treatment, time)
-      return if @max_number_of_keys <= 0 # shortcut to desable impressions
-      impressions = KeyImpressions.new(id, treatment, time)
-      begin 
-        @queue.push( {feature: feature, impressions: impressions} , true ) # don't wait if queue is full
-      rescue ThreadError
-        @random_sampler ||=  Random.new
-        if @random_sampler.rand(1..1000) <= 2 # log only 0.2 % of the time.
-          @config.logger.warn("Dropping impressions. Current size is #{@max_number_of_keys}. Consider increasing impressions_queue_size")
-        end
-      end
-    end
-
-    #
-    # clears the impressions queue
-    #
-    # @returns void
-    def clear
-      popped_impressions = []
-      begin
-        loop do
-          impression_element = @queue.pop(true)
-          feature_hash = popped_impressions.find { |i| i[:feature] == impression_element[:feature] }
-          if feature_hash.nil?
-            popped_impressions << {feature: impression_element[:feature], impressions: [] << impression_element[:impressions]}
-          else
-            feature_hash[:impressions] << impression_element[:impressions]
-          end
-        end
-      rescue ThreadError
-      end
-      popped_impressions
-    end
-
-  end
-
-  #
-  # small class to use as DTO for impressions
-  #
-  class KeyImpressions
-    attr_accessor :key
-    attr_accessor :treatment
-    attr_accessor :time
-
-    def initialize(key, treatment, time)
-      @key = key
-      @treatment = treatment
-      @time = time
-    end
-  end
-
-end