flipper 1.3.6 → 1.4.2

data/lib/flipper/expressions/time.rb

@@ -1,8 +1,15 @@
+require "time"
+
 module Flipper
   module Expressions
     class Time
       def self.call(value)
-        ::Time.parse(value)
+        case value
+        when Numeric
+          ::Time.at(value).utc
+        else
+          ::Time.parse(value).utc
+        end
       end
     end
   end

data/lib/flipper/gates/expression.rb

@@ -30,10 +30,10 @@ module Flipper
         expression = Flipper::Expression.build(data)
 
         if context.actors.nil? || context.actors.empty?
-          !!expression.evaluate(feature_name: context.feature_name, properties: DEFAULT_PROPERTIES)
+          !!expression.evaluate(feature_name: context.feature_name, properties: DEFAULT_PROPERTIES, actor: nil)
         else
           context.actors.any? do |actor|
-            !!expression.evaluate(feature_name: context.feature_name, properties: properties(actor))
+            !!expression.evaluate(feature_name: context.feature_name, properties: properties(actor), actor: actor)
           end
         end
       end

data/lib/flipper/poller.rb

@@ -2,6 +2,7 @@ require 'logger'
 require 'concurrent/utility/monotonic_time'
 require 'concurrent/map'
 require 'concurrent/atomic/atomic_fixnum'
+require 'concurrent/atomic/atomic_boolean'
 
 module Flipper
   class Poller
@@ -17,7 +18,10 @@ module Flipper
     end
 
     def self.reset
-      instances.each {|_, instance| instance.stop }.clear
+      instances.each do |_, instance|
+        instance.stop
+        instance.thread&.join(1)
+      end.clear
     end
 
     MINIMUM_POLL_INTERVAL = 10
@@ -28,14 +32,12 @@ module Flipper
       @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)
+      @shutdown_requested = Concurrent::AtomicBoolean.new(false)
 
-      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
+      self.interval = options.fetch(:interval, 10)
+      @initial_interval = @interval
 
       @start_automatically = options.fetch(:start_automatically, true)
 
@@ -46,6 +48,7 @@ module Flipper
 
     def start
       reset if forked?
+      return if @shutdown_requested.true?
       ensure_worker_running
     end
 
@@ -72,9 +75,25 @@ module Flipper
 
     def sync
       @instrumenter.instrument("poller.#{InstrumentationNamespace}", operation: :poll) do
-        @adapter.import @remote_adapter
-        @last_synced_at.update { |time| Concurrent.monotonic_time }
+        begin
+          @adapter.import @remote_adapter
+          @last_synced_at.update { |time| Concurrent.monotonic_time }
+        ensure
+          apply_response_headers
+        end
+      end
+    end
+
+    # Internal: Sets the interval in seconds for how often to poll.
+    def interval=(value)
+      requested_interval = Flipper::Typecast.to_float(value)
+      new_interval = [requested_interval, MINIMUM_POLL_INTERVAL].max
+
+      if requested_interval < MINIMUM_POLL_INTERVAL
+        warn "Flipper::Cloud poll interval must be greater than or equal to #{MINIMUM_POLL_INTERVAL} but was #{requested_interval}. Setting interval to #{MINIMUM_POLL_INTERVAL}."
       end
+
+      @interval = new_interval
     end
 
     private
@@ -98,6 +117,7 @@ module Flipper
       begin
         return if thread_alive?
         @thread = Thread.new { run }
+        @thread&.report_on_exception = false
         @instrumenter.instrument("poller.#{InstrumentationNamespace}", {
           operation: :thread_start,
         })
@@ -112,7 +132,28 @@ module Flipper
 
     def reset
       @pid = Process.pid
+      @shutdown_requested.make_false
       mutex.unlock if mutex.locked?
     end
+
+    def apply_response_headers
+      return unless @remote_adapter.respond_to?(:last_get_all_response)
+
+      if response = @remote_adapter.last_get_all_response
+        # shutdown based on response header
+        if Flipper::Typecast.to_boolean(response["poll-shutdown"])
+          @shutdown_requested.make_true
+          @instrumenter.instrument("poller.#{InstrumentationNamespace}", {
+            operation: :shutdown_requested,
+          })
+          stop
+        end
+
+        # update interval based on response header
+        if interval = response["poll-interval"]
+          self.interval = [Flipper::Typecast.to_float(interval), @initial_interval].max
+        end
+      end
+    end
   end
 end

data/lib/flipper/version.rb

