flipper-redis 0.26.0 → 1.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4fe57b8039f49c839ad48193abfe3b84781d52c43d1cbefa4ed1ab101ad5f447
-  data.tar.gz: e469d55199c97789efc4ac225ac7e66e7631ebbe939d1b5637a8f724752f84f3
+  metadata.gz: 1ab27a744d523e5882067b51c63b5701a72128abc56b63ea017a7e34ee72c442
+  data.tar.gz: b22fdc07f401183cc8ff0715250e883f21864f75d1e9b2965d73debb22145bd1
 SHA512:
-  metadata.gz: 9507c5f73bde9786d0c34e772b8b0314c94b6352281687cf01650557ad7b8f0136d51c0635ac249ce2a95a8e427c9fd8b2841dbeb996d78518cd1f067b6b57a0
-  data.tar.gz: 0e050b755f0745f2d9551e3cf7a2676b99fde5b15d8181e9512a79cfacba12d6f86f35301b19c70a3ac99d41c4c16d443d45881570da81f9818986b38fd51205
+  metadata.gz: 77bc8292777d556eaab00f3d8c6f8b048995f3f68cc9d64973a8ae3540cd0d1a280c18c9ee7a79d19fc0295799468e294ec1bafe87cc7ebe31eae28e035dd2bd
+  data.tar.gz: aa80897bed12f93ef24a3220a748d3fb227b45357af6bc7c1e23e5c88db6bf763b4dce6c6b05404a2810a4c341708eec960f26c339ff069c83a2d144b9c31101

data/examples/redis/internals.rb

@@ -6,8 +6,8 @@ require 'flipper/adapters/redis'
 client = Redis.new
 
 # Register a few groups.
-Flipper.register(:admins) { |thing| thing.admin? }
-Flipper.register(:early_access) { |thing| thing.early_access? }
+Flipper.register(:admins) { |actor| actor.admin? }
+Flipper.register(:early_access) { |actor| actor.early_access? }
 
 # Create a user class that has flipper_id instance method.
 User = Struct.new(:flipper_id)

data/flipper-redis.gemspec

@@ -8,10 +8,10 @@ end
 
 Gem::Specification.new do |gem|
   gem.authors       = ['John Nunemaker']
-  gem.email         = ['nunemaker@gmail.com']
-  gem.summary       = 'Redis adapter for Flipper'
+  gem.email         = 'support@flippercloud.io'
+  gem.summary       = 'Redis feature flag adapter for Flipper'
   gem.license       = 'MIT'
-  gem.homepage      = 'https://github.com/jnunemaker/flipper'
+  gem.homepage      = 'https://www.flippercloud.io/docs/adapters/redis'
 
   gem.files         = `git ls-files`.split("\n").select(&flipper_redis_files) + ['lib/flipper/version.rb']
   gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n").select(&flipper_redis_files)

data/lib/flipper/adapters/redis.rb

@@ -1,24 +1,35 @@
 require 'set'
 require 'redis'
 require 'flipper'
+require 'flipper/adapters/redis_shared/methods'
 
 module Flipper
   module Adapters
     class Redis
       include ::Flipper::Adapter
+      include ::Flipper::Adapters::RedisShared
 
-      # Private: The key that stores the set of known features.
-      FeaturesKey = :flipper_features
+      attr_reader :key_prefix
 
-      # Public: The name of the adapter.
-      attr_reader :name
+      def features_key
+        "#{key_prefix}flipper_features"
+      end
+
+      def key_for(feature_name)
+        "#{key_prefix}#{feature_name}"
+      end
 
       # Public: Initializes a Redis flipper adapter.
       #
-      # client - The Redis client to use. Feel free to namespace it.
-      def initialize(client)
+      # client - The Redis client to use.
+      # key_prefix - an optional prefix with which to namespace
+      #              flipper's Redis keys
+      def initialize(client, key_prefix: nil)
         @client = client
