splitclient-rb 3.1.0.pre.rc12 → 3.1.0

data/NEWS

@@ -1,6 +1,7 @@
 3.1.0
 
 Now supporting Redis as a cache adapter
+Factory is build now as SplitIoClient::SplitFactoryBuilder.build('<API_KEY>')
 
 3.0.2
 

data/README.md

@@ -1,364 +1,52 @@
 # Split Ruby SDK
 
-Ruby SDK for Split software, provided as a gem that can be installed to your Ruby application.
+This SDK is designed to work with [Split](https://www.split.io), the platform for controlled rollouts, serving features to your users via the Split feature flag to manage your complete customer experience.
 
-## Installation
----
+### Quick setup
 
- - Once the gem is published you can install it with the following steps:
+For specific instructions on how to set up the Ruby SDK refer to our [Detailed-README](Detailed-README.md) or our [official SDK documentation](http://docs.split.io/docs/sdk-overview).
 
-	Add this line to your application's Gemfile:
+### Commitment to Quality:
 
-	```ruby
-	gem 'splitclient-rb'
-	```
+Split’s SDKs are in active development and are constantly tested for quality. Unit tests are developed for each SDK based on the unique needs of that language, and integration tests, load and performance tests, and behavior consistency tests are running 24/7 via automated bots. In addition, monitoring instrumentation ensures that these SDKs behave under the expected parameters of memory, CPU, and I/O.
 
-	And then execute:
+### About Split:
 
-	    $ bundle install
+Split builds on feature flags to create the platform for controlled rollouts, so any team can target customers and release or revert new features without a deployment—or touching code. Get started quickly with SDKs in your language, then create on/off, percentage, and multivariate rollout plans in seconds. Integrations with the services you use to monitor, alert and track issues reduce time-to-resolution when things go wrong, and hotfixes are entirely avoided by killing problem features with a single click.
 
-	Or install it yourself as:
+ * What you can do with Split. Split goes beyond the simple on/off capabilities of basic feature flagging to give your team the power to:
 
-	    $ gem install splitclient-rb
+ 	* Create multivariate feature releases
+	* Create A/B feature releases
+	* Kill any feature, over the browser, with a single click
+	* Target releases to subsets of your audience, including percentage roll outs, whitelists,    attribute-based targeting, and individual user IDs 
+	* Integrate with the services your team uses to monitor, plan and communicate, like Datadog, JIRA and Slack 
+	* Manage team access, with features like two-factor authentication and role-based permissioning.
 
- - You can also use the most recent version from github:
 
-	Add these lines to you application's `Gemfile`:
-	```ruby
-	gem 'splitclient-rb', git: 'https://github.com/splitio/ruby-client.git',
-	```
-	You can also use any specific branch if necessary:
-	```ruby
-	gem 'splitclient-rb', git: 'https://github.com/splitio/ruby-client.git', branch: 'development'
-	```
-	And then execute:
+Split has built and maintains a SDKs for:
 
-	    $ bundle install
+* Java [Docs](http://docs.split.io/docs/java-sdk-guide)
+* Javascript [Github](https://github.com/splitio/javascript-client) [Docs](http://docs.split.io/docs/javascript-sdk-overview)
+* Node [Github](https://github.com/splitio/javascript-client) [Docs](http://docs.split.io/docs/nodejs-sdk-overview)
+* .NET [Github](https://github.com/splitio/.net-client) [Docs](http://docs.split.io/docs/net-sdk-overview)
+* Ruby [Github](https://github.com/splitio/ruby-client) [Docs](http://docs.split.io/docs/ruby-sdk-overview)
+* PHP [Github](https://github.com/splitio/php-client) [Docs](http://docs.split.io/docs/php-sdk-overview)
+* Python [Github](https://github.com/splitio/python-client) [Docs](http://docs.split.io/docs/python-sdk-overview)
 
-## Usage
+For a comprenhensive list of opensource projects visit our [Github page](https://github.com/splitio?utf8=%E2%9C%93&query=%20only%3Apublic%20).
 
-### Quick Setup
----
+**Try Split for Free:**
 
-Within your application you need the following:
+Split is available as a 30-day free trial. To create an account, visit [split.io/trial](https://www.split.io/trial).
 
-Require the Split client:
-```ruby
-require 'splitclient-rb'
-```
+**Learn more about Split:** 
 
-Create a new split client instance with your API key:
-```ruby
-factory  = SplitIoClient::SplitFactory.new('YOUR_API_KEY').client
-split_client = factory.client
-```
+Visit [split.io/product](https://www.split.io/product) for an overview of Split, or visit our documentation at [docs.split.io](http://docs.split.io) for more detailed information.
 
-For advance use cases you can also obtain a `manager` instance from the factory.
-```ruby
-manager = factory.manager
-```
+**System Status:**
 
-### Ruby on Rails
----
+We use a status page to monitor the availability of Split’s various services. You can check the current status at [status.split.io](http://status.split.io).
 
-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
-```
-In your controllers, access the client using:
+----
 
-```ruby
-Rails.application.config.split_client
-```
-
-### Configuration
----
-
-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/`
-
-**connection_timeout** :  timeout for network connections in seconds
-
-*default value* = `5`
-
-**read_timeout** : timeout for requests in seconds
-
-*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`
-
-**segments_refresh_rate** : The SDK polls Split servers for changes to segment definitions. This parameter controls this polling period in seconds
-
-*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`
-
-**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 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`
-
-**debug_enabled** : Enables extra logging
-
-*default value* = `false`
-
-**transport_debug_enabled** : Enables extra transport logging
-
-*default value* = `false`
-
-**logger** : default logger for messages and errors
-
-*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`
-
-**mode** : See [SDK modes section](#sdk-modes).
-
-*default value* = `:standalone`
-
-#### Cache adapter
-
-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.
-
-**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 using Redis
-```ruby
-options = {
-  connection_timeout: 10,
-  read_timeout: 5,
-  features_refresh_rate: 120,
-  segments_refresh_rate: 120,
-  metrics_refresh_rate: 360,
-  impressions_refresh_rate: 360,
-  logger: Logger.new('logfile.log'),
-  block_until_ready: 5,
-  cache_adapter: :redis,
-  mode: :standalone,
-  redis_url: 'redis://127.0.0.1:6379/0'
-}
-begin
-  split_client = SplitIoClient::SplitFactory.new('YOUR_API_KEY', options).client
-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
----
-
-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')
-```
-
-For example
-```ruby
-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'
-)
-```
-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'
-)
-```
-Is exactly the same as calling
-```ruby
-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
-```
-
-With the manager you can get a list of your splits by doing:
-
-```ruby
-manager.splits
-```
-
-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,
-		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'
-: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
-:mode: :producer
-: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
-
-After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
-
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
-
-## Coverage
-
-The gem uses rspec for unit testing. Under the default `/spec` folder you will find the files for the unit tests and the specs helper file ( spec_helper.rb ). If a new spec file with new unit tests is required you just simply need to create it under the spec folder and all its test will be executed on the next rspec execution.
-
-To run the suite of unit tests a rake task is provided. It's executed with the following command:
-
-```bash
-  $ rake spec
-```
-
-Also, simplecov is used for coverage reporting. After the execution of the rake task it will create the `/coverage` folder with coverage reports in pretty HTML format.
-Right now, the code coverage of the gem is at about 95%.
-
-
-## Contributing
-
-Bug reports and pull requests are welcome on GitHub at https://github.com/splitio/ruby-client.
-
-## Gem version publish
-
-To build a new version of the gem, after you have finished the desired changes, documented the CHANGES.txt and the NEWS, as well as named it properly in the version.rb. This steps assume that all of your new cool features and fixes have been merged into development, and into master branches of the ruby-client repo. Once that is ready to go, you will have to run the build command to obtain a .gem file:
-
-```bash
-gem build splitclient-rb.gemspec
-```
-
-That will generate a splitclient-rb-x.x.x.gem file, with the corresponding version information on it.
-To publish this new version of the gem at rubygems.org you must run the following command:
-
-```bash
-gem push splitclient-rb-x.x.x.gem
-```
-
-A valid rubygems username and password will be required.
-
-After this action, the new splitclient-rb-x.x.x version is available for its use from any ruby app.
-
-So for instance in a rails app Gemfile, you could add the:
-
-```ruby
-gem 'splitclient-rb', '~> x.x.x'
-```
-
-line to have the latest version of the gem ready to be used.
-
-## License
-
-The gem is available as open source under the terms of the [Apache License](http://www.apache.org/licenses/).

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

@@ -31,7 +31,7 @@ module SplitIoClient
             if fields.is_a? Array
               fields.each { |field| @map[key].delete(field) }
             else
-              @map[key].delete(field)
+              @map[key].delete(fields)
             end
           end
 
@@ -97,9 +97,11 @@ module SplitIoClient
           end
 
           def union_sets(set_keys)
-            set_keys.each_with_object([]) do |key, memo|
+            array = set_keys.each_with_object([]) do |key, memo|
               memo << get_set(key)
             end.flatten
+
+            Set.new(array)
           end
 
           # General

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

@@ -4,24 +4,32 @@ module SplitIoClient
       module MemoryAdapters
         # Memory adapter implementation, which stores everything inside queue
         class QueueAdapter
-          def initialize(size)
-            @size = size
+          def initialize(max_size)
+            @max_size = max_size
             @queue = Queue.new
+            @current_size = Concurrent::AtomicFixnum.new(0)
           end
 
           # Adds data to queue in non-blocking mode
           def add_to_queue(data)
+            fail ThreadError if @current_size.value >= @max_size
+
             @queue.push(data)
+
+            @current_size.increment
           end
 
           # Get all items from the queue
           def clear
             items = []
 
-            loop { items << @queue.pop(true) }
+            loop do
+              items << @queue.pop(true)
+
+              @current_size.decrement
+            end
 
           rescue ThreadError
-            # Last queue item reached
             items
           end
         end