splitclient-rb 7.0.0.pre.rc3-java → 7.0.1-java

data/lib/splitclient-rb/split_config.rb

@@ -38,7 +38,18 @@ module SplitIoClient
       )
       @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
+
+      @logger = opts[:logger] || SplitConfig.default_logger
+
+      if(opts[:reload_rate])
+        @features_refresh_rate = opts[:reload_rate]
+        @logger.warn('Localhost mode: reload_rate will be deprecated soon in favor of ' \
+          'features_refresh_rate. Take a look in our documentation.'
+        )
+      else
+        @features_refresh_rate = opts[:features_refresh_rate] || SplitConfig.default_features_refresh_rate
+      end
+
       @segments_refresh_rate = opts[:segments_refresh_rate] || SplitConfig.default_segments_refresh_rate
       @metrics_refresh_rate = opts[:metrics_refresh_rate] || SplitConfig.default_metrics_refresh_rate
 
@@ -48,21 +59,20 @@ module SplitIoClient
         opts[:cache_adapter] || SplitConfig.default_cache_adapter, :queue_adapter, @impressions_queue_size, @redis_url
       )
       #Safeguard for users of older SDK versions.
-      @disable_impressions = @impressions_queue_size == -1
-      #Safeguard for users of older SDK versions.
       @impressions_bulk_size = opts[:impressions_bulk_size] || @impressions_queue_size > 0 ? @impressions_queue_size : 0
 
       @metrics_adapter = SplitConfig.init_cache_adapter(
         opts[:cache_adapter] || SplitConfig.default_cache_adapter, :map_adapter, nil, @redis_url
       )
 
-      @logger = opts[:logger] || SplitConfig.default_logger
       @debug_enabled = opts[:debug_enabled] || SplitConfig.default_debug
       @transport_debug_enabled = opts[:transport_debug_enabled] || SplitConfig.default_debug
       @block_until_ready = SplitConfig.default_block_until_ready
 
-      @machine_name = opts[:machine_name] || SplitConfig.machine_hostname
-      @machine_ip = opts[:machine_ip] || SplitConfig.machine_ip
+      @ip_addresses_enabled = opts[:ip_addresses_enabled].nil? ? SplitConfig.default_ip_addresses_enabled : opts[:ip_addresses_enabled]
+
+      @machine_name = SplitConfig.machine_hostname(@ip_addresses_enabled, opts[:machine_name], opts[:cache_adapter] || SplitConfig.default_cache_adapter)
+      @machine_ip = SplitConfig.machine_ip(@ip_addresses_enabled, opts[:machine_ip], opts[:cache_adapter] || SplitConfig.default_cache_adapter)
 
       @cache_ttl = opts[:cache_ttl] || SplitConfig.cache_ttl
       @max_cache_size = opts[:max_cache_size] || SplitConfig.max_cache_size
@@ -84,9 +94,14 @@ module SplitIoClient
       @events_adapter = SplitConfig.init_cache_adapter(
         opts[:cache_adapter] || SplitConfig.default_cache_adapter, :queue_adapter, @events_queue_size, @redis_url
       )
+
+      @split_file = opts[:split_file] || SplitConfig.default_split_file
+
       @valid_mode = true
       @split_logger = SplitIoClient::SplitLogger.new(self)
       @split_validator = SplitIoClient::Validators.new(self)
+      @localhost_mode = opts[:localhost_mode]
+
       startup_log
     end
 
@@ -209,12 +224,11 @@ module SplitIoClient
     attr_accessor :impression_listener_refresh_rate
 
     #
-    # How big the impressions queue is before dropping impressions. -1 to disable it.
+    # How big the impressions queue is before dropping impressions
     #
     # @return [Integer]
     attr_accessor :impressions_queue_size
     attr_accessor :impressions_bulk_size
-    attr_accessor :disable_impressions
 
     attr_accessor :redis_url
     attr_accessor :redis_namespace
@@ -235,6 +249,12 @@ module SplitIoClient
     # @return [Integer]
     attr_accessor :events_queue_size
 
+    attr_accessor :split_file
+
+    attr_accessor :localhost_mode
+
+    attr_accessor :ip_addresses_enabled
+
     #
     # The default split client configuration
     #
@@ -340,6 +360,14 @@ module SplitIoClient
       500
     end
 
