flipper 0.16.0 → 1.4.0

data/lib/flipper/gates/group.rb

@@ -23,13 +23,11 @@ module Flipper
       #
       # Returns true if gate open for thing, false if not.
       def open?(context)
-        value = context.values[key]
-        if context.thing.nil?
-          false
-        else
-          value.any? do |name|
-            group = Flipper.group(name)
-            group.match?(context.thing, context)
+        return false unless context.actors?
+
+        context.values.groups.any? do |name|
+          context.actors.any? do |actor|
+            Flipper.group(name).match?(actor, context)
           end
         end
       end

data/lib/flipper/gates/percentage_of_actors.rb

@@ -21,21 +21,18 @@ module Flipper
         value > 0
       end
 
-      # Internal: Checks if the gate is open for a thing.
+      # Private: this constant is used to support up to 3 decimal places
+      # in percentages.
+      SCALING_FACTOR = 1_000
+      private_constant :SCALING_FACTOR
+
+      # Internal: Checks if the gate is open for one or more actors.
       #
-      # Returns true if gate open for thing, false if not.
+      # Returns true if gate open for any actors, false if not.
       def open?(context)
-        percentage = context.values[key]
-
-        if Types::Actor.wrappable?(context.thing)
-          actor = Types::Actor.wrap(context.thing)
-          id = "#{context.feature_name}#{actor.value}"
-          # this is to support up to 3 decimal places in percentages
-          scaling_factor = 1_000
-          Zlib.crc32(id) % (100 * scaling_factor) < percentage * scaling_factor
-        else
-          false
-        end
+        return false unless context.actors?
+        id = "#{context.feature_name}#{context.actors.map(&:value).sort.join}"
+        Zlib.crc32(id) % (100 * SCALING_FACTOR) < context.values.percentage_of_actors * SCALING_FACTOR
       end
 
       def protects?(thing)

data/lib/flipper/gates/percentage_of_time.rb

@@ -23,8 +23,7 @@ module Flipper
       #
       # Returns true if gate open for thing, false if not.
       def open?(context)
-        value = context.values[key]
-        rand < (value / 100.0)
+        rand < (context.values.percentage_of_time / 100.0)
       end
 
       def protects?(thing)

data/lib/flipper/identifier.rb

@@ -0,0 +1,17 @@
+module Flipper
+  # A default implementation of `#flipper_id` for actors.
+  #
+  #   class User < Struct.new(:id)
+  #     include Flipper::Identifier
+  #   end
+  #
+  #   user = User.new(99)
+  #   Flipper.enable :some_feature, user
+  #   Flipper.enabled? :some_feature, user #=> true
+  #
+  module Identifier
+    def flipper_id
+      "#{self.class.name};#{id}"
+    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'
 
@@ -10,7 +11,7 @@ module Flipper
       # Example Output
       #
       #   flipper[:search].enabled?(user)
-      #   # Flipper feature(search) enabled? false (1.2ms)  [ thing=... ]
+      #   # Flipper feature(search) enabled? false (1.2ms)  [ actors=... ]
       #
       # Returns nothing.
       def feature_operation(event)
@@ -20,15 +21,19 @@ module Flipper
         gate_name = event.payload[:gate_name]
         operation = event.payload[:operation]
         result = event.payload[:result]
-        thing = event.payload[:thing]
 
         description = "Flipper feature(#{feature_name}) #{operation} #{result.inspect}"
-        details = "thing=#{thing.inspect}"
+
+        details = if event.payload.key?(:actors)
+          "actors=#{event.payload[:actors].inspect}"
+        else
+          "thing=#{event.payload[:thing].inspect}"
+        end
 
         details += " gate_name=#{gate_name}" unless gate_name.nil?
 
         name = '%s (%.1fms)' % [description, event.duration]
-        debug "  #{color(name, CYAN, true)}  [ #{details} ]"
+        debug "  #{color_name(name)}  [ #{details} ]"
       end
 
       # Logs an adapter operation. If operation is for a feature, then that
@@ -48,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} "
@@ -60,14 +64,37 @@ module Flipper
         details = "result=#{result.inspect}"
 
         name = '%s (%.1fms)' % [description, event.duration]
