flipper 0.28.3 → 1.4.2

data/lib/flipper/expressions/random.rb

@@ -0,0 +1,9 @@
+module Flipper
+  module Expressions
+    class Random
+      def self.call(max = 0)
+        rand max
+      end
+    end
+  end
+end

data/lib/flipper/expressions/string.rb

@@ -0,0 +1,9 @@
+module Flipper
+  module Expressions
+    class String
+      def self.call(value)
+        value.to_s
+      end
+    end
+  end
+end

data/lib/flipper/expressions/time.rb

@@ -0,0 +1,16 @@
+require "time"
+
+module Flipper
+  module Expressions
+    class Time
+      def self.call(value)
+        case value
+        when Numeric
+          ::Time.at(value).utc
+        else
+          ::Time.parse(value).utc
+        end
+      end
+    end
+  end
+end

data/lib/flipper/feature.rb

@@ -100,7 +100,14 @@ module Flipper
     #
     # Returns true if enabled, false if not.
     def enabled?(*actors)
-      actors = actors.flatten.compact.map { |actor| Types::Actor.wrap(actor) }
+      actors = Array(actors).
+        # Avoids to_ary warning that happens when passing DelegateClass of an 
+        # ActiveRecord object and using flatten here. This is tested in 
+        # spec/flipper/model/active_record_spec.rb.
+        flat_map { |actor| actor.is_a?(Array) ? actor : [actor] }. 
+        # Allows null object pattern. See PR for more. https://github.com/flippercloud/flipper/pull/887
+        reject(&:nil?). 
+        map { |actor| Types::Actor.wrap(actor) }
       actors = nil if actors.empty?
 
       # thing is left for backwards compatibility
@@ -120,6 +127,28 @@ module Flipper
       end
     end
 
+    # Public: Enables an expression_to_add for a feature.
+    #
+    # expression - an Expression or Hash that can be converted to an expression.
+    #
+    # Returns result of enable.
+    def enable_expression(expression)
+      enable Expression.build(expression)
+    end
+
+    # Public: Add an expression for a feature.
+    #
+    # expression_to_add - an expression or Hash that can be converted to an expression.
+    #
+    # Returns result of enable.
+    def add_expression(expression_to_add)
+      if (current_expression = expression)
+        enable current_expression.add(expression_to_add)
+      else
+        enable expression_to_add
+      end
+    end
+
     # Public: Enables a feature for an actor.
     #
     # actor - a Flipper::Types::Actor instance or an object that responds
@@ -160,6 +189,27 @@ module Flipper
       enable Types::PercentageOfActors.wrap(percentage)
     end
 
+    # Public: Disables an expression for a feature.
+    #
+    # expression - an expression or Hash that can be converted to an expression.
+    #
+    # Returns result of disable.
+    def disable_expression
+      disable Flipper.all # just need an expression to clear
+    end
+
+    # Public: Remove an expression from a feature. Does nothing if no expression is
+    # currently enabled.
+    #
+    # expression - an Expression or Hash that can be converted to an expression.
+    #
+    # Returns result of enable or nil (if no expression enabled).
+    def remove_expression(expression_to_remove)
+      if (current_expression = expression)
+        enable current_expression.remove(expression_to_remove)
+      end
+    end
+
     # Public: Disables a feature for an actor.
     #
     # actor - a Flipper::Types::Actor instance or an object that responds
@@ -252,6 +302,10 @@ module Flipper
       Flipper.groups - enabled_groups
     end
 
+    def expression
+      Flipper::Expression.build(expression_value) if expression_value
+    end
+
     # Public: Get the adapter value for the groups gate.
     #
     # Returns Set of String group names.
@@ -259,6 +313,13 @@ module Flipper
       gate_values.groups
     end
 
+    # Public: Get the adapter value for the expression gate.
+    #
+    # Returns expression.
+    def expression_value
+      gate_values.expression
+    end
+
     # Public: Get the adapter value for the actors gate.
     #
     # Returns Set of String flipper_id's.
