flipper 0.16.0 → 1.4.0

data/lib/flipper/adapters/memoizable.rb

@@ -5,39 +5,28 @@ module Flipper
     # Internal: Adapter that wraps another adapter with the ability to memoize
     # adapter calls in memory. Used by flipper dsl and the memoizer middleware
     # to make it possible to memoize adapter calls for the duration of a request.
-    class Memoizable < SimpleDelegator
+    class Memoizable
       include ::Flipper::Adapter
 
-      FeaturesKey = :flipper_features
-      GetAllKey = :all_memoized
-
       # Internal
       attr_reader :cache
 
-      # Public: The name of the adapter.
-      attr_reader :name
-
       # Internal: The adapter this adapter is wrapping.
       attr_reader :adapter
 
-      # Private
-      def self.key_for(key)
-        "feature/#{key}"
-      end
-
       # Public
       def initialize(adapter, cache = nil)
-        super(adapter)
         @adapter = adapter
-        @name = :memoizable
         @cache = cache || {}
         @memoize = false
+        @features_key = :flipper_features
+        @get_all_key = :all_memoized
       end
 
       # Public
       def features
         if memoizing?
-          cache.fetch(FeaturesKey) { cache[FeaturesKey] = @adapter.features }
+          cache.fetch(@features_key) { cache[@features_key] = @adapter.features }
         else
           @adapter.features
         end
@@ -45,24 +34,20 @@ module Flipper
 
       # Public
       def add(feature)
-        result = @adapter.add(feature)
-        expire_features_set
-        result
+        @adapter.add(feature).tap { expire_features_set }
       end
 
       # Public
       def remove(feature)
-        result = @adapter.remove(feature)
-        expire_features_set
-        expire_feature(feature)
-        result
+        @adapter.remove(feature).tap do
+          expire_features_set
+          expire_feature(feature)
+        end
       end
 
       # Public
       def clear(feature)
-        result = @adapter.clear(feature)
-        expire_feature(feature)
-        result
+        @adapter.clear(feature).tap { expire_feature(feature) }
       end
 
       # Public
@@ -96,21 +81,21 @@ module Flipper
         end
       end
 
-      def get_all
+      def get_all(**kwargs)
         if memoizing?
           response = nil
-          if cache[GetAllKey]
+          if cache[@get_all_key]
             response = {}
-            cache[FeaturesKey].each do |key|
+            cache[@features_key].each do |key|
               response[key] = cache[key_for(key)]
             end
           else
-            response = @adapter.get_all
+            response = @adapter.get_all(**kwargs)
             response.each do |key, value|
               cache[key_for(key)] = value
             end
-            cache[FeaturesKey] = response.keys.to_set
-            cache[GetAllKey] = true
+            cache[@features_key] = response.keys.to_set
+            cache[@get_all_key] = true
           end
 
           # Ensures that looking up other features that do not exist doesn't
@@ -118,22 +103,31 @@ module Flipper
           response.default_proc = ->(memo, key) { memo[key] = default_config }
           response
         else
-          @adapter.get_all
+          @adapter.get_all(**kwargs)
         end
       end
 
       # Public
       def enable(feature, gate, thing)
-        result = @adapter.enable(feature, gate, thing)
-        expire_feature(feature)
-        result
+        @adapter.enable(feature, gate, thing).tap { expire_feature(feature) }
       end
 
       # Public
       def disable(feature, gate, thing)
-        result = @adapter.disable(feature, gate, thing)
-        expire_feature(feature)
-        result
+        @adapter.disable(feature, gate, thing).tap { expire_feature(feature) }
+      end
+
+      # Public
+      def read_only?
+        @adapter.read_only?
+      end
+
+      def import(source)
+        @adapter.import(source).tap { cache.clear if memoizing? }
+      end
+
+      def export(format: :json, version: 1)
+        @adapter.export(format: format, version: version)
       end
 
       # Internal: Turns local caching on/off.
@@ -149,10 +143,20 @@ module Flipper
         !!@memoize
       end
 