-        debug "  #{color(name, CYAN, true)}  [ #{details} ]"
+        debug "  #{color_name(name)}  [ #{details} ]"
       end
 
       def logger
         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.
+      COLOR_OPTIONS = if Gem::Requirement.new(">=7.1").satisfied_by?(ActiveSupport.gem_version)
+        { bold: true }.freeze
+      else
+        true
+      end
+      private_constant :COLOR_OPTIONS
+
+      def color_name(name)
+        color(name, CYAN, COLOR_OPTIONS)
+      end
     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,10 +42,8 @@ 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]
-        thing = @payload[:thing]
 
         update_timer "flipper.feature_operation.#{operation}"
 
@@ -65,13 +63,18 @@ 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
 
+      def update_poller_metrics
+        # noop
+      end
+
+      def update_synchronizer_call_metrics
+        # noop
+      end
+
       QUESTION_MARK = '?'.freeze
 
       # Private

data/lib/flipper/instrumenters/memory.rb

@@ -17,9 +17,13 @@ module Flipper
         # block rather than the one passed to #instrument.
         payload = payload.dup
 
-        result = (yield payload if block_given?)
+        result = yield payload if block_given?
+      rescue Exception => e
+        payload[:exception] = [e.class.name, e.message]
+        payload[:exception_object] = e
+        raise e
+      ensure
         @events << Event.new(name, payload, result)
-        result
       end
 
       def events_by_name(name)

data/lib/flipper/metadata.rb