-        @name = :redis
+        @key_prefix = key_prefix
+        @sadd_returns_boolean = with_connection do |conn|
+          conn.class.respond_to?(:sadd_returns_boolean) && conn.class.sadd_returns_boolean
+        end
       end
 
       # Public: The set of known features.
@@ -29,9 +40,9 @@ module Flipper
       # Public: Adds a feature to the set of known features.
       def add(feature)
         if redis_sadd_returns_boolean?
-          @client.sadd? FeaturesKey, feature.key
+          with_connection { |conn| conn.sadd? features_key, feature.key }
         else
-          @client.sadd FeaturesKey, feature.key
+          with_connection { |conn| conn.sadd features_key, feature.key }
         end
         true
       end
@@ -39,17 +50,17 @@ module Flipper
       # Public: Removes a feature from the set of known features.
       def remove(feature)
         if redis_sadd_returns_boolean?
-          @client.srem? FeaturesKey, feature.key
+          with_connection { |conn| conn.srem? features_key, feature.key }
         else
-          @client.srem FeaturesKey, feature.key
+          with_connection { |conn| conn.srem features_key, feature.key }
         end
-        @client.del feature.key
+        with_connection { |conn| conn.del key_for(feature.key) }
         true
       end
 
       # Public: Clears the gate values for a feature.
       def clear(feature)
-        @client.del feature.key
+        with_connection { |conn| conn.del key_for(feature.key) }
         true
       end
 
@@ -73,19 +84,22 @@ module Flipper
       # Public: Enables a gate for a given thing.
       #
       # feature - The Flipper::Feature for the gate.
-      # gate - The Flipper::Gate to disable.
+      # gate - The Flipper::Gate to enable.
       # thing - The Flipper::Type being enabled for the gate.
       #
       # Returns true.
       def enable(feature, gate, thing)
+        feature_key = key_for(feature.key)
         case gate.data_type
         when :boolean
           clear(feature)
-          @client.hset feature.key, gate.key, thing.value.to_s
+          with_connection { |conn| conn.hset feature_key, gate.key, thing.value.to_s }
         when :integer
-          @client.hset feature.key, gate.key, thing.value.to_s
+          with_connection { |conn| conn.hset feature_key, gate.key, thing.value.to_s }
         when :set
-          @client.hset feature.key, to_field(gate, thing), 1
+          with_connection { |conn| conn.hset feature_key, to_field(gate, thing), 1 }
+        when :json
+          with_connection { |conn| conn.hset feature_key, gate.key, Typecast.to_json(thing.value) }
         else
           unsupported_data_type gate.data_type
         end
@@ -101,13 +115,16 @@ module Flipper
       #
       # Returns true.
       def disable(feature, gate, thing)
+        feature_key = key_for(feature.key)
         case gate.data_type
         when :boolean
-          @client.del feature.key
+          with_connection { |conn| conn.del feature_key }
         when :integer
-          @client.hset feature.key, gate.key, thing.value.to_s
+          with_connection { |conn| conn.hset feature_key, gate.key, thing.value.to_s }
         when :set
-          @client.hdel feature.key, to_field(gate, thing)
+          with_connection { |conn| conn.hdel feature_key, to_field(gate, thing) }
+        when :json
+          with_connection { |conn| conn.hdel feature_key, gate.key }
         else
           unsupported_data_type gate.data_type
         end
@@ -118,7 +135,7 @@ module Flipper
       private
 
       def redis_sadd_returns_boolean?
-        @client.class.respond_to?(:sadd_returns_boolean) && @client.class.sadd_returns_boolean
+        @sadd_returns_boolean
       end
 
       def read_many_features(features)
@@ -131,20 +148,26 @@ module Flipper
       end
 
       def read_feature_keys
-        @client.smembers(FeaturesKey).to_set
+        with_connection { |conn| conn.smembers(features_key).to_set }
       end
 
       # Private: Gets a hash of fields => values for the given feature.
       #
       # Returns a Hash of fields => values.
