flipper 0.24.1 → 1.3.0

data/lib/flipper/feature_check_context.rb

@@ -7,13 +7,17 @@ module Flipper
     # gates for the feature.
     attr_reader :values
 
-    # Public: The thing we want to know if a feature is enabled for.
-    attr_reader :thing
+    # Public: The actors we want to know if a feature is enabled for.
+    attr_reader :actors
 
-    def initialize(options = {})
-      @feature_name = options.fetch(:feature_name)
-      @values = options.fetch(:values)
-      @thing = options.fetch(:thing)
+    def initialize(feature_name:, values:, actors:)
+      @feature_name = feature_name
+      @values = values
+      @actors = actors
+    end
+
+    def actors?
+      !@actors.nil? && !@actors.empty?
     end
 
     # Public: Convenience method for groups value like Feature has.

data/lib/flipper/gate.rb

@@ -18,28 +18,29 @@ module Flipper
       raise 'Not implemented'
     end
 
-    def enabled?(_value)
+    def enabled?(value)
       raise 'Not implemented'
     end
 
-    # Internal: Check if a gate is open for a thing. Implemented in subclass.
+    # Internal: Check if a gate is open for one or more actors. Implemented
+    # in subclass.
     #
-    # Returns true if gate open for thing, false if not.
-    def open?(_thing, _value, _options = {})
+    # Returns true if gate open for any actor, false if not.
+    def open?(actors, value, options = {})
       false
     end
 
-    # Internal: Check if a gate is protects a thing. Implemented in subclass.
+    # Internal: Check if a gate is protects an actor. Implemented in subclass.
     #
-    # Returns true if gate protects thing, false if not.
-    def protects?(_thing)
+    # Returns true if gate protects actor, false if not.
+    def protects?(actor)
       false
     end
 
-    # Internal: Allows gate to wrap thing using one of the supported flipper
-    # types so adapters always get something that responds to value.
-    def wrap(thing)
-      thing
+    # Internal: Allows gate to wrap actor using one of the supported flipper
+    # types so adapters always get someactor that responds to value.
+    def wrap(actor)
+      actor
     end
 
     # Public: Pretty string version for debugging.
@@ -59,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

@@ -3,19 +3,10 @@ require 'flipper/typecast'
 
 module Flipper
   class GateValues
-    # Private: Array of instance variables that are readable through the []
-    # instance method.
-    LegitIvars = {
-      'boolean' => '@boolean',
-      'actors' => '@actors',
-      'groups' => '@groups',
-      'percentage_of_time' => '@percentage_of_time',
-      'percentage_of_actors' => '@percentage_of_actors',
-    }.freeze
-
     attr_reader :boolean
     attr_reader :actors
     attr_reader :groups
+    attr_reader :expression
     attr_reader :percentage_of_actors
     attr_reader :percentage_of_time
 
@@ -23,14 +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])
-    end
-
-    def [](key)
-      if ivar = LegitIvars[key.to_s]
-        instance_variable_get(ivar)
-      end
+      @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)
@@ -38,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/actor.rb

@@ -19,30 +19,23 @@ module Flipper
         !value.empty?
       end
 
-      # Internal: Checks if the gate is open for a thing.
+      # Internal: Checks if the gate is open for an actor.
       #
-      # Returns true if gate open for thing, false if not.
+      # Returns true if gate open for actor, false if not.
       def open?(context)
-        value = context.values[key]
-        if context.thing.nil?
-          false
-        else
-          if protects?(context.thing)
-            actor = wrap(context.thing)
-            enabled_actor_ids = value
-            enabled_actor_ids.include?(actor.value)
-          else
-            false
-          end
+        return false unless context.actors?
+
+        context.actors.any? do |actor|
+          context.values.actors.include?(actor.value)
         end
       end
 
-      def wrap(thing)
-        Types::Actor.wrap(thing)
+      def wrap(actor)
+        Types::Actor.wrap(actor)
       end
 
-      def protects?(thing)
-        Types::Actor.wrappable?(thing)
+      def protects?(actor)
+        Types::Actor.wrappable?(actor)
       end
     end
   end