@@ -347,6 +408,7 @@ module Flipper
     def gates_hash
       @gates_hash ||= {
         boolean: Gates::Boolean.new,
+        expression: Gates::Expression.new,
         actor: Gates::Actor.new,
         percentage_of_actors: Gates::PercentageOfActors.new,
         percentage_of_time: Gates::PercentageOfTime.new,

data/lib/flipper/gate.rb

@@ -26,7 +26,7 @@ module Flipper
     # in subclass.
     #
     # Returns true if gate open for any actor, false if not.
-    def open?(actors, value, options = {})
+    def open?(context)
       false
     end
 
@@ -60,3 +60,4 @@ require 'flipper/gates/boolean'
 require 'flipper/gates/group'
 require 'flipper/gates/percentage_of_actors'
 require 'flipper/gates/percentage_of_time'
+require 'flipper/gates/expression'

data/lib/flipper/gate_values.rb

@@ -6,6 +6,7 @@ module Flipper
     attr_reader :boolean
     attr_reader :actors
     attr_reader :groups
+    attr_reader :expression
     attr_reader :percentage_of_actors
     attr_reader :percentage_of_time
 
@@ -13,8 +14,9 @@ module Flipper
       @boolean = Typecast.to_boolean(adapter_values[:boolean])
       @actors = Typecast.to_set(adapter_values[:actors])
       @groups = Typecast.to_set(adapter_values[:groups])
-      @percentage_of_actors = Typecast.to_percentage(adapter_values[:percentage_of_actors])
-      @percentage_of_time = Typecast.to_percentage(adapter_values[:percentage_of_time])
+      @expression = adapter_values[:expression]
+      @percentage_of_actors = Typecast.to_number(adapter_values[:percentage_of_actors])
+      @percentage_of_time = Typecast.to_number(adapter_values[:percentage_of_time])
     end
 
     def eql?(other)
@@ -22,6 +24,7 @@ module Flipper
         boolean == other.boolean &&
         actors == other.actors &&
         groups == other.groups &&
+        expression == other.expression &&
         percentage_of_actors == other.percentage_of_actors &&
         percentage_of_time == other.percentage_of_time
     end

data/lib/flipper/gates/expression.rb

@@ -0,0 +1,75 @@
+require "flipper/expression"
+
+module Flipper
+  module Gates
+    class Expression < Gate
+      # Internal: The name of the gate. Used for instrumentation, etc.
+      def name
+        :expression
+      end
+
+      # Internal: Name converted to value safe for adapter.
+      def key
+        :expression
+      end
+
+      def data_type
+        :json
+      end
+
+      def enabled?(value)
+        !value.nil? && !value.empty?
+      end
+
+      # Internal: Checks if the gate is open for a thing.
+      #
+      # Returns true if gate open for thing, false if not.
+      def open?(context)
+        data = context.values.expression
+        return false if data.nil? || data.empty?
+        expression = Flipper::Expression.build(data)
+
+        if context.actors.nil? || context.actors.empty?
+          !!expression.evaluate(feature_name: context.feature_name, properties: DEFAULT_PROPERTIES, actor: nil)
+        else
+          context.actors.any? do |actor|
+            !!expression.evaluate(feature_name: context.feature_name, properties: properties(actor), actor: actor)
+          end
+        end
+      end
+
+      def protects?(thing)
+        thing.is_a?(Flipper::Expression) || thing.is_a?(Hash)
+      end
+
+      def wrap(thing)
+        Flipper::Expression.build(thing)
+      end
+
+      private
+
+      # Internal
+      DEFAULT_PROPERTIES = {}.freeze
+
+      def properties(actor)
+        return DEFAULT_PROPERTIES if actor.nil?
+
+        properties = {}
+
+        if actor.respond_to?(:flipper_properties)
+          properties.update(actor.flipper_properties)
+        else
+          warn "#{actor.inspect} does not respond to `flipper_properties` but should."
+        end
+
+        properties.transform_keys!(&:to_s)
+
+        if actor.respond_to?(:flipper_id)
+          properties["flipper_id".freeze] = actor.flipper_id
+        end
+
+        properties
+      end
+    end
+  end
+end

data/lib/flipper/instrumentation/log_subscriber.rb

@@ -1,4 +1,5 @@
 require 'securerandom'
+require 'active_support/gem_version'
 require 'active_support/notifications'
 require 'active_support/log_subscriber'
 
@@ -52,11 +53,10 @@ module Flipper
 
         feature_name = event.payload[:feature_name]
         adapter_name = event.payload[:adapter_name]
-        gate_name = event.payload[:gate_name]
         operation = event.payload[:operation]
         result = event.payload[:result]
 
-        description = 'Flipper '
+        description = String.new('Flipper ')
         description << "feature(#{feature_name}) " unless feature_name.nil?
         description << "adapter(#{adapter_name}) "
         description << "#{operation} "
@@ -71,11 +71,19 @@ module Flipper
         self.class.logger
       end
 
+      def self.attach
+        attach_to InstrumentationNamespace
+      end
+
+      def self.detach
+        # Rails 5.2 doesn't support this, that's fine
+        detach_from InstrumentationNamespace if respond_to?(:detach_from)
+      end
+
       private
 
       # Rails 7.1 changed the signature of this function.
-      # Checking if > 7.0.99 rather than >= 7.1 so that 7.1 pre-release versions are included.
-      COLOR_OPTIONS = if Rails.gem_version > Gem::Version.new('7.0.99')
+      COLOR_OPTIONS = if Gem::Requirement.new(">=7.1").satisfied_by?(ActiveSupport.gem_version)
         { bold: true }.freeze
       else
         true
@@ -88,5 +96,5 @@ module Flipper
     end
   end
 
-  Instrumentation::LogSubscriber.attach_to InstrumentationNamespace
+  Instrumentation::LogSubscriber.attach
 end

data/lib/flipper/instrumentation/statsd.rb

@@ -2,5 +2,7 @@ require 'securerandom'
 require 'active_support/notifications'
 require 'flipper/instrumentation/statsd_subscriber'
 
-ActiveSupport::Notifications.subscribe /\.flipper$/,
-                                       Flipper::Instrumentation::StatsdSubscriber
+ActiveSupport::Notifications.subscribe(
+  /\.flipper$/,
+  Flipper::Instrumentation::StatsdSubscriber
+)

data/lib/flipper/instrumentation/statsd_subscriber.rb

@@ -12,13 +12,11 @@ module Flipper
       end
 
       def update_timer(metric)
-        if self.class.client
-          self.class.client.timing metric, (@duration * 1_000).round
-        end
+        self.class.client&.timing metric, (@duration * 1_000).round
       end
 
       def update_counter(metric)
-        self.class.client.increment metric if self.class.client
+        self.class.client&.increment metric
       end
     end
   end

data/lib/flipper/instrumentation/subscriber.rb

@@ -42,7 +42,6 @@ module Flipper
       # Private
       def update_feature_operation_metrics
         feature_name = @payload[:feature_name]
-        gate_name = @payload[:gate_name]
         operation = strip_trailing_question_mark(@payload[:operation])
         result = @payload[:result]
 
@@ -64,9 +63,6 @@ module Flipper
       def update_adapter_operation_metrics
         adapter_name = @payload[:adapter_name]
         operation = @payload[:operation]
-        result = @payload[:result]
-        value = @payload[:value]
-        key = @payload[:key]
 
         update_timer "flipper.adapter.#{adapter_name}.#{operation}"
       end

data/lib/flipper/metadata.rb

@@ -1,5 +1,12 @@
+require_relative './version'
+
 module Flipper
   METADATA = {
-    'changelog_uri' => 'https://github.com/jnunemaker/flipper/blob/main/Changelog.md',
+    "documentation_uri" => "https://www.flippercloud.io/docs",
+    "homepage_uri"      => "https://www.flippercloud.io",
+    "source_code_uri"   => "https://github.com/flippercloud/flipper",
+    "bug_tracker_uri"   => "https://github.com/flippercloud/flipper/issues",
+    "changelog_uri"     => "https://github.com/flippercloud/flipper/releases/tag/v#{Flipper::VERSION}",
+    "funding_uri"       => "https://github.com/sponsors/flippercloud",
   }.freeze
 end

data/lib/flipper/middleware/memoizer.rb

@@ -20,6 +20,14 @@ module Flipper
       #   # using with preload specific features
       #   use Flipper::Middleware::Memoizer, preload: [:stats, :search, :some_feature]
       #
+      #   # using with preload block that returns true/false
+      #   use Flipper::Middleware::Memoizer, preload: ->(request) { !request.path.start_with?('/assets') }
+      #
+      #   # using with preload block that returns specific features
+      #   use Flipper::Middleware::Memoizer, preload: ->(request) {
+      #     request.path.starts_with?('/admin') ? [:stats, :search] : false
+      #   }
+      #
       def initialize(app, opts = {})
         if opts.is_a?(Flipper::DSL) || opts.is_a?(Proc)
           raise 'Flipper::Middleware::Memoizer no longer initializes with a flipper instance or block. Read more at: https://git.io/vSo31.'
@@ -34,7 +42,7 @@ module Flipper
         request = Rack::Request.new(env)
 
         if memoize?(request)
-          memoized_call(env)
+          memoized_call(request)
         else
           @app.call(env)
         end
@@ -52,26 +60,34 @@ module Flipper
         end
       end
 
-      def memoized_call(env)
-        reset_on_body_close = false
-        flipper = env.fetch(@env_key) { Flipper }
+      def memoized_call(request)
+        flipper = request.env.fetch(@env_key) { Flipper }
 
         # Already memoizing. This instance does not need to do anything.
         if flipper.memoizing?
-          warn "Flipper::Middleware::Memoizer appears to be running twice. Read how to resolve this at https://github.com/jnunemaker/flipper/pull/523"
-          return @app.call(env)
+          warn "Flipper::Middleware::Memoizer appears to be running twice. Read how to resolve this at https://github.com/flippercloud/flipper/pull/523"
+          return @app.call(request.env)
         end
 
-        flipper.memoize = true
+        begin
+          flipper.memoize = true
 
-        case @opts[:preload]
-        when true then flipper.preload_all
-        when Array then flipper.preload(@opts[:preload])
-        end
+          # Preloading is pointless without memoizing.
+          preload = if @opts[:preload].respond_to?(:call)
+            @opts[:preload].call(request)
+          else
+            @opts[:preload]
+          end
 
-        @app.call(env)
-      ensure
-        flipper.memoize = false if flipper
+          case preload
+          when true then flipper.preload_all
+          when Array then flipper.preload(preload)
+          end
+
+          @app.call(request.env)
+        ensure
+          flipper.memoize = false
+        end
       end
     end
   end

data/lib/flipper/model/active_record.rb

@@ -0,0 +1,23 @@
+module Flipper
+  module Model
+    module ActiveRecord
+      # The id of the record when used as an actor.
+      #
+      #   class User < ActiveRecord::Base
+      #   end
+      #
+      #   user = User.first
+      #   Flipper.enable :some_feature, user
+      #   Flipper.enabled? :some_feature, user #=> true
+      #
+      def flipper_id
+        "#{self.class.base_class.name};#{id}"
+      end
+
+      # Properties used to evaluate expressions
+      def flipper_properties
+        {"type" => self.class.name}.merge(attributes)
+      end
+    end
+  end
+end

data/lib/flipper/poller.rb

@@ -2,6 +2,7 @@ require 'logger'
 require 'concurrent/utility/monotonic_time'
 require 'concurrent/map'
 require 'concurrent/atomic/atomic_fixnum'
+require 'concurrent/atomic/atomic_boolean'
 
 module Flipper
   class Poller
@@ -17,23 +18,26 @@ module Flipper
     end
 
     def self.reset
-      instances.each {|_,poller| poller.stop }.clear
+      instances.each do |_, instance|
+        instance.stop
+        instance.thread&.join(1)
+      end.clear
     end
 
+    MINIMUM_POLL_INTERVAL = 10
+
     def initialize(options = {})
       @thread = nil
       @pid = Process.pid
       @mutex = Mutex.new
       @instrumenter = options.fetch(:instrumenter, Instrumenters::Noop)
       @remote_adapter = options.fetch(:remote_adapter)
-      @interval = options.fetch(:interval, 10).to_f
       @last_synced_at = Concurrent::AtomicFixnum.new(0)
       @adapter = Adapters::Memory.new(nil, threadsafe: true)
+      @shutdown_requested = Concurrent::AtomicBoolean.new(false)
 
-      if @interval < 1
-        warn "Flipper::Cloud poll interval must be greater than or equal to 1 but was #{@interval}. Setting @interval to 1."
-        @interval = 1
-      end
+      self.interval = options.fetch(:interval, 10)
+      @initial_interval = @interval
 
       @start_automatically = options.fetch(:start_automatically, true)
 
@@ -44,6 +48,7 @@ module Flipper
 
     def start
       reset if forked?
+      return if @shutdown_requested.true?
       ensure_worker_running
     end
 
@@ -57,23 +62,38 @@ module Flipper
     def run
       loop do
         sleep jitter
-        start = Concurrent.monotonic_time
+
         begin
           sync
-        rescue => exception
+        rescue
           # you can instrument these using poller.flipper
         end
 
-        sleep_interval = interval - (Concurrent.monotonic_time - start)
-        sleep sleep_interval if sleep_interval.positive?
+        sleep interval
       end
     end
 
     def sync
       @instrumenter.instrument("poller.#{InstrumentationNamespace}", operation: :poll) do
-        @adapter.import @remote_adapter
-        @last_synced_at.update { |time| Concurrent.monotonic_time }
+        begin
+          @adapter.import @remote_adapter
+          @last_synced_at.update { |time| Concurrent.monotonic_time }
+        ensure
+          apply_response_headers
+        end
+      end
+    end
+
+    # Internal: Sets the interval in seconds for how often to poll.
+    def interval=(value)
+      requested_interval = Flipper::Typecast.to_float(value)
+      new_interval = [requested_interval, MINIMUM_POLL_INTERVAL].max
+
+      if requested_interval < MINIMUM_POLL_INTERVAL
+        warn "Flipper::Cloud poll interval must be greater than or equal to #{MINIMUM_POLL_INTERVAL} but was #{requested_interval}. Setting interval to #{MINIMUM_POLL_INTERVAL}."
       end
+
+      @interval = new_interval
     end
 
     private
@@ -97,6 +117,7 @@ module Flipper
       begin
         return if thread_alive?
         @thread = Thread.new { run }
+        @thread&.report_on_exception = false
         @instrumenter.instrument("poller.#{InstrumentationNamespace}", {
           operation: :thread_start,
         })
@@ -111,7 +132,28 @@ module Flipper
 
     def reset
       @pid = Process.pid
+      @shutdown_requested.make_false
       mutex.unlock if mutex.locked?
     end
+
+    def apply_response_headers
+      return unless @remote_adapter.respond_to?(:last_get_all_response)
+
+      if response = @remote_adapter.last_get_all_response
+        # shutdown based on response header
+        if Flipper::Typecast.to_boolean(response["poll-shutdown"])
+          @shutdown_requested.make_true
+          @instrumenter.instrument("poller.#{InstrumentationNamespace}", {
+            operation: :shutdown_requested,
+          })
+          stop
+        end
+
+        # update interval based on response header
+        if interval = response["poll-interval"]
+          self.interval = [Flipper::Typecast.to_float(interval), @initial_interval].max
+        end
+      end
+    end
   end
 end

data/lib/flipper/serializers/gzip.rb

@@ -0,0 +1,22 @@
+require "zlib"
+require "stringio"
+
+module Flipper
+  module Serializers
+    class Gzip
+      def self.serialize(source)
+        return if source.nil?
+        output = StringIO.new
+        gz = Zlib::GzipWriter.new(output)
+        gz.write(source)
+        gz.close
+        output.string
+      end
+
+      def self.deserialize(source)
+        return if source.nil?
+        Zlib::GzipReader.wrap(StringIO.new(source), &:read)
+      end
+    end
+  end
+end

data/lib/flipper/serializers/json.rb

@@ -0,0 +1,17 @@
+require "json"
+
+module Flipper
+  module Serializers
+    class Json
+      def self.serialize(source)
+        return if source.nil?
+        JSON.generate(source)
+      end
+
+      def self.deserialize(source)
+        return if source.nil?
+        JSON.parse(source)
+      end
+    end
+  end
+end