-      def doc_for(feature, pipeline: @client)
-        pipeline.hgetall(feature.key)
+      def doc_for(feature, pipeline: nil)
+        if pipeline
+          pipeline.hgetall(key_for(feature.key))
+        else
+          with_connection { |conn| conn.hgetall(key_for(feature.key)) }
+        end
       end
 
       def docs_for(features)
-        @client.pipelined do |pipeline|
-          features.each do |feature|
-            doc_for(feature, pipeline: pipeline)
+        with_connection do |conn|
+          conn.pipelined do |pipeline|
+            features.each do |feature|
+              doc_for(feature, pipeline: pipeline)
+            end
           end
         end
       end
@@ -160,6 +183,9 @@ module Flipper
               doc[gate.key.to_s]
             when :set
               fields_to_gate_value fields, gate
+            when :json
+              value = doc[gate.key.to_s]
+              Typecast.from_json(value)
             else
               unsupported_data_type gate.data_type
             end
@@ -193,7 +219,7 @@ end
 
 Flipper.configure do |config|
   config.adapter do
-    client = Redis.new(url: ENV["FLIPPER_REDIS_URL"] || ENV["REDIS_URL"])
+    client = Redis.new(url: ENV["FLIPPER_REDIS_URL"] || ENV["REDIS_URL"] || "redis://localhost:6379")
     Flipper::Adapters::Redis.new(client)
   end
 end

data/lib/flipper/adapters/redis_cache.rb

@@ -1,156 +1,49 @@
 require 'redis'
 require 'flipper'
+require 'flipper/adapters/cache_base'
+require 'flipper/adapters/redis_shared/methods'
 
 module Flipper
   module Adapters
     # Public: Adapter that wraps another adapter with the ability to cache
-    # adapter calls in Redis
-    class RedisCache
-      include ::Flipper::Adapter
+    # adapter calls in Redis.
+    class RedisCache < CacheBase
+      include ::Flipper::Adapters::RedisShared
 
-      Version = 'v1'.freeze
-      Namespace = "flipper/#{Version}".freeze
-      FeaturesKey = "#{Namespace}/features".freeze
-      GetAllKey = "#{Namespace}/get_all".freeze
-
-      # Private
-      def self.key_for(key)
-        "#{Namespace}/feature/#{key}"
-      end
-
-      # Internal
-      attr_reader :cache
-
-      # Public: The name of the adapter.
-      attr_reader :name
-
-      # Public
-      def initialize(adapter, cache, ttl = 3600)
-        @adapter = adapter
-        @name = :redis_cache
-        @cache = cache
-        @ttl = ttl
-      end
-
-      # Public
-      def features
-        read_feature_keys
-      end
-
-      # Public
-      def add(feature)
-        result = @adapter.add(feature)
-        @cache.del(FeaturesKey)
-        result
-      end
-
-      # Public
-      def remove(feature)
-        result = @adapter.remove(feature)
-        @cache.del(FeaturesKey)
-        @cache.del(key_for(feature.key))
-        result
-      end
-
-      # Public
-      def clear(feature)
-        result = @adapter.clear(feature)
-        @cache.del(key_for(feature.key))
-        result
-      end
-
-      # Public
-      def get(feature)
-        fetch(key_for(feature.key)) do
-          @adapter.get(feature)
-        end
-      end
-
-      def get_multi(features)
-        read_many_features(features)
-      end
-
-      def get_all
-        if @cache.setnx(GetAllKey, Time.now.to_i)
-          @cache.expire(GetAllKey, @ttl)
-          response = @adapter.get_all
-          response.each do |key, value|
-            set_with_ttl key_for(key), value
-          end
-          set_with_ttl FeaturesKey, response.keys.to_set
-          response
-        else
-          features = read_feature_keys.map { |key| Flipper::Feature.new(key, self) }
-          read_many_features(features)
-        end
-      end
-
-      # Public
-      def enable(feature, gate, thing)
-        result = @adapter.enable(feature, gate, thing)
-        @cache.del(key_for(feature.key))
-        result
-      end
-
-      # Public
-      def disable(feature, gate, thing)
-        result = @adapter.disable(feature, gate, thing)
-        @cache.del(key_for(feature.key))
-        result
+      def initialize(adapter, cache, ttl = 3600, prefix: nil)
+        @client = cache
+        super
       end
 
       private
 
