splitclient-rb 3.0.3 → 3.1.0.pre.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bf91b9689764a6cd21126498db0c25132eaf8174
-  data.tar.gz: c56a293e949a5f438ede87dc96496e6d5ae86599
+  metadata.gz: 848d0aacbc266ce731699e451bd82976446240e0
+  data.tar.gz: 3de885436b94b499290e29a0aac4ca1f1767e660
 SHA512:
-  metadata.gz: e78db8256afcfcff7267a099389ddc1552799a54fb46901867972fa33be54a85c8bba4f65190878429f2e41fc58096fb1270076dd5fe52be13838d2171752978
-  data.tar.gz: 138aa921d468371860f7dfd56907727278a17ffeca7d1ec50cfd1f5c4aaa9ee9717e9ce1394bac9eeb5f4c9dea18125ef2425012d349c6f6085c6e233f092640
+  metadata.gz: 550e6f8a4e3bf0b475946055fe432ce1a3790035170811a131270e25ee8dee6ebdfc70ce6baedd9797f07d56cea9cc1904fa23fe4dff630c3823463dd8fe3cf1
+  data.tar.gz: cc9e7d82c6878c698614de9b092a8ca705f884127213c9359bd1aafbeabd3abe20b08760d50e52cdba1d14b0013b65d76467993e3c3ab1ef21e20b34fe0bcb70

data/CHANGES.txt

@@ -1,3 +1,6 @@
+3.1.0
+- Add RedisAdapter 
+
 3.0.3
 - Fix nil ref in manager
 

data/NEWS

