unleash 3.2.2 → 4.3.0

data/lib/unleash/bootstrap/provider/from_file.rb

@@ -0,0 +1,14 @@
+require 'unleash/bootstrap/provider/base'
+
+module Unleash
+  module Bootstrap
+    module Provider
+      class FromFile < Base
+        # @param file_path [String]
+        def self.read(file_path)
+          File.read(file_path)
+        end
+      end
+    end
+  end
+end

data/lib/unleash/bootstrap/provider/from_url.rb

@@ -0,0 +1,19 @@
+require 'unleash/bootstrap/provider/base'
+
+module Unleash
+  module Bootstrap
+    module Provider
+      class FromUrl < Base
+        # @param url [String]
+        # @param headers [Hash, nil] HTTP headers to use. If not set, the unleash client SDK ones will be used.
+        def self.read(url, headers = nil)
+          response = Unleash::Util::Http.get(URI.parse(url), nil, headers)
+
+          return nil if response.code != '200'
+
+          response.body
+        end
+      end
+    end
+  end
+end

data/lib/unleash/client.rb

@@ -18,8 +18,9 @@ module Unleash
       Unleash.logger = Unleash.configuration.logger.clone
       Unleash.logger.level = Unleash.configuration.log_level
 
+      Unleash.toggle_fetcher = Unleash::ToggleFetcher.new
       if Unleash.configuration.disable_client
-        Unleash.logger.warn "Unleash::Client is disabled! Will only return default results!"
+        Unleash.logger.warn "Unleash::Client is disabled! Will only return default (or bootstrapped if available) results!"
         return
       end
 
@@ -28,13 +29,14 @@ module Unleash
       start_metrics unless Unleash.configuration.disable_metrics
     end
 
-    def is_enabled?(feature, context = nil, default_value = false)
+    def is_enabled?(feature, context = nil, default_value_param = false, &fallback_blk)
       Unleash.logger.debug "Unleash::Client.is_enabled? feature: #{feature} with context #{context}"
 
-      if Unleash.configuration.disable_client
-        Unleash.logger.warn "unleash_client is disabled! Always returning #{default_value} for feature #{feature}!"
-        return default_value
-      end
+      default_value = if block_given?
+                        default_value_param || !!fallback_blk.call(feature, context)
+                      else
+                        default_value_param
+                      end
 
       toggle_as_hash = Unleash&.toggles&.select{ |toggle| toggle['name'] == feature }&.first
 
@@ -45,7 +47,7 @@ module Unleash
 
       toggle = Unleash::FeatureToggle.new(toggle_as_hash)
 
-      toggle.is_enabled?(context, default_value)
+      toggle.is_enabled?(context)
     end
 
     # enabled? is a more ruby idiomatic method name than is_enabled?
@@ -56,19 +58,19 @@ module Unleash
       yield(blk) if is_enabled?(feature, context, default_value)
     end
 
-    def get_variant(feature, context = nil, fallback_variant = nil)
+    def get_variant(feature, context = Unleash::Context.new, fallback_variant = disabled_variant)
       Unleash.logger.debug "Unleash::Client.get_variant for feature: #{feature} with context #{context}"
 
       if Unleash.configuration.disable_client
-        Unleash.logger.debug "unleash_client is disabled! Always returning #{default_variant} for feature #{feature}!"
-        return fallback_variant || Unleash::FeatureToggle.disabled_variant
+        Unleash.logger.debug "unleash_client is disabled! Always returning #{fallback_variant} for feature #{feature}!"
+        return fallback_variant
       end
 
       toggle_as_hash = Unleash&.toggles&.select{ |toggle| toggle['name'] == feature }&.first
 
       if toggle_as_hash.nil?
         Unleash.logger.debug "Unleash::Client.get_variant feature: #{feature} not found"
-        return fallback_variant || Unleash::FeatureToggle.disabled_variant
+        return fallback_variant
       end
 
       toggle = Unleash::FeatureToggle.new(toggle_as_hash)
@@ -76,7 +78,7 @@ module Unleash
 
       if variant.nil?
         Unleash.logger.debug "Unleash::Client.get_variant variants for feature: #{feature} not found"
-        return fallback_variant || Unleash::FeatureToggle.disabled_variant
+        return fallback_variant
       end
 
       # TODO: Add to README: name, payload, enabled (bool)