+    def self.default_split_file
+      File.join(Dir.home, '.split')
+    end
+
+    def self.default_offline_refresh_rate
+      5
+    end
+
     #
     # The default logger object
     #
@@ -388,6 +416,14 @@ module SplitIoClient
       15
     end
 
+    #
+    # The default ip addresses enabled value
+    #
+    # @return [boolean]
+    def self.default_ip_addresses_enabled
+      true
+    end
+
     #
     # The default transport_debug_enabled value
     #
@@ -454,23 +490,49 @@ module SplitIoClient
     # gets the hostname where the sdk gem is running
     #
     # @return [string]
-    def self.machine_hostname
-      Socket.gethostname
-    rescue
-      'localhost'.freeze
+    def self.machine_hostname(ip_addresses_enabled, machine_name, adapter)
+      if ip_addresses_enabled
+        begin
+          return machine_name || Socket.gethostname
+        rescue
+          return 'unknown'.freeze
+        end
+      else
+        case adapter
+        when :redis
+          return 'NA'.freeze
+        end
+      end
+      
+      return ''.freeze
     end
 
     #
     # gets the ip where the sdk gem is running
     #
     # @return [string]
-    def self.machine_ip
-      loopback_ip = Socket.ip_address_list.find { |ip| ip.ipv4_loopback? }
-      private_ip = Socket.ip_address_list.find { |ip| ip.ipv4_private? }
+    def self.machine_ip(ip_addresses_enabled, ip, adapter)
+      if ip_addresses_enabled
+        begin          
+          return ip unless ip.nil? || ip.to_s.empty?
+
+          loopback_ip = Socket.ip_address_list.find { |ip| ip.ipv4_loopback? }
+          private_ip = Socket.ip_address_list.find { |ip| ip.ipv4_private? }
+
+          addr_info = private_ip || loopback_ip
 
-      addr_info = private_ip || loopback_ip
+          return addr_info.ip_address
+        rescue
+          return 'unknown'.freeze
+        end
+      else
+        case adapter
+        when :redis
+          return 'NA'.freeze
+        end
+      end
 
-      addr_info.ip_address
+      return ''.freeze
     end
   end
 end

data/lib/splitclient-rb/split_factory.rb

@@ -2,6 +2,8 @@ module SplitIoClient
   class SplitFactory
     ROOT_PROCESS_ID = Process.pid
     SINGLETON_WARN = 'We recommend keeping only one instance of the factory at all times (Singleton pattern) and reusing it throughout your application'
+    LOCALHOST_API_KEY = 'localhost'
+
     include SplitIoClient::Cache::Repositories
     include SplitIoClient::Cache::Stores
 
@@ -20,10 +22,10 @@ module SplitIoClient
       end
 
       @api_key = api_key
-      @config = SplitConfig.new (config_hash)
+      @config = SplitConfig.new(config_hash.merge(localhost_mode: @api_key == LOCALHOST_API_KEY ))
 
       raise 'Invalid SDK mode' unless valid_mode
-      
+
       @splits_repository = SplitsRepository.new(@config)
       @segments_repository = SegmentsRepository.new(@config)
       @impressions_repository = ImpressionsRepository.new(@config)
@@ -35,7 +37,7 @@ module SplitIoClient
       @adapter = start!
 
       @client = SplitClient.new(@api_key, @adapter, @splits_repository, @segments_repository, @impressions_repository, @metrics_repository, @events_repository, @sdk_blocker, @config)
-      @manager = SplitManager.new(@api_key, @adapter, @splits_repository, @sdk_blocker, @config)
+      @manager = SplitManager.new(@splits_repository, @sdk_blocker, @config)
 
       validate_api_key
 
@@ -72,7 +74,12 @@ module SplitIoClient
       case @config.mode
       when :consumer
         if @config.cache_adapter.is_a? SplitIoClient::Cache::Adapters::RedisAdapter
-          valid_startup_mode = true
+          if !@config.localhost_mode
+            valid_startup_mode = true
+          else
+            @config.logger.error('Localhost mode cannot be used with Redis. ' \
+              'Use standalone mode and Memory adapter instead.')
+          end
         else
           @config.logger.error('Consumer mode cannot be used with Memory adapter. ' \
             'Use Redis adapter instead.')

data/lib/splitclient-rb/split_factory_builder.rb