@@ -1,3 +1,6 @@
+3.1.0
+Now supporting Redis as a cache adapter
+
 3.0.2
 
 now support also client.get_treatment( { :matching_key = 'bb' , "bucketing_key = ''}, ....)

data/README.md

@@ -1,9 +1,9 @@
-# splitclient-rb
+# Split Ruby SDK
 
-Ruby client for split software. This is provided as a gem that can be installed to your Ruby application
+Ruby SDK for Split software, provided as a gem that can be installed to your Ruby application.
 
 ## Installation
-----------
+---
 
  - Once the gem is published you can install it with the following steps:
 
@@ -15,30 +15,32 @@ Ruby client for split software. This is provided as a gem that can be installed
 
 	And then execute:
 
-	    $ bundle
+	    $ bundle install
 
 	Or install it yourself as:
 
 	    $ gem install splitclient-rb
 
- - If the gem is still unpublished you can install it through this git repository with the following instructions:
+ - You can also use the most recent version from github:
 
-	Add these lines to you application's Gemnfile
+	Add these lines to you application's `Gemfile`:
 	```ruby
-	gem 'splitclient-rb', :git=>'https://github.com/splitio/ruby-client.git',
+	gem 'splitclient-rb', git: 'https://github.com/splitio/ruby-client.git',
 	```
-	You can also specify any specific branch if necessary
+	You can also use any specific branch if necessary:
 	```ruby
-	gem 'splitclient-rb', :git=>'https://github.com/splitio/ruby-client.git', :branch=>'development'
+	gem 'splitclient-rb', git: 'https://github.com/splitio/ruby-client.git', branch: 'development'
 	```
 	And then execute:
 
 	    $ bundle install
 
 ## Usage
-###Quick Setup
-------
-Within your application you need the following
+
+### Quick Setup
+---
+
+Within your application you need the following:
 
 Require the Split client:
 ```ruby
@@ -47,7 +49,7 @@ require 'splitclient-rb'
 
 Create a new split client instance with your API key:
 ```ruby
-factory  = SplitIoClient::SplitFactory.new("your_api_key").client
+factory  = SplitIoClient::SplitFactory.new('YOUR_API_KEY').client
 split_client = factory.client
 ```
 
@@ -56,67 +58,101 @@ For advance use cases you can also obtain a `manager` instance from the factory.
 manager = factory.manager
 ```
 
-###Ruby on Rails
-----
-If you're using Ruby on Rails
+### Ruby on Rails
+---
 
-Create an initializer file at config/initializers/splitclient.rb and then initialize the split client :
+Create an initializer: `config/initializers/splitclient.rb` and then initialize the split client:
 ```ruby
-Rails.configuration.split_client = SplitIoClient::SplitFactory.new("your_api_key").client
+Rails.configuration.split_client = SplitIoClient::SplitFactory.new('YOUR_API_KEY').client
 ```
-In your controllers, access the client using
+In your controllers, access the client using:
 
 ```ruby
 Rails.application.config.split_client
 ```
 
-###Configuration
+### Configuration
 ---
-By default the split client uses its default configuration, it will be sufficient for most scenarios. However you can also provide custom configuration when initializing the client using an optional hash of options.
 
-The following values can be customized
+Split client's default configuration should be sufficient for most scenarios. However you can also provide custom configuration when initializing the client using an optional hash of options.
+
+The following values can be customized:
 
 **base_uri** :  URI for the api endpoints
-*defualt value* :  https://sdk.split.io/api/
 
-**local_store** : optional cache storage
-*default value* : custom cache local storage
+*defualt value* = `https://sdk.split.io/api/`
 
 **connection_timeout** :  timeout for network connections in seconds
-*default value* =   5
+
+*default value* = `5`
 
 **read_timeout** : timeout for requests in seconds
-*default value* = 5
+
+*default value* = `5`
 
 **features_refresh_rate** : The SDK polls Split servers for changes to feature roll-out plans. This parameter controls this polling period in seconds
-*default value* = 30
+
+*default value* = `30`
 
 **segments_refresh_rate** : The SDK polls Split servers for changes to segment definitions. This parameter controls this polling period in seconds
-*default value* = 60
+
+*default value* = `60`
 
 **metrics_refresh_rate** : The SDK sends diagnostic metrics to Split servers. This parameters controls this metric flush period in seconds
-*default value* = 60
+
+*default value* = `60`
 
 **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
-*default value* = 60
+
+*default value* = `60`
 
 **debug_enabled** : Enables extra logging
-*default value* = false
+
+*default value* = `false`
 
 **transport_debug_enabled** : Enables extra transport logging
-*default value* = false
+
+*default value* = `false`
 
 **logger** : default logger for messages and errors
-*default value* : Ruby logger class set to STDOUT
+
+*default value* = `Logger.new($stdout)`
 
 **block_until_ready** : The SDK will block your app for provided amount of seconds until it's ready. If timeout expires `SplitIoClient::SDKBlockerTimeoutExpiredException` will be thrown. If `false` provided, then SDK would run in non-blocking mode
-*default value* : false
+
+*default value* = `false`
+
+**mode** : See [SDK modes section](#sdk-modes).
+
+*default value* = `:standalone`
+
+#### 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.
+
+To use Redis, you have to include `redis-rb` in your app's Gemfile.
+
+**cache_adapter** : Supported options: `:memory`, `:redis`
+
+*default value* = `memory`
+
+**redis_url** : Redis URL or hash with configuration for SDK to connect to.
+
+*default value* = `'redis://127.0.0.1:6379/0'`
+
+You can also use Sentinel like this:
+
+```ruby
+SENTINELS = [{host: '127.0.0.1', port: 26380},
+             {host: '127.0.0.1', port: 26381}]
+
+redis_url = Redis.new(url: 'redis://mymaster', sentinels: SENTINELS, role: :master)
+```
 
 Example
 ```ruby
 options = {
   base_uri: 'https://my.app.api/',
-  local_store: Rails.cache,
   connection_timeout: 10,
   read_timeout: 5,
   features_refresh_rate: 120,
@@ -124,51 +160,62 @@ options = {
   metrics_refresh_rate: 360,
   impressions_refresh_rate: 360,
   logger: Logger.new('logfile.log'),
-  block_until_ready: 5
+  block_until_ready: 5,
+  cache_adapter: :redis,
+  redis_url: 'redis://127.0.0.1:6379/0'
 }
 begin
-  split_client = SplitIoClient::SplitFactory.new("your_api_key", options).client
+  split_client = SplitIoClient::SplitFactory.new('YOUR_API_KEY', options).client
 rescue SplitIoClient::SDKBlockerTimeoutExpiredException
   # Some arbitrary actions
 end
 ```
-This begin-rescue-end block is optional, you might want to use it to catch timeout expired exception and apply some logic here.
+This begin-rescue-end block is optional, you might want to use it to catch timeout expired exception and apply some logic.
 
 ### Execution
 ---
-In your application code you just need to call the get_treatment method with the required parameters for key and feature name
+
+In your application code you just need to call the `get_treatment` method with the required parameters for key and feature name:
 ```ruby
-split_client.get_treatment('user_id','feature_name', {attr: 'val'})
+split_client.get_treatment('user_id','feature_name', attr: 'val')
 ```
 
 For example
 ```ruby
-if split_client.get_treatment('employee_user_01','view_main_list', {age: 35})
+if split_client.get_treatment('employee_user_01','view_main_list', age: 35)
    my_app.display_main_list
 end
 ```
 
 Also, you can use different keys for actually getting treatment and sending impressions to the server:
 ```ruby
-split_client.get_treatment({ matching_key: 'user_id', bucketing_key: 'private_user_id' },'feature_name', {attr: 'val'})
+split_client.get_treatment(
+	{ matching_key: 'user_id', bucketing_key: 'private_user_id' },
+	'feature_name',
+	attr: 'val'
+)
 ```
 When it might be useful? Say, you have a user browsing your website and not signed up yet. You assign some internal id to that user (i.e. bucketing_key) and after user signs up you assign him a matching_key.
 By doing this you can provide both anonymous and signed up user with the same treatment.
 
 `bucketing_key` may be `nil` in that case `matching_key` would be used as a key, so calling
 ```ruby
-split_client.get_treatment({ matching_key: 'user_id' },'feature_name', {attr: 'val'})
+split_client.get_treatment(
+	{ matching_key: 'user_id' },
+	'feature_name',
+	attr: 'val'
+)
 ```
 Is exactly the same as calling
 ```ruby
-split_client.get_treatment('user_id' ,'feature_name', {attr: 'val'})
+split_client.get_treatment('user_id' ,'feature_name', attr: 'val')
 ```
 `bucketing_key` must not be nil
 
 Also you can use the split manager:
 
 ```ruby
-split_manager = SplitIoClient::SplitFactory.new("your_api_key", options).manager
+split_manager = SplitIoClient::SplitFactory.new('your_api_key', options).manager
 ```
 
 With the manager you can get a list of your splits by doing:
@@ -179,10 +226,81 @@ manager.splits
 
 And you should get something like this:
 
-```bash
- => [{: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, :treatments=>nil, :change_number=>1469133757521}]
+```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,
+		treatments: nil,
+		change_number: 1469133757521
+	}
+]
  ```
 
+### SDK Modes
+
+By default SDK would run alongside with your application and will be run in `standalone` mode, which includes two modes:
+- `producer` - storing information from the Splits API in the chosen cache
+- `consumer` - retrieving data from the cache and providing `get_treatment` interface
+
+As you might think, you can choose between these 3 modes by providing `mode` option in the config.
+
+#### Producer mode
+
+If you have, say, one Redis cache which is used by several Split SDKs at once, e.g.: Python and Ruby, you want to have only one of them to write data to Redis, so it would remain consistent. That's why we have producer mode.
+
+SDK can be ran in `producer` mode both in the scope of the application (e.g. as a part of the Rails app), and as a separate process. Let's see what steps are needed to run it as a separate process:
+
+- You need to create a config file with .yml extension. All options specified in the above example section are valid, but you should write them in the YAML format, like this:
+
+```yaml
+---
+:api_key: 'SECRET_API_KEY'
+:base_uri: 'https://my.app.api/'
+:connection_timeout: 10
+:read_timeout: 5
+:features_refresh_rate: 120
+:segments_refresh_rate: 120
+:metrics_refresh_rate: 360
+:impressions_refresh_rate: 360
+:block_until_ready: 5
+:cache_adapter: :redis
+:redis_url: 'redis://127.0.0.1:6379/0'
+```
+
+- Install binstubs
+```ruby
+bundle binstubs splitclient-rb
+```
+
+- Run the executable provided by the SDK: 
+```ruby
+bundle exec bin/splitio -c ~/path/to/config/file.yml
+```
+
+That's it!
 
 ## Development
 

data/exe/splitio

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'optparse'
+require 'yaml'
+require_relative '../lib/splitclient-rb'
+
+ARGV << '-h' if ARGV.empty?
+
+options = {}
+opt_parser = OptionParser.new do |opts|
+  opts.banner = "Usage: splitio [options]"
+
+  opts.on("-cPATH", "--config=PATH", "Set the path to splitio.yml config file") do |c|
+    options[:config_path] = c
+  end
+
+  opts.on_tail("-h", "--help", "Prints this help") do
+    puts opts
+    exit
+  end
+end
+
+begin
+   opt_parser.parse!(ARGV)
+ rescue OptionParser::InvalidOption => e
+   puts e
+   puts opt_parser
+   exit(1)
+ end
+
+config = YAML.load_file(options[:config_path])
+config.merge!(mode: :producer, cache_adapter: :redis)
+
+SplitIoClient::SplitFactory.new(config[:api_key], config)

data/lib/cache/adapters/memory_adapter.rb

@@ -3,42 +3,91 @@ require 'concurrent'
 module SplitIoClient
   module Cache
     module Adapters
-      class MemoryAdapter < Adapter
+      class MemoryAdapter
         def initialize
           @map = Concurrent::Map.new
         end
 
         # Map
-        def [](key)
+        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
 
-        def []=(key, obj)
-          @map[key] = obj
+        # String
+        def string(key)
+          @map[key]
         end
 
-        def initialize_map(key)
-          @map[key] = Concurrent::Map.new
+        def set_string(key, str)
+          @map[key] = str
         end
 
-        def add_to_map(key, map_key, map_value)
-          @map[key].put(map_key, map_value)
+        def find_strings_by_prefix(prefix)
+          @map.keys.select { |str| str.start_with? prefix }
         end
 
-        def find_in_map(key, map_key)
-          return nil if @map[key].nil?
+        # Bool
+        def set_bool(key, val)
+          @map[key] = val
+        end
 
-          @map[key].get(map_key)
+        def bool(key)
+          @map[key]
         end
 
-        def delete_from_map(key, map_key)
-          @map[key].delete(map_key)
+        # 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
 
-        def in_map?(key, map_key)
-          return false if @map[key].nil?
+        # General
+        def exists?(key)
+          !@map[key].nil?
+        end
 
-          @map[key].key?(map_key)
+        def delete(key)
+          @map[key] = nil
         end
       end
     end

data/lib/cache/adapters/redis_adapter.rb

@@ -0,0 +1,95 @@
+require 'redis'
+require 'json'
+
+module SplitIoClient
+  module Cache
+    module Adapters
+      class RedisAdapter
+        def initialize(redis_url)
+          connection = redis_url.is_a?(Hash) ? redis_url : { url: redis_url }
+
+          @redis = Redis.new(connection)
+        end
+
+        # Map
+        def initialize_map(key)
+          # No need to initialize hash/map in Redis
+        end
+
+        def add_to_map(key, field, value)
+          @redis.hset(key, field, value)
+        end
+
+        def find_in_map(key, field)
+          @redis.hget(key, field)
+        end
+
+        def delete_from_map(key, field)
+          @redis.hdel(key, field)
+        end
+
+        def in_map?(key, field)
+          @redis.hexists(key, field)
+        end
+
+        def map_keys(key)
+          @redis.hkeys(key)
+        end
+
+        def get_map(key)
+          @redis.hgetall(key)
+        end
+
+        # String
+        def string(key)
+          @redis.get(key)
+        end
+
+        def set_string(key, str)
+          @redis.set(key, str)
+        end
+
+        def find_strings_by_prefix(prefix)
+          @redis.keys("#{prefix}*")
+        end
+
+        # Bool
+        def set_bool(key, val)
+          @redis.set(key, val.to_s)
+        end
+
+        def bool(key)
+          @redis.get(key) == 'true'
+        end
+
+        # Set
+        alias_method :initialize_set, :initialize_map
+
+        def add_to_set(key, val)
+          @redis.sadd(key, val)
+        end
+
+        def delete_from_set(key, val)
+          @redis.srem(key, val)
+        end
+
+        def get_set(key)
+          @redis.smembers(key)
+        end
+
+        def in_set?(key, val)
+          @redis.sismember(key, val)
+        end
+
+        # General
+        def exists?(key)
+          @redis.exists(key)
+        end
+
+        def delete(key)
+          @redis.del(key)
+        end
+      end
+    end
+  end
+end

data/lib/cache/repositories/repository.rb

@@ -1,24 +1,18 @@
 module SplitIoClient
   module Cache
     class Repository
-      def initialize(adapter)
-        @adapter = adapter
-
-        @adapter[namespace_key('ready')] = false
-      end
-
-      def []=(key, obj)
-        @adapter[namespace_key(key)] = obj
+      def set_string(key, str)
+        @adapter.set_string(namespace_key(key), str)
       end
 
-      def [](key)
-        @adapter[namespace_key(key)]
+      def string(key)
+        @adapter.string(namespace_key(key))
       end
 
       protected
 
       def namespace_key(key)
-        "repository_#{key}"
+        "SPLITIO.#{key}"
       end
     end
   end

data/lib/cache/repositories/segments_repository.rb

@@ -2,49 +2,59 @@ module SplitIoClient
   module Cache
     module Repositories
       class SegmentsRepository < Repository
+        KEYS_SLICE = 3000
+
+        def initialize(adapter)
+          @adapter = adapter
+
+          @adapter.set_bool(namespace_key('ready'), false)
+        end
+
         def add_to_segment(segment)
           name = segment[:name]
 
-          @adapter.initialize_map(namespace_key("segments:#{name}")) if @adapter[namespace_key("segments:#{name}")].nil?
+          @adapter.initialize_set(segment_data(name)) unless @adapter.exists?(segment_data(name))
 
           add_keys(name, segment[:added])
           remove_keys(name, segment[:removed])
         end
 
         def get_segment_keys(name)
-          @adapter[namespace_key("segments:#{name}")]
+          @adapter.get_set(segment_data(name))
         end
 
         def in_segment?(name, key)
-          @adapter.in_map?(namespace_key("segments:#{name}"), key)
+          @adapter.in_set?(segment_data(name), key)
         end
 
         def used_segment_names
-          @adapter['splits_repository_used_segment_names'].keys
+          @adapter.get_set(namespace_key('segments.registered'))
         end
 
         def set_change_number(name, last_change)
-          @adapter.initialize_map(namespace_key('changes')) if @adapter[namespace_key('changes')].nil?
-
-          @adapter.add_to_map(namespace_key('changes'), name, last_change)
+          @adapter.set_string(namespace_key("segment.#{name}.till"), last_change)
         end
 
         def get_change_number(name)
-          @adapter.find_in_map(namespace_key('changes'), name) || -1
+          @adapter.string(namespace_key("segment.#{name}.till")) || -1
         end
 
         private
 
-        def namespace_key(key)
-          "segments_repository_#{key}"
+        def segment_data(name)
+          namespace_key("segmentData.#{name}")
         end
 
         def add_keys(name, keys)
-          keys.each { |key| @adapter.add_to_map(namespace_key("segments:#{name}"), key, 1) }
+          keys.each_slice(KEYS_SLICE) do |keys_slice|
+            @adapter.add_to_set(segment_data(name), keys_slice)
+          end
         end
 
         def remove_keys(name, keys)
-          keys.each { |key| @adapter.delete_from_map(namespace_key("segments:#{name}"), key) }
+          keys.each_slice(KEYS_SLICE) do |keys_slice|
+            @adapter.delete_from_set(segment_data(name), keys_slice)
+          end
         end
       end
     end

data/lib/cache/repositories/splits_repository.rb

@@ -1,3 +1,5 @@
+require 'concurrent'
+
 module SplitIoClient
   module Cache
     module Repositories
@@ -5,50 +7,57 @@ module SplitIoClient
         def initialize(adapter)
           @adapter = adapter
 
-          @adapter[namespace_key('last_change')] = -1
-          @adapter.initialize_map(namespace_key('splits'))
-          @adapter.initialize_map(namespace_key('used_segment_names'))
+          @adapter.set_string(namespace_key('split.till'), '-1')
+          @adapter.initialize_map(namespace_key('segments.registered'))
         end
 
         def add_split(split)
-          split_without_name = split.select { |k, _| k != :name }
-
-          @adapter.add_to_map(namespace_key('splits'), split[:name], split_without_name)
+          @adapter.set_string(namespace_key("split.#{split[:name]}"), split.to_json)
         end
 
         def remove_split(name)
-          @adapter.add_to_map(namespace_key('splits'), name, nil)
+          @adapter.delete(namespace_key("split.#{name}"))
         end
 
-        def get_split(name)
-          @adapter.find_in_map(namespace_key('splits'), name)
+        def get_split(name, prefixed = false)
+          split = prefixed ? @adapter.string(name) : @adapter.string(namespace_key("split.#{name}"))
+
+          JSON.parse(split, symbolize_names: true)
         end
 
-        def list_splits()
-          @adapter[namespace_key('splits')]
+        def splits
+          splits_hash = {}
+          splits = []
+          split_names = @adapter.find_strings_by_prefix(namespace_key('split'))
+
+          split_names.each do |name|
+            next if name == namespace_key('split.till')
+
+            splits << get_split(name, true)
+          end
+
+          splits.each do |split|
+            splits_hash[split[:name]] = split
+          end
+
+          splits_hash
         end
 
         def set_change_number(since)
-          @adapter[namespace_key('last_change')] = since
+          @adapter.set_string(namespace_key('split.till'), since)
         end
 
         def get_change_number
-          @adapter[namespace_key('last_change')]
+          @adapter.string(namespace_key('split.till'))
         end
 
         def set_segment_names(names)
           return if names.nil? || names.empty?
 
           names.each do |name|
-            @adapter.add_to_map(namespace_key('used_segment_names'), name, 1)
+            @adapter.add_to_set(namespace_key('segments.registered'), name)
           end
         end
-
-        private
-
-        def namespace_key(key)
-          "splits_repository_#{key}"
-        end
       end
     end
   end

data/lib/cache/stores/split_store.rb

@@ -44,7 +44,7 @@ module SplitIoClient
             @sdk_blocker.splits_ready!
             @config.logger.info('splits are ready')
           end
-          
+
         rescue StandardError => error
           @config.log_found_exception(__method__.to_s, error)
         end

data/lib/engine/parser/split_adapter.rb

@@ -40,7 +40,6 @@ module SplitIoClient
     #
     # @return [SplitIoClient] split.io client instance
     def initialize(api_key, config, splits_repository, segments_repository, sdk_blocker)
-
       @api_key = api_key
       @config = config
       @impressions = Impressions.new(100)
@@ -56,11 +55,25 @@ module SplitIoClient
         builder.adapter :net_http_persistent
       end
 
-      @splits_consumer = create_splits_api_consumer
-      @segments_consumer = create_segments_api_consumer
-      @metrics_producer = create_metrics_api_producer
-      @impressions_producer = create_impressions_api_producer
+      start_based_on_mode(@config.mode)
+    end
 
+    def start_based_on_mode(mode)
+      case mode
+      when :standalone
+        split_store
+        segment_store
+        metrics_sender
+        impressions_sender
+      when :consumer
+        metrics_sender
+        impressions_sender
+      when :producer
+        split_store
+        segment_store
+
+        sleep unless ENV['SPLITCLIENT_ENV'] == 'test'
+      end
     end
 
     #
@@ -69,11 +82,11 @@ module SplitIoClient
     # provided within the configuration
     #
     # @return [void]
-    def create_splits_api_consumer
+    def split_store
       SplitIoClient::Cache::Stores::SplitStore.new(@splits_repository, @config, @api_key, @metrics, @sdk_blocker).call
     end
 
-    def create_segments_api_consumer
+    def segment_store
       SplitIoClient::Cache::Stores::SegmentStore.new(@segments_repository, @config, @api_key, @metrics, @sdk_blocker).call
     end
 
@@ -116,11 +129,10 @@ module SplitIoClient
     # provided within the configuration
     #
 
-    def create_metrics_api_producer
+    def metrics_sender
       Thread.new do
         loop do
           begin
-            #post captured metrics
             post_metrics
 
             random_interval = randomize_interval @config.metrics_refresh_rate
@@ -132,11 +144,10 @@ module SplitIoClient
       end
     end
 
-    def create_impressions_api_producer
+    def impressions_sender
       Thread.new do
         loop do
           begin
-            #post captured impressions
             post_impressions
 
             random_interval = randomize_interval @config.impressions_refresh_rate
@@ -161,14 +172,14 @@ module SplitIoClient
         test_impression_array = []
         popped_impressions.each do |i|
           filtered = []
-          keys_seen = []
+          keys_treatments_seen = []
 
           impressions = i[:impressions]
           impressions.each do |imp|
-            if keys_seen.include?(imp.key)
+            if keys_treatments_seen.include?("#{imp.key}:#{imp.treatment}")
               next
             end
-            keys_seen << imp.key
+            keys_treatments_seen << "#{imp.key}:#{imp.treatment}"
             filtered << imp
           end
 

data/lib/splitclient-rb.rb

@@ -5,8 +5,8 @@ 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/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'

data/lib/splitclient-rb/split_config.rb

@@ -15,7 +15,6 @@ module SplitIoClient
     # @option opts [String] :events_uri ("https://events.split.io/api/") The events URL for events end points
     # @option opts [Int] :read_timeout (10) The read timeout for network connections in seconds.
     # @option opts [Int] :connection_timeout (2) The connect timeout for network connections in seconds.
-    # @option opts [Object] :local_store A cache store for the Faraday HTTP caching library. Defaults to the Rails cache in a Rails environment, or a thread-safe in-memory store otherwise.
     # @option opts [Int] :features_refresh_rate The SDK polls Split servers for changes to feature roll-out plans. This parameter controls this polling period in seconds.
     # @option opts [Int] :segments_refresh_rate
     # @option opts [Int] :metrics_refresh_rate
@@ -27,7 +26,9 @@ module SplitIoClient
     def initialize(opts = {})
       @base_uri = (opts[:base_uri] || SplitConfig.default_base_uri).chomp('/')
       @events_uri = (opts[:events_uri] || SplitConfig.default_events_uri).chomp('/')
-      @cache_adapter = opts[:cache_adapter] || SplitConfig.default_cache_adapter
+      @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)
       @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
@@ -41,7 +42,7 @@ module SplitIoClient
       @machine_name = SplitConfig.get_hostname
       @machine_ip = SplitConfig.get_ip
 
-      log_loaded_cache
+      startup_log
     end
 
     #
@@ -57,13 +58,11 @@ module SplitIoClient
     attr_reader :events_uri
 
     #
-    # The store for the Faraday HTTP caching library. Stores should respond to
-    # 'read', 'write' and 'delete' requests.
+    # The mode SDK will run
     #
-    # @return [Object] The configured store for the Faraday HTTP caching library.
-    attr_reader :local_store
+    # @return [Symbol] One of the available SDK modes: standalone, consumer, producer
+    attr_reader :mode
 
-    #
     # The read timeout for network connections in seconds.
     #
     # @return [Int] The timeout in seconds.
@@ -114,6 +113,8 @@ module SplitIoClient
     attr_reader :metrics_refresh_rate
     attr_reader :impressions_refresh_rate
 
+    attr_reader :redis_url
+
     #
     # The default split client configuration
     #
@@ -134,9 +135,22 @@ module SplitIoClient
       'https://events.split.io/api/'
     end
 
+    def self.init_cache_adapter(adapter, redis_url)
+      case adapter
+      when :memory
+        SplitIoClient::Cache::Adapters::MemoryAdapter.new
+      when :redis
+        SplitIoClient::Cache::Adapters::RedisAdapter.new(redis_url)
+      end
+    end
+
+    def self.default_mode
+      :standalone
+    end
+
     # @return [LocalStore] configuration value for local cache store
     def self.default_cache_adapter
-      SplitIoClient::Cache::Adapters::MemoryAdapter.new
+      :memory
     end
 
     #
@@ -187,6 +201,10 @@ module SplitIoClient
       false
     end
 
+    def self.default_redis_url
+      'redis://127.0.0.1:6379/0'
+    end
+
     #
     # The default transport_debug_enabled value
     #
@@ -206,10 +224,11 @@ module SplitIoClient
     end
 
     #
-    # log which cache class was loaded
+    # log which cache class was loaded and SDK mode
     #
     # @return [void]
-    def log_loaded_cache
+    def startup_log
+      @logger.info("Loaded SDK in the #{@mode} mode")
       @logger.info("Loaded cache class: #{@cache_adapter.class}")
     end
 

data/lib/splitclient-rb/split_factory.rb

@@ -49,19 +49,12 @@ module SplitIoClient
       #
       # @returns [object] array of splits
       def splits
-
         return @localhost_mode_features if @localhost_mode
-        return nil if  @splits_repository.nil?
-          
-        splits = @splits_repository.list_splits 
-        ret = []
-        splits.keys.each do |key|
-              
-          split = splits.get(key)
-          ret << build_split_view(key, split) if !Engine::Parser::SplitTreatment.archived?(split)
-        end
+        return if @splits_repository.nil?
 
-        ret
+        @splits_repository.splits.each_with_object([]) do |(name, split), memo|
+          memo << build_split_view(name, split) unless Engine::Parser::SplitTreatment.archived?(split)
+        end
       end
 
       #
@@ -75,8 +68,8 @@ module SplitIoClient
         end
 
         if @splits_repository
-          
-          split = @splits_repository.get_split(split_name) 
+
+          split = @splits_repository.get_split(split_name)
 
           build_split_view(split_name, split) if split and !Engine::Parser::SplitTreatment.archived?(split)
         end
@@ -169,9 +162,9 @@ module SplitIoClient
           begin
             @adapter.impressions.log(matching_key, feature, result, (Time.now.to_f * 1000.0))
             latency = (Time.now - start) * 1000.0
-            if (@adapter.impressions.queue.length >= @adapter.impressions.max_number_of_keys)
-              @adapter.impressions_producer.wakeup
-            end
+            # if (@adapter.impressions.queue.length >= @adapter.impressions.max_number_of_keys)
+            #   @adapter.impressions_producer.wakeup
+            # end
           rescue StandardError => error
             @config.log_found_exception(__method__.to_s, error)
           end

data/lib/splitclient-rb/version.rb

@@ -1,3 +1,3 @@
 module SplitIoClient
-  VERSION = '3.0.3'
+  VERSION = '3.1.0-rc2'
 end

data/splitclient-rb.gemspec

@@ -35,4 +35,5 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "faraday-http-cache"
   spec.add_runtime_dependency "faraday_middleware"
   spec.add_runtime_dependency "net-http-persistent", "<= 2.9.4"
+  spec.add_runtime_dependency "redis", "~> 3.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: splitclient-rb
 version: !ruby/object:Gem::Version
-  version: 3.0.3
+  version: 3.1.0.pre.rc2
 platform: ruby
 authors:
 - Split Software
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-10-18 00:00:00.000000000 Z
+date: 2016-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -220,10 +220,25 @@ dependencies:
     - - "<="
       - !ruby/object:Gem::Version
         version: 2.9.4
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
 description: Ruby client for using split SDK.
 email:
 - pato@split.io
-executables: []
+executables:
+- splitio
 extensions: []
 extra_rdoc_files: []
 files:
@@ -234,8 +249,9 @@ files:
 - NEWS
 - README.md
 - Rakefile
-- lib/cache/adapters/adapter.rb
+- exe/splitio
 - lib/cache/adapters/memory_adapter.rb
+- lib/cache/adapters/redis_adapter.rb
 - lib/cache/repositories/repository.rb
 - lib/cache/repositories/segments_repository.rb
 - lib/cache/repositories/splits_repository.rb
@@ -293,12 +309,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: Ruby client for split SDK.

data/lib/cache/adapters/adapter.rb

@@ -1,23 +0,0 @@
-module SplitIoClient
-  module Cache
-    module Adapters
-      class Adapter
-        def set
-          raise NoMethodError
-        end
-
-        def get
-          raise NoMethodError
-        end
-
-        def remove
-          raise NoMethodError
-        end
-
-        def key?
-          raise NoMethodError
-        end
-      end
-    end
-  end
-end