@@ -88,7 +90,7 @@ module Unleash
     def shutdown
       unless Unleash.configuration.disable_client
         Unleash.toggle_fetcher.save!
-        Unleash.reporter.send unless Unleash.configuration.disable_metrics
+        Unleash.reporter.post unless Unleash.configuration.disable_metrics
         shutdown!
       end
     end
@@ -115,11 +117,11 @@ module Unleash
     end
 
     def start_toggle_fetcher
-      Unleash.toggle_fetcher = Unleash::ToggleFetcher.new
       self.fetcher_scheduled_executor = Unleash::ScheduledExecutor.new(
         'ToggleFetcher',
         Unleash.configuration.refresh_interval,
-        Unleash.configuration.retry_limit
+        Unleash.configuration.retry_limit,
+        first_fetch_is_eager
       )
       self.fetcher_scheduled_executor.run do
         Unleash.toggle_fetcher.fetch
@@ -135,7 +137,7 @@ module Unleash
         Unleash.configuration.retry_limit
       )
       self.metrics_scheduled_executor.run do
-        Unleash.reporter.send
+        Unleash.reporter.post
       end
     end
 
@@ -144,12 +146,20 @@ module Unleash
 
       # Send the request, if possible
       begin
-        response = Unleash::Util::Http.post(Unleash.configuration.client_register_url, info.to_json)
+        response = Unleash::Util::Http.post(Unleash.configuration.client_register_uri, info.to_json)
       rescue StandardError => e
         Unleash.logger.error "unable to register client with unleash server due to exception #{e.class}:'#{e}'."
         Unleash.logger.error "stacktrace: #{e.backtrace}"
       end
       Unleash.logger.debug "client registered: #{response}"
     end
+
+    def disabled_variant
+      @disabled_variant ||= Unleash::FeatureToggle.disabled_variant
+    end
+
+    def first_fetch_is_eager
+      Unleash.configuration.use_bootstrap?
+    end
   end
 end

data/lib/unleash/configuration.rb

@@ -1,5 +1,6 @@
 require 'securerandom'
 require 'tmpdir'
+require 'unleash/bootstrap/configuration'
 
 module Unleash
   class Configuration
@@ -8,6 +9,7 @@ module Unleash
       :app_name,
       :environment,
       :instance_id,
+      :project_name,
       :custom_http_headers,
       :disable_client,
       :disable_metrics,
@@ -17,10 +19,11 @@ module Unleash
       :metrics_interval,
       :backup_file,
       :logger,
-      :log_level
+      :log_level,
+      :bootstrap_config
 
     def initialize(opts = {})
-      ensure_valid_opts(opts)
+      validate_custom_http_headers!(opts[:custom_http_headers]) if opts.has_key?(:custom_http_headers)
       set_defaults
 
       initialize_default_logger if opts[:logger].nil?
@@ -37,53 +40,60 @@ module Unleash
       return if self.disable_client
 
       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)
+
+      validate_custom_http_headers!(self.custom_http_headers)
     end
 
     def refresh_backup_file!
-      self.backup_file = Dir.tmpdir + "/unleash-#{app_name}-repo.json" if self.backup_file.nil?
+      self.backup_file = File.join(Dir.tmpdir, "unleash-#{app_name}-repo.json")
     end
 
     def http_headers
       {
         'UNLEASH-INSTANCEID' => self.instance_id,
         'UNLEASH-APPNAME' => self.app_name
-      }.merge(custom_http_headers.dup)
+      }.merge!(generate_custom_http_headers)
     end
 
-    def fetch_toggles_url
-      self.url + '/client/features'
+    def fetch_toggles_uri
+      uri = URI("#{self.url_stripped_of_slash}/client/features")
+      uri.query = "project=#{self.project_name}" unless self.project_name.nil?
+      uri
     end
 
-    def client_metrics_url
-      self.url + '/client/metrics'
+    def client_metrics_uri
+      URI("#{self.url_stripped_of_slash}/client/metrics")
     end
 
-    def client_register_url
-      self.url + '/client/register'
+    def client_register_uri
+      URI("#{self.url_stripped_of_slash}/client/register")
     end
 
-    private
+    def url_stripped_of_slash
+      self.url.delete_suffix '/'
+    end
 