@@ -1,5 +1,5 @@
 module Flipper
-  VERSION = '1.3.6'.freeze
+  VERSION = '1.4.2'.freeze
 
   REQUIRED_RUBY_VERSION = '2.6'.freeze
   NEXT_REQUIRED_RUBY_VERSION = '3.0'.freeze

data/lib/flipper.rb

@@ -64,7 +64,7 @@ module Flipper
                  :enable_percentage_of_actors, :disable_percentage_of_actors,
                  :enable_percentage_of_time, :disable_percentage_of_time,
                  :features, :feature, :[], :preload, :preload_all,
-                 :adapter, :add, :exist?, :remove, :import, :export,
+                 :adapter, :adapter_stack, :add, :exist?, :remove, :import, :export,
                  :memoize=, :memoizing?, :read_only?,
                  :sync, :sync_secret # For Flipper::Cloud. Will error for OSS Flipper.
 
@@ -100,6 +100,22 @@ module Flipper
     Expression.build({ Random: max })
   end
 
+  def now
+    Expression.build({ Now: [] })
+  end
+
+  def time(value)
+    Expression.build({ Time: value })
+  end
+
+  def feature_enabled(name)
+    Expression.build({ FeatureEnabled: name })
+  end
+
+  def feature_disabled(name)
+    feature_enabled(name).eq(false)
+  end
+
   # Public: Use this to register a group by name.
   #
   # name - The Symbol name of the group.

data/spec/flipper/adapter_spec.rb

@@ -143,4 +143,24 @@ RSpec.describe Flipper::Adapter do
       expect(export.features.dig("search", :boolean)).to eq("true")
     end
   end
+
+  describe "#adapter_stack" do
+    it "returns the adapter name for a simple adapter" do
+      adapter = Flipper::Adapters::Memory.new
+      expect(adapter.adapter_stack).to eq("memory")
+    end
+
+    it "returns the chain for wrapped adapters" do
+      memory = Flipper::Adapters::Memory.new
+      memoizable = Flipper::Adapters::Memoizable.new(memory)
+      expect(memoizable.adapter_stack).to eq("memoizable -> memory")
+    end
+
+    it "returns the chain for deeply nested adapters" do
+      memory = Flipper::Adapters::Memory.new
+      strict = Flipper::Adapters::Strict.new(memory)
+      memoizable = Flipper::Adapters::Memoizable.new(strict)
+      expect(memoizable.adapter_stack).to eq("memoizable -> strict -> memory")
+    end
+  end
 end

data/spec/flipper/adapters/actor_limit_spec.rb

@@ -15,6 +15,61 @@ RSpec.describe Flipper::Adapters::ActorLimit do
           feature.enable Flipper::Actor.new("User;6")
         }.to raise_error(Flipper::Adapters::ActorLimit::LimitExceeded)
       end
+
+      it "allows exceeding limit when in sync mode" do
+        5.times { |i| feature.enable Flipper::Actor.new("User;#{i}") }
+
+        described_class.with_sync_mode do
+          expect {
+            feature.enable Flipper::Actor.new("User;6")
+          }.not_to raise_error
+        end
+      end
+    end
+  end
+
+  describe '.sync_mode' do
+    after do
+      described_class.sync_mode = nil
+    end
+
+    it 'defaults to nil/falsy' do
+      expect(described_class.sync_mode).to be_falsy
+    end
+
+    it 'can be set and read' do
+      described_class.sync_mode = true
+      expect(described_class.sync_mode).to be true
+    end
+  end
+
+  describe '.with_sync_mode' do
+    after do
+      described_class.sync_mode = nil
+    end
+
+    it 'sets sync_mode to true within block' do
+      described_class.with_sync_mode do
+        expect(described_class.sync_mode).to be true
+      end
+    end
+
+    it 'restores previous value after block' do
+      expect(described_class.sync_mode).to be_falsy
+      described_class.with_sync_mode { }
+      expect(described_class.sync_mode).to be_falsy
+    end
+
+    it 'restores previous value even on exception' do
+      expect {
+        described_class.with_sync_mode { raise "boom" }
+      }.to raise_error("boom")
+      expect(described_class.sync_mode).to be_falsy
+    end
+
+    it 'returns the block result' do
+      result = described_class.with_sync_mode { 42 }
+      expect(result).to eq(42)
     end
   end
 end

data/spec/flipper/adapters/dual_write_spec.rb