-      def key_for(key)
-        self.class.key_for(key)
-      end
-
-      def read_feature_keys
-        fetch(FeaturesKey) { @adapter.features }
-      end
-
-      def read_many_features(features)
-        keys = features.map(&:key)
-        cache_result = Hash[keys.zip(multi_cache_get(keys))]
-        uncached_features = features.reject { |feature| cache_result[feature.key] }
-
-        if uncached_features.any?
-          response = @adapter.get_multi(uncached_features)
-          response.each do |key, value|
-            set_with_ttl(key_for(key), value)
-            cache_result[key] = value
-          end
-        end
-
-        result = {}
-        features.each do |feature|
-          result[feature.key] = cache_result[feature.key]
-        end
-        result
-      end
-
-      def fetch(cache_key)
-        cached = @cache.get(cache_key)
+      def cache_fetch(key, &block)
+        cached = with_connection { |conn| conn.get(key) }
         if cached
           Marshal.load(cached)
         else
           to_cache = yield
-          set_with_ttl(cache_key, to_cache)
+          cache_write key, to_cache
           to_cache
         end
       end
 
-      def set_with_ttl(key, value)
-        @cache.setex(key, @ttl, Marshal.dump(value))
-      end
-
-      def multi_cache_get(keys)
-        return [] if keys.empty?
+      def cache_read_multi(keys)
+        return {} if keys.empty?
 
-        cache_keys = keys.map { |key| key_for(key) }
-        @cache.mget(*cache_keys).map do |value|
+        values = with_connection { |conn| conn.mget(*keys) }.map do |value|
           value ? Marshal.load(value) : nil
         end
+
+        Hash[keys.zip(values)]
+      end
+
+      def cache_write(key, value)
+        with_connection { |conn| conn.setex(key, @ttl, Marshal.dump(value)) }
+      end
+
+      def cache_delete(key)
+        with_connection { |conn| conn.del(key) }
       end
     end
   end

data/lib/flipper/adapters/redis_shared/methods.rb

@@ -0,0 +1,64 @@
+module Flipper
+  module Adapters
+    module RedisShared
+      private
+
+      # Safely executes a block with a Redis connection, handling compatibility
+      # issues between different Redis client versions and Rails versions.
+      #
+      # This method exists to fix a compatibility issue between Rails 7.1.* and
+      # Redis versions below 4.7.0. The issue occurs because:
+      #
+      # 1. In Redis versions below 4.7.0, the `with` method is not defined on
+      #    the Redis client, so Flipper would fall back to `yield(@client)`
+      # 2. However, Rails 7.1.* introduced `Object#with` via ActiveSupport,
+      #    which shadows the Redis client's `with` method
+      # 3. Rails 7.1.*'s `Object#with` doesn't pass `self` to the block parameter
+      #    (this was fixed in Rails 7.2.0), causing the block parameter to be `nil`
+      #
+      # This method ensures that:
+      # - For Redis >= 4.7.0: Uses the Redis client's native `with` method
+      # - For ConnectionPool: Uses the ConnectionPool's `with` method
+      # - For Redis < 4.7.0: Falls back to `yield(@client)` to avoid the Rails
+      #   ActiveSupport `Object#with` method
+      #
+      # @see https://github.com/redis/redis-rb/blob/master/CHANGELOG.md#470
+      # @see https://github.com/rails/rails/pull/46681
+      # @see https://github.com/rails/rails/pull/50470
+      def with_connection(&block)
+        if client_has_correct_with_method?
+          @client.with(&block)
+        else
+          yield(@client)
+        end
+      end
+
+      # Determines if the Redis client has a safe `with` method that can be used
+      # without conflicts with Rails ActiveSupport's `Object#with`.
+      #
+      # This method checks for:
+      # 1. ConnectionPool instances (which have their own `with` method)
+      # 2. Redis instances with version >= 4.7.0 (which have a proper `with` method)
+      #
+      # The method caches its result to avoid repeated checks.
+      #
+      # @return [Boolean] true if the client has a safe `with` method, false otherwise
+      def client_has_correct_with_method?
+        return @client_has_correct_with_method if defined?(@client_has_correct_with_method)
+
+        @client_has_correct_with_method = @client.respond_to?(:with) && (client_is_connection_pool? || client_is_redis_that_has_with?)
+      rescue
+        @client_has_correct_with_method = false
+      end
+
+      def client_is_connection_pool?
+        defined?(ConnectionPool) && @client.is_a?(ConnectionPool)
+      end
+
+      def client_is_redis_that_has_with?
+        @client.is_a?(::Redis) && defined?(::Redis::VERSION) &&
+          ::Gem::Version.new(::Redis::VERSION) >= ::Gem::Version.new('4.7.0')
+      end
+    end
+  end
+end