-    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
+    def use_bootstrap?
+      self.bootstrap_config&.valid?
     end
 
+    private
+
     def set_defaults
       self.app_name         = nil
       self.environment      = 'default'
       self.url              = nil
       self.instance_id      = SecureRandom.uuid
+      self.project_name     = nil
       self.disable_client   = false
       self.disable_metrics  = false
-      self.refresh_interval = 15
-      self.metrics_interval = 10
+      self.refresh_interval = 10
+      self.metrics_interval = 60
       self.timeout          = 30
-      self.retry_limit      = 1
+      self.retry_limit      = Float::INFINITY
       self.backup_file      = nil
       self.log_level        = Logger::WARN
+      self.bootstrap_config = nil
 
       self.custom_http_headers = {}
     end
@@ -103,6 +113,18 @@ module Unleash
       self
     end
 
+    def validate_custom_http_headers!(custom_http_headers)
+      return if custom_http_headers.is_a?(Hash) || custom_http_headers.respond_to?(:call)
+
+      raise ArgumentError, "custom_http_headers must be a Hash or a Proc."
+    end
+
+    def generate_custom_http_headers
+      return self.custom_http_headers.call if self.custom_http_headers.respond_to?(:call)
+
+      self.custom_http_headers
+    end
+
     def set_option(opt, val)
       __send__("#{opt}=", val)
     rescue NoMethodError

data/lib/unleash/constraint.rb

@@ -1,26 +1,104 @@
+require 'date'
+
 module Unleash
   class Constraint
-    attr_accessor :context_name, :operator, :values
+    attr_accessor :context_name, :operator, :value, :inverted, :case_insensitive
+
+    OPERATORS = {
+      IN: ->(context_v, constraint_v){ constraint_v.include? context_v },
+      NOT_IN: ->(context_v, constraint_v){ !constraint_v.include? context_v },
+      STR_STARTS_WITH: ->(context_v, constraint_v){ constraint_v.any?{ |v| context_v.start_with? v } },
+      STR_ENDS_WITH: ->(context_v, constraint_v){ constraint_v.any?{ |v| context_v.end_with? v } },
+      STR_CONTAINS: ->(context_v, constraint_v){ constraint_v.any?{ |v| context_v.include? v } },
+      NUM_EQ: ->(context_v, constraint_v){ on_valid_float(constraint_v, context_v){ |x, y| (x - y).abs < Float::EPSILON } },
+      NUM_LT: ->(context_v, constraint_v){ on_valid_float(constraint_v, context_v){ |x, y| (x > y) } },
+      NUM_LTE: ->(context_v, constraint_v){ on_valid_float(constraint_v, context_v){ |x, y| (x >= y) } },
+      NUM_GT: ->(context_v, constraint_v){ on_valid_float(constraint_v, context_v){ |x, y| (x < y) } },
+      NUM_GTE: ->(context_v, constraint_v){ on_valid_float(constraint_v, context_v){ |x, y| (x <= y) } },
+      DATE_AFTER: ->(context_v, constraint_v){ on_valid_date(constraint_v, context_v){ |x, y| (x < y) } },
+      DATE_BEFORE: ->(context_v, constraint_v){ on_valid_date(constraint_v, context_v){ |x, y| (x > y) } },
+      SEMVER_EQ: ->(context_v, constraint_v){ on_valid_version(constraint_v, context_v){ |x, y| (x == y) } },
+      SEMVER_GT: ->(context_v, constraint_v){ on_valid_version(constraint_v, context_v){ |x, y| (x < y) } },
+      SEMVER_LT: ->(context_v, constraint_v){ on_valid_version(constraint_v, context_v){ |x, y| (x > y) } }
+    }.freeze
 
-    VALID_OPERATORS = ['IN', 'NOT_IN'].freeze
+    LIST_OPERATORS = [:IN, :NOT_IN, :STR_STARTS_WITH, :STR_ENDS_WITH, :STR_CONTAINS].freeze
 
-    def initialize(context_name, operator, values = [])
+    def initialize(context_name, operator, value = [], inverted: false, case_insensitive: false)
       raise ArgumentError, "context_name is not a String" unless context_name.is_a?(String)