@@ -66,4 +66,17 @@ RSpec.describe Flipper::Adapters::DualWrite do
     expect(remote_adapter.count(:disable)).to be(1)
     expect(local_adapter.count(:disable)).to be(1)
   end
+
+  describe '#adapter_stack' do
+    it 'returns the tree representation' do
+      expect(subject.adapter_stack).to eq("dual_write(local: operation_logger -> memory, remote: operation_logger -> memory)")
+    end
+
+    it 'shows nested adapters in the tree' do
+      memory = Flipper::Adapters::Memory.new
+      strict = Flipper::Adapters::Strict.new(Flipper::Adapters::Memory.new)
+      adapter = described_class.new(memory, strict)
+      expect(adapter.adapter_stack).to eq("dual_write(local: memory, remote: strict -> memory)")
+    end
+  end
 end

data/spec/flipper/adapters/failover_spec.rb

@@ -126,4 +126,16 @@ RSpec.describe Flipper::Adapters::Failover do
       end
     end
   end
+
+  describe '#adapter_stack' do
+    it 'returns the tree representation' do
+      expect(subject.adapter_stack).to eq("failover(primary: memory, secondary: memory)")
+    end
+
+    it 'shows nested adapters in the tree' do
+      strict_primary = Flipper::Adapters::Strict.new(primary)
+      adapter = described_class.new(strict_primary, secondary)
+      expect(adapter.adapter_stack).to eq("failover(primary: strict -> memory, secondary: memory)")
+    end
+  end
 end

data/spec/flipper/adapters/http_spec.rb

@@ -185,6 +185,246 @@ RSpec.describe Flipper::Adapters::Http do
         adapter.get_all
       }.to raise_error(Flipper::Adapters::Http::Error)
     end