@@ -1,5 +1,12 @@
+require_relative './version'
+
 module Flipper
   METADATA = {
-    'changelog_uri' => 'https://github.com/jnunemaker/flipper/blob/master/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

@@ -1,5 +1,3 @@
-require 'rack/body_proxy'
-
 module Flipper
   module Middleware
     class Memoizer
@@ -10,22 +8,29 @@ module Flipper
       #
       # app - The app this middleware is included in.
       # opts - The Hash of options.
-      #        :preload_all - Boolean of whether or not to preload all features.
-      #        :preload - Array of Symbol feature names to preload.
+      #        :preload - Boolean to preload all features or Array of Symbol feature names to preload.
       #
       # Examples
       #
       #   use Flipper::Middleware::Memoizer
       #
       #   # using with preload_all features
-      #   use Flipper::Middleware::Memoizer, preload_all: true
+      #   use Flipper::Middleware::Memoizer, preload: true
       #
       #   # 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.' # rubocop:disable LineLength
+          raise 'Flipper::Middleware::Memoizer no longer initializes with a flipper instance or block. Read more at: https://git.io/vSo31.'
         end
 
         @app = app
@@ -36,39 +41,53 @@ module Flipper
       def call(env)
         request = Rack::Request.new(env)
 
-        if skip_memoize?(request)
-          @app.call(env)
+        if memoize?(request)
+          memoized_call(request)
         else
-          memoized_call(env)
+          @app.call(env)
         end
       end
 
       private
 
-      def skip_memoize?(request)
-        @opts[:unless] && @opts[:unless].call(request)
+      def memoize?(request)
+        if @opts[:if]
+          @opts[:if].call(request)
+        elsif @opts[:unless]
+          !@opts[:unless].call(request)
+        else
+          true
+        end
       end
 
-      def memoized_call(env)
-        reset_on_body_close = false
-        flipper = env.fetch(@env_key) { Flipper }
-        original = flipper.memoizing?
-        flipper.memoize = true
-
-        flipper.preload_all if @opts[:preload_all]
+      def memoized_call(request)
+        flipper = request.env.fetch(@env_key) { Flipper }
 
-        if (preload = @opts[:preload])
-          flipper.preload(preload)
+        # 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/flippercloud/flipper/pull/523"
+          return @app.call(request.env)
         end
 
-        response = @app.call(env)
-        response[2] = Rack::BodyProxy.new(response[2]) do
-          flipper.memoize = original
+        begin
+          flipper.memoize = true
+
+          # Preloading is pointless without memoizing.
+          preload = if @opts[:preload].respond_to?(:call)
+            @opts[:preload].call(request)
+          else
+            @opts[:preload]
+          end
+
+          case preload
+          when true then flipper.preload_all
+          when Array then flipper.preload(preload)
+          end
+
+          @app.call(request.env)
+        ensure
+          flipper.memoize = false
         end
-        reset_on_body_close = true
-        response
-      ensure
-        flipper.memoize = original if flipper && !reset_on_body_close
       end
     end
   end

data/lib/flipper/middleware/setup_env.rb

@@ -7,7 +7,8 @@ module Flipper
       #
       # app - The app this middleware is included in.
       # flipper_or_block - The Flipper::DSL instance or a block that yields a
-      #                    Flipper::DSL instance to use for all operations.
+      #                    Flipper::DSL instance to use for all operations
+      #                    (optional, default: Flipper).
       #
       # Examples
       #
@@ -19,18 +20,27 @@ module Flipper
       #   # using with a block that yields a flipper instance
       #   use Flipper::Middleware::SetupEnv, lambda { Flipper.new(...) }
       #
-      def initialize(app, flipper_or_block, options = {})
+      #   # using default configured Flipper instance
+      #   Flipper.configure do |config|
+      #     config.default { Flipper.new(...) }
+      #   end
+      #   use Flipper::Middleware::SetupEnv
+      def initialize(app, flipper_or_block = nil, options = {})
         @app = app
         @env_key = options.fetch(:env_key, 'flipper')
 
         if flipper_or_block.respond_to?(:call)
           @flipper_block = flipper_or_block
         else
-          @flipper = flipper_or_block
+          @flipper = flipper_or_block || Flipper
         end
       end
 
       def call(env)
+        dup.call!(env)
+      end
+
+      def call!(env)
         env[@env_key] ||= flipper
         @app.call(env)
       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

@@ -0,0 +1,157 @@
+require 'logger'
+require 'concurrent/utility/monotonic_time'
+require 'concurrent/map'
+require 'concurrent/atomic/atomic_fixnum'
+require 'concurrent/atomic/atomic_boolean'
+
+module Flipper
+  class Poller
+    attr_reader :adapter, :thread, :pid, :mutex, :interval, :last_synced_at
+
+    def self.instances
+      @instances ||= Concurrent::Map.new
+    end
+    private_class_method :instances
+
+    def self.get(key, options = {})
+      instances.compute_if_absent(key) { new(options) }
+    end
+
+    def self.reset
+      instances.each {|_, instance| instance.stop }.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)
+      @last_synced_at = Concurrent::AtomicFixnum.new(0)
+      @adapter = Adapters::Memory.new(nil, threadsafe: true)
+      @shutdown_requested = Concurrent::AtomicBoolean.new(false)
+
+      self.interval = options.fetch(:interval, 10)
+      @initial_interval = @interval
+
+      @start_automatically = options.fetch(:start_automatically, true)
+
+      if options.fetch(:shutdown_automatically, true)
+        at_exit { stop }
+      end
+    end
+
+    def start
+      reset if forked?
+      return if @shutdown_requested.true?
+      ensure_worker_running
+    end
+
+    def stop
+      @instrumenter.instrument("poller.#{InstrumentationNamespace}", {
+        operation: :stop,
+      })
+      @thread&.kill
+    end
+
+    def run
+      loop do
+        sleep jitter
+
+        begin
+          sync
+        rescue
+          # you can instrument these using poller.flipper
+        end
+
+        sleep interval
+      end
+    end
+
+    def sync
+      @instrumenter.instrument("poller.#{InstrumentationNamespace}", operation: :poll) do
+        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
+
+    def jitter
+      # Cap jitter at 30 seconds to prevent excessive delays for large intervals
+      max_jitter = [interval * 0.1, 30].min
+      rand * max_jitter
+    end
+
+    def forked?
+      pid != Process.pid
+    end
+
+    def ensure_worker_running
+      # Return early if thread is alive and avoid the mutex lock and unlock.
+      return if thread_alive?
+
+      # If another thread is starting worker thread, then return early so this
+      # thread can enqueue and move on with life.
+      return unless mutex.try_lock
+
+      begin
+        return if thread_alive?
+        @thread = Thread.new { run }
+        @instrumenter.instrument("poller.#{InstrumentationNamespace}", {
+          operation: :thread_start,
+        })
+      ensure
+        mutex.unlock
+      end
+    end
+
+    def thread_alive?
+      @thread && @thread.alive?
+    end
+
+    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