data/lib/flipper/version.rb

@@ -1,3 +1,13 @@
 module Flipper
-  VERSION = '0.26.0'.freeze
+  VERSION = '1.3.6'.freeze
+
+  REQUIRED_RUBY_VERSION = '2.6'.freeze
+  NEXT_REQUIRED_RUBY_VERSION = '3.0'.freeze
+
+  REQUIRED_RAILS_VERSION = '5.2'.freeze
+  NEXT_REQUIRED_RAILS_VERSION = '6.1.0'.freeze
+
+  def self.deprecated_ruby_version?
+    Gem::Version.new(RUBY_VERSION) < Gem::Version.new(NEXT_REQUIRED_RUBY_VERSION)
+  end
 end

data/spec/flipper/adapters/redis_cache_spec.rb

@@ -3,35 +3,98 @@ require 'flipper/adapters/redis_cache'
 
 RSpec.describe Flipper::Adapters::RedisCache do
   let(:client) do
-    options = {}
-    options[:url] = ENV['REDIS_URL'] if ENV['REDIS_URL']
-    Redis.new(options)
+    Redis.new(url: ENV.fetch('REDIS_URL', 'redis://localhost:6379'))
   end
 
   let(:memory_adapter) do
     Flipper::Adapters::OperationLogger.new(Flipper::Adapters::Memory.new)
   end
-  let(:adapter) { described_class.new(memory_adapter, client) }
+  let(:adapter) { described_class.new(memory_adapter, client, 10) }
   let(:flipper) { Flipper.new(adapter) }
 
   subject { adapter }
 
   before do
-    begin
+    skip_on_error(Redis::CannotConnectError, 'Redis not available') do
       client.flushdb
-    rescue Redis::CannotConnectError
-      ENV['CI'] ? raise : skip('Redis not available')
     end
   end
 
   it_should_behave_like 'a flipper adapter'
 