+
+    it "stores ETag and sends If-None-Match on subsequent requests" do
+      features_response = {
+        "features" => [
+          {
+            "key" => "search",
+            "gates" => [
+              {"key" => "boolean", "value" => true}
+            ]
+          }
+        ]
+      }
+
+      # First request - server returns ETag
+      stub_request(:get, "http://app.com/flipper/features?exclude_gate_names=true")
+        .to_return(
+          status: 200,
+          body: JSON.generate(features_response),
+          headers: { 'ETag' => '"abc123"' }
+        )
+
+      adapter = described_class.new(url: 'http://app.com/flipper')
+      result = adapter.get_all
+
+      expect(result).to have_key("search")
+
+      # Second request - should send If-None-Match header
+      stub_request(:get, "http://app.com/flipper/features?exclude_gate_names=true")
+        .with(headers: { 'If-None-Match' => '"abc123"' })
+        .to_return(
+          status: 200,
+          body: JSON.generate(features_response),
+          headers: { 'ETag' => '"abc123"' }
+        )
+
+      etag_result = adapter.get_all
+
+      expect(etag_result).to eq(result)
+      expect(etag_result).to have_key("search")
+      expect(
+        a_request(:get, "http://app.com/flipper/features?exclude_gate_names=true")
+        .with(headers: { 'If-None-Match' => '"abc123"' })
+      ).to have_been_made.once
+    end
+
+    it "returns cached result when server returns 304 Not Modified" do
+      features_response = {
+        "features" => [
+          {
+            "key" => "search",
+            "gates" => [
+              {"key" => "boolean", "value" => true}
+            ]
+          }
+        ]
+      }
+
+      # First request - server returns ETag
+      stub_request(:get, "http://app.com/flipper/features?exclude_gate_names=true")
+        .to_return(
+          status: 200,
+          body: JSON.generate(features_response),
+          headers: { 'ETag' => '"abc123"' }
+        )
+
+      adapter = described_class.new(url: 'http://app.com/flipper')
+      first_result = adapter.get_all
+
+      expect(first_result).to have_key("search")
+
+      # Second request - server returns 304
+      stub_request(:get, "http://app.com/flipper/features?exclude_gate_names=true")
+        .with(headers: { 'If-None-Match' => '"abc123"' })
+        .to_return(status: 304, headers: { 'ETag' => '"abc123"' })
+
+      second_result = adapter.get_all
+
+      # Should return the cached result
+      expect(second_result).to eq(first_result)
+      expect(second_result).to have_key("search")
+    end
+
+    it "raises error when 304 received without cached result" do
+      # Server returns 304 without any prior request
+      stub_request(:get, "http://app.com/flipper/features?exclude_gate_names=true")
+        .to_return(status: 304)
+
+      adapter = described_class.new(url: 'http://app.com/flipper')
+      expect {
+        adapter.get_all
+      }.to raise_error(Flipper::Adapters::Http::Error)
+    end
+
+    it "skips If-None-Match header when cache_bust is true" do
+      features_response = {
+        "features" => [
+          {
+            "key" => "search",
+            "gates" => [
+              {"key" => "boolean", "value" => true}
+            ]
+          }
+        ]
+      }
+
+      # First request - populate the ETag cache
+      stub_request(:get, "http://app.com/flipper/features?exclude_gate_names=true")
+        .to_return(
+          status: 200,
+          body: JSON.generate(features_response),
+          headers: { 'ETag' => '"abc123"' }
+        )
+
+      adapter = described_class.new(url: 'http://app.com/flipper')
+      adapter.get_all
+
+      # Second request with cache_bust - should NOT send If-None-Match
+      cache_bust_stub = stub_request(:get, %r{/flipper/features\?_cb=\d+&exclude_gate_names=true})
+        .to_return(
+          status: 200,
+          body: JSON.generate(features_response),
+          headers: { 'ETag' => '"def456"' }
+        )
+
+      adapter.get_all(cache_bust: true)
+
+      expect(cache_bust_stub).to have_been_requested.once
+      expect(
+        a_request(:get, %r{/flipper/features\?_cb=\d+&exclude_gate_names=true})
+        .with { |req| req.headers['If-None-Match'].nil? }
+      ).to have_been_made.once
+    end
+
+    it "returns fresh data on cache_bust even when ETag is cached" do
+      stale_response = {
+        "features" => [
+          {
+            "key" => "search",
+            "gates" => [
+              {"key" => "boolean", "value" => nil}
+            ]
+          }
+        ]
+      }
+
+      fresh_response = {
+        "features" => [
+          {
+            "key" => "search",
+            "gates" => [
+              {"key" => "boolean", "value" => true}
+            ]
+          }
+        ]
+      }
+
+      # First request - populate ETag cache with feature disabled
+      stub_request(:get, "http://app.com/flipper/features?exclude_gate_names=true")
+        .to_return(
+          status: 200,
+          body: JSON.generate(stale_response),
+          headers: { 'ETag' => '"abc123"' }
+        )
+
+      adapter = described_class.new(url: 'http://app.com/flipper')
+      stale_result = adapter.get_all
+
+      expect(stale_result["search"][:boolean]).to be_nil
+
+      # Cache bust request returns fresh data (feature now enabled)
+      stub_request(:get, %r{/flipper/features\?_cb=\d+&exclude_gate_names=true})
+        .to_return(
+          status: 200,
+          body: JSON.generate(fresh_response),
+          headers: { 'ETag' => '"def456"' }
+        )
+
+      fresh_result = adapter.get_all(cache_bust: true)
+
+      expect(fresh_result["search"][:boolean]).to eq("true")
+    end
+
+    it "does not send If-None-Match for other endpoints" do
+      stub_request(:get, "http://app.com/flipper/features/search")
+        .to_return(status: 404)
+
+      adapter = described_class.new(url: 'http://app.com/flipper')
+      adapter.get(flipper[:search])
+
+      # Verify no If-None-Match header was sent
+      expect(
+        a_request(:get, "http://app.com/flipper/features/search")
+        .with { |req| req.headers['If-None-Match'].nil? }
+      ).to have_been_made.once
+    end
+
+    it "stores last get_all response for poll-shutdown header checking" do
+      features_response = {
+        "features" => [
+          {
+            "key" => "search",
+            "gates" => [
+              {"key" => "boolean", "value" => true}
+            ]
+          }
+        ]
+      }
+
+      stub_request(:get, "http://app.com/flipper/features?exclude_gate_names=true")
+        .to_return(
+          status: 200,
+          body: JSON.generate(features_response),
+          headers: { 'poll-shutdown' => 'true' }
+        )
+
+      adapter = described_class.new(url: 'http://app.com/flipper')
+      adapter.get_all
+
+      expect(adapter.last_get_all_response).not_to be_nil
+      expect(adapter.last_get_all_response['poll-shutdown']).to eq('true')
+    end
+
+    it "stores last get_all response even for error responses" do
+      stub_request(:get, "http://app.com/flipper/features?exclude_gate_names=true")
+        .to_return(
+          status: 404,
+          body: JSON.generate({ error: "Not found" }),
+          headers: { 'poll-shutdown' => 'true' }
+        )
+
+      adapter = described_class.new(url: 'http://app.com/flipper')
+
+      expect {
+        adapter.get_all
+      }.to raise_error(Flipper::Adapters::Http::Error)
+
+      # Even though it raised an error, response should be stored
+      expect(adapter.last_get_all_response).not_to be_nil
+      expect(adapter.last_get_all_response['poll-shutdown']).to eq('true')
+    end
   end
 
   describe "#features" do