-      raise ArgumentError, "operator does not hold a valid value:" + VALID_OPERATORS unless VALID_OPERATORS.include? operator
-      raise ArgumentError, "values does not hold an Array" unless values.is_a?(Array)
+      raise ArgumentError, "operator does not hold a valid value:" + OPERATORS.keys unless OPERATORS.include? operator.to_sym
+
+      self.validate_constraint_value_type(operator.to_sym, value)
 
       self.context_name = context_name
-      self.operator = operator
-      self.values = values
+      self.operator = operator.to_sym
+      self.value = value
+      self.inverted = !!inverted
+      self.case_insensitive = !!case_insensitive
     end
 
     def matches_context?(context)
-      Unleash.logger.debug "Unleash::Constraint matches_context? values: #{self.values} context.get_by_name(#{self.context_name})" \
+      Unleash.logger.debug "Unleash::Constraint matches_context? value: #{self.value} context.get_by_name(#{self.context_name})" \
         " #{context.get_by_name(self.context_name)} "
+      match = matches_constraint?(context)
+      self.inverted ? !match : match
+    rescue KeyError
+      Unleash.logger.warn "Attemped to resolve a context key during constraint resolution: #{self.context_name} but it wasn't \
+      found on the context"
+      false
+    end
+
+    def self.on_valid_date(val1, val2)
+      val1 = DateTime.parse(val1)
+      val2 = DateTime.parse(val2)
+      yield(val1, val2)
+    rescue ArgumentError
+      Unleash.logger.warn "Unleash::ConstraintMatcher unable to parse either context_value (#{val1}) \
+      or constraint_value (#{val2}) into a date. Returning false!"
+      false
+    end
+
+    def self.on_valid_float(val1, val2)
+      val1 = Float(val1)
+      val2 = Float(val2)
+      yield(val1, val2)
+    rescue ArgumentError
+      Unleash.logger.warn "Unleash::ConstraintMatcher unable to parse either context_value (#{val1}) \
+      or constraint_value (#{val2}) into a number. Returning false!"
+      false
+    end
+
+    def self.on_valid_version(val1, val2)
+      val1 = Gem::Version.new(val1)
+      val2 = Gem::Version.new(val2)
+      yield(val1, val2)
+    rescue ArgumentError
+      Unleash.logger.warn "Unleash::ConstraintMatcher unable to parse either context_value (#{val1}) \
+      or constraint_value (#{val2}) into a version. Return false!"
+      false
+    end
+
+    # This should be a private method but for some reason this fails on Ruby 2.5
+    def validate_constraint_value_type(operator, value)
+      raise ArgumentError, "context_name is not an Array" if LIST_OPERATORS.include?(operator) && value.is_a?(String)
+      raise ArgumentError, "context_name is not a String" if !LIST_OPERATORS.include?(operator) && value.is_a?(Array)
+    end
+
+    private
+
+    def matches_constraint?(context)
+      unless OPERATORS.include?(self.operator)
+        Unleash.logger.warn "Invalid constraint operator: #{self.operator}, this should be unreachable. Always returning false."
+        false
+      end
+
+      v = self.value.dup
+      context_value = context.get_by_name(self.context_name)
 
-      is_included = self.values.include? context.get_by_name(self.context_name)
+      v.map!(&:upcase) if self.case_insensitive
+      context_value.upcase! if self.case_insensitive
 
-      operator == 'IN' ? is_included : !is_included
+      OPERATORS[self.operator].call(context_value, v)
     end
   end
 end

data/lib/unleash/context.rb

@@ -1,6 +1,6 @@
 module Unleash
   class Context
-    ATTRS = [:app_name, :environment, :user_id, :session_id, :remote_address].freeze
+    ATTRS = [:app_name, :environment, :user_id, :session_id, :remote_address, :current_time].freeze
 
     attr_accessor(*[ATTRS, :properties].flatten)
 
@@ -12,6 +12,7 @@ module Unleash
       self.user_id     = value_for('userId', params)
       self.session_id  = value_for('sessionId', params)
       self.remote_address = value_for('remoteAddress', params)
+      self.current_time = value_for('currentTime', params, Time.now.utc.iso8601.to_s)
 
       properties = value_for('properties', params)
       self.properties = properties.is_a?(Hash) ? properties.transform_keys(&:to_sym) : {}
@@ -28,7 +29,7 @@ module Unleash
       if ATTRS.include? normalized_name
         self.send(normalized_name)
       else
