unleash 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d8661e45cf753ab1c4ffdda0c4445657237cf0dafb26c1f701e258a3fe8c28f
-  data.tar.gz: 440ddb7d149983453cbda346264e12510fb97a3372ac99bcb5e5e8d60e25df7d
+  metadata.gz: 99d6b4f0efb9cf53a2f86930e2e26594d2de8c72aee68ee20e1374f6ac1826cc
+  data.tar.gz: ac9905dee38bb80b0f94595907e74856be1842149bfbfc54ee0ff8390bd9dcda
 SHA512:
-  metadata.gz: d913c18a4dc0894b19a6281dfb6112891bcb296725afd75aa84172fc7849b36c87962f55151094820d0951c0ea5ec2dd4c8e0e9ce946cc99e2747c9b41e94472
-  data.tar.gz: bcd865ead7231ea7dbc24b3318498ccbddaab5a7032375c8d25f603952b094141126ebae8e0cf668e74d7ba9e6c73be27f083175211529714967e941d0744521
+  metadata.gz: b0ce261b43d7325d3aac1ed62a60d7fdec14543d92e5da63f3e1e699ab6a79d5a529c9080f51dfaf641ce72e18518a61ac1f14395987b3e515503865ed1ef5bf
+  data.tar.gz: 3b4cf6548b3c19be261f3794370a80868f0c07cec0988423aa1388f5a75349f880ef1b824652a2bd582814149c985f82e7e1b01772470e41fd119406272f3b42

data/.rubocop.yml

@@ -9,3 +9,8 @@ Style/RedundantSelf:
   Enabled: false
 Style/PreferredHashMethods:
   Enabled: false
+Style/StringLiterals:
+  Enabled: false
+
+Layout/SpaceBeforeBlockBraces:
+  Enabled: false

data/.travis.yml

@@ -7,6 +7,6 @@ rvm:
   - 2.6
   - jruby
 before_install:
-  - gem install bundler -v 2.0.1
+  - gem install bundler -v 2.0.2
   # install client spec from official repository:
   - git clone --depth 5 https://github.com/Unleash/client-specification.git client-specification

data/README.md

