unleash 0.1.6 → 3.2.0

data/lib/unleash/configuration.rb

@@ -3,7 +3,8 @@ require 'tmpdir'
 
 module Unleash
   class Configuration
-    attr_accessor :url,
+    attr_accessor \
+      :url,
       :app_name,
       :environment,
       :instance_id,
@@ -19,37 +20,12 @@ module Unleash
       :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
-
-      if opts[:custom_http_headers].is_a?(Hash) || opts[:custom_http_headers].nil?
-        self.custom_http_headers = opts[:custom_http_headers] || {}
-      else
-        raise ArgumentError, "custom_http_headers must be a hash."
-      end
-      self.disable_client   = opts[:disable_client]   || false
-      self.disable_metrics  = opts[:disable_metrics]  || false
-      self.refresh_interval = opts[:refresh_interval] || 15
-      self.metrics_interval = opts[:metrics_interval] || 10
-      self.timeout          = opts[:timeout] || 30
-      self.retry_limit      = opts[:retry_limit] || 1
-
-      self.backup_file   = opts[:backup_file] || nil
+      ensure_valid_opts(opts)
+      set_defaults
 
-      self.logger    = opts[:logger] || Logger.new(STDOUT)
-      self.log_level = opts[:log_level] || Logger::WARN
-
-
-      if opts[:logger].nil?
-        # on default logger, use custom formatter that includes thread_name:
-        self.logger.formatter = proc do |severity, datetime, progname, msg|
-          thread_name = (Thread.current[:name] || "Unleash").rjust(16, ' ')
-          "[#{datetime.iso8601(6)} #{thread_name} #{severity.ljust(5, ' ')}] : #{msg}\n"
-        end
-      end
+      initialize_default_logger if opts[:logger].nil?
 
+      merge(opts)
       refresh_backup_file!
     end
 
@@ -60,17 +36,15 @@ module Unleash
     def validate!
       return if self.disable_client
 
-      raise ArgumentError, "URL and app_name are required parameters." if self.app_name.nil? or self.url.nil?
+      raise ArgumentError, "URL and app_name are required parameters." if self.app_name.nil? || 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!
-      if self.backup_file.nil?
-        self.backup_file = Dir.tmpdir + "/unleash-#{app_name}-repo.json"
-      end
+      self.backup_file = Dir.tmpdir + "/unleash-#{app_name}-repo.json" if self.backup_file.nil?
     end
 