-        self.properties.fetch(normalized_name)
+        self.properties.fetch(normalized_name, nil) || self.properties.fetch(name.to_sym)
       end
     end
 

data/lib/unleash/feature_toggle.rb

@@ -23,8 +23,8 @@ module Unleash
       "<FeatureToggle: name=#{name},enabled=#{enabled},strategies=#{strategies},variant_definitions=#{variant_definitions}>"
     end
 
-    def is_enabled?(context, default_result)
-      result = am_enabled?(context, default_result)
+    def is_enabled?(context)
+      result = am_enabled?(context)
 
       choice = result ? :yes : :no
       Unleash.toggle_metrics.increment(name, choice) unless Unleash.configuration.disable_metrics
@@ -32,25 +32,32 @@ module Unleash
       result
     end
 
-    def get_variant(context, fallback_variant = disabled_variant)
+    def get_variant(context, fallback_variant = Unleash::FeatureToggle.disabled_variant)
       raise ArgumentError, "Provided fallback_variant is not of type Unleash::Variant" if fallback_variant.class.name != 'Unleash::Variant'
 
       context = ensure_valid_context(context)
 
-      return disabled_variant unless self.enabled && am_enabled?(context, true)
-      return disabled_variant if sum_variant_defs_weights <= 0
+      return Unleash::FeatureToggle.disabled_variant unless self.enabled && am_enabled?(context)
+      return Unleash::FeatureToggle.disabled_variant if sum_variant_defs_weights <= 0
 
-      variant = variant_from_override_match(context)
-      variant = variant_from_weights(context) if variant.nil?
+      variant = variant_from_override_match(context) || variant_from_weights(context, resolve_stickiness)
 
       Unleash.toggle_metrics.increment_variant(self.name, variant.name) unless Unleash.configuration.disable_metrics
       variant
     end
 
+    def self.disabled_variant
+      Unleash::Variant.new(name: 'disabled', enabled: false)
+    end
+
     private
 
+    def resolve_stickiness
+      self.variant_definitions&.map(&:stickiness)&.compact&.first || "default"
+    end
+
     # only check if it is enabled, do not do metrics
-    def am_enabled?(context, default_result)
+    def am_enabled?(context)
       result =
         if self.enabled
           self.strategies.empty? ||
@@ -58,10 +65,10 @@ module Unleash
               strategy_enabled?(s, context) && strategy_constraint_matches?(s, context)
             end
         else
-          default_result
+          false
         end
 
-      Unleash.logger.debug "Unleash::FeatureToggle (enabled:#{self.enabled} default_result:#{default_result} " \
+      Unleash.logger.debug "Unleash::FeatureToggle (enabled:#{self.enabled} " \
         "and Strategies combined with contraints returned #{result})"
 
       result
@@ -77,15 +84,12 @@ module Unleash
       strategy.constraints.empty? || strategy.constraints.all?{ |c| c.matches_context?(context) }
     end
 
-    def disabled_variant
-      Unleash::Variant.new(name: 'disabled', enabled: false)
-    end
-
     def sum_variant_defs_weights
       self.variant_definitions.map(&:weight).reduce(0, :+)
     end
 
-    def variant_salt(context)
+    def variant_salt(context, stickiness = "default")
+      return context.get_by_name(stickiness) unless stickiness == "default"
       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?
@@ -100,8 +104,8 @@ module Unleash
       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, sum_variant_defs_weights)
+    def variant_from_weights(context, stickiness)
+      variant_weight = Unleash::Strategy::Util.get_normalized_number(variant_salt(context, stickiness), self.name, sum_variant_defs_weights)
       prev_weights = 0
 
       variant_definition = self.variant_definitions
@@ -110,7 +114,7 @@ module Unleash
           prev_weights += v.weight
           res
         end
-      return disabled_variant if variant_definition.nil?
+      return self.disabled_variant if variant_definition.nil?
 
       Unleash::Variant.new(name: variant_definition.name, enabled: true, payload: variant_definition.payload)
     end
@@ -135,7 +139,9 @@ module Unleash
               Constraint.new(
                 c.fetch('contextName'),
                 c.fetch('operator'),
-                c.fetch('values')
+                c.fetch('values', nil) || c.fetch('value', nil),
+                inverted: c.fetch('inverted', false),
+                case_insensitive: c.fetch('caseInsensitive', false)
               )
             end
           )