+  it "knows ttl" do
+    expect(adapter.ttl).to eq(10)
+  end
+
+  it "knows features_cache_key" do
+    expect(adapter.features_cache_key).to eq("flipper/v1/features")
+  end
+
+  it "can expire features cache" do
+    # cache the features
+    adapter.features
+    expect(client.get("flipper/v1/features")).not_to be(nil)
+
+    # expire cache
+    adapter.expire_features_cache
+    expect(client.get("flipper/v1/features")).to be(nil)
+  end
+
+  it "can expire feature cache" do
+    # cache the features
+    adapter.get(flipper[:stats])
+    expect(client.get("flipper/v1/feature/stats")).not_to be(nil)
+
+    # expire cache
+    adapter.expire_feature_cache("stats")
+    expect(client.get("flipper/v1/feature/stats")).to be(nil)
+  end
+
+  it "can generate feature cache key" do
+    expect(adapter.feature_cache_key("stats")).to eq("flipper/v1/feature/stats")
+  end
+
+  context "when using a prefix" do
+    let(:adapter) { described_class.new(memory_adapter, client, 3600, prefix: "foo/") }
+    it_should_behave_like 'a flipper adapter'
+
+    it "knows features_cache_key" do
+      expect(adapter.features_cache_key).to eq("foo/flipper/v1/features")
+    end
+
+    it "can generate feature cache key" do
+      expect(adapter.feature_cache_key("stats")).to eq("foo/flipper/v1/feature/stats")
+    end
+
+    it "uses the prefix for all keys" do
+      # check individual feature get cached with prefix
+      adapter.get(flipper[:stats])
+      expect(Marshal.load(client.get("foo/flipper/v1/feature/stats"))).not_to be(nil)
+
+      # check individual feature expired with prefix
+      adapter.remove(flipper[:stats])
+      expect(client.get("foo/flipper/v1/feature/stats")).to be(nil)
+
+      # enable some stuff
+      flipper.enable_percentage_of_actors(:search, 10)
+      flipper.enable(:stats)
+
+      # populate the cache
+      adapter.get_all
+
+      # verify cached with prefix
+      expect(Marshal.load(client.get("foo/flipper/v1/features"))).to eq(Set["stats", "search"])
+      expect(Marshal.load(client.get("foo/flipper/v1/feature/search"))[:percentage_of_actors]).to eq("10")
+      expect(Marshal.load(client.get("foo/flipper/v1/feature/stats"))[:boolean]).to eq("true")
+    end
+  end
+
   describe '#remove' do
     it 'expires feature' do
       feature = flipper[:stats]
       adapter.get(feature)
       adapter.remove(feature)
-      expect(client.get(described_class.key_for(feature))).to be(nil)
+      expect(client.get("flipper/v1/feature/#{feature.key}")).to be(nil)
     end
   end
 
@@ -39,7 +102,7 @@ RSpec.describe Flipper::Adapters::RedisCache do
     it 'uses correct cache key' do
       stats = flipper[:stats]
       adapter.get(stats)
-      expect(client.get(described_class.key_for(stats))).not_to be_nil
+      expect(client.get("flipper/v1/feature/#{stats.key}")).not_to be_nil
     end
   end
 
@@ -54,13 +117,13 @@ RSpec.describe Flipper::Adapters::RedisCache do
       memory_adapter.reset
 
       adapter.get(stats)
-      expect(client.get(described_class.key_for(search))).to be(nil)
-      expect(client.get(described_class.key_for(other))).to be(nil)
+      expect(client.get("flipper/v1/feature/#{search.key}")).to be(nil)
+      expect(client.get("flipper/v1/feature/#{other.key}")).to be(nil)
 
       adapter.get_multi([stats, search, other])
 
       search_cache_value, other_cache_value = [search, other].map do |f|
-        Marshal.load(client.get(described_class.key_for(f)))
+        Marshal.load(client.get("flipper/v1/feature/#{f.key}"))
       end
       expect(search_cache_value[:boolean]).to eq('true')
       expect(other_cache_value[:boolean]).to be(nil)
@@ -82,19 +145,21 @@ RSpec.describe Flipper::Adapters::RedisCache do
 
     it 'warms all features' do
       adapter.get_all
-      expect(Marshal.load(client.get(described_class.key_for(stats.key)))[:boolean]).to eq('true')
-      expect(Marshal.load(client.get(described_class.key_for(search.key)))[:boolean]).to be(nil)
-      expect(client.get(described_class::GetAllKey).to_i).to be_within(2).of(Time.now.to_i)
+      expect(Marshal.load(client.get("flipper/v1/feature/#{stats.key}"))[:boolean]).to eq('true')
+      expect(Marshal.load(client.get("flipper/v1/feature/#{search.key}"))[:boolean]).to be(nil)
+      expect(Marshal.load(client.get("flipper/v1/features"))).to eq(Set["stats", "search"])
     end
 
     it 'returns same result when already cached' do
       expect(adapter.get_all).to eq(adapter.get_all)
     end
 
