Poll Memoizer

lib/flipper.rb

@@ -178,6 +178,7 @@ def groups_registry=(registry)
 require 'flipper/adapters/memory'
 require 'flipper/adapters/strict'
 require 'flipper/adapters/instrumented'
+require 'flipper/adapters/poll'
 require 'flipper/adapter_builder'
 require 'flipper/configuration'
 require 'flipper/dsl'
@@ -189,6 +190,7 @@ def groups_registry=(registry)
 require 'flipper/identifier'
 require 'flipper/middleware/memoizer'
 require 'flipper/middleware/setup_env'
+require 'flipper/middleware/sync'
 require 'flipper/poller'
 require 'flipper/registry'
 require 'flipper/expression'

lib/flipper/adapters/poll.rb

@@ -1,36 +1,64 @@
-require 'flipper/adapters/sync/synchronizer'
+require 'flipper/adapters/dual_write'
 require 'flipper/poller'
 
 module Flipper
  module Adapters
- class Poll
- extend Forwardable
- include ::Flipper::Adapter
+ # An adapter that keeps a local and remote adapter in sync via a background poller.
+ #
+ # Synchronization is performed when the adapter is accessed if the background
+ # poller has synced.
+ class Poll < DualWrite
+ # Public: The Poller used to sync in a background thread.
+ attr_reader :poller
 
- # 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
+ # Instantiate a new Poll adapter.
+ #
+ # local = Flipper::Adapters::ActiveRecord.new
+ # remote = Flipper::Adapters::Http.new(url: 'http://example.com/flipper')
+ # adapter = Flipper::Adapters::Poll.new(local, remote, key: 'unique_poller_name', interval: 5)
+ #
+ # local - Local adapter that will be used for reads and gets synchronized on an interval.
+ # remote - Remote adapter that will be polled on an interval.
+ # key: The key used to identify the poller.
+ # **options: Options to pass to the poller. See Flipper::Poller for options.
+ def initialize(local, remote, key:, **options)
+ super(local, remote)
+ @name = :poll
+ @poller = Flipper::Poller.get(key, remote, options).tap(&:start)
  @last_synced_at = 0
- @poller.start
+ @sync_automatically = true
  end
 
- private
+ # Public: Synchronizes the local adapter with the current state of the remote adapter.
+ # If given a block, the adapter will be synced once and then not synced again for the
+ # duration of the block.
+ #
+ # poll = Flipper::Adapters::Poll.new(local, remote)
+ # poll.sync do
+ # # Long running operation that doesn't need to be synced
+ # end
+ def sync
+ if @sync_automatically
+ poller_last_synced_at = @poller.last_synced_at.value
+ if poller_last_synced_at > @last_synced_at
+ @local.import(@poller.adapter)
+ @last_synced_at = poller_last_synced_at
+ end
+ end
+ if block_given?
+ begin
+ sync_automatically_was, @sync_automatically = @sync_automatically, false
+ yield
+ ensure
+ @sync_automatically = sync_automatically_was
+ end
+ end
+ end
 
- 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
+ %i[features get get_multi get_all add remove clear enable disable].each do |method|
+ define_method(method) do |*args|
+ sync { super(*args) }
  end
- @adapter
  end
  end
  end

lib/flipper/adapters/poll/poller.rb

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

lib/flipper/cloud/configuration.rb

@@ -2,7 +2,6 @@
 require "socket"
 require "flipper/adapters/http"
 require "flipper/adapters/poll"
-require "flipper/poller"
 require "flipper/adapters/memory"
 require "flipper/adapters/dual_write"
 require "flipper/adapters/sync/synchronizer"
@@ -38,6 +37,9 @@ class Configuration
  # Public: net/http write timeout for all http requests (default: 5).
  attr_accessor :write_timeout
 
+ # Public: Memoize adapter operations. Defaults to true.
+ attr_accessor :memoize
+
  # Public: IO stream to send debug output too. Off by default.
  #
  # # for example, this would send all http request information to STDOUT
@@ -138,20 +140,19 @@ def log(message, level: :debug)
  private
 
  def app_adapter