+      if RUBY_VERSION >= '3.0'
+        def method_missing(name, *args, **kwargs, &block)
+          @adapter.send name, *args, **kwargs, &block
+        end
+      else
+        def method_missing(name, *args, &block)
+          @adapter.send name, *args, &block
+        end
+      end
+
       private
 
       def key_for(key)
-        self.class.key_for(key)
+        "feature/#{key}"
       end
 
       def expire_feature(feature)
@@ -160,7 +164,7 @@ module Flipper
       end
 
       def expire_features_set
-        cache.delete(FeaturesKey) if memoizing?
+        cache.delete(@features_key) if memoizing?
       end
     end
   end

data/lib/flipper/adapters/memory.rb

@@ -1,95 +1,106 @@
-require 'set'
+require "flipper/adapter"
+require "flipper/typecast"
 
 module Flipper
   module Adapters
-    # Public: Adapter for storing everything in memory (ie: Hash).
+    # Public: Adapter for storing everything in memory.
     # Useful for tests/specs.
     class Memory
       include ::Flipper::Adapter
 
-      FeaturesKey = :features
-
-      # Public: The name of the adapter.
-      attr_reader :name
-
       # Public
-      def initialize(source = nil)
-        @source = source || {}
-        @name = :memory
+      def initialize(source = nil, threadsafe: true)
+        @source = Typecast.features_hash(source)
+        @lock = Mutex.new if threadsafe
+        reset
       end
 
       # Public: The set of known features.
       def features
-        read_feature_keys
+        synchronize { @source.keys }.to_set
       end
 
       # Public: Adds a feature to the set of known features.
       def add(feature)
-        features.add(feature.key)
+        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)
-        features.delete(feature.name.to_s)
-        clear(feature)
+        synchronize { @source.delete(feature.key) }
         true
       end
 
       # Public: Clears all the gate values for a feature.
       def clear(feature)
-        feature.gates.each do |gate|
-          delete key(feature, gate)
-        end
+        synchronize { @source[feature.key] = default_config }
         true
       end
 
       # Public
       def get(feature)
-        read_feature(feature)
+        synchronize { @source[feature.key] } || default_config
       end
 
       def get_multi(features)
-        read_many_features(features)
-      end
-
-      def get_all
-        features = read_feature_keys.map do |key|
-          Flipper::Feature.new(key, self)
+        synchronize do
+          result = {}
+          features.each do |feature|
+            result[feature.key] = @source[feature.key] || default_config
+          end
+          result
         end
+      end
 
-        read_many_features(features)
+      def get_all(**kwargs)
+        synchronize { Typecast.features_hash(@source) }
       end
 
       # Public
       def enable(feature, gate, thing)
-        case gate.data_type
-        when :boolean, :integer
-          write key(feature, gate), thing.value.to_s
-        when :set
-          set_add key(feature, gate), thing.value.to_s
-        else
-          raise "#{gate} is not supported by this adapter yet"
+        synchronize do
+          @source[feature.key] ||= default_config
+
+          case gate.data_type
+          when :boolean
+            @source[feature.key] = default_config
+            @source[feature.key][gate.key] = thing.value.to_s
+          when :integer
+            @source[feature.key][gate.key] = thing.value.to_s
+          when :set
+            @source[feature.key][gate.key] << thing.value.to_s
+          when :json
+            @source[feature.key][gate.key] = thing.value
+          else
+            raise "#{gate} is not supported by this adapter yet"
+          end
+
+          true
         end
-
-        true
       end
 
       # Public
       def disable(feature, gate, thing)
-        case gate.data_type
-        when :boolean
-          clear(feature)
-        when :integer
-          write key(feature, gate), thing.value.to_s
-        when :set
-          set_delete key(feature, gate), thing.value.to_s
-        else
-          raise "#{gate} is not supported by this adapter yet"
+        synchronize do
+          @source[feature.key] ||= default_config
+
+          case gate.data_type
+          when :boolean
+            @source[feature.key] = default_config
+          when :integer
+            @source[feature.key][gate.key] = thing.value.to_s
+          when :set
+            @source[feature.key][gate.key].delete thing.value.to_s
+          when :json
+            @source[feature.key].delete(gate.key)
+          else
+            raise "#{gate} is not supported by this adapter yet"
+          end
+
+          true
         end