-    it 'only invokes one call to wrapped adapter' do
+    it 'only invokes two calls to wrapped adapter (for features set and gate data for each feature in set)' do
       memory_adapter.reset
       5.times { adapter.get_all }
-      expect(memory_adapter.count(:get_all)).to eq(1)
+      expect(memory_adapter.count(:features)).to eq(1)
+      expect(memory_adapter.count(:get_multi)).to eq(1)
+      expect(memory_adapter.count).to eq(2)
     end
   end
 

data/spec/flipper/adapters/redis_spec.rb

@@ -1,33 +1,101 @@
 require 'flipper/adapters/redis'
+require 'connection_pool'
 
 RSpec.describe Flipper::Adapters::Redis do
-  let(:client) do
-    options = {}
+  context "redis instance" do
+    let(:client) do
+      Redis.raise_deprecations = true
+      Redis.new(url: ENV.fetch('REDIS_URL', 'redis://localhost:6379'))
+    end
 
-    options[:url] = ENV['REDIS_URL'] if ENV['REDIS_URL']
+    subject { described_class.new(client) }
 
-    Redis.raise_deprecations = true
-    Redis.new(options)
-  end
+    before do
+      skip_on_error(Redis::CannotConnectError, 'Redis not available') do
+        client.flushdb
+      end
+    end
 
-  subject { described_class.new(client) }
+    it_should_behave_like 'a flipper adapter'
 
-  before do
-    begin
-      client.flushdb
-    rescue Redis::CannotConnectError
-      ENV['CI'] ? raise : skip('Redis not available')
+    it 'configures itself on load' do
+      Flipper.configuration = nil
+      Flipper.instance = nil
+
+      silence { load 'flipper/adapters/redis.rb' }
+
+      expect(Flipper.adapter.adapter).to be_a(Flipper::Adapters::Redis)
+    end
+
+    describe 'with a key_prefix' do
+      let(:subject) { described_class.new(client, key_prefix: "lockbox:") }
+      let(:feature) { Flipper::Feature.new(:search, subject) }
+
+      it_should_behave_like 'a flipper adapter'
+
+      it 'namespaces feature-keys' do
+        subject.add(feature)
+
+        expect(client.smembers("flipper_features")).to eq([])
+        expect(client.exists?("search")).to eq(false)
+        expect(client.smembers("lockbox:flipper_features")).to eq(["search"])
+        expect(client.hgetall("lockbox:search")).not_to eq(nil)
+      end
+
+      it "can remove namespaced keys" do
+        subject.add(feature)
+        expect(client.smembers("lockbox:flipper_features")).to eq(["search"])
+
+        subject.remove(feature)
+        expect(client.smembers("lockbox:flipper_features")).to be_empty
+      end
     end
   end
 
-  it_should_behave_like 'a flipper adapter'
+  context "with a connection pool instance" do
+    let(:client) do
+      Redis.raise_deprecations = true
+      ConnectionPool.new(size: 1, timeout: 1) {
+        Redis.new(url: ENV.fetch('REDIS_URL', 'redis://localhost:6379'))
+      }
+    end
+
+    subject { described_class.new(client) }
+
+    before do
+      skip_on_error(Redis::CannotConnectError, 'Redis not available') do
+        client.with { |conn| conn.flushdb }
+      end
+    end
+
+    it_should_behave_like 'a flipper adapter'
+
+    describe 'with a key_prefix' do
+      let(:subject) { described_class.new(client, key_prefix: "lockbox:") }
+      let(:feature) { Flipper::Feature.new(:search, subject) }
+
+      it_should_behave_like 'a flipper adapter'
 
-  it 'configures itself on load' do
-    Flipper.configuration = nil
-    Flipper.instance = nil
+      it 'namespaces feature-keys' do
+        subject.add(feature)
 
-    silence { load 'flipper/adapters/redis.rb' }
+        client.with do |conn|
+          expect(conn.smembers("flipper_features")).to eq([])
+          expect(conn.exists?("search")).to eq(false)
+          expect(conn.smembers("lockbox:flipper_features")).to eq(["search"])
+          expect(conn.hgetall("lockbox:search")).not_to eq(nil)
+        end
+      end
 