@@ -1,27 +1,7 @@
-require 'logger'
-
 module SplitIoClient
   class SplitFactoryBuilder
     def self.build(api_key, config = {})
-      case api_key
-      when 'localhost'
-        configuration = SplitConfig.new(config)
-        LocalhostSplitFactory.new(split_file(config[:split_file], configuration.logger), configuration, config[:reload_rate])
-      else
-        SplitFactory.new(api_key, config)
-      end
-    end
-
-    private
-
-    def self.split_file(split_file_path, logger)
-      return split_file_path unless split_file_path.nil?
-
-      logger.warn('Localhost mode: .split mocks ' \
-        'will be deprecated soon in favor of YAML files, which provide more ' \
-        'targeting power. Take a look in our documentation.')
-
-      File.join(Dir.home, '.split')
+      SplitFactory.new(api_key, config)
     end
   end
 end

data/lib/splitclient-rb/version.rb

@@ -1,3 +1,3 @@
 module SplitIoClient
-  VERSION = '7.0.0.pre.rc3'
+  VERSION = '7.0.1'
 end

data/sonar-scanner.sh

@@ -0,0 +1,42 @@
+#/bin/bash -e
+
+sonar_scanner() {
+  local params=$@
+
+  sonar-scanner \
+    -Dsonar.host.url='https://sonarqube.split-internal.com' \
+    -Dsonar.login="$SONAR_TOKEN" \
+    -Dsonar.ws.timeout='300' \
+    -Dsonar.sources='lib' \
+    -Dsonar.projectName='ruby-client' \
+    -Dsonar.projectKey='ruby-client' \
+    -Dsonar.ruby.coverage.reportPaths='coverage/.resultset.json' \
+    -Dsonar.links.ci='https://travis-ci.com/splitio/ruby-client' \
+    -Dsonar.links.scm='https://github.com/splitio/ruby-client' \
+    ${params}
+
+  return $?
+}
+
+if [ "$TRAVIS_PULL_REQUEST" != "false" ]; then
+  sonar_scanner \
+    -Dsonar.pullrequest.provider='GitHub' \
+    -Dsonar.pullrequest.github.repository='splitio/ruby-client' \
+    -Dsonar.pullrequest.key=$TRAVIS_PULL_REQUEST \
+    -Dsonar.pullrequest.branch=$TRAVIS_PULL_REQUEST_BRANCH \
+    -Dsonar.pullrequest.base=$TRAVIS_BRANCH
+else
+  if [ "$TRAVIS_BRANCH" == 'master' ]; then
+    sonar_scanner \
+      -Dsonar.branch.name=$TRAVIS_BRANCH
+  else
+    if [ "$TRAVIS_BRANCH" == 'development' ]; then
+      TARGET_BRANCH='master'
+    else
+      TARGET_BRANCH='development'
+    fi
+    sonar_scanner \
+      -Dsonar.branch.name=$TRAVIS_BRANCH \
+      -Dsonar.branch.target=$TARGET_BRANCH
+  fi
+fi

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: splitclient-rb
 version: !ruby/object:Gem::Version
-  version: 7.0.0.pre.rc3
+  version: 7.0.1
 platform: java
 authors:
 - Split Software
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-08-21 00:00:00.000000000 Z
+date: 2019-11-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -283,16 +283,16 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/pull_request_template.md"
 - ".gitignore"
 - ".rubocop.yml"
 - ".simplecov"
 - ".travis.yml"
 - Appraisals
 - CHANGES.txt
-- Detailed-README.md
+- CONTRIBUTORS-GUIDE.md
 - Gemfile
 - LICENSE
-- NEWS
 - README.md
 - Rakefile
 - ext/murmurhash/MurmurHash3.java
@@ -323,11 +323,14 @@ files:
 - lib/splitclient-rb/cache/senders/events_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
 - lib/splitclient-rb/cache/senders/metrics_sender.rb
+- lib/splitclient-rb/cache/stores/localhost_split_builder.rb
+- lib/splitclient-rb/cache/stores/localhost_split_store.rb
 - lib/splitclient-rb/cache/stores/sdk_blocker.rb
 - lib/splitclient-rb/cache/stores/segment_store.rb
 - lib/splitclient-rb/cache/stores/split_store.rb
-- lib/splitclient-rb/clients/localhost_split_client.rb
+- lib/splitclient-rb/cache/stores/store_utils.rb
 - lib/splitclient-rb/clients/split_client.rb
 - lib/splitclient-rb/engine/api/client.rb
 - lib/splitclient-rb/engine/api/events.rb