@@ -150,6 +156,7 @@ module Unleash
             v.fetch('name', ''),
             v.fetch('weight', 0),
             v.fetch('payload', nil),
+            v.fetch('stickiness', nil),
             v.fetch('overrides', [])
           )
         end || []

data/lib/unleash/metrics_reporter.rb

@@ -6,6 +6,8 @@ require 'time'
 
 module Unleash
   class MetricsReporter
+    LONGEST_WITHOUT_A_REPORT = 600
+
     attr_accessor :last_time
 
     def initialize
@@ -33,16 +35,28 @@ module Unleash
       report
     end
 
-    def send
-      Unleash.logger.debug "send() Report"
+    def post
+      Unleash.logger.debug "post() Report"
+
+      if bucket_empty? && (Time.now - self.last_time < LONGEST_WITHOUT_A_REPORT) # and last time is less then 10 minutes...
+        Unleash.logger.debug "Report not posted to server, as it would have been empty. (and has been empty for up to 10 min)"
+
+        return
+      end
 
-      response = Unleash::Util::Http.post(Unleash.configuration.client_metrics_url, self.generate_report.to_json)
+      response = Unleash::Util::Http.post(Unleash.configuration.client_metrics_uri, self.generate_report.to_json)
 
       if ['200', '202'].include? response.code
-        Unleash.logger.debug "Report sent to unleash server sucessfully. Server responded with http code #{response.code}"
+        Unleash.logger.debug "Report sent to unleash server successfully. 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
+
+    private
+
+    def bucket_empty?
+      Unleash.toggle_metrics.features.empty?
+    end
   end
 end

data/lib/unleash/scheduled_executor.rb

@@ -1,19 +1,22 @@
 module Unleash
   class ScheduledExecutor
-    attr_accessor :name, :interval, :max_exceptions, :retry_count, :thread
+    attr_accessor :name, :interval, :max_exceptions, :retry_count, :thread, :immediate_execution
 
-    def initialize(name, interval, max_exceptions = 5)
+    def initialize(name, interval, max_exceptions = 5, immediate_execution = false)
       self.name = name || ''
       self.interval = interval
       self.max_exceptions = max_exceptions
       self.retry_count = 0
       self.thread = nil
+      self.immediate_execution = immediate_execution
     end
 
     def run(&blk)
       self.thread = Thread.new do
         Thread.current[:name] = self.name
 
+        run_blk{ blk.call } if self.immediate_execution
+
         Unleash.logger.debug "thread #{name} loop starting"
         loop do
           Unleash.logger.debug "thread #{name} sleeping for #{interval} seconds"

data/lib/unleash/strategy/application_hostname.rb

@@ -4,6 +4,7 @@ module Unleash
   module Strategy
     class ApplicationHostname < Base
       attr_accessor :hostname
+
       PARAM = 'hostnames'.freeze
 
       def initialize

data/lib/unleash/strategy/flexible_rollout.rb

@@ -38,16 +38,16 @@ module Unleash
 
       def resolve_stickiness(stickiness, context)
         case stickiness
-        when 'userId'
-          context.user_id
-        when 'sessionId'
-          context.session_id
         when 'random'
           random
         when 'default'
           context.user_id || context.session_id || random
         else
-          nil
+          begin
+            context.get_by_name(stickiness)
+          rescue KeyError
+            nil
+          end
         end
       end
     end

data/lib/unleash/strategy/remote_address.rb

@@ -13,7 +13,23 @@ module Unleash
         return false unless params.fetch(PARAM, nil).is_a? String
         return false unless context.class.name == 'Unleash::Context'
 
-        params[PARAM].split(',').map(&:strip).include?(context.remote_address)
+        remote_address = ipaddr_or_nil_from_str(context.remote_address)
+
+        params[PARAM]
+          .split(',')
+          .map(&:strip)
+          .map{ |ipblock| ipaddr_or_nil_from_str(ipblock) }
+          .compact
+          .map{ |ipb| ipb.include? remote_address }
+          .any?
+      end
+
+      private
+
+      def ipaddr_or_nil_from_str(ip)
+        IPAddr.new(ip)
+      rescue StandardError
+        nil
       end
     end
   end