@@ -2,17 +2,26 @@
 
 [![Build Status](https://travis-ci.org/Unleash/unleash-client-ruby.svg?branch=master)](https://travis-ci.org/Unleash/unleash-client-ruby)
 [![Coverage Status](https://coveralls.io/repos/github/Unleash/unleash-client-ruby/badge.svg?branch=master)](https://coveralls.io/github/Unleash/unleash-client-ruby?branch=master)
+[![Gem Version](https://badge.fury.io/rb/unleash.svg)](https://badge.fury.io/rb/unleash)
 
 Unleash client so you can roll out your features with confidence.
 
 Leverage the [Unleash Server](https://github.com/Unleash/unleash) for powerful feature toggling in your ruby/rails applications.
 
+## Supported Ruby Interpreters
+
+  * MRI 2.3
+  * MRI 2.4
+  * MRI 2.5
+  * MRI 2.6
+  * jruby
+
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'unleash', '~> 0.1.5'
+gem 'unleash', '~> 0.1.6'
 ```
 
 And then execute:
@@ -50,16 +59,17 @@ Argument | Description | Required? |  Type |  Default Value|
 `url`      | Unleash server URL. | Y | String | N/A |
 `app_name` | Name of your program. | Y | String | N/A |
 `instance_id` | Identifier for the running instance of program. Important so you can trace back to where metrics are being collected from. **Highly recommended be be set.** | N | String | random UUID |
+`environment` | Environment the program is running on. Could be for example `prod` or `dev`. Not yet in use. | N | String | `default` |
 `refresh_interval` | How often the unleash client should check with the server for configuration changes. | N | Integer |  15 |
 `metrics_interval` | How often the unleash client should send metrics to server. | N | Integer | 10 |
-`disable_client` | Disables all communication with the Unleash server. If set, `is_enabled?` will always answer with the `default_value` and configuration validation is skipped. Defeats the entire purpose of using unleash, but can be useful in when running tests. | N | Boolean | F |
-`disable_metrics` | Disables sending metrics to Unleash server. | N | Boolean | F |
+`disable_client` | Disables all communication with the Unleash server, effectively taking it *offline*. If set, `is_enabled?` will always answer with the `default_value` and configuration validation is skipped. Defeats the entire purpose of using unleash, but can be useful in when running tests. | N | Boolean | `false` |
+`disable_metrics` | Disables sending metrics to Unleash server. | N | Boolean | `false` |
 `custom_http_headers` | Custom headers to send to Unleash. | N | Hash | {} |
 `timeout` | How long to wait for the connection to be established or wait in reading state (open_timeout/read_timeout) | N | Integer | 30 |
 `retry_limit` | How many consecutive failures in connecting to the Unleash server are allowed before giving up. | N | Integer | 1 |
-`backup_file` | Filename to store the last known state from the Unleash server. Best to not change this from the default. | N | `Dir.tmpdir + "/unleash-#{app_name}-repo.json` |
-`logger` | Specify a custom `Logger` class to handle logs from the client. | N | `Logger.new(STDOUT)` |
-`log_level` | Change the log level for the `Logger` class. | N | `Logger::ERROR` |
+`backup_file` | Filename to store the last known state from the Unleash server. Best to not change this from the default. | N | String | `Dir.tmpdir + "/unleash-#{app_name}-repo.json` |
+`logger` | Specify a custom `Logger` class to handle logs for the Unleash client. | N | Class | `Logger.new(STDOUT)` |
+`log_level` | Change the log level for the `Logger` class. Constant from `Logger::Severity`. | N | Constant | `Logger::ERROR` |
 
 For in a more in depth look, please see `lib/unleash/configuration.rb`.
 
@@ -95,6 +105,7 @@ Unleash.configure do |config|
   config.app_name = Rails.application.class.parent.to_s
   # config.instance_id = "#{Socket.gethostname}"
   config.logger   = Rails.logger
+  config.environment = Rails.env
 end
 
 UNLEASH = Unleash::Client.new
@@ -113,6 +124,7 @@ on_worker_boot do
   Unleash.configure do |config|
     config.url      = 'http://unleash.herokuapp.com/api'
     config.app_name = Rails.application.class.parent.to_s
+    config.environment = Rails.env
   end
   Rails.configuration.unleash = Unleash::Client.new
 end
@@ -168,9 +180,45 @@ if UNLEASH.is_enabled? "AwesomeFeature", @unleash_context, true
 end
 ```
 
+Alternatively by using `if_enabled` you can send a code block to be executed as a parameter:
+
+```ruby
+UNLEASH.if_enabled "AwesomeFeature", @unleash_context, true do
+  puts "AwesomeFeature is enabled by default"
+end
+```
+
+##### Variations
+
+If no variant is found in the server, use the fallback variant.
+
+```ruby
+fallback_variant = Unleash::Variant.new(name: 'default', enabled: true, payload: {"color" => "blue"})
+variant = UNLEASH.get_variant "ColorVariants", @unleash_context, fallback_variant
+
+puts "variant color is: #{variant.payload.fetch('color')}"
+```
+
+
+#### Client methods
+
+Method Name | Description | Return Type |
+---------|-------------|-------------|
+`is_enabled?` | Check if feature toggle is to be enabled or not. | Boolean |
+`enabled?` | Alias to the `is_enabled?` method. But more ruby idiomatic. | Boolean |
+`if_enabled` | Run a code block, if a feature is enabled. | `yield` |
+`get_variant` | Get variant for a given feature | `Unleash::Variant` |
+`shutdown` | Save metrics to disk, flush metrics to server, and then kill ToggleFetcher and MetricsReporter threads. A safe shutdown. Not really useful in long running applications, like web applications. | nil |
+`shutdown!` | Kill ToggleFetcher and MetricsReporter threads immediately. | nil |
+
+
 ## Local test client
 
 ```
+# cli unleash client:
+bundle exec bin/unleash-client --help
+
+# or a simple sample implementation (with values hardcoded):
 bundle exec examples/simple.rb
 ```
 

data/bin/unleash-client

@@ -0,0 +1,105 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'unleash'
+require 'unleash/client'
+require 'unleash/context'
+
+options = {
+  variant: false,
+  verbose: false,
+  quiet: false,
+  url: 'http://localhost:4242',
+  demo: false,
+  disable_metrics: true,
+  sleep: 0.1,
+}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{__FILE__} [options] feature [key1=val1] [key2=val2]"
+
+  opts.on("-V", "--variant", "Fetch variant for feature") do |v|
+    options[:variant] = v
+  end
+
+  opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+    options[:verbose] = v
+  end
+
+  opts.on("-q", "--quiet", "Quiet mode, minimum output only") do |v|
+    options[:quiet] = v
+  end
+
+  opts.on("-uURL", "--url=URL", "URL base for the Unleash feature toggle service") do |u|
+    options[:url] = u
+  end
+
+  opts.on("-d", "--demo", "Demo load by looping, instead of a simple lookup") do |d|
+    options[:demo] = d
+  end
+
+  opts.on("-m", "--[no-]metrics", "Enable metrics reporting") do |m|
+    options[:disable_metrics] = !m
+  end
+
+  opts.on("-sSLEEP", "--sleep=SLEEP", Float, "Sleep interval between checks (seconds) in demo") do |s|
+    options[:sleep] = s
+  end
+
+  opts.on("-h", "--help", "Prints this help") do
+    puts opts
+    exit
+  end
+end.parse!
+
+feature_name = ARGV.shift
+raise 'feature_name is required. see --help for usage.' unless feature_name
+
+options[:verbose] = false if options[:quiet]
+
+@unleash = Unleash::Client.new(
+  url: options[:url],
+  app_name: 'unleash-client-ruby-cli',
+  disable_metrics: options[:metrics],
+  log_level: log_level = options[:quiet] ? Logger::ERROR : (options[:verbose] ? Logger::DEBUG : Logger::WARN),
+)
+
+context_params = ARGV.map{ |e| e.split("=") }.map{ |k,v| [k.to_sym, v] }.to_h
+context_properties = context_params.reject{ |k,v| [:user_id, :session_id, :remote_address].include? k }
+context_params.select!{ |k,v| [:user_id, :session_id, :remote_address].include? k }
+context_params.merge!( properties: context_properties ) unless context_properties.nil?
+unleash_context = Unleash::Context.new(context_params)
+
+if options[:verbose]
+  puts "Running configuration:"
+  p options
+  puts "feature: #{feature_name}"
+  puts "context_args: #{ARGV}"
+  puts "context_params: #{context_params}"
+  puts "context: #{unleash_context}"
+  puts ""
+end
+
+
+
+if options[:demo]
+  loop do
+    enabled = @unleash.is_enabled?(feature_name, unleash_context)
+    print enabled ? '.' : '|'
+    sleep options[:sleep]
+  end
+else
+  if options[:variant]
+    variant = @unleash.get_variant(feature_name, unleash_context)
+    puts " For feature \'#{feature_name}\' got variant \'#{variant}\'"
+  else
+    if @unleash.is_enabled?(feature_name, unleash_context)
+      puts " \'#{feature_name}\' is enabled according to unleash"
+    else
+      puts " \'#{feature_name}\' is disabled according to unleash"
+    end
+  end
+end
+
+
+@unleash.shutdown

data/examples/simple.rb

@@ -50,4 +50,10 @@ else
   puts "> #{feature_name} is not enabled"
 end
 
+puts "> shutting down client..."
+
+@unleash.shutdown
+
 puts ">> END simple.rb"
+
+

data/lib/unleash/activation_strategy.rb

@@ -1,11 +1,10 @@
-
-
 module Unleash
   class ActivationStrategy
     attr_accessor :name, :params
 
-    def initialize(name, params = {})
+    def initialize(name, params)
       self.name = name
+
       if params.is_a?(Hash)
         self.params = params
       else

data/lib/unleash/client.rb

@@ -1,6 +1,7 @@
 require 'unleash/configuration'
 require 'unleash/toggle_fetcher'
 require 'unleash/metrics_reporter'
+require 'unleash/scheduled_executor'
 require 'unleash/feature_toggle'
 require 'logger'
 require 'time'
@@ -8,22 +9,30 @@ require 'time'
 module Unleash
 
   class Client
+    attr_accessor :fetcher_scheduled_executor, :metrics_scheduled_executor
+
     def initialize(*opts)
       Unleash.configuration ||= Unleash::Configuration.new(*opts)
       Unleash.configuration.validate!
 
-      Unleash.logger = Unleash.configuration.logger
+      Unleash.logger = Unleash.configuration.logger.clone
       Unleash.logger.level = Unleash.configuration.log_level
 
       unless Unleash.configuration.disable_client
         Unleash.toggle_fetcher = Unleash::ToggleFetcher.new
+
         register
 
+        self.fetcher_scheduled_executor = Unleash::ScheduledExecutor.new('ToggleFetcher', Unleash.configuration.refresh_interval)
+        self.fetcher_scheduled_executor.run do
+          Unleash.toggle_fetcher.fetch
+        end
+
         unless Unleash.configuration.disable_metrics
           Unleash.toggle_metrics = Unleash::Metrics.new
           Unleash.reporter = Unleash::MetricsReporter.new
-          scheduledExecutor = Unleash::ScheduledExecutor.new('MetricsReporter', Unleash.configuration.metrics_interval)
-          scheduledExecutor.run do
+          self.metrics_scheduled_executor = Unleash::ScheduledExecutor.new('MetricsReporter', Unleash.configuration.metrics_interval)
+          self.metrics_scheduled_executor.run do
             Unleash.reporter.send
           end
         end
@@ -53,6 +62,60 @@ module Unleash
         return toggle_result
     end
 
+    # enabled? is a more ruby idiomatic method name than is_enabled?
+    alias_method :enabled?, :is_enabled?
+
+    # execute a code block (passed as a parameter), if is_enabled? is true.
+    def if_enabled(feature, context = nil, default_value = false, &blk)
+      yield if is_enabled?(feature, context, default_value)
+    end
+
+
+    def get_variant(feature, context = nil, fallback_variant = false)
+      Unleash.logger.debug "Unleash::Client.get_variant for feature: #{feature} with context #{context}"
+
+      if Unleash.configuration.disable_client
+        Unleash.logger.warn "unleash_client is disabled! Always returning #{default_variant} for feature #{feature}!"
+        return fallback_variant || Unleash::FeatureToggle.disabled_variant
+      end
+
+      toggle_as_hash = Unleash.toggles.select{ |toggle| toggle['name'] == feature }.first if Unleash.toggles
+
+      if toggle_as_hash.nil?
+        Unleash.logger.debug "Unleash::Client.is_enabled? feature: #{feature} not found"
+        return fallback_variant || Unleash::FeatureToggle.disabled_variant
+      end
+
+      toggle = Unleash::FeatureToggle.new(toggle_as_hash)
+      variant = toggle.get_variant(context, fallback_variant)
+
+      if variant.nil?
+        Unleash.logger.debug "Unleash::Client.get_variant variants for feature: #{feature} not found"
+        return fallback_variant || Unleash::FeatureToggle.disabled_variant
+      end
+
+      # TODO: Add to README: name, payload, enabled (bool)
+
+      return variant
+    end
+
+    # safe shutdown: also flush metrics to server and toggles to disk
+    def shutdown
+      unless Unleash.configuration.disable_client
+        Unleash.toggle_fetcher.save!
+        Unleash.reporter.send unless Unleash.configuration.disable_metrics
+        shutdown!
+      end
+    end
+
+    # quick shutdown: just kill running threads
+    def shutdown!
+      unless Unleash.configuration.disable_client
+        self.fetcher_scheduled_executor.exit
+        self.metrics_scheduled_executor.exit unless Unleash.configuration.disable_metrics
+      end
+    end
+
     private
     def info
       return {

data/lib/unleash/configuration.rb

@@ -3,15 +3,24 @@ require 'tmpdir'
 
 module Unleash
   class Configuration
-    attr_accessor :url, :app_name, :instance_id,
+    attr_accessor :url,
+      :app_name,
+      :environment,
+      :instance_id,
       :custom_http_headers,
       :disable_client,
-      :disable_metrics, :timeout, :retry_limit,
-      :refresh_interval, :metrics_interval,
-      :backup_file, :logger, :log_level
+      :disable_metrics,
+      :timeout,
+      :retry_limit,
+      :refresh_interval,
+      :metrics_interval,
+      :backup_file,
+      :logger,
+      :log_level
 
     def initialize(opts = {})
       self.app_name      = opts[:app_name]    || nil
+      self.environment   = opts[:environment] || 'default'
       self.url           = opts[:url]         || nil
       self.instance_id   = opts[:instance_id] || SecureRandom.uuid
 
@@ -51,13 +60,8 @@ module Unleash
     def validate!
       return if self.disable_client
 
-      if self.app_name.nil? or self.url.nil?
-        raise ArgumentError, "URL and app_name are required parameters."
-      end
-
-      if ! self.custom_http_headers.is_a?(Hash)
-        raise ArgumentError, "custom_http_headers must be a hash."
-      end
+      raise ArgumentError, "URL and app_name are required parameters." if self.app_name.nil? or self.url.nil?
+      raise ArgumentError, "custom_http_headers must be a hash." unless self.custom_http_headers.is_a?(Hash)
     end
 
     def refresh_backup_file!

data/lib/unleash/context.rb

@@ -1,39 +1,23 @@
 module Unleash
 
   class Context
-    attr_accessor :user_id, :session_id, :remote_address, :properties
+    attr_accessor :app_name, :environment, :user_id, :session_id, :remote_address, :properties
 
     def initialize(params = {})
-      params_is_a_hash = params.is_a?(Hash)
-      self.user_id    = fetch(params, 'userId')
-      self.session_id = fetch(params, 'sessionId')
-      self.remote_address = fetch(params, 'remoteAddress')
-      self.properties =
-        if params_is_a_hash && ( params.fetch(:properties, nil) || params.fetch('properties', nil) ).is_a?(Hash)
-          fetch(params, 'properties', {})
-        else
-          {}
-        end
-    end
+      raise ArgumentError, "Unleash::Context must be initialized with a hash." unless params.is_a?(Hash)
 
-    def to_s
-      "<Context: user_id=#{self.user_id},session_id=#{self.session_id},remote_address=#{self.remote_address},properties=#{self.properties}>"
-    end
+      self.app_name    = params.values_at('appName', :app_name).compact.first || ( !Unleash.configuration.nil? ? Unleash.configuration.app_name : nil )
+      self.environment = params.values_at('environment', :environment).compact.first || ( !Unleash.configuration.nil? ? Unleash.configuration.environment : 'default' )
+      self.user_id    = params.values_at('userId', :user_id).compact.first || ''
+      self.session_id = params.values_at('sessionId', :session_id).compact.first || ''
+      self.remote_address = params.values_at('remoteAddress', :remote_address).compact.first || ''
 
-    private
-    # Fetch key from hash. Try first with using camelCase, and if not found, try with snake case.
-    # This way we are are idiomatically compliant with ruby, but still giving priority to the same
-    # key names as in the other clients.
-    def fetch(params, camelcase_key, default_ret = '')
-      return default_ret unless params.is_a?(Hash)
-      return default_ret unless camelcase_key.is_a?(String) or camelcase_key.is_a?(Symbol)
-
-      params.fetch(camelcase_key, nil) || params.fetch(snake_sym(camelcase_key), nil) || default_ret
+      properties = params.values_at('properties', :properties).compact.first
+      self.properties = properties.is_a?(Hash) ? properties : {}
     end
 
-    # transform CamelCase to snake_case and make it a sym, if it is a string
-    def snake_sym(key)
-      key.is_a?(String) ? key.gsub(/(.)([A-Z])/,'\1_\2').downcase.to_sym  : key
+    def to_s
+      "<Context: user_id=#{self.user_id},session_id=#{self.session_id},remote_address=#{self.remote_address},properties=#{self.properties}>"
     end
   end
 end

data/lib/unleash/feature_toggle.rb

@@ -1,8 +1,12 @@
 require 'unleash/activation_strategy'
+require 'unleash/variant_definition'
+require 'unleash/variant'
+require 'unleash/strategy/util'
+require 'securerandom'
 
 module Unleash
   class FeatureToggle
-    attr_accessor :name, :enabled, :strategies, :choices, :choices_lock
+    attr_accessor :name, :enabled, :strategies, :variant_definitions
 
     def initialize(params={})
       params = {} if params.nil?
@@ -11,32 +15,32 @@ module Unleash
       self.enabled = params.fetch('enabled', false)
 
       self.strategies = params.fetch('strategies', [])
-        .select{|s| ( s.key?('name') && Unleash::STRATEGIES.key?(s['name'].to_sym) ) }
-        .map{|s| ActivationStrategy.new(s['name'], s['parameters'])} || []
+        .select{ |s| ( s.key?('name') && Unleash::STRATEGIES.key?(s['name'].to_sym) ) }
+        .map{ |s| ActivationStrategy.new(s['name'], s['parameters'] || {}) } || []
 
-      # Unleash.logger.debug "FeatureToggle params: #{params}"
-      # Unleash.logger.debug "strategies: #{self.strategies}"
+      self.variant_definitions = (params.fetch('variants', []) || [])
+        .select{ |v| v.is_a?(Hash) && v.key?('name') }
+        .map{ |v|
+          VariantDefinition.new(
+            v.fetch('name', ''),
+            v.fetch('weight', 0),
+            v.fetch('payload', nil),
+            v.fetch('overrides', [])
+          )
+        } || []
     end
 
     def to_s
-      "<FeatureToggle: name=#{self.name},enabled=#{self.enabled},choices=#{self.choices},strategies=#{self.strategies}>"
+      "<FeatureToggle: name=#{self.name},enabled=#{self.enabled},strategies=#{self.strategies},variant_definitions=#{self.variant_definitions}>"
     end
 
     def is_enabled?(context, default_result)
-      if not ['NilClass', 'Unleash::Context'].include? context.class.name
+      unless ['NilClass', 'Unleash::Context'].include? context.class.name
         Unleash.logger.error "Provided context is not of the correct type #{context.class.name}, please use Unleash::Context. Context set to nil."
         context = nil
       end
 
-      result = self.enabled && ( self.strategies.select{ |s|
-        strategy = Unleash::STRATEGIES.fetch(s.name.to_sym, :unknown)
-        r = strategy.is_enabled?(s.params, context)
-        Unleash.logger.debug "Strategy #{s.name} returned #{r} with context: #{context}" #"for params #{s.params} "
-        r
-      }.any? || self.strategies.empty? )
-      result ||= default_result
-
-      Unleash.logger.debug "FeatureToggle (enabled:#{self.enabled} default_result:#{default_result} and Strategies combined returned #{result})"
+      result = am_enabled?(context, default_result)
 
       choice = result ? :yes : :no
       Unleash.toggle_metrics.increment(name, choice) unless Unleash.configuration.disable_metrics
@@ -44,5 +48,83 @@ module Unleash
       return result
     end
 
+    def get_variant(context, fallback_variant = disabled_variant)
+      unless ['NilClass', 'Unleash::Context'].include? context.class.name
+        Unleash.logger.error "Provided context is not of the correct type #{context.class.name}, please use Unleash::Context. Context set to nil."
+        context = nil
+      end
+
+      unless ['Unleash::Variant'].include? fallback_variant.class.name
+        raise ArgumentError, "Provided fallback_variant is not of the correct type #{fallback_variant.class.name}, please use Unleash::Variant."
+      end
+
+      return disabled_variant unless self.enabled && am_enabled?(context, true)
+      return disabled_variant if get_sum_variant_defs_weights <= 0
+
+      variant = variant_from_override_match(context)
+      variant = variant_from_weights(context) if variant.nil?
+
+      Unleash.toggle_metrics.increment_variant(self.name, variant.name) unless Unleash.configuration.disable_metrics
+      return variant
+    end
+
+    private
+
+    # only check if it is enabled, do not do metrics
+    def am_enabled?(context, default_result)
+      result =
+        if self.enabled
+          self.strategies.empty? ||
+          self.strategies.select{ |s|
+            strategy = Unleash::STRATEGIES.fetch(s.name.to_sym, :unknown)
+            r = strategy.is_enabled?(s.params, context)
+            Unleash.logger.debug "Strategy #{s.name} returned #{r} with context: #{context}" #"for params #{s.params} "
+            r
+          }.any?
+        else
+          default_result
+        end
+
+      Unleash.logger.debug "FeatureToggle (enabled:#{self.enabled} default_result:#{default_result} and Strategies combined returned #{result})"
+      return result
+    end
+
+    def disabled_variant
+      Unleash::Variant.new(name: 'disabled', enabled: false)
+    end
+
+    def get_sum_variant_defs_weights
+      self.variant_definitions.map{ |v| v.weight }.reduce(0, :+)
+    end
+
+    def variant_salt(context)
+      return context.user_id unless context.user_id.to_s.empty?
+      return context.session_id unless context.session_id.to_s.empty?
+      return context.remote_address unless context.remote_address.to_s.empty?
+      return SecureRandom.random_number
+    end
+
+    def variant_from_override_match(context)
+      variant = self.variant_definitions.select{ |vd| vd.override_matches_context?(context) }.first
+
+      return nil if variant.nil?
+      Unleash::Variant.new(name: variant.name, enabled: true, payload: variant.payload)
+    end
+
+    def variant_from_weights(context)
+      variant_weight = Unleash::Strategy::Util.get_normalized_number(variant_salt(context), self.name, get_sum_variant_defs_weights())
+      prev_weights = 0
+
+      variant_definition = self.variant_definitions
+        .select{ |v|
+          res = (prev_weights + v.weight >= variant_weight)
+          prev_weights += v.weight
+          res
+        }
+        .first
+      return disabled_variant if variant_definition.nil?
+
+      Unleash::Variant.new(name: variant_definition.name, enabled: true, payload: variant_definition.payload)
+    end
   end
 end

data/lib/unleash/metrics.rb

@@ -3,6 +3,8 @@ module Unleash
   class Metrics
     attr_accessor :features
 
+    # NOTE: no mutexes for features
+
     def initialize
       self.features = {}
     end
@@ -18,8 +20,15 @@ module Unleash
       self.features[feature][choice] += 1
     end
 
+    def increment_variant(feature, variant)
+      self.features[feature] = {yes: 0, no: 0} unless self.features.include? feature
+      self.features[feature]['variant'] = {}   unless self.features[feature].include? 'variant'
+      self.features[feature]['variant'][variant] = 0 unless self.features[feature]['variant'].include? variant
+      self.features[feature]['variant'][variant] += 1
+    end
+
     def reset
       self.features = {}
     end
   end
-end
+end

data/lib/unleash/metrics_reporter.rb

@@ -7,15 +7,12 @@ require 'time'
 module Unleash
 
   class MetricsReporter
-    attr_accessor :last_time, :client
+    attr_accessor :last_time
 
     def initialize
       self.last_time = Time.now
     end
 
-    def build_hash
-    end
-
     def generate_report
       now = Time.now
       start, stop, self.last_time = self.last_time, now, now

data/lib/unleash/scheduled_executor.rb

@@ -1,17 +1,18 @@
 module Unleash
 
   class ScheduledExecutor
-    attr_accessor :name, :interval, :max_exceptions, :retry_count
+    attr_accessor :name, :interval, :max_exceptions, :retry_count, :thread
 
     def initialize(name, interval, max_exceptions = 5)
       self.name = name || ''
       self.interval = interval
       self.max_exceptions = max_exceptions
       self.retry_count = 0
+      self.thread = nil
     end
 
     def run(&blk)
-      thread = Thread.new do
+      self.thread = Thread.new do
         Thread.current[:name] = self.name
 
         loop do
@@ -29,11 +30,23 @@ module Unleash
           end
 
           if self.retry_count > self.max_exceptions
-            Unleash.logger.info "thread #{name} retry_count (#{self.retry_count}) exceeded max_exceptions (#{self.max_exceptions}). Stopping with retries."
+            Unleash.logger.error "thread #{name} retry_count (#{self.retry_count}) exceeded max_exceptions (#{self.max_exceptions}). Stopping with retries."
             break
           end
         end
-        Unleash.logger.info "thread #{name} ended"
+        Unleash.logger.warn "thread #{name} loop ended"
+      end
+    end
+
+    def running?
+      self.thread.is_a?(Thread) && self.thread.alive?
+    end
+
+    def exit
+      if self.running?
+        Unleash.logger.warn "thread #{name} will exit!"
+        self.thread.exit
+        self.thread.join if self.running?
       end
     end
   end

data/lib/unleash/strategy/application_hostname.rb

@@ -18,7 +18,7 @@ module Unleash
       def is_enabled?(params = {}, _context = nil)
         return false unless params.is_a?(Hash) && params.has_key?(PARAM)
 
-        params[PARAM].split(",").map(&:strip).map{|h| h.downcase }.include?(self.hostname)
+        params[PARAM].split(",").map(&:strip).map{ |h| h.downcase }.include?(self.hostname)
       end
     end
   end

data/lib/unleash/strategy/util.rb

@@ -7,10 +7,10 @@ module Unleash
 
       NORMALIZER = 100
 
-      # convert the two strings () into a number between 1 and 100
-      def get_normalized_number(identifier, group_id)
-        MurmurHash3::V32.str_hash("#{group_id}:#{identifier}") % NORMALIZER + 1
+      # convert the two strings () into a number between 1 and base (100 by default)
+      def get_normalized_number(identifier, group_id, base = NORMALIZER)
+        MurmurHash3::V32.str_hash("#{group_id}:#{identifier}") % base + 1
       end
     end
   end
-end
+end

data/lib/unleash/toggle_fetcher.rb

@@ -1,5 +1,4 @@
 require 'unleash/configuration'
-require 'unleash/scheduled_executor'
 require 'net/http'
 require 'json'
 require 'thread'
@@ -21,12 +20,11 @@ module Unleash
         fetch
       rescue Exception => e
         Unleash.logger.warn "ToggleFetcher was unable to fetch from the network, attempting to read from backup file."
+        Unleash.logger.debug "Exception Caught: #{e}"
         read!
       end
 
-      # once we have initialized, start the fetcher loop
-      scheduledExecutor = Unleash::ScheduledExecutor.new('ToggleFetcher', Unleash.configuration.refresh_interval)
-      scheduledExecutor.run { remote_toggles = fetch() }
+      # once initialized, somewhere else you will want to start a loop with fetch()
     end
 
     def toggles
@@ -38,7 +36,7 @@ module Unleash
     end
 
     # rename to refresh_from_server!  ??
-    # TODO: should simplify by moving uri / http initialization to class initialization
+    # TODO: should simplify by moving uri / http initialization elsewhere
     def fetch
       Unleash.logger.debug "fetch()"
       Unleash.logger.debug "ETag: #{self.etag}" unless self.etag.nil?
@@ -82,6 +80,26 @@ module Unleash
       save!
     end
 
+    def save!
+      begin
+        backup_file = Unleash.configuration.backup_file
+        backup_file_tmp = "#{backup_file}.tmp"
+
+        self.toggle_lock.synchronize do
+          file = File.open(backup_file_tmp, "w")
+          file.write(self.toggle_cache.to_json)
+          File.rename(backup_file_tmp, backup_file)
+        end
+      rescue Exception => e
+        # This is not really the end of the world. Swallowing the exception.
+        Unleash.logger.error "Unable to save backup file. Exception thrown #{e.class}:'#{e}'"
+        Unleash.logger.error "stacktrace: #{e.backtrace}"
+      ensure
+        file.close if defined?(file) && ! file.nil?
+        self.toggle_lock.unlock if self.toggle_lock.locked?
+      end
+    end
+
     private
 
     def synchronize_with_local_cache!(features)
@@ -102,48 +120,23 @@ module Unleash
       end
     end
 
-    def backup_file_exists?
-      File.exists?(backup_file)
-    end
-
-    def save!
-      begin
-        file = File.open(Unleash.configuration.backup_file, "w")
-
-        self.toggle_lock.synchronize do
-          file.write(self.toggle_cache.to_json)
-        end
-      rescue Exception => e
-        # This is not really the end of the world. Swallowing the exception.
-        Unleash.logger.error "Unable to save backup file. Exception thrown #{e.class}:'#{e}'"
-        Unleash.logger.error "stacktrace: #{e.backtrace}"
-      ensure
-        file.close unless file.nil?
-      end
-    end
-
     def read!
       Unleash.logger.debug "read!()"
-      return nil unless File.exists?(Unleash.configuration.backup_file)
+      return nil unless File.exist?(Unleash.configuration.backup_file)
 
       begin
-        file = File.open(Unleash.configuration.backup_file, "r")
-        line_cache = ""
-        file.each_line do |line|
-          line_cache += line
-        end
+        file = File.new(Unleash.configuration.backup_file, "r")
+        file_content = file.read
 
-        backup_as_hash = JSON.parse(line_cache)
+        backup_as_hash = JSON.parse(file_content)
         synchronize_with_local_cache!(backup_as_hash)
         update_client!
-
       rescue IOError => e
         Unleash.logger.error "Unable to read the backup_file."
       rescue JSON::ParserError => e
         Unleash.logger.error "Unable to parse JSON from existing backup_file."
       rescue Exception => e
-        Unleash.logger.error "Unable to extract valid data from backup_file. Exception thrown #{e.class}:'#{e}'"
-        Unleash.logger.error "stacktrace: #{e.backtrace}"
+        Unleash.logger.error "Unable to extract valid data from backup_file. Exception thrown", e
       ensure
         file.close unless file.nil?
       end

data/lib/unleash/variant.rb

@@ -0,0 +1,26 @@
+
+
+module Unleash
+  class Variant
+    attr_accessor :name, :enabled, :payload
+
+    def initialize(params = {})
+      raise ArgumentError, "Variant initializer requires a hash." unless params.is_a?(Hash)
+
+      self.name = params.values_at('name', :name).compact.first
+      self.enabled = params.values_at('enabled', :enabled).compact.first || false
+      self.payload = params.values_at('payload', :payload).compact.first
+
+      raise ArgumentError, "Variant requires a name." if self.name.nil?
+    end
+
+    def to_s
+      "<Variant: name=#{self.name},enabled=#{self.enabled},payload=#{self.payload}>"
+    end
+
+    def ==(v)
+      self.name == v.name && self.enabled == v.enabled && self.payload == v.payload
+    end
+
+  end
+end

data/lib/unleash/variant_definition.rb

@@ -0,0 +1,26 @@
+require 'unleash/variant_override'
+
+
+module Unleash
+  class VariantDefinition
+    attr_accessor :name, :weight, :payload, :overrides
+
+    def initialize(name, weight = 0, payload = nil, overrides = [])
+      self.name = name
+      self.weight = weight
+      self.payload = payload
+      # self.overrides = overrides
+      self.overrides = (overrides || [])
+        .select{ |v| v.is_a?(Hash) && v.key?('contextName') }
+        .map{ |v| VariantOverride.new(v.fetch('contextName', ''), v.fetch('values', [])) } || []
+    end
+
+    def override_matches_context?(context)
+      self.overrides.select{ |o| o.matches_context?(context) }.first
+    end
+
+    def to_s
+      "<VariantDefinition: name=#{self.name},weight=#{self.weight},payload=#{self.payload},overrides=#{self.overrides}>"
+    end
+  end
+end

data/lib/unleash/variant_override.rb

@@ -0,0 +1,44 @@
+module Unleash
+  class VariantOverride
+    attr_accessor :context_name, :values
+
+    def initialize(context_name, values = [])
+      self.context_name = context_name
+      self.values = values || []
+
+      validate
+    end
+
+    def to_s
+      "<VariantOverride: context_name=#{self.context_name},values=#{self.values}>"
+    end
+
+    def matches_context?(context)
+      raise ArgumentError, 'context must be of class Unleash::Context' unless context.class.name == 'Unleash::Context'
+
+      context_value =
+        case self.context_name
+        when 'userId'
+          context.user_id
+        when 'sessionId'
+          context.session_id
+        when 'remoteAddress'
+          context.remote_address
+        else
+          context.properties.fetch(self.context_name, nil)
+        end
+
+      Unleash.logger.debug "VariantOverride: context_name: #{context_name} context_value: #{context_value}"
+
+      self.values.include? context_value.to_s
+    end
+
+    private
+
+    def validate
+      raise ArgumentError, 'context_name must be a String' unless self.context_name.is_a?(String)
+      raise ArgumentError, 'values must be an Array of strings' unless self.values.is_a?(Array) \
+          && self.values.reject{ |v| v.is_a?(String) }.empty?
+    end
+  end
+end

data/lib/unleash/version.rb

@@ -1,3 +1,3 @@
 module Unleash
-  VERSION = "0.1.5"
+  VERSION = "0.1.6"
 end

data/unleash-client.gemspec

@@ -29,6 +29,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 2.0"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "rspec-json_expectations", "~> 2.1"
   spec.add_development_dependency "webmock", "~> 3.0"
   spec.add_development_dependency "coveralls"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: unleash
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
 platform: ruby
 authors:
 - Renato Arruda
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-01-04 00:00:00.000000000 Z
+date: 2019-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: murmurhash3
@@ -66,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-json_expectations
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
 - !ruby/object:Gem::Dependency
   name: webmock
   requirement: !ruby/object:Gem::Requirement
@@ -114,6 +128,7 @@ files:
 - TODO.md
 - bin/console
 - bin/setup
+- bin/unleash-client
 - examples/simple.rb
 - lib/unleash.rb
 - lib/unleash/activation_strategy.rb
@@ -134,6 +149,9 @@ files:
 - lib/unleash/strategy/user_with_id.rb
 - lib/unleash/strategy/util.rb
 - lib/unleash/toggle_fetcher.rb
+- lib/unleash/variant.rb
+- lib/unleash/variant_definition.rb
+- lib/unleash/variant_override.rb
 - lib/unleash/version.rb
 - unleash-client.gemspec
 homepage: https://github.com/unleash/unleash-client-ruby
@@ -155,8 +173,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Unleash feature toggle client.