data/spec/flipper/adapters/strict_spec.rb

@@ -21,6 +21,12 @@ RSpec.describe Flipper::Adapters::Strict do
           expect { subject.get_multi([feature]) }.to raise_error(Flipper::Adapters::Strict::NotFound)
         end
       end
+
+      context "#add" do
+        it "raises an error for unknown feature" do
+          expect { subject.add(feature) }.to raise_error(Flipper::Adapters::Strict::NotFound)
+        end
+      end
     end
   end
 
@@ -28,16 +34,22 @@ RSpec.describe Flipper::Adapters::Strict do
     subject { described_class.new(Flipper::Adapters::Memory.new, :warn) }
 
     context "#get" do
-      it "raises an error for unknown feature" do
+      it "warns for unknown feature" do
         expect(capture_output { subject.get(feature) }).to match(/Could not find feature "unknown"/)
       end
     end
 
     context "#get_multi" do
-      it "raises an error for unknown feature" do
+      it "warns for unknown feature" do
         expect(capture_output { subject.get_multi([feature]) }).to match(/Could not find feature "unknown"/)
       end
     end
+
+    context "#add" do
+      it "warns for unknown feature" do
+        expect(capture_output { subject.add(feature) }).to match(/Could not find feature "unknown"/)
+      end
+    end
   end
 
   context "handler = Block" do
@@ -48,17 +60,63 @@ RSpec.describe Flipper::Adapters::Strict do
 
 
     context "#get" do
-      it "raises an error for unknown feature" do
+      it "calls block for unknown feature" do
         subject.get(feature)
         expect(unknown_features).to eq(["unknown"])
       end
     end
 
     context "#get_multi" do
-      it "raises an error for unknown feature" do
+      it "calls block for unknown feature" do
         subject.get_multi([flipper[:foo], flipper[:bar]])
         expect(unknown_features).to eq(["foo", "bar"])
       end
     end
+
+    context "#add" do
+      it "calls block for unknown feature" do
+        subject.add(feature)
+        expect(unknown_features).to eq(["unknown"])
+      end
+    end
+  end
+
+  describe ".with_sync_mode" do
+    subject { described_class.new(Flipper::Adapters::Memory.new, :raise) }
+
+    it "bypasses strict checks for add" do
+      described_class.with_sync_mode do
+        expect { subject.add(feature) }.not_to raise_error
+      end
+    end
+
+    it "bypasses strict checks for get" do
+      described_class.with_sync_mode do
+        expect { subject.get(feature) }.not_to raise_error
+      end
+    end
+
+    it "bypasses strict checks for get_multi" do
+      described_class.with_sync_mode do
+        expect { subject.get_multi([feature]) }.not_to raise_error
+      end
+    end
+
+    it "restores previous sync mode after block" do
+      described_class.with_sync_mode do
+        # inside sync mode
+      end
+      expect { subject.add(feature) }.to raise_error(Flipper::Adapters::Strict::NotFound)
+    end
+
+    it "restores previous sync mode even on error" do
+      begin
+        described_class.with_sync_mode do
+          raise "boom"
+        end
+      rescue RuntimeError
+      end
+      expect { subject.add(feature) }.to raise_error(Flipper::Adapters::Strict::NotFound)
+    end
   end
 end

data/spec/flipper/adapters/sync/feature_synchronizer_spec.rb

@@ -105,6 +105,18 @@ RSpec.describe Flipper::Adapters::Sync::FeatureSynchronizer do
       expect_no_enable_or_disable
     end
 
+    it "updates expression when remote conditionally enabled but expression is nil" do
+      remote = Flipper::GateValues.new(expression: nil, actors: Set["1"])
+      feature.enable_expression(plan_expression)
+      feature.enable_actor(Flipper::Actor.new("1"))
+      adapter.reset
+
+      described_class.new(feature, feature.gate_values, remote).call
+
+      expect(feature.expression_value).to eq(nil)
+      expect_only_disable
+    end
+
     it "adds remotely added actors" do
       remote = Flipper::GateValues.new(actors: Set["1", "2"])
       feature.enable_actor(Flipper::Actor.new("1"))