flipper 0.27.1 → 0.28.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba1d158db684bce01872e3f32c81f522d32086a78af94a78a6266422079a3473
-  data.tar.gz: 9a7ea456415d5fd73d5adcb66bb77c4701a2a6e6b3ab94d5c89af52202907e7c
+  metadata.gz: 5373416d79c0f4e67654bf9945bb4b1702fae520946f127be970fa89a7f3151a
+  data.tar.gz: 194180daeb197f5f2323363915de63daea4458486585eb687c76d380cc48df93
 SHA512:
-  metadata.gz: f708342f07ebe1bfbf3c9d0e0f1db184ccd686bdd995752b6459f96ab119fe589573e0077d156afad1ac8f73b45140a54e301ff23ef423e92b3c109e89285992
-  data.tar.gz: e9ca8640f9c9b655ae464651adda6cb6998355b967b58119fc42c2a87d3c3f848538dd05ff36585e75527384aca05ab6be1996558679a0090ef24bb8a6a7a682
+  metadata.gz: 8e6652132da82dfd9ee46419d3f4fcc9836b6464fe2a89d670e17315f1664db6f88784ab3b3006b2aa43b150461a1645791d9334d96b93dd685b31cf98909a1d
+  data.tar.gz: 161e2acea4928753b8ebb8d83e9fa05e33dcee6bab15cc2323c3acc3beb8d5e95f96aace11ffceddcc2dc035ee3d9aa3918f61e956a9c4eeb243387c8eacf87a

data/Changelog.md

@@ -2,6 +2,51 @@
 
 All notable changes to this project will be documented in this file.
 