- read_adapter = sync_method == :webhook ? local_adapter : poll_adapter
- Flipper::Adapters::DualWrite.new(read_adapter, http_adapter)
+ if sync_method == :webhook
+ Flipper::Adapters::DualWrite.new(local_adapter, http_adapter)
+ else
+ poll_adapter
+ end
  end
 
- def poller
- Flipper::Poller.get(@url + @token, {
+ def poll_adapter
+ Flipper::Adapters::Poll.new(local_adapter, http_adapter,
+ key: @url + @token,
  interval: sync_interval,
- remote_adapter: http_adapter,
  instrumenter: instrumenter,
- }).tap(&:start)
- end
-
- def poll_adapter
- Flipper::Adapters::Poll.new(poller, local_adapter)
+ )
  end
 
  def http_adapter
@@ -197,6 +198,7 @@ def setup_sync(options)
  end
 
  def setup_adapter(options)
+ set_option :memoize, options, default: true
  set_option :local_adapter, options, default: -> { Adapters::Memory.new }, from_env: false
  @adapter_block = ->(adapter) { adapter }
  end

lib/flipper/cloud/dsl.rb

@@ -7,7 +7,10 @@ class DSL < SimpleDelegator
 
  def initialize(cloud_configuration)
  @cloud_configuration = cloud_configuration
- super Flipper.new(@cloud_configuration.adapter, instrumenter: @cloud_configuration.instrumenter)
+ super Flipper.new(@cloud_configuration.adapter,
+ instrumenter: @cloud_configuration.instrumenter,
+ memoize: @cloud_configuration.memoize
+ )
  end
 
  def sync

lib/flipper/dsl.rb

@@ -21,8 +21,21 @@ class DSL
  def initialize(adapter, options = {})
  @instrumenter = options.fetch(:instrumenter, Instrumenters::Noop)
  memoize = options.fetch(:memoize, true)
- adapter = Adapters::Memoizable.new(adapter) if memoize
- @adapter = adapter
+ @adapter = if memoize == :poll
+ Adapters::Poll.new(Adapters::Memory.new, adapter,
+ key: 'memoizer',
+ interval: 5,
+ instrumenter: @instrumenter
+ ).tap do |poll|
+ # Force poller to sync in current thread now
+ poll.poller.sync
+ end
+ elsif memoize
+ Adapters::Memoizable.new(adapter)
+ else
+ adapter
+ end
+
  @memoized_features = {}
  end
 

lib/flipper/engine.rb

@@ -37,10 +37,14 @@ class Engine < Rails::Engine
  if cloud?
  Flipper::Cloud.new(
  local_adapter: config.adapter,
- instrumenter: app.config.flipper.instrumenter
+ instrumenter: app.config.flipper.instrumenter,
+ memoize: app.config.flipper.memoize
  )
  else
- Flipper.new(config.adapter, instrumenter: app.config.flipper.instrumenter)
+ Flipper.new(config.adapter, {
+ instrumenter: app.config.flipper.instrumenter,
+ memoize: app.config.flipper.memoize,
+ })
  end
  end
  end
@@ -57,7 +61,9 @@ class Engine < Rails::Engine
  initializer "flipper.memoizer", after: :load_config_initializers do |app|
  flipper = app.config.flipper
 
- if flipper.memoize
+ if flipper.memoize == :poll
+ app.middleware.use Flipper::Middleware::Sync
+ elsif flipper.memoize
  app.middleware.use Flipper::Middleware::Memoizer, {
  env_key: flipper.env_key,
  preload: flipper.preload,

lib/flipper/middleware/memoizer.rb

@@ -51,7 +51,11 @@ def call(env)
  private
 
  def memoize?(request)
- if @opts[:if]
+ flipper = request.env.fetch(@env_key) { Flipper }
+
+ if !flipper.adapter.is_a?(Flipper::Adapters::Memoizable)
+ return false
+ elsif @opts[:if]
  @opts[:if].call(request)
  elsif @opts[:unless]
  !@opts[:unless].call(request)

lib/flipper/middleware/sync.rb

@@ -0,0 +1,19 @@
+module Flipper
+ module Middleware
+ class Sync
+ def initialize(app, options = {})
+ @app = app
+ @env_key = options.fetch(:env_key, 'flipper')
+ end
+
+ def call(env)
+ flipper = env.fetch(@env_key) { Flipper }
+ if flipper.adapter.respond_to?(:sync)
+ flipper.adapter.sync { @app.call(env) }
+ else
+ @app.call(env)
+ end
+ end
+ end
+ end
+end

lib/flipper/poller.rb

@@ -12,34 +12,32 @@ def self.instances
  end
  private_class_method :instances
 
- def self.get(key, options = {})
- instances.compute_if_absent(key) { new(options) }
+ def self.get(key, *args)
+ instances.compute_if_absent(key) { new(*args) }
  end
 
  def self.reset
  instances.each {|_, instance| instance.stop }.clear
  end
 
- def initialize(options = {})
- @thread = nil
- @pid = Process.pid
- @mutex = Mutex.new
+ def initialize(remote_adapter, options = {})
+ @remote_adapter = remote_adapter
  @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 < 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)