-    def get_http_headers
+    def http_headers
       {
         'UNLEASH-INSTANCEID' => self.instance_id,
         'UNLEASH-APPNAME' => self.app_name
@@ -89,5 +63,50 @@ module Unleash
       self.url + '/client/register'
     end
 
+    private
+
+    def ensure_valid_opts(opts)
+      unless opts[:custom_http_headers].is_a?(Hash) || opts[:custom_http_headers].nil?
+        raise ArgumentError, "custom_http_headers must be a hash."
+      end
+    end
+
+    def set_defaults
+      self.app_name         = nil
+      self.environment      = 'default'
+      self.url              = nil
+      self.instance_id      = SecureRandom.uuid
+      self.disable_client   = false
+      self.disable_metrics  = false
+      self.refresh_interval = 15
+      self.metrics_interval = 10
+      self.timeout          = 30
+      self.retry_limit      = 1
+      self.backup_file      = nil
+      self.log_level        = Logger::WARN
+
+      self.custom_http_headers = {}
+    end
+
+    def initialize_default_logger
+      self.logger = Logger.new(STDOUT)
+
+      # on default logger, use custom formatter that includes thread_name:
+      self.logger.formatter = proc do |severity, datetime, _progname, msg|
+        thread_name = (Thread.current[:name] || "Unleash").rjust(16, ' ')
+        "[#{datetime.iso8601(6)} #{thread_name} #{severity.ljust(5, ' ')}] : #{msg}\n"
+      end
+    end
+
+    def merge(opts)
+      opts.each_pair{ |opt, val| set_option(opt, val) }
+      self
+    end
+
+    def set_option(opt, val)
+      __send__("#{opt}=", val)
+    rescue NoMethodError
+      raise ArgumentError, "unknown configuration parameter '#{val}'"
+    end
   end
 end

data/lib/unleash/context.rb

@@ -1,23 +1,34 @@
 module Unleash
-
   class Context
     attr_accessor :app_name, :environment, :user_id, :session_id, :remote_address, :properties
 
     def initialize(params = {})
       raise ArgumentError, "Unleash::Context must be initialized with a hash." unless params.is_a?(Hash)
 
-      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 || ''
+      self.app_name    = value_for('appName', params, Unleash&.configuration&.app_name)
+      self.environment = value_for('environment', params, Unleash&.configuration&.environment || 'default')
+      self.user_id     = value_for('userId', params)
+      self.session_id  = value_for('sessionId', params)
+      self.remote_address = value_for('remoteAddress', params)
 
-      properties = params.values_at('properties', :properties).compact.first
+      properties = value_for('properties', params)
       self.properties = properties.is_a?(Hash) ? properties : {}
     end
 
     def to_s
       "<Context: user_id=#{self.user_id},session_id=#{self.session_id},remote_address=#{self.remote_address},properties=#{self.properties}>"
     end
+
+    private
+
+    # Method to fetch values from hash for two types of keys: string in camelCase and symbol in snake_case
+    def value_for(key, params, default_value = '')
+      params.values_at(key, underscore(key).to_sym).compact.first || default_value
+    end
+
+    # converts CamelCase to snake_case
+    def underscore(camel_cased_word)
+      camel_cased_word.to_s.gsub(/(.)([A-Z])/, '\1_\2').downcase
+    end
   end
 end

data/lib/unleash/feature_toggle.rb

@@ -8,64 +8,53 @@ module Unleash
   class FeatureToggle
     attr_accessor :name, :enabled, :strategies, :variant_definitions
 
-    def initialize(params={})
+    def initialize(params = {})
       params = {} if params.nil?
 
-      self.name = params.fetch('name', nil)
-      self.enabled = params.fetch('enabled', false)
-
+      self.name       = params.fetch('name', nil)
+      self.enabled    = params.fetch('enabled', false)
       self.strategies = params.fetch('strategies', [])
-        .select{ |s| ( s.key?('name') && Unleash::STRATEGIES.key?(s['name'].to_sym) ) }
+        .select{ |s| s.has_key?('name') && Unleash::STRATEGIES.has_key?(s['name'].to_sym) }
         .map{ |s| ActivationStrategy.new(s['name'], s['parameters'] || {}) } || []
 
       self.variant_definitions = (params.fetch('variants', []) || [])
-        .select{ |v| v.is_a?(Hash) && v.key?('name') }
-        .map{ |v|
+        .select{ |v| v.is_a?(Hash) && v.has_key?('name') }
+        .map do |v|
           VariantDefinition.new(
             v.fetch('name', ''),
             v.fetch('weight', 0),
             v.fetch('payload', nil),
             v.fetch('overrides', [])
           )
-        } || []
+        end || []
     end
 
     def to_s
-      "<FeatureToggle: name=#{self.name},enabled=#{self.enabled},strategies=#{self.strategies},variant_definitions=#{self.variant_definitions}>"
+      "<FeatureToggle: name=#{name},enabled=#{enabled},strategies=#{strategies},variant_definitions=#{variant_definitions}>"
     end
 
     def is_enabled?(context, default_result)
-      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 = am_enabled?(context, default_result)
 
       choice = result ? :yes : :no
       Unleash.toggle_metrics.increment(name, choice) unless Unleash.configuration.disable_metrics
 
-      return result
+      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
+      raise ArgumentError, "Provided fallback_variant is not of type Unleash::Variant" if fallback_variant.class.name != 'Unleash::Variant'
 
-      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
+      context = ensure_valid_context(context)
 
       return disabled_variant unless self.enabled && am_enabled?(context, true)
-      return disabled_variant if get_sum_variant_defs_weights <= 0
+      return disabled_variant if 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
+      variant
     end
 
     private
@@ -75,56 +64,68 @@ module Unleash
       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?
+            self.strategies.any?{ |s| strategy_enabled?(s, context) }
         else
           default_result
         end
 
-      Unleash.logger.debug "FeatureToggle (enabled:#{self.enabled} default_result:#{default_result} and Strategies combined returned #{result})"
-      return result
+      Unleash.logger.debug "FeatureToggle (enabled:#{self.enabled} default_result:#{default_result} " \
+        "and Strategies combined returned #{result})"
+
+      result
+    end
+
+    def strategy_enabled?(strategy, context)
+      r = Unleash::STRATEGIES.fetch(strategy.name.to_sym, :unknown).is_enabled?(strategy.params, context)
+      Unleash.logger.debug "Strategy #{strategy.name} returned #{r} with context: #{context}" # "for params #{strategy.params} "
+      r
     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, :+)
+    def sum_variant_defs_weights
+      self.variant_definitions.map(&: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
+
+      SecureRandom.random_number
     end
 
     def variant_from_override_match(context)
-      variant = self.variant_definitions.select{ |vd| vd.override_matches_context?(context) }.first
-
+      variant = self.variant_definitions.find{ |vd| vd.override_matches_context?(context) }
       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())
+      variant_weight = Unleash::Strategy::Util.get_normalized_number(variant_salt(context), self.name, sum_variant_defs_weights)
       prev_weights = 0
 
       variant_definition = self.variant_definitions
-        .select{ |v|
+        .find do |v|
           res = (prev_weights + v.weight >= variant_weight)
           prev_weights += v.weight
           res
-        }
-        .first
+        end
       return disabled_variant if variant_definition.nil?
 
       Unleash::Variant.new(name: variant_definition.name, enabled: true, payload: variant_definition.payload)
     end