@@ -370,9 +373,6 @@ files:
 - lib/splitclient-rb/engine/parser/partition.rb
 - lib/splitclient-rb/engine/parser/split_adapter.rb
 - lib/splitclient-rb/exceptions.rb
-- lib/splitclient-rb/localhost_split_factory.rb
-- lib/splitclient-rb/localhost_utils.rb
-- lib/splitclient-rb/managers/localhost_split_manager.rb
 - lib/splitclient-rb/managers/split_manager.rb
 - lib/splitclient-rb/redis_metrics_fixer.rb
 - lib/splitclient-rb/split_config.rb
@@ -383,6 +383,7 @@ files:
 - lib/splitclient-rb/utilitites.rb
 - lib/splitclient-rb/validators.rb
 - lib/splitclient-rb/version.rb
+- sonar-scanner.sh
 - splitclient-rb.gemspec
 - tasks/benchmark_get_treatment.rake
 - tasks/irb.rake
@@ -401,9 +402,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project:
 rubygems_version: 2.6.14

data/Detailed-README.md

@@ -1,576 +0,0 @@
-# Split Ruby SDK
-
-Ruby [Split](https://www.split.io/) SDK client.
-
-## Installation
-
-Install by running:
-
-    $ gem install splitclient-rb
-
-If using [Bundler](https://bundler.io/), add this line to your `Gemfile`:
-
-```ruby
-gem 'splitclient-rb'
-```
-
-And then run:
-
-    $ bundle install
-
-Or use any specific branch by adding the following to your `Gemfile` instead:
-
-```ruby
-gem 'splitclient-rb', git: 'https://github.com/splitio/ruby-client.git', branch: 'branch_name'
-```
-
-## Usage
-
-### Quick Setup
----
-
-Within your application, include the Split client using Ruby's `require`:
-```ruby
-require 'splitclient-rb'
-```
-
-Then, create a new split client instance with your API key, which can be found in your Organization Settings page, in the APIs tab.
-
-```ruby
-factory  = SplitIoClient::SplitFactoryBuilder.build('YOUR_API_KEY')
-split_client = factory.client
-```
-
-### Ruby on Rails
----
-
-Create an initializer (typically `config/initializers/split_client.rb`) with the following code:
-
-```ruby
-Rails.configuration.split_client = SplitIoClient::SplitFactoryBuilder.build('YOUR_API_KEY').client
-```
-And use the snippet below to access the client in your controllers:
-
-```ruby
-Rails.application.config.split_client
-```
-
-### Using the SDK
----
-
-In its simplest form, using the SDK is reduced to calling the `get_treatment` method of the SDK client to decide what version of your features your customers should be served for a specific feature and user. You can then use an if-else-if block for the different treatments that you defined in the Split UI:
-
-```ruby
-treatment = split_client.get_treatment('user_id', 'feature_name');
-
-if treatment == 'on'
-  # insert code here to show on treatment
-elsif treatment == 'off'
-  # insert code here to show off treatment
-else
-  # handle the client returning the control treatment
-end
-```
-
-**Note**: You can ensure the SDK resources are loaded before querying for treatments by using `block_until_ready`.
-
-``` ruby
-factory  = SplitIoClient::SplitFactoryBuilder.build('YOUR_API_KEY')
-split_client = factory.client
-split_client.block_until_ready # Wait for a specified time (default 15 seconds). SDK raises an SDKBlockerTimeoutExpiredException if not ready by then
-```
-
-For features that use targeting rules based on user attributes, you can call the `get_treatment` method the following way:
-
-```ruby
-split_client.get_treatment('user_id','feature_name', attr: 'val')
-```
-
-e.g.
-```ruby
-if split_client.get_treatment('employee_user_01','view_main_list', age: 35)
-   my_app.display_main_list
-end
-```
-
-Also, you can you can provide two different keys - one for matching and the other for bucketing:
-```ruby
-split_client.get_treatment(
-	{ matching_key: 'subscriber_id', bucketing_key: 'user_id' },
-	'feature_name',
-	attr: 'val'
-)
-```
-An scenario that requires the usage of both keys is a visitor user that browses the site and at some point gets logged into the system: as an anonymous visitor, the user browses the home page and is given the `new_homepage` treatment based on her visitor id. If the visitor signs up and turns into a subscriber, then upon being given her `subscriber_id`, Split may decide to give her the old_homepage treatment. This is of course, the opposite of the desired outcome, as the visitor's entire homepage experience would change as soon as she signs up.
-
- Split solves this situation by introducing the concept of a matching_key and a bucketing key. By providing the `subscriber_id` as the `matching_key` and the `visitor_id` as the `bucketing_key`, Split will give the same treatment back to the user that it used to give to the visitor.
-
-The `bucketing_key` may be `nil`. In that case the `matching_key` would be used instead, so calling:
-```ruby
-split_client.get_treatment(
-	{ matching_key: 'subscriber_id' },
-	'feature_name',
-	attr: 'val'
-)
-```
-It's exactly the same as calling:
-```ruby
-split_client.get_treatment('subscriber_id' ,'feature_name', attr: 'val')
-```
-**Important:** `matching_key` cannot be nil.
-
-#### Split Manager
-
-For some advanced use cases you can use the Split Manager. To get a `manager` instance, do:
-
-```ruby
-split_manager = SplitIoClient::SplitFactoryBuilder.build('your_api_key', options).manager
-```
-_Or simply call `#manager` in your factory instance if you built it previously._
-
-As an example, using the manager you could get a list of your splits by doing:
-
-```ruby
-split_manager.splits
-```
-
-Which would produce an output similar to:
-
-```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
-	}
-]
- ```
-
-**Note**: `block_until_ready` is also available as a Split manager method
-
- #### Localhost Mode
-
- You can run the SDK in _localhost_ mode. In this mode, the SDK won't actually communicate with the Split API, but it'll rather return treatments based on a `.split` file on your local environment. This file must be a list of `split_name treatment_name_to_be_returned` entries. e.g.:
-
- ```
- reporting_v2 on
- double_writes_to_cassandra off
- new-navigation v3
- ```
-
-Using the file above, when calling:
-```ruby
-split_client.get_treatment('foo', 'reporting_v2')
-```
-
-The split client will return `on`. Note that this will be true for any bucketing or matching key.
-
- To configure the SDK to work in localhost mode, use `localhost` as the API key:
-
- ```ruby
- factory = SplitIoClient::SplitFactoryBuilder.build('localhost', path: '/where/to-look-for/<file_name>')
- split_client = factory.client
- ```
-
- By default, the SDK will look in your home directory (i.e. `~`) for the `.split` file. You can change this location by specifying an absolute path instead.
-
- When in localhost mode, you can make use of the SDK ability to automatically refresh the splits from the `.split` file. To do that, just specify a reload rate in seconds when building the split factory instance, like this:
-
- ```ruby
- factory = SplitIoClient::SplitFactoryBuilder.build('localhost', path: '/where/to-look-for/<file_name>', reload_rate: 3)
- ```
-
-### SDK Input Validations
-
-In order to provide consistency among the SDKs for the different programming languages, provide better output to users in case of errors, and prevent unexpected errors to raise exceptions in your application, most of the parameters in the SDK methods are validated against a set of rules. Similarly, some of the configuration parameters must follow these rules, too. Check your application against the list below to prevent issues when using the SDK.
-
-#### get_treatment (split_client)
-
-- `key` (when not using matching_key and bucketing_key): must be a non-empty `String` or a `Symbol`, shorter than 250 characters. If a non-NaN `Numeric` value is used, it'll be converted to its `String` representation.
-
-- `matching_key`, `bucketing_key`: the containing `Hash` must have both keys, and the same rules above apply for each.
-
-- `split_name`: must be a non-empty `String` or a `Symbol`. Whitespaces will be trimmed from both ends of it. The trimmed version of the `split_name` will be used for both evaluation and to store the resulting impression. In addition, split must exist in the environment.
-
-- `attributes`: must be of type `Hash`.
-
-#### get_treatments (split_client)
-
-- `key`, `matching_key`, `bucketing_key`: same rules as those for `get_treatment` apply.
-
-- `split_names`: must be an non-empty Array. Split names will be filtered removing those not matching the corresponding rules for `split_name` in `get_treatment`. In addition, duplicates will be removed.
-
-#### track (split_client)
-
-- `key`: must be a non-empty `String` or a `Symbol`, shorter than 250 characters. If a non-NaN `Numeric` value is used, it'll be converted to its `String` representation.
-
-- `traffic_type_name`: must be a non-empty `String` or a `Symbol`. If `traffic_type_name` contains uppercase letters, it will be lowercased.
-
-- `event_type`: must be a non-empty `String` or `Symbol` that conforms with the regular expression `^[a-zA-Z0-9][-_.:a-zA-Z0-9]{0,79}$` (i.e. event name must be alphanumeric, cannot be more than 80 characters long, and can only include a dash, underscore, period, or colon as separators of alphanumeric characters).
-
-- `value`: must be either a non-NaN `Numeric` value, or nil.
-
-#### split (split_manager)
-
-- `split_name`: must be a non-empty `String` or a `Symbol`. In addition, split must exist in the environment.
-
-#### Configuration Parameters
-
-- `api_key`: must be a non-empty `String` or a `Symbol` of type `sdk` (`browser` type API keys will break this rule).
-
-#### Client Destroyed Rules
-Calls to the SDK methods are still possible after `destroy` is called. All will log an error message stating _client has been destroyed_.
-
-- `get_treatment` will return `control` for all calls (`get_treatments`, will return an Array of `control` values, correspondingly).
-
-- Calls to `track` will return `false`.  
-
-- All calls to `split_manager` methods will return an empty Array, except `split`, which will return `nil`.
-
-
-## Advanced Configuration
-
-Split client's default configuration should cover most scenarios. However, you can also provide custom configuration settings when initializing the factory using a hash of options. e.g.:
-
-```ruby
-options = {
-  impressions_refresh_rate: 10,
-  debug_enabled: true,
-  transport_debug_enabled: false
-}
-
-factory = SplitIoClient::SplitFactoryBuilder.build('your_api_key'], options)
-```
-
-The following values can be customized:
-
-**base_uri** :  URI for the api endpoints.
-
-*default value* = `https://sdk.split.io/api/`
-
-**connection_timeout** : Http client connection timeout (in seconds).
-
-*default value* = `5`
-
-**read_timeout** : Http socket read timeout (in seconds).
-
-*default value* = `5`
-
-**features_refresh_rate** : The SDK polls Split servers for changes to feature Splits every X seconds, where X is this property's value.
-
-*default value* = `5`
-
-**segments_refresh_rate** : The SDK polls Split servers for changes to segments every X seconds, where X is this property's value.
-
-*default value* = `60`
-
-**metrics_refresh_rate** : The SDK sends and flushes diagnostic metrics to Split servers every X seconds where X is this property's value.
-
-*default value* = `60`
-
-**impressions_refresh_rate** : The treatment log captures which customer saw what treatment ("on", "off", etc) at what time. This parameter controls how often this log is flushed back to Split servers to power analytics (in seconds).
-
-*default value* = `60`
-
-**impressions_queue_size** : The size of the impressions queue in case of `cache_adapter == :memory`. When the queue is full, existing impressions will be dropped.
-
-*default value* = 5000
-
-**impressions_bulk_size** : Maximum number of impressions to be sent to Split servers on each post.
-
-*default value* = defaults to `impressions_queue_size`
-
-**events_queue_size** : The size of the events queue in case of `cache_adapter == :memory`. When the queue is full, existing events will be dropped.
-
-*default value* = 500
-
-**debug_enabled** : Enables extra logging (verbose mode).
-
-*default value* = `false`
-
-**transport_debug_enabled** : Super verbose mode that prints network payloads among others.
-
-*default value* = `false`
-
-**logger** : Default logger for messages and errors.
-
-*default value* = `Logger.new($stdout)`
-
-**impression_listener** : Route impressions' information to a location of your choice (in addition to the SDK servers). _See [Impression Listener](#impression-listener) section for specifics._
-
-*default value* = (no impression listener)
-
-**labels_enabled** : Allows preventing labels from being sent to the Split servers, as they may contain sensitive information.
-
-*default value* = `true`
-
-**mode** : See [SDK Modes](#sdk-modes).
-
-*default value* = `:standalone`
-
-**cache_adapter** : Where to store data (splits, segments, and impressions) in between calls to the the Split servers. Supported options are `:memory` (default) and `:redis`.
-
-_To use Redis, include `redis-rb` in your app's Gemfile._
-
-*default value* = `:memory`
-
-**redis_namespace** : Prefix to add to elements in Redis cache when having to share redis with other applications.
-
-*default value* = `SPLITIO`
-
-**language** : SDK language (used in the Redis namespace for metrics and impressions, also included in requests' headers).
-
-*default value* = `'ruby'`
-
-**version** : SDK version (used in the Redis namespace for metrics and impressions, also included in requests' headers).
-
-*default value* = (current version of the SDK)
-
-**machine_ip** : SDK machine ip (used in the Redis namespace for metrics and impressions, also included in requests' headers).
-
-*default value* = (your current host's ip)
-
-**machine_name** : SDK machine name (used in the Redis namespace for metrics and impressions, also included in requests' headers).
-
-*default value* = (your current hostname)
-
-**cache_ttl** : Time to live in seconds for the memory cache values when using Redis.
-
-*default value* = `5`
-
-**max_cache_size** : Maximum number of items held in the memory cache values when using Redis. When cache is full an LRU strategy for pruning shall be used.
-
-*default value* = `500`
-
-**redis_url** : Redis URL or hash with configuration for the SDK to connect to. See [Redis#initialize](https://www.rubydoc.info/github/redis/redis-rb/Redis%3Ainitialize) for detailed information.
-
-*default value* = `'redis://127.0.0.1:6379/0'`
-
-_You can also use [Redis Sentinel](https://redis.io/topics/sentinel) by providing an array of sentinels in the Redis configuration:_
-
-```ruby
-SENTINELS = [{host: '127.0.0.1', port: 26380},
-             {host: '127.0.0.1', port: 26381}]
-
-options = {
-  # Other options here
-  redis_url: { url: 'redis://mymaster', sentinels: SENTINELS, role: :master }
-}
-```
-### Sample Configuration Using Redis
----
-
-```ruby
-options = {
-  # other options
-  cache_adapter: :redis,
-  mode: :consumer,
-  redis_url: 'redis://127.0.0.1:6379/0'
-}
-
-split_client = SplitIoClient::SplitFactoryBuilder.build('YOUR_API_KEY', options).client
-```
-
-### Logging
----
-
-By default, the SDK makes use of Ruby stdlib's `Logger` class to log errors and events. You can change the following options when configuring the SDK in your application:
-
-```ruby
-logger: Logger.new('logfile.log'), # Logger class instance.
-debug_enabled: true, # Verbose logging.
-transport_debug_enabled: true # Super verbose logging, including http request data.
-```
-
-_Refer to [Advanced Configuration](#advanced-configuration) for more information._
-
-#### Impression Listener
-
-The SDK provides an optional featured called Impression Listener, that captures every single impression in your app.
-
-To set up an Impression Listener, define a class that implements a `log` instance method, which must receive the `impression` argument. e.g.:
-
-```ruby
-class MyImpressionListener
-  def log(impression)
-    Logger.new($stdout).info(impression)
-  end
-end
-```
-
-In the example above, the listener simply takes an impression and logs it to the stdout. By providing a specific listener, you could send this information to a location of your choice. To use this feature, you need to specify the class name in the corresponding option of your configuration (i.e. initializer) like this:
-
-```ruby
-{
-  # other options
-  impression_listener: MyImpressionListener.new # remember to initialize your class here
-}
-```
-
-### SDK Modes
----
-
-The SDK is capable of running in two different modes to fit in different infrastructure configurations:
-
-- `:standalone` - (default) : The SDK will retrieve information (e.g. split definitions) periodically from the Split servers, and store it in the memory cache. It'll also store the application execution information (e.g. impressions) in the cache and send it periodically to the Split servers. As it name implies, in this mode, the SDK neither relies nor synchronizes with any other component. _This mode is only available when using the `memory` cache adapter._
-- `:consumer` - If using a load balancer or more than one SDK in your application, guaranteeing that all changes in split definitions are picked up by all SDK instances at the same time is highly recommended in order to ensure consistent results across your infrastructure (i.e. getting the same treatment for a specific split and user pair). To achieve this, use the [Split Synchronizer](https://docs.split.io/docs/split-synchronizer)) and setup your SDKs to work in the `consumer` mode. Setting the components this way, all communication with the Split server is orchestrated by the Synchronizer, while the SDKs pick up definitions and store the execution information from / into a shared Redis data store. _This mode is only available when using the `redis` cache adapter. In addition, note that `block_until_ready` has no effect in this mode_
-
-_You can choose between these 2 modes setting the `mode` option in the config. An invalid combination of `cache_adaper` and `mode` will result in an Invalid Mode exception being raised._
-
-## SDK Server Compatibility
-
-The Split Ruby SDK has been tested as a standalone app as well as using the following web servers:
-  - Thin
-  - Puma
-  - Passenger
-  - Unicorn
-
-For other setups, please reach out to [support@split.io](mailto:support@split.io).
-
-### Server Compatibility Notes
----
-
-#### Unicorn and Puma in cluster mode (only for "memory mode")
-
-During the start of your application, the SDK spawns multiple threads. Each thread has an infinite loop inside,
-which is used to fetch splits/segments or send impressions/metrics to the Split service continuously.
-When using Unicorn or Puma in cluster mode (i.e. with `workers` > 0) the application
-server will spawn multiple child processes, but they won't recreate the threads that existed in the parent process.
-So, if your application is running in Unicorn or Puma in cluster mode you need to make two small extra steps.
-
-For both servers you will need to have the following line in your `config/initializers/splitclient.rb`:
-
-```ruby
-Rails.configuration.split_factory = factory
-```
-
-#### Unicorn
-
-If you’re using Unicorn you’ll need to include these lines in your Unicorn config (likely `config/unicorn.rb`):
-
-```ruby
-before_fork do |server, worker|
-  # keep your existing before_fork code if any
-  Rails.configuration.split_factory.stop!
-end
-
-after_fork do |server, worker|
-  # keep your existing after_fork code if any
-  Rails.configuration.split_factory.resume!
-end
-```
-
-#### Puma
-
-If using Puma in cluster mode, add these lines to your Puma config (likely `config/puma.rb`):
-
-```ruby
-before_fork do
-  # keep your existing before_fork code if any
-  Rails.configuration.split_factory.stop!
-end
-
-on_worker_boot do
-  # keep your existing on_worker_boot code if any
-  Rails.configuration.split_factory.resume!
-end
-```
-
-By doing the above, the SDK will recreate the threads for each new worker and prevent the master process (that doesn't handle requests) from needlessly querying the Split service.
-
-## Proxy Support
-
-SDK uses the `http_proxy` environment variable. Assign your proxy address to the variable value in the following format, and the SDK will make use of it:
-
-```
-http_proxy=http://username:password@hostname:port
-```
-
-## Development Notes
-
-Check out the repository and run `bin/setup` to install dependencies. You can also run `bin/console` to get an interactive prompt.
-
-To install this gem onto your local machine, run `bundle exec rake install`.
-
-### Tests & Coverage
----
-
-The gem uses `rspec` for unit testing. You can find the files for the unit tests and the specs helper file (`spec_helper.rb`) under the default `/spec` folder.
-
-To run all the specs in the `spec` folder, use the provided rake task (_make sure Redis is running in localhost_):
-
-```bash
-  bundle exec rspec
-```
-
-`Simplecov` is used for coverage reporting. Upon executing the rake task it will store the reports in the `/coverage` folder.
-
-### Benchmarks
----
-
-To benchmark the hashing algorithms (MurmurHash) run:
-
-```bash
-bundle exec rake benchmark_hashing_algorithm
-```
-
-### Contribute
----
-
-Bug reports and pull requests are welcome on GitHub at https://github.com/splitio/ruby-client.
-
-### Release
----
-
-To build and release a new version of the gem, document any changes into the `CHANGES.txt` and the `NEWS` files. Then, increase the version number in `version.rb`.
-**Note**: This step assumes that all new features and fixes have been merged into the `development` branch, tested, validated, and finally merged into the `master` branch of the `ruby-client` repository.
-
-To build a new version of the gem after making the changes specified above, run:
-
-```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 release the new version of the gem at [rubygems.org](rubygems.org) run the following command:
-
-```bash
-gem push splitclient-rb-x.x.x.gem
-```
-
-_A valid rubygems username and password is required._
-
-Once released, `splitclient-rb-x.x.x` version will be available for use in any ruby application.
-
-To get a specific gem version in a Rails application that uses Bundler, add this line to your gemfile:
-
-```ruby
-gem 'splitclient-rb', '~> x.x.x'
-```
-
-## License
-
-The gem is available as open source under the terms of the [Apache License](http://www.apache.org/licenses/).