data/lib/flipper/gates/boolean.rb

@@ -24,7 +24,7 @@ module Flipper
       # Returns true if explicitly set to true, false if explicitly set to false
       # or nil if not explicitly set.
       def open?(context)
-        context.values[key]
+        context.values.boolean
       end
 
       def wrap(thing)

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)
+        else
+          context.actors.any? do |actor|
+            !!expression.evaluate(feature_name: context.feature_name, properties: properties(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/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

@@ -6,8 +6,8 @@ module Flipper
   #   end
   #
   #   user = User.new(99)
-  #   Flipper.enable :thing, user
-  #   Flipper.enabled? :thing, user #=> true
+  #   Flipper.enable :some_feature, user
+  #   Flipper.enabled? :some_feature, user #=> true
   #
   module Identifier
     def flipper_id

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
@@ -60,14 +65,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_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

@@ -45,7 +45,6 @@ module Flipper
         gate_name = @payload[:gate_name]
         operation = strip_trailing_question_mark(@payload[:operation])
         result = @payload[:result]
-        thing = @payload[:thing]
 
         update_timer "flipper.feature_operation.#{operation}"
 
@@ -72,6 +71,14 @@ module Flipper
         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/metadata.rb

@@ -1,5 +1,11 @@
+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}",
   }.freeze
 end

data/lib/flipper/middleware/memoizer.rb

@@ -20,16 +20,19 @@ 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.'
         end
 
-        if opts[:preload_all]
-          warn "Flipper::Middleware::Memoizer: `preload_all` is deprecated, use `preload: true`"
-          opts[:preload] = true
-        end
-
         @app = app
         @opts = opts
         @env_key = opts.fetch(:env_key, 'flipper')
@@ -39,7 +42,7 @@ module Flipper
         request = Rack::Request.new(env)
 
         if memoize?(request)
-          memoized_call(env)
+          memoized_call(request)
         else
           @app.call(env)
         end
@@ -57,31 +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
+
+          case preload
+          when true then flipper.preload_all
+          when Array then flipper.preload(preload)
+          end
 
-        response = @app.call(env)
-        response[2] = Rack::BodyProxy.new(response[2]) do
+          @app.call(request.env)
+        ensure
           flipper.memoize = false
         end
-        reset_on_body_close = true
-        response
-      ensure
-        flipper.memoize = false if flipper && !reset_on_body_close
       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

@@ -0,0 +1,118 @@
+require 'logger'
+require 'concurrent/utility/monotonic_time'
+require 'concurrent/map'
+require 'concurrent/atomic/atomic_fixnum'
+
+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)
+      @interval = options.fetch(:interval, 10).to_f
+      @last_synced_at = Concurrent::AtomicFixnum.new(0)
+      @adapter = Adapters::Memory.new(nil, threadsafe: true)
+
+      if @interval < MINIMUM_POLL_INTERVAL
+        warn "Flipper::Cloud poll interval must be greater than or equal to #{MINIMUM_POLL_INTERVAL} but was #{@interval}. Setting @interval to #{MINIMUM_POLL_INTERVAL}."
+        @interval = MINIMUM_POLL_INTERVAL
+      end
+
+      @start_automatically = options.fetch(:start_automatically, true)
+
+      if options.fetch(:shutdown_automatically, true)
+        at_exit { stop }
+      end
+    end
+
+    def start
+      reset if forked?
+      ensure_worker_running
+    end
+
+    def stop
+      @instrumenter.instrument("poller.#{InstrumentationNamespace}", {
+        operation: :stop,
+      })
+      @thread&.kill
+    end
+
+    def run
+      loop do
+        sleep jitter
+        start = Concurrent.monotonic_time
+        begin
+          sync
+        rescue => exception
+          # you can instrument these using poller.flipper
+        end
+
+        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 }
+      end
+    end
+
+    private
+
+    def jitter
+      rand
+    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
+      mutex.unlock if mutex.locked?
+    end
+  end
+end