-
-        true
       end
 
       # Public
@@ -101,79 +112,32 @@ module Flipper
         "#<#{self.class.name}:#{object_id} #{attributes.join(', ')}>"
       end
 
-      private
-
-      def read_feature_keys
-        set_members(FeaturesKey)
-      end
-
-      # Private
-      def key(feature, gate)
-        "feature/#{feature.key}/#{gate.key}"
-      end
-
-      def read_many_features(features)
-        result = {}
-        features.each do |feature|
-          result[feature.key] = read_feature(feature)
-        end
-        result
-      end
-
-      def read_feature(feature)
-        result = {}
-
-        feature.gates.each do |gate|
-          result[gate.key] =
-            case gate.data_type
-            when :boolean, :integer
-              read key(feature, gate)
-            when :set
-              set_members key(feature, gate)
-            else
-              raise "#{gate} is not supported by this adapter yet"
-            end
-        end
-
-        result
-      end
-
-      # Private
-      def read(key)
-        @source[key.to_s]
-      end
-
-      # Private
-      def write(key, value)
-        @source[key.to_s] = value.to_s
-      end
-
-      # Private
-      def delete(key)
-        @source.delete(key.to_s)
+      # Public: a more efficient implementation of import for this adapter
+      def import(source)
+        adapter = self.class.from(source)
+        get_all = Typecast.features_hash(adapter.get_all)
+        synchronize { @source.replace(get_all) }
+        true
       end
 
-      # Private
-      def set_add(key, value)
-        ensure_set_initialized(key)
-        @source[key.to_s].add(value.to_s)
-      end
+      private
 
-      # Private
-      def set_delete(key, value)
-        ensure_set_initialized(key)
-        @source[key.to_s].delete(value.to_s)
+      def reset
+        @pid = Process.pid
+        @lock&.unlock if @lock&.locked?
       end
 
-      # Private
-      def set_members(key)
-        ensure_set_initialized(key)
-        @source[key.to_s]
+      def forked?
+        @pid != Process.pid
       end
 
-      # Private
-      def ensure_set_initialized(key)
-        @source[key.to_s] ||= Set.new
+      def synchronize(&block)
+        if @lock
+          reset if forked?
+          @lock.synchronize(&block)
+        else
+          block.call
+        end
       end
     end
   end

data/lib/flipper/adapters/operation_logger.rb

@@ -5,102 +5,34 @@ module Flipper
     # Public: Adapter that wraps another adapter and stores the operations.
     #
     # Useful in tests to verify calls and such. Never use outside of testing.
-    class OperationLogger < SimpleDelegator
-      include ::Flipper::Adapter
+    class OperationLogger < Wrapper
 
       class Operation
-        attr_reader :type, :args
+        attr_reader :type, :args, :kwargs
 
-        def initialize(type, args)
+        def initialize(type, args, kwargs = {})
           @type = type
           @args = args
+          @kwargs = kwargs
         end
       end
 
-      OperationTypes = [
-        :features,
-        :add,
-        :remove,
-        :clear,
-        :get,
-        :get_multi,
-        :get_all,
-        :enable,
-        :disable,
-      ].freeze
-
       # Internal: An array of the operations that have happened.
       attr_reader :operations
 
-      # Internal: The name of the adapter.
-      attr_reader :name
-
       # Public
       def initialize(adapter, operations = nil)
         super(adapter)
-        @adapter = adapter
-        @name = :operation_logger
         @operations = operations || []
       end
 
