flipper 0.26.0 → 0.27.0

data/lib/flipper/adapters/operation_logger.rb

@@ -5,8 +5,8 @@ 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
+      include Flipper::Adapter
 
       class Operation
         attr_reader :type, :args
@@ -18,6 +18,8 @@ module Flipper
       end
 
       OperationTypes = [
+        :import,
+        :export,
         :features,
         :add,
         :remove,
@@ -37,7 +39,6 @@ module Flipper
 
       # Public
       def initialize(adapter, operations = nil)
-        super(adapter)
         @adapter = adapter
         @name = :operation_logger
         @operations = operations || []
@@ -98,6 +99,18 @@ module Flipper
         @adapter.disable(feature, gate, thing)
       end
 
+      # Public
+      def import(source)
+        @operations << Operation.new(:import, [source])
+        @adapter.import(source)
+      end
+
+      # Public
+      def export(format: :json, version: 1)
+        @operations << Operation.new(:export, [format, version])
+        @adapter.export(format: format, version: version)
+      end
+
       # Public: Count the number of times a certain operation happened.
       def count(type)
         type(type).size

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

@@ -1,125 +1,2 @@
-require 'logger'
-require 'concurrent/atomic/read_write_lock'
-require 'concurrent/utility/monotonic_time'
-require 'concurrent/map'
-
-module Flipper
-  module Adapters
-    class Poll
-      class Poller
-        attr_reader :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 {|_,poller| poller.stop }.clear
-        end
-
-        def initialize(options = {})
-          @thread = nil
-          @pid = Process.pid
-          @mutex = Mutex.new
-          @adapter = Memory.new
-          @instrumenter = options.fetch(:instrumenter, Instrumenters::Noop)
-          @remote_adapter = options.fetch(:remote_adapter)
-          @interval = options.fetch(:interval, 10).to_f
-          @lock = Concurrent::ReadWriteLock.new
-          @last_synced_at = Concurrent::AtomicFixnum.new(0)
-
-          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
-
-          @start_automatically = options.fetch(:start_automatically, true)
-
-          if options.fetch(:shutdown_automatically, true)
-            at_exit { stop }
-          end
-        end
-
-        def adapter
-          @lock.with_read_lock { Memory.new(@adapter.get_all.dup) }
-        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
-              @instrumenter.instrument("poller.#{InstrumentationNamespace}", operation: :poll) do
-                adapter = Memory.new
-                adapter.import(@remote_adapter)
-
-                @lock.with_write_lock { @adapter.import(adapter) }
-                @last_synced_at.update { |time| Concurrent.monotonic_time }
-              end
-            rescue => exception
-              # you can instrument these using poller.flipper
-            end
-
-            sleep_interval = interval - (Concurrent.monotonic_time - start)
-            sleep sleep_interval if sleep_interval.positive?
-          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
-  end
-end
+warn "DEPRECATION WARNING: Flipper::Adapters::Poll::Poller is deprecated. Use Flipper::Poller instead."
+require 'flipper/adapters/poll'

data/lib/flipper/adapters/poll.rb

@@ -1,4 +1,5 @@
 require 'flipper/adapters/sync/synchronizer'
+require 'flipper/poller'
 
 module Flipper
   module Adapters
@@ -6,6 +7,9 @@ module Flipper
       extend Forwardable
       include ::Flipper::Adapter
 
+      # Deprecated
+      Poller = ::Flipper::Poller
+
       # Public: The name of the adapter.
       attr_reader :name, :adapter, :poller
 

data/lib/flipper/dsl.rb

@@ -10,7 +10,7 @@ module Flipper
     # Private: What is being used to instrument all the things.
     attr_reader :instrumenter
 
-    def_delegators :@adapter, :memoize=, :memoizing?
+    def_delegators :@adapter, :memoize=, :memoizing?, :import, :export
 
     # Public: Returns a new instance of the DSL.
     #
@@ -272,10 +272,6 @@ module Flipper
       adapter.features.map { |name| feature(name) }.to_set
     end
 
-    def import(flipper)
-      adapter.import(flipper.adapter)
-    end
-
     # Cloud DSL method that does nothing for open source version.
     def sync
     end

data/lib/flipper/export.rb

@@ -0,0 +1,26 @@
+require "flipper/adapters/memory"
+
+module Flipper
+  class Export
+    attr_reader :contents, :format, :version
+
+    def initialize(contents:, format: :json, version: 1)
+      @contents = contents
+      @format = format
+      @version = version
+    end
+
+    def features
+      raise NotImplementedError
+    end
+
+    def adapter
+      @adapter ||= Flipper::Adapters::Memory.new(features)
+    end
+
+    def eql?(other)
+      self.class.eql?(other.class) && @contents == other.contents && @format == other.format && @version == other.version
+    end
+    alias_method :==, :eql?
+  end
+end

data/lib/flipper/exporter.rb

@@ -0,0 +1,17 @@
+require "flipper/exporters/json/v1"
+
+module Flipper
+  module Exporter
+    extend self
+
+    FORMATTERS = {
+      json: {
+        1 => Flipper::Exporters::Json::V1,
+      }
+    }.freeze
+
+    def build(format: :json, version: 1)
+      FORMATTERS.fetch(format).fetch(version).new
+    end
+  end
+end

data/lib/flipper/exporters/json/export.rb

@@ -0,0 +1,32 @@
+require "flipper/export"
+require "flipper/typecast"
+
+module Flipper
+  module Exporters
+    module Json
+      # Raised when the contents of the export are not valid.
+      class InvalidError < StandardError; end
+      class JsonError < InvalidError; end
+
+      # Internal: JSON export class that knows how to build features hash
+      # from data.
+      class Export < ::Flipper::Export
+        def initialize(contents:, version: 1)
+          super contents: contents, version: version, format: :json
+        end
+
+        # Public: The features hash identical to calling get_all on adapter.
+        def features
+          @features ||= begin
+            features = JSON.parse(contents).fetch("features")
+            Typecast.features_hash(features)
+          rescue JSON::ParserError
+            raise JsonError
+          rescue
+            raise InvalidError
+          end
+        end
+      end
+    end
+  end
+end

data/lib/flipper/exporters/json/v1.rb

@@ -0,0 +1,33 @@
+require "json"
+require "flipper/exporters/json/export"
+
+module Flipper
+  module Exporters
+    module Json
+      class V1
+        VERSION = 1
+
+        def call(adapter)
+          features = adapter.get_all
+
+          # Convert sets to arrays for json
+          features.each do |feature_key, gates|
+            gates.each do |key, value|
+              case value
+              when Set
+                features[feature_key][key] = value.to_a
+              end
+            end
+          end
+
+          json = JSON.dump({
+            version: VERSION,
+            features: features,
+          })
+
+          Json::Export.new(contents: json, version: VERSION)
+        end
+      end
+    end
+  end
+end

data/lib/flipper/feature.rb

@@ -100,13 +100,12 @@ module Flipper
     #
     # Returns true if enabled, false if not.
     def enabled?(thing = nil)
-      instrument(:enabled?) do |payload|
-        values = gate_values
-        thing = gate(:actor).wrap(thing) unless thing.nil?
-        payload[:thing] = thing
+      thing = Types::Actor.wrap(thing) unless thing.nil?
+
+      instrument(:enabled?, thing: thing) do |payload|
         context = FeatureCheckContext.new(
           feature_name: @name,
-          values: values,
+          values: gate_values,
           thing: thing
         )
 
@@ -207,7 +206,7 @@ module Flipper
 
       if values.boolean || values.percentage_of_time == 100
         :on
-      elsif non_boolean_gates.detect { |gate| gate.enabled?(values[gate.key]) }
+      elsif non_boolean_gates.detect { |gate| gate.enabled?(values.send(gate.key)) }
         :conditional
       else
         :off
@@ -232,7 +231,8 @@ module Flipper
 
     # Public: Returns the raw gate values stored by the adapter.
     def gate_values
-      GateValues.new(adapter.get(self))
+      adapter_values = adapter.get(self)
+      GateValues.new(adapter_values)
     end
 
     # Public: Get groups enabled for this feature.
@@ -290,7 +290,7 @@ module Flipper
     # Returns an Array of Flipper::Gate instances.
     def enabled_gates
       values = gate_values
-      gates.select { |gate| gate.enabled?(values[gate.key]) }
+      gates.select { |gate| gate.enabled?(values.send(gate.key)) }
     end
 
     # Public: Get the names of the enabled gates.
@@ -339,20 +339,24 @@ module Flipper
     #
     # Returns an array of gates
     def gates
-      @gates ||= [
-        Gates::Boolean.new,
-        Gates::Actor.new,
-        Gates::PercentageOfActors.new,
-        Gates::PercentageOfTime.new,
-        Gates::Group.new,
-      ]
+      @gates ||= gates_hash.values.freeze
+    end
+
+    def gates_hash
+      @gates_hash ||= {
+        boolean: Gates::Boolean.new,
+        actor: Gates::Actor.new,
+        percentage_of_actors: Gates::PercentageOfActors.new,
+        percentage_of_time: Gates::PercentageOfTime.new,
+        group: Gates::Group.new,
+      }.freeze
     end
 
     # Public: Find a gate by name.
     #
     # Returns a Flipper::Gate if found, nil if not.
     def gate(name)
-      gates.detect { |gate| gate.name == name.to_sym }
+      gates_hash[name.to_sym]
     end
 
     # Public: Find the gate that protects a thing.
@@ -368,8 +372,8 @@ module Flipper
     private
 
     # Private: Instrument a feature operation.
-    def instrument(operation)
-      @instrumenter.instrument(InstrumentationName) do |payload|
+    def instrument(operation, initial_payload = {})
+      @instrumenter.instrument(InstrumentationName, initial_payload) do |payload|
         payload[:feature_name] = name
         payload[:operation] = operation
         payload[:result] = yield(payload) if block_given?

data/lib/flipper/feature_check_context.rb

@@ -10,10 +10,10 @@ module Flipper
     # Public: The thing we want to know if a feature is enabled for.
     attr_reader :thing
 
-    def initialize(options = {})
-      @feature_name = options.fetch(:feature_name)
-      @values = options.fetch(:values)
-      @thing = options.fetch(:thing)
+    def initialize(feature_name:, values:, thing:)
+      @feature_name = feature_name
+      @values = values
+      @thing = thing
     end
 
     # Public: Convenience method for groups value like Feature has.

data/lib/flipper/gate_values.rb

@@ -3,16 +3,6 @@ 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
@@ -27,12 +17,6 @@ module Flipper
       @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
-    end
-
     def eql?(other)
       self.class.eql?(other.class) &&
         boolean == other.boolean &&

data/lib/flipper/gates/actor.rb

@@ -23,18 +23,8 @@ 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
-          if protects?(context.thing)
-            actor = wrap(context.thing)
-            enabled_actor_ids = value
-            enabled_actor_ids.include?(actor.value)
-          else
-            false
-          end
-        end
+        return false if context.thing.nil?
+        context.values.actors.include?(context.thing.value)
       end
 
       def wrap(thing)

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/group.rb

@@ -23,14 +23,10 @@ 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)
-          end
+        return false if context.thing.nil?
+
+        context.values.groups.any? do |name|
+          Flipper.group(name).match?(context.thing, context)
         end
       end
 

data/lib/flipper/gates/percentage_of_actors.rb

@@ -21,21 +21,19 @@ module Flipper
         value > 0
       end
 
+      # 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 a thing.
       #
       # Returns true if gate open for thing, 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 if context.thing.nil?
+
+        id = "#{context.feature_name}#{context.thing.value}"
+        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/instrumentation/subscriber.rb

@@ -72,6 +72,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/poller.rb

@@ -0,0 +1,117 @@
+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 {|_,poller| poller.stop }.clear
+    end
+
+    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
+
+      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
+
+      @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 = interval - (Concurrent.monotonic_time - start)
+        sleep sleep_interval if sleep_interval.positive?
+      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