+ @thread = nil
+ @pid = Process.pid
+ @mutex = Mutex.new
+ @last_synced_at = Concurrent::AtomicFixnum.new(0)
+ @adapter = Adapters::Memory.new
 
- if options.fetch(:shutdown_automatically, true)
- at_exit { stop }
- end
+ start if options.fetch(:start_automatically, true)
+ at_exit { stop } if options.fetch(:shutdown_automatically, true)
  end
 
  def start

spec/flipper/adapters/poll_spec.rb

@@ -0,0 +1,66 @@
+require 'flipper/adapters/poll'
+require 'flipper/adapters/operation_logger'
+require 'active_support/notifications'
+
+RSpec.describe Flipper::Adapters::Poll do
+ let(:remote_adapter) do
+ Flipper::Adapters::OperationLogger.new Flipper::Adapters::Memory.new
+ end
+ let(:local_adapter) do
+ Flipper::Adapters::OperationLogger.new Flipper::Adapters::Memory.new
+ end
+ let(:local) { Flipper.new(local_adapter) }
+ let(:remote) { Flipper.new(remote_adapter) }
+ let(:poll) { Flipper.new(subject) }
+
+ subject do
+ described_class.new(local_adapter, remote_adapter, key: 'test', start_automatically: false)
+ end
+
+ it_should_behave_like 'a flipper adapter'
+
+ it 'syncs features when poller has been synced' do
+ remote.enable(:search)
+
+ subject.poller.sync # sync poller from remote
+
+ expect(subject.poller.adapter).to receive(:get_all).and_call_original
+ expect(poll[:search].boolean_value).to be(true)
+ expect(subject.features.sort).to eq(%w(search))
+ end
+
+ it 'writes to both local and remote' do
+ poll.enable(:search)
+
+ expect(local[:search].boolean_value).to be(true)
+ expect(remote[:search].boolean_value).to be(true)
+ end
+
+ it 'does not sync features with poller has not been synced' do
+ # Perform initial sync
+ subject.poller.sync
+ subject.features
+
+ # Remote feature enabled, but poller has not synced yet
+ remote.enable(:search)
+ expect(subject.poller.adapter).to_not receive(:get_all)
+
+ expect(subject.features.sort).to eq(%w())
+ end
+
+ describe '#sync' do
+ it "performs initial sync and then does not sync during block" do
+ remote.enable(:search)
+ subject.poller.sync # Sync poller
+
+ subject.sync do
+ expect(poll[:search].boolean_value).to be(true)
+
+ remote.enable(:stats)
+ subject.poller.sync # Sync poller
+
+ expect(poll[:stats].boolean_value).to be(false)
+ end
+ end
+ end
+end

spec/flipper/cloud/configuration_spec.rb

@@ -77,7 +77,7 @@
  stub_request(:get, /flippercloud\.io/).to_return(status: 200, body: "{}")
 
  instance = described_class.new(required_options.merge(sync_interval: 20))
- poller = instance.send(:poller)
+ poller = instance.send(:poll_adapter).poller
  expect(poller.interval).to eq(20)
  end
 
@@ -91,7 +91,7 @@
  stub_request(:get, /flippercloud\.io/).to_return(status: 200, body: "{}")
 
  instance = described_class.new(required_options)
- expect(instance.adapter).to be_instance_of(Flipper::Adapters::DualWrite)
+ expect(instance.adapter).to be_instance_of(Flipper::Adapters::Poll)
  end
 
  it "can override adapter block" do