-    expect(Flipper.adapter.adapter).to be_a(Flipper::Adapters::Redis)
+      it "can remove namespaced keys" do
+        client.with do |conn|
+          subject.add(feature)
+          expect(conn.smembers("lockbox:flipper_features")).to eq(["search"])
+
+          subject.remove(feature)
+          expect(conn.smembers("lockbox:flipper_features")).to be_empty
+        end
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: flipper-redis
 version: !ruby/object:Gem::Version
-  version: 0.26.0
+  version: 1.3.6
 platform: ruby
 authors:
 - John Nunemaker
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-12-05 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: flipper
@@ -16,14 +15,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.26.0
+        version: 1.3.6
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.26.0
+        version: 1.3.6
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
@@ -44,31 +43,33 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '6'
-description:
-email:
-- nunemaker@gmail.com
+email: support@flippercloud.io
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - examples/redis/basic.rb
 - examples/redis/internals.rb
-- examples/redis/namespaced.rb
 - flipper-redis.gemspec
 - lib/flipper-redis.rb
 - lib/flipper/adapters/redis.rb
 - lib/flipper/adapters/redis_cache.rb
+- lib/flipper/adapters/redis_shared/methods.rb
 - lib/flipper/version.rb
 - spec/flipper/adapters/redis_cache_spec.rb
 - spec/flipper/adapters/redis_spec.rb
 - test/adapters/redis_cache_test.rb
 - test/adapters/redis_test.rb
-homepage: https://github.com/jnunemaker/flipper
+homepage: https://www.flippercloud.io/docs/adapters/redis
 licenses:
 - MIT
 metadata:
-  changelog_uri: https://github.com/jnunemaker/flipper/blob/main/Changelog.md
-post_install_message:
+  documentation_uri: https://www.flippercloud.io/docs
+  homepage_uri: https://www.flippercloud.io
+  source_code_uri: https://github.com/flippercloud/flipper
+  bug_tracker_uri: https://github.com/flippercloud/flipper/issues
+  changelog_uri: https://github.com/flippercloud/flipper/releases/tag/v1.3.6
+  funding_uri: https://github.com/sponsors/flippercloud
 rdoc_options: []
 require_paths:
 - lib
@@ -83,10 +84,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
-summary: Redis adapter for Flipper
+summary: Redis feature flag adapter for Flipper
 test_files:
 - spec/flipper/adapters/redis_cache_spec.rb
 - spec/flipper/adapters/redis_spec.rb

data/examples/redis/namespaced.rb

@@ -1,37 +0,0 @@
-require 'bundler/setup'
-require 'redis-namespace'
-require 'flipper/adapters/redis'
-
-options = {url: 'redis://127.0.0.1:6379'}
-if ENV['REDIS_URL']
-  options[:url] = ENV['REDIS_URL']
-end
-client = Redis.new(options)
-namespaced_client = Redis::Namespace.new(:flipper_namespace, redis: client)
-adapter = Flipper::Adapters::Redis.new(namespaced_client)
-flipper = Flipper.new(adapter)
-
-# Register a few groups.
-Flipper.register(:admins) { |thing| thing.admin? }
-Flipper.register(:early_access) { |thing| thing.early_access? }
-
-# Create a user class that has flipper_id instance method.
-User = Struct.new(:flipper_id)
-
-flipper[:stats].enable
-flipper[:stats].enable_group :admins
-flipper[:stats].enable_group :early_access
-flipper[:stats].enable_actor User.new('25')
-flipper[:stats].enable_actor User.new('90')
-flipper[:stats].enable_actor User.new('180')
-flipper[:stats].enable_percentage_of_time 15
-flipper[:stats].enable_percentage_of_actors 45
-
-flipper[:search].enable
-
-print 'all keys: '
-pp client.keys
-# all keys: ["stats", "flipper_features", "search"]
-puts
-
-puts 'notice how all the keys are namespaced'