+## 0.28.1
+
+### Additions/Changes
+
+* Use new method of making logs bold for rails (https://github.com/jnunemaker/flipper/pull/726)
+* Bundle bootstrap, jquery and poppler with the library. (https://github.com/jnunemaker/flipper/pull/731)
+
+## 0.28.0
+
+### Additions/Changes
+
+* Allow multiple actors for Flipper.enabled?. Improves performance of feature flags for multiple actors and simplifies code for users of flipper. This likely breaks things for anyone using Flipper internal classes related to actors, but that isn't likely you so you should be fine.
+  ```diff
+  - [user, user.team, user.org].any? { |actor| Flipper.enabled?(:my_feature, actor) }
+  + Flipper.enabled?(:my_feature, user, user.team, user.org)
+  ```
+* If you currently use `actor.thing` in a group, you'll need to change it to `actor.actor`.
+  ```diff
+  - Flipper.register(:our_group) do |actor|
+  -   actor.thing.is_a?(OurClassName)
+  - end
+  + Flipper.register(:our_group) do |actor|
+  +   actor.actor.is_a?(OurClassName)
+  + end
+  ```
+* If you currently use `context.thing` in a group or elsewhere, you'll need to change it to `context.actors`.
+  ```diff
+  - Flipper.register(:our_group) do |actor, context|
+  -   context.thing.is_a?(OurClassName)
+  - end
+  + Flipper.register(:our_group) do |actor, context|
+  +   context.actors.any? { |actor| actor.is_a?(OurClassName) }
+  + end
+  ```
+
+### Deprecations
+
+* `:thing` in `enabled?` instrumentation payload. Use `:actors` instead.
+    ```diff
+    ActiveSupport::Notifications.subscribe('enabled?.feature_operation.flipper') do |name, start, finish, id, payload|
+    -   payload[:thing]
+    +   payload[:actors]
+    end
+    ```
+
 ## 0.27.1
 
 * Quick fix for missing require of "flipper/version" that was causing issues with some flipper-ui people.

data/Rakefile

@@ -17,9 +17,9 @@ end
 
 desc 'Tags version, pushes to remote, and pushes gem'
 task release: :build do
-  # sh 'git', 'tag', "v#{Flipper::VERSION}"
-  # sh 'git push origin main'
-  # sh "git push origin v#{Flipper::VERSION}"
+  sh 'git', 'tag', "v#{Flipper::VERSION}"
+  sh 'git push origin main'
+  sh "git push origin v#{Flipper::VERSION}"
   puts "\nWhat OTP code should be used?"
   otp_code = STDIN.gets.chomp
   sh "ls pkg/*.gem | xargs -n 1 gem push --otp #{otp_code}"

data/benchmark/enabled_multiple_actors_ips.rb

@@ -0,0 +1,20 @@
+require 'bundler/setup'
+require 'flipper'
+require 'benchmark/ips'
+
+actor1 = Flipper::Actor.new("User;1")
+actor2 = Flipper::Actor.new("User;2")
+actor3 = Flipper::Actor.new("User;3")
+actor4 = Flipper::Actor.new("User;4")
+actor5 = Flipper::Actor.new("User;5")
+actor6 = Flipper::Actor.new("User;6")
+actor7 = Flipper::Actor.new("User;7")
+actor8 = Flipper::Actor.new("User;8")
+
+actors = [actor1, actor2, actor3, actor4, actor5, actor6, actor7, actor8]
+
+Benchmark.ips do |x|
+  x.report("with array of actors") { Flipper.enabled?(:foo, actors) }
+  x.report("with multiple enabled? checks") { actors.each { |actor| Flipper.enabled?(:foo, actor) } }
+  x.compare!
+end

data/examples/dsl.rb

@@ -1,7 +1,7 @@
 require 'bundler/setup'
 require 'flipper'
 
-# create a thing with an identifier
+# create an actor with an identifier
 class Person < Struct.new(:id)
   include Flipper::Identifier
 end
@@ -58,8 +58,8 @@ responds_to_flipper_id = Struct.new(:flipper_id).new(10)
 puts Flipper.actor(responds_to_flipper_id).inspect
 
 # get an instance of an actor using an object
-thing = Struct.new(:flipper_id).new(22)
-puts Flipper.actor(thing).inspect
+actor = Struct.new(:flipper_id).new(22)
+puts Flipper.actor(actor).inspect
 
 # register a top level group
 admins = Flipper.register(:admins) { |actor|

data/examples/enabled_for_actor.rb

@@ -31,5 +31,7 @@ Flipper.enable_percentage_of_actors :pro_stats, 50
 Flipper.enable_group :tweets, :admins
 Flipper.enable_actor :posts, user2
 
-pp Flipper.features.select { |feature| feature.enabled?(user1) }.map(&:name)
-pp Flipper.features.select { |feature| feature.enabled?(user2) }.map(&:name)
+pp Flipper.features.select { |feature| feature.enabled?(user1) }.map(&:name).sort
+pp Flipper.features.select { |feature| feature.enabled?(user2) }.map(&:name).sort
+pp Flipper.features.select { |feature| feature.enabled?(user1, user2) }.map(&:name).sort
+pp Flipper.features.select { |feature| feature.enabled?([user2, user1]) }.map(&:name).sort

data/examples/mirroring.rb

@@ -0,0 +1,59 @@
+require 'bundler/setup'
+require_relative 'active_record/ar_setup'
+require 'flipper'
+require 'flipper/adapters/redis'
+require 'flipper/adapters/active_record'
+
+# Say you have production...
+production_adapter = Flipper::Adapters::Memory.new
+production = Flipper.new(production_adapter)
+
+# And production has some stuff enabled...
+production.enable(:search)
+production.enable_percentage_of_time(:verbose_logging, 5)
+production.enable_percentage_of_actors(:new_feature, 5)
+production.enable_actor(:issues, Flipper::Actor.new('1'))
+production.enable_actor(:issues, Flipper::Actor.new('2'))
+production.enable_group(:request_tracing, :staff)
+
+# And you would like to mirror production to staging...
+staging_adapter = Flipper::Adapters::Memory.new
+staging = Flipper.new(staging_adapter)
+staging_export = staging.export
+
+puts "Here is the state of the world for staging and production..."
+puts "Staging"
+staging.features.each do |feature|
+  pp feature: feature.key, values: feature.gate_values
+end
+puts "Production"
+production.features.each do |feature|
+  pp feature: feature.key, values: feature.gate_values
+end
+
+# NOTE: This wipes active record clean and copies features/gates from redis into active record.
+puts "Mirroring production to staging..."
+staging.import(production.export)
+puts "Staging is now identical to Production."
+
+puts "Staging"
+staging.features.each do |feature|
+  pp feature: feature.key, values: feature.gate_values
+end
+puts "Production"
+production.features.each do |feature|
+  pp feature: feature.key, values: feature.gate_values
+end
+
+puts "Restoring staging to original state..."
+staging.import(staging_export)
+puts "Staging restored."
+
+puts "Staging"
+staging.features.each do |feature|
+  pp feature: feature.key, values: feature.gate_values
+end
+puts "Production"
+production.features.each do |feature|
+  pp feature: feature.key, values: feature.gate_values
+end

data/lib/flipper/adapters/memory.rb

@@ -1,6 +1,5 @@
 require "flipper/adapter"
 require "flipper/typecast"
-require 'concurrent/atomic/read_write_lock'
 
 module Flipper
   module Adapters
@@ -15,43 +14,44 @@ module Flipper
       attr_reader :name
 
       # Public
-      def initialize(source = nil)
+      def initialize(source = nil, threadsafe: true)
         @source = Typecast.features_hash(source)
         @name = :memory
-        @lock = Concurrent::ReadWriteLock.new
+        @lock = Mutex.new if threadsafe
+        reset
       end
 
       # Public: The set of known features.
       def features
-        @lock.with_read_lock { @source.keys }.to_set
+        synchronize { @source.keys }.to_set
       end
 
       # Public: Adds a feature to the set of known features.
       def add(feature)
-        @lock.with_write_lock { @source[feature.key] ||= default_config }
+        synchronize { @source[feature.key] ||= default_config }
         true
       end
 
       # Public: Removes a feature from the set of known features and clears
       # all the values for the feature.
       def remove(feature)
-        @lock.with_write_lock { @source.delete(feature.key) }
+        synchronize { @source.delete(feature.key) }
         true
       end
 
       # Public: Clears all the gate values for a feature.
       def clear(feature)
-        @lock.with_write_lock { @source[feature.key] = default_config }
+        synchronize { @source[feature.key] = default_config }
         true
       end
 
       # Public
       def get(feature)
-        @lock.with_read_lock { @source[feature.key] } || default_config
+        synchronize { @source[feature.key] } || default_config
       end
 
       def get_multi(features)
-        @lock.with_read_lock do
+        synchronize do
           result = {}
           features.each do |feature|
             result[feature.key] = @source[feature.key] || default_config
@@ -61,12 +61,12 @@ module Flipper
       end
 
       def get_all
-        @lock.with_read_lock { Typecast.features_hash(@source) }
+        synchronize { Typecast.features_hash(@source) }
       end
 
       # Public
       def enable(feature, gate, thing)
-        @lock.with_write_lock do
+        synchronize do
           @source[feature.key] ||= default_config
 
           case gate.data_type
@@ -87,7 +87,7 @@ module Flipper
 
       # Public
       def disable(feature, gate, thing)
-        @lock.with_write_lock do
+        synchronize do
           @source[feature.key] ||= default_config
 
           case gate.data_type
@@ -118,9 +118,29 @@ module Flipper
       def import(source)
         adapter = self.class.from(source)
         get_all = Typecast.features_hash(adapter.get_all)
-        @lock.with_write_lock { @source.replace(get_all) }
+        synchronize { @source.replace(get_all) }
         true
       end
+
+      private
+
+      def reset
+        @pid = Process.pid
+        @lock&.unlock if @lock&.locked?
+      end
+
+      def forked?
+        @pid != Process.pid
+      end
+
+      def synchronize(&block)
+        if @lock
+          reset if forked?
+          @lock.synchronize(&block)
+        else
+          block.call
+        end
+      end
     end
   end
 end

data/lib/flipper/dsl.rb

@@ -237,12 +237,12 @@ module Flipper
 
     # Public: Wraps an object as a flipper actor.
     #
-    # thing - The object that you would like to wrap.
+    # actor - The object that you would like to wrap.
     #
     # Returns an instance of Flipper::Types::Actor.
-    # Raises ArgumentError if thing does not respond to `flipper_id`.
-    def actor(thing)
-      Types::Actor.new(thing)
+    # Raises ArgumentError if actor does not respond to `flipper_id`.
+    def actor(actor)
+      Types::Actor.new(actor)
     end
 
     # Public: Shortcut for getting a percentage of time instance.

data/lib/flipper/errors.rb

@@ -2,10 +2,10 @@ module Flipper
   # Top level error that all other errors inherit from.
   class Error < StandardError; end
 
-  # Raised when gate can not be found for a thing.
+  # Raised when gate can not be found for an actor.
   class GateNotFound < Error
-    def initialize(thing)
-      super "Could not find gate for #{thing.inspect}"
+    def initialize(actor)
+      super "Could not find gate for #{actor.inspect}"
     end
   end
 

data/lib/flipper/feature.rb

@@ -96,17 +96,19 @@ module Flipper
       instrument(:clear) { adapter.clear(self) }
     end
 
-    # Public: Check if a feature is enabled for a thing.
+    # Public: Check if a feature is enabled for zero or more actors.
     #
     # Returns true if enabled, false if not.
-    def enabled?(thing = nil)
-      thing = Types::Actor.wrap(thing) unless thing.nil?
+    def enabled?(*actors)
+      actors = actors.flatten.compact.map { |actor| Types::Actor.wrap(actor) }
+      actors = nil if actors.empty?
 
-      instrument(:enabled?, thing: thing) do |payload|
+      # thing is left for backwards compatibility
+      instrument(:enabled?, thing: actors&.first, actors: actors) do |payload|
         context = FeatureCheckContext.new(
           feature_name: @name,
           values: gate_values,
-          thing: thing
+          actors: actors
         )
 
         if open_gate = gates.detect { |gate| gate.open?(context) }
@@ -359,14 +361,14 @@ module Flipper
       gates_hash[name.to_sym]
     end
 
-    # Public: Find the gate that protects a thing.
+    # Public: Find the gate that protects an actor.
     #
-    # thing - The object for which you would like to find a gate
+    # actor - The object for which you would like to find a gate
     #
     # Returns a Flipper::Gate.
-    # Raises Flipper::GateNotFound if no gate found for thing
-    def gate_for(thing)
-      gates.detect { |gate| gate.protects?(thing) } || raise(GateNotFound, thing)
+    # Raises Flipper::GateNotFound if no gate found for actor
+    def gate_for(actor)
+      gates.detect { |gate| gate.protects?(actor) } || raise(GateNotFound, actor)
     end
 
     private

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(feature_name:, values:, thing:)
+    def initialize(feature_name:, values:, actors:)
       @feature_name = feature_name
       @values = values
-      @thing = thing
+      @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.

data/lib/flipper/gates/actor.rb

@@ -19,20 +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)
-        return false if context.thing.nil?
-        context.values.actors.include?(context.thing.value)
+        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/group.rb

@@ -23,10 +23,12 @@ module Flipper
       #
       # Returns true if gate open for thing, false if not.
       def open?(context)
-        return false if context.thing.nil?
+        return false unless context.actors?
 
         context.values.groups.any? do |name|
-          Flipper.group(name).match?(context.thing, context)
+          context.actors.any? do |actor|
+            Flipper.group(name).match?(actor, context)
+          end
         end
       end
 

data/lib/flipper/gates/percentage_of_actors.rb

@@ -26,13 +26,12 @@ module Flipper
       SCALING_FACTOR = 1_000
       private_constant :SCALING_FACTOR
 
-      # Internal: Checks if the gate is open for a thing.
+      # 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)
-        return false if context.thing.nil?
-
-        id = "#{context.feature_name}#{context.thing.value}"
+        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
 

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

@@ -10,7 +10,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 +20,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,12 +64,27 @@ 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
+
+      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')
+        { bold: true }.freeze
+      else
+        true
+      end
+      private_constant :COLOR_OPTIONS
+
+      def color_name(name)
+        color(name, CYAN, COLOR_OPTIONS)
+      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}"
 

data/lib/flipper/poller.rb

@@ -28,7 +28,7 @@ module Flipper
       @remote_adapter = options.fetch(:remote_adapter)
       @interval = options.fetch(:interval, 10).to_f
       @last_synced_at = Concurrent::AtomicFixnum.new(0)
-      @adapter = Adapters::Memory.new
+      @adapter = Adapters::Memory.new(nil, threadsafe: true)
 
       if @interval < 1
         warn "Flipper::Cloud poll interval must be greater than or equal to 1 but was #{@interval}. Setting @interval to 1."

data/lib/flipper/types/actor.rb

@@ -1,35 +1,35 @@
 module Flipper
   module Types
     class Actor < Type
-      def self.wrappable?(thing)
-        return false if thing.nil?
-        thing.respond_to?(:flipper_id)
+      def self.wrappable?(actor)
+        return false if actor.nil?
+        actor.respond_to?(:flipper_id)
       end
 
-      attr_reader :thing
+      attr_reader :actor
 
-      def initialize(thing)
-        raise ArgumentError, 'thing cannot be nil' if thing.nil?
+      def initialize(actor)
+        raise ArgumentError, 'actor cannot be nil' if actor.nil?
 
-        unless thing.respond_to?(:flipper_id)
-          raise ArgumentError, "#{thing.inspect} must respond to flipper_id, but does not"
+        unless actor.respond_to?(:flipper_id)
+          raise ArgumentError, "#{actor.inspect} must respond to flipper_id, but does not"
         end
 
-        @thing = thing
-        @value = thing.flipper_id.to_s
+        @actor = actor
+        @value = actor.flipper_id.to_s
       end
 
       def respond_to?(*args)
-        super || @thing.respond_to?(*args)
+        super || @actor.respond_to?(*args)
       end
 
       if RUBY_VERSION >= '3.0'
         def method_missing(name, *args, **kwargs, &block)
-          @thing.send name, *args, **kwargs, &block
+          @actor.send name, *args, **kwargs, &block
         end
       else
         def method_missing(name, *args, &block)
-          @thing.send name, *args, &block
+          @actor.send name, *args, &block
         end
       end
     end