+
+    def ensure_valid_context(context)
+      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
+      context
+    end
   end
 end

data/lib/unleash/metrics.rb

@@ -1,5 +1,4 @@
 module Unleash
-
   class Metrics
     attr_accessor :features
 
@@ -16,13 +15,13 @@ module Unleash
     def increment(feature, choice)
       raise "InvalidArgument choice must be :yes or :no" unless [:yes, :no].include? choice
 
-      self.features[feature] = {yes: 0, no: 0} unless self.features.include? feature
+      self.features[feature] = { yes: 0, no: 0 } unless self.features.include? feature
       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] = { 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

data/lib/unleash/metrics_reporter.rb

@@ -5,7 +5,6 @@ require 'json'
 require 'time'
 
 module Unleash
-
   class MetricsReporter
     attr_accessor :last_time
 
@@ -15,7 +14,11 @@ module Unleash
 
     def generate_report
       now = Time.now
-      start, stop, self.last_time = self.last_time, now, now
+
+      start = self.last_time
+      stop  = now
+      self.last_time = now
+
       report = {
         'appName': Unleash.configuration.app_name,
         'instanceId': Unleash.configuration.instance_id,
@@ -25,37 +28,21 @@ module Unleash
           'toggles': Unleash.toggle_metrics.features
         }
       }
-
       Unleash.toggle_metrics.reset
-      return report
+
+      report
     end
 
     def send
       Unleash.logger.debug "send() Report"
 
-      generated_report = self.generate_report()
+      response = Unleash::Util::Http.post(Unleash.configuration.client_metrics_url, self.generate_report.to_json)
 
-      uri = URI(Unleash.configuration.client_metrics_url)
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = true if uri.scheme == 'https'
-      http.open_timeout = Unleash.configuration.timeout # in seconds
-      http.read_timeout = Unleash.configuration.timeout # in seconds
-
-      headers = (Unleash.configuration.get_http_headers || {}).dup
-      headers['Content-Type'] = 'application/json'
-      request = Net::HTTP::Post.new(uri.request_uri, headers)
-      request.body = generated_report.to_json
-
-      Unleash.logger.debug "Report to send: #{request.body}"
-
-      response = http.request(request)
-
-      if ['200','202'].include? response.code
+      if ['200', '202'].include? response.code
         Unleash.logger.debug "Report sent to unleash server sucessfully. Server responded with http code #{response.code}"
       else
         Unleash.logger.error "Error when sending report to unleash server. Server responded with http code #{response.code}."
       end
-
     end
   end
 end

data/lib/unleash/scheduled_executor.rb

@@ -1,5 +1,4 @@
 module Unleash
-
   class ScheduledExecutor
     attr_accessor :name, :interval, :max_exceptions, :retry_count, :thread
 
@@ -15,26 +14,20 @@ module Unleash
       self.thread = Thread.new do
         Thread.current[:name] = self.name
 
+        Unleash.logger.debug "thread #{name} loop starting"
         loop do
           Unleash.logger.debug "thread #{name} sleeping for #{interval} seconds"
           sleep interval
 
-          Unleash.logger.debug "thread #{name} started"
-          begin
-            yield
-            self.retry_count = 0
-          rescue Exception => e
-            self.retry_count += 1
-            Unleash.logger.error "thread #{name} threw exception #{e.class}:'#{e}' (#{self.retry_count}/#{self.max_exceptions})"
-            Unleash.logger.error "stacktrace: #{e.backtrace}"
-          end
+          run_blk{ blk.call }
 
-          if self.retry_count > self.max_exceptions
-            Unleash.logger.error "thread #{name} retry_count (#{self.retry_count}) exceeded max_exceptions (#{self.max_exceptions}). Stopping with retries."
+          if exceeded_max_exceptions?
+            Unleash.logger.error "thread #{name} retry_count (#{self.retry_count}) exceeded " \
+                "max_exceptions (#{self.max_exceptions}). Stopping with retries."
             break
           end
         end
-        Unleash.logger.warn "thread #{name} loop ended"
+        Unleash.logger.debug "thread #{name} loop ended"
       end
     end
 
@@ -47,7 +40,27 @@ module Unleash
         Unleash.logger.warn "thread #{name} will exit!"
         self.thread.exit
         self.thread.join if self.running?
+      else
+        Unleash.logger.info "thread #{name} was already stopped!"
       end
     end
+
+    private
+
+    def run_blk(&blk)
+      Unleash.logger.debug "thread #{name} starting execution"
+
+      yield(blk)
+      self.retry_count = 0
+    rescue StandardError => e
+      self.retry_count += 1
+      Unleash.logger.error "thread #{name} threw exception #{e.class} " \
+          " (#{self.retry_count}/#{self.max_exceptions}): '#{e}'"
+      Unleash.logger.debug "stacktrace: #{e.backtrace}"
+    end
+
+    def exceeded_max_exceptions?
+      self.retry_count > self.max_exceptions
+    end
   end
 end