-      # Public: The set of known features.
-      def features
-        @operations << Operation.new(:features, [])
-        @adapter.features
-      end
-
-      # Public: Adds a feature to the set of known features.
-      def add(feature)
-        @operations << Operation.new(:add, [feature])
-        @adapter.add(feature)
-      end
-
-      # Public: Removes a feature from the set of known features and clears
-      # all the values for the feature.
-      def remove(feature)
-        @operations << Operation.new(:remove, [feature])
-        @adapter.remove(feature)
-      end
-
-      # Public: Clears all the gate values for a feature.
-      def clear(feature)
-        @operations << Operation.new(:clear, [feature])
-        @adapter.clear(feature)
-      end
-
-      # Public
-      def get(feature)
-        @operations << Operation.new(:get, [feature])
-        @adapter.get(feature)
-      end
-
-      # Public
-      def get_multi(features)
-        @operations << Operation.new(:get_multi, [features])
-        @adapter.get_multi(features)
-      end
-
-      # Public
-      def get_all
-        @operations << Operation.new(:get_all, [])
-        @adapter.get_all
-      end
-
-      # Public
-      def enable(feature, gate, thing)
-        @operations << Operation.new(:enable, [feature, gate, thing])
-        @adapter.enable(feature, gate, thing)
-      end
-
-      # Public
-      def disable(feature, gate, thing)
-        @operations << Operation.new(:disable, [feature, gate, thing])
-        @adapter.disable(feature, gate, thing)
-      end
-
       # Public: Count the number of times a certain operation happened.
-      def count(type)
-        type(type).size
+      def count(type = nil)
+        if type
+          type(type).size
+        else
+          @operations.size
+        end
       end
 
       # Public: Get all operations of a certain type.
@@ -117,6 +49,18 @@ module Flipper
       def reset
         @operations.clear
       end
+
+      def inspect
+        inspect_id = ::Kernel::format "%x", (object_id * 2)
+        %(#<#{self.class}:0x#{inspect_id} @name=#{name.inspect}, @operations=#{@operations.inspect}, @adapter=#{@adapter.inspect}>)
+      end
+
+      private
+
+      def wrap(method, *args, **kwargs, &block)
+        @operations << Operation.new(method, args, kwargs)
+        block.call
+      end
     end
   end
 end

data/lib/flipper/adapters/poll/poller.rb

@@ -0,0 +1,2 @@
+warn "DEPRECATION WARNING: Flipper::Adapters::Poll::Poller is deprecated. Use Flipper::Poller instead."
+require 'flipper/adapters/poll'

data/lib/flipper/adapters/poll.rb

@@ -0,0 +1,52 @@
+require 'flipper/adapters/sync/synchronizer'
+require 'flipper/poller'
+
+module Flipper
+  module Adapters
+    class Poll
+      extend Forwardable
+      include ::Flipper::Adapter
+
+      # Deprecated
+      Poller = ::Flipper::Poller
+
+      attr_reader :adapter, :poller
+
+      def_delegators :synced_adapter, :features, :get, :get_multi, :get_all, :add, :remove, :clear, :enable, :disable
+
+      def initialize(poller, adapter)
+        @adapter = adapter
+        @poller = poller
+        @last_synced_at = 0
+
+        # If the adapter is empty, we need to sync before starting the poller.
+        # Yes, this will block the main thread, but that's better than thinking
+        # nothing is enabled.
+        if adapter.features.empty?
+          begin
+            @poller.sync
+          rescue
+            # TODO: Warn here that it's possible that no data has been synced
+            # and flags are being evaluated without flag data being present
+            # until a sync completes. We rescue to avoid flipper being down
+            # causing your processes to crash.
+          end
+        end
+
+        @poller.start
+      end
+
+      private
+
+      def synced_adapter
+        @poller.start
+        poller_last_synced_at = @poller.last_synced_at.value
+        if poller_last_synced_at > @last_synced_at
+          Flipper::Adapters::Sync::Synchronizer.new(@adapter, @poller.adapter).call
+          @last_synced_at = poller_last_synced_at
+        end
+        @adapter
+      end
+    end
+  end
+end