flipper-active_record 1.0.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f11ba9f2e7fa94ab06ddddfc753ccb1b398ffc19023ab6b2f5a980ccb55bd974
-  data.tar.gz: 2566b337548372d8d080f732dbb2824b771f5c58e429ac350ceb0afb5455fea8
+  metadata.gz: d550530c982b783d5bb01547b0dd63e65ae28cf684baf5cab91f633b45546a6a
+  data.tar.gz: abe3da9138ef86cc0a7fecf5496d4ac78b036cfb9f8188b782debf9be8ab92ba
 SHA512:
-  metadata.gz: 40e29c142239ff3a5f474f2f0dd6019d3bc60fcc4aaa76021715cf1dcb241c50c2d2dbf1e669cd5b2efcfa5f6740b40bea477988e25d6b5445ff4fcddd111173
-  data.tar.gz: 6d9c313e0402d1bd197a1abc17a1aa930296f8f854c132773bebc08c6dbf5fab49a2978a4df196267ca0e29af8b5277868458ba4a7d7a35feb4efdcdb44ed1e0
+  metadata.gz: fe247ffa161d7090ff3630a50329f128c75b7ef65109b9a9fb85bd4432892752d7f106b21bf05f9cf5de913ed43e72f18d9316e9775300d9cc7be4c571c8f492
+  data.tar.gz: 82583bfa629d02c3eeba04b9cb7b32ba78ff65fcb39bba598c07e9a9dc843a486fe3a08351b528db3a1d032a7632593af92a6b1045c0d2af568c30974474c684

data/benchmark/active_record_adapter_ips.rb

@@ -6,10 +6,13 @@ require 'benchmark/ips'
 
 flipper = Flipper.new(Flipper::Adapters::ActiveRecord.new)
 
-2000.times do |i|
-  flipper.enable_actor :foo, Flipper::Actor.new("User;#{i}")
+10.times do |n|
+  2000.times do |i|
+    flipper.enable_actor 'feature' + n.to_s, Flipper::Actor.new("User;#{i}")
+  end
 end
 
 Benchmark.ips do |x|
   x.report("get_all") { flipper.preload_all }
+  x.report("features") { flipper.features }
 end

data/examples/active_record/ar_setup.rb

@@ -28,3 +28,18 @@ SQL
 ActiveRecord::Base.connection.execute <<-SQL
   CREATE UNIQUE INDEX index_gates_on_keys_and_value on flipper_gates (feature_key, key, value)
 SQL
+
+ActiveRecord::Base.connection.execute <<-SQL
+  CREATE TABLE users (
+    id integer PRIMARY KEY,
+    name string NOT NULL,
+    influencer boolean,
+    created_at datetime NOT NULL,
+    updated_at datetime NOT NULL
+  )
+SQL
+
+require 'flipper/model/active_record'
+class User < ActiveRecord::Base
+  include Flipper::Model::ActiveRecord
+end

data/examples/active_record/group_migration.rb

@@ -0,0 +1,68 @@
+# This is an example script that shows how to migrate from a bunch of individual
+# actors to a group. Should be useful for those who have ended up with large
+# actor sets and want to slim them down for performance reasons.
+
+require_relative "./ar_setup"
+require 'flipper/adapters/active_record'
+require 'active_support/all'
+
+# 1. enable feature for 100 actors, make 80 influencers
+users = 100.times.map do |n|
+  influencer = n < 80 ? true : false
+  user = User.create(name: n, influencer: influencer)
+  Flipper.enable :stats, user
+  user
+end
+
+# check enabled, should all be because individual actors are enabled
+print 'Should be [[true, 100]]: '
+print users.group_by { |user| Flipper.enabled?(:stats, user) }.map { |result, users| [result, users.size]}
+puts
+
+# 2. register a group so flipper knows what to do with it
+Flipper.register(:influencers) do |actor, context|
+  actor.respond_to?(:influencer) && actor.influencer
+end
+
+# 3. enable group for feature, THIS IS IMPORTANT
+Flipper.enable :stats, :influencers
+
+# check enabled again, should all still be true because individual actors are
+# enabled, but also the group gate would return true for 80 influencers. At this
+# point, it's kind of double true but flipper just cares if any gate returns true.
+print 'Should be [[true, 100]]: '
+print users.group_by { |user| Flipper.enabled?(:stats, user) }.map { |result, users| [result, users.size]}
+puts
+
+# 4. now we want to clean up the actors that are covered by the group to slim down
+# the actor set size. So we loop through actors and remove them if group returns
+# true for the provided actor and context.
+Flipper[:stats].actors_value.each do |flipper_id|
+  # Hydrate the flipper_id into an active record object. Modify this based on
+  # your flipper_id's if you use anything other than active record models and
+  # the default flipper_id provided by flipper.
+  class_name, id = flipper_id.split(';')
+  klass = class_name.constantize
+  user = klass.find(id)
+
+  # if user is in group then disable for actor because they'll still get the feature
+  context = Flipper::FeatureCheckContext.new(
+    feature_name: :stats,
+    values: Flipper[:stats].gate_values,
+    actors: [Flipper::Types::Actor.wrap(user)]
+  )
+
+  if Flipper::Gates::Group.new.open?(context)
+    Flipper.disable(:stats, user)
+  end
+end
+
+# check enabled again, should be the same result as previous checks
+print 'Should be [[true, 100]]: '
+print users.group_by { |user| Flipper.enabled?(:stats, user) }.map { |result, users| [result, users.size]}
+puts
+
+puts "Actors enabled: #{Flipper[:stats].actors_value.size}"
+puts "Groups enabled: #{Flipper[:stats].groups_value.size}"
+
+puts "All actors that could be migrated to groups were migrated. Yay!"

data/flipper-active_record.gemspec

@@ -1,15 +1,22 @@
 # -*- encoding: utf-8 -*-
 require File.expand_path('../lib/flipper/version', __FILE__)
 require File.expand_path('../lib/flipper/metadata', __FILE__)
+require "set"
+
+# Files that should exist in main flipper gem.
+main_flipper_active_record_files = Set[
+  "lib/flipper/model/active_record.rb",
+  "spec/flipper/model/active_record_spec.rb",
+]
 
 flipper_active_record_files = lambda do |file|
-  file =~ /active_record/
+  file =~ /active_record/ && !main_flipper_active_record_files.include?(file)
 end
 
 Gem::Specification.new do |gem|
   gem.authors       = ['John Nunemaker']
   gem.email         = 'support@flippercloud.io'
-  gem.summary       = 'ActiveRecord adapter for Flipper'
+  gem.summary       = 'ActiveRecord feature flag adapter for Flipper'
   gem.license       = 'MIT'
   gem.homepage      = 'https://www.flippercloud.io/docs/adapters/active-record'
 
@@ -25,5 +32,5 @@ Gem::Specification.new do |gem|
   gem.metadata      = Flipper::METADATA
 
   gem.add_dependency 'flipper', "~> #{Flipper::VERSION}"
-  gem.add_dependency 'activerecord', '>= 4.2', '< 8'
+  gem.add_dependency 'activerecord', '>= 4.2', '< 9'
 end

data/lib/flipper/adapters/active_record/feature.rb

@@ -0,0 +1,20 @@
+require 'flipper/adapters/active_record/model'
+
+module Flipper
+  module Adapters
+    class ActiveRecord
+      # Private: Do not use outside of this adapter.
+      class Feature < Model
+        self.table_name = [
+          Model.table_name_prefix,
+          "flipper_features",
+          Model.table_name_suffix,
+        ].join
+
+        has_many :gates, foreign_key: "feature_key", primary_key: "key"
+
+        validates :key, presence: true
+      end
+    end
+  end
+end

data/lib/flipper/adapters/active_record/gate.rb

@@ -0,0 +1,19 @@
+require 'flipper/adapters/active_record/model'
+
+module Flipper
+  module Adapters
+    class ActiveRecord
+      # Private: Do not use outside of this adapter.
+      class Gate < Model
+        self.table_name = [
+          Model.table_name_prefix,
+          "flipper_gates",
+          Model.table_name_suffix,
+        ].join
+
+        validates :feature_key, presence: true
+        validates :key, presence: true
+      end
+    end
+  end
+end

data/lib/flipper/adapters/active_record/model.rb

@@ -0,0 +1,9 @@
+module Flipper
+  module Adapters
+    class ActiveRecord
+      class Model < ::ActiveRecord::Base
+        self.abstract_class = true
+      end
+    end
+  end
+end

data/lib/flipper/adapters/active_record.rb

@@ -1,37 +1,20 @@
 require 'set'
+require 'securerandom'
 require 'flipper'
 require 'active_record'
+require_relative 'active_record/model'
+require_relative 'active_record/feature'
+require_relative 'active_record/gate'
 
 module Flipper
   module Adapters
     class ActiveRecord
       include ::Flipper::Adapter
 
-      # Abstract base class for internal models
-      class Model < ::ActiveRecord::Base
-        self.abstract_class = true
-      end
-
-      # Private: Do not use outside of this adapter.
-      class Feature < Model
-        self.table_name = [
-          Model.table_name_prefix,
-          "flipper_features",
-          Model.table_name_suffix,
-        ].join
-      end
-
-      # Private: Do not use outside of this adapter.
-      class Gate < Model
-        self.table_name = [
-          Model.table_name_prefix,
-          "flipper_gates",
-          Model.table_name_suffix,
-        ].join
-      end
-
-      # Public: The name of the adapter.
-      attr_reader :name
+      VALUE_TO_TEXT_WARNING = <<-EOS
+        Your database needs to be migrated to use the latest Flipper features.
+        Run `rails generate flipper:update` and `rails db:migrate`.
+      EOS
 
       # Public: Initialize a new ActiveRecord adapter instance.
       #
@@ -47,26 +30,27 @@ module Flipper
       # can roll your own tables and what not, if you so desire.
       def initialize(options = {})
         @name = options.fetch(:name, :active_record)
-        @feature_class = options.fetch(:feature_class) { Feature }
-        @gate_class = options.fetch(:gate_class) { Gate }
+        @feature_class = options.fetch(:feature_class) { Flipper::Adapters::ActiveRecord::Feature }
+        @gate_class = options.fetch(:gate_class) { Flipper::Adapters::ActiveRecord::Gate }
       end
 
       # Public: The set of known features.
       def features
-        with_connection(@feature_class) { @feature_class.all.map(&:key).to_set }
+        with_connection(@feature_class) { @feature_class.distinct.pluck(:key).to_set }
       end
 
       # Public: Adds a feature to the set of known features.
       def add(feature)
-        with_connection(@feature_class) do
-          # race condition, but add is only used by enable/disable which happen
-          # super rarely, so it shouldn't matter in practice
-          @feature_class.transaction do
-            unless @feature_class.where(key: feature.key).first
-              begin
-                @feature_class.create! { |f| f.key = feature.key }
-              rescue ::ActiveRecord::RecordNotUnique
+        with_write_connection(@feature_class) do
+          @feature_class.transaction(requires_new: true) do
+            begin
+              # race condition, but add is only used by enable/disable which happen
+              # super rarely, so it shouldn't matter in practice
+              unless @feature_class.where(key: feature.key).exists?
+                @feature_class.create!(key: feature.key)
               end
+            rescue ::ActiveRecord::RecordNotUnique
+              # already added
             end
           end
         end
@@ -76,7 +60,7 @@ module Flipper
 
       # Public: Removes a feature from the set of known features.
       def remove(feature)
-        with_connection(@feature_class) do
+        with_write_connection(@feature_class) do
           @feature_class.transaction do
             @feature_class.where(key: feature.key).destroy_all
             clear(feature)
@@ -87,7 +71,7 @@ module Flipper
 
       # Public: Clears the gate values for a feature.
       def clear(feature)
-        with_connection(@gate_class) { @gate_class.where(feature_key: feature.key).destroy_all }
+        with_write_connection(@gate_class) { @gate_class.where(feature_key: feature.key).destroy_all }
         true
       end
 
@@ -116,15 +100,15 @@ module Flipper
         end
       end
 
-      def get_all
-        with_connection(@feature_class) do
+      def get_all(**kwargs)
+        with_connection(@feature_class) do |connection|
           # query the gates from the db in a single query
           features = ::Arel::Table.new(@feature_class.table_name.to_sym)
           gates = ::Arel::Table.new(@gate_class.table_name.to_sym)
           rows_query = features.join(gates, ::Arel::Nodes::OuterJoin)
             .on(features[:key].eq(gates[:feature_key]))
             .project(features[:key].as('feature_key'), gates[:key], gates[:value])
-          gates = @feature_class.connection.select_rows(rows_query)
+          gates = connection.select_rows(rows_query)
 
           # group the gates by feature key
           grouped_gates = gates.inject({}) do |hash, (feature_key, key, value)|
@@ -139,6 +123,7 @@ module Flipper
           features.each do |feature|
             result[feature.key] = result_for_gates(feature, grouped_gates[feature.key])
           end
+          result.default_proc = nil
           result
         end
       end
@@ -156,6 +141,8 @@ module Flipper
           set(feature, gate, thing, clear: true)
         when :integer
           set(feature, gate, thing)
+        when :json
+          set(feature, gate, thing, json: true)
         when :set
           enable_multi(feature, gate, thing)
         else
@@ -178,8 +165,12 @@ module Flipper
           clear(feature)
         when :integer
           set(feature, gate, thing)
+        when :json
+          with_write_connection(@gate_class) do
+            delete(feature, gate)
+          end
         when :set
-          with_connection(@gate_class) do
+          with_write_connection(@gate_class) do
             @gate_class.where(feature_key: feature.key, key: gate.key, value: thing.value).destroy_all
           end
         else
@@ -198,15 +189,19 @@ module Flipper
 
       def set(feature, gate, thing, options = {})
         clear_feature = options.fetch(:clear, false)
-        with_connection(@gate_class) do
-          @gate_class.transaction do
+        json_feature = options.fetch(:json, false)
+
+        raise VALUE_TO_TEXT_WARNING if json_feature && value_not_text?
+
+        with_write_connection(@gate_class) do
+          @gate_class.transaction(requires_new: true) do
             clear(feature) if clear_feature
-            @gate_class.where(feature_key: feature.key, key: gate.key).destroy_all
+            delete(feature, gate)
             begin
               @gate_class.create! do |g|
                 g.feature_key = feature.key
                 g.key = gate.key
-                g.value = thing.value.to_s
+                g.value = json_feature ? Typecast.to_json(thing.value) : thing.value.to_s
               end
             rescue ::ActiveRecord::RecordNotUnique
               # assume this happened concurrently with the same thing and its fine
@@ -218,18 +213,26 @@ module Flipper
         nil
       end
 
+      def delete(feature, gate)
+        @gate_class.where(feature_key: feature.key, key: gate.key).destroy_all
+      end
+
       def enable_multi(feature, gate, thing)
-        with_connection(@gate_class) do
-          @gate_class.create! do |g|
-            g.feature_key = feature.key
-            g.key = gate.key
-            g.value = thing.value.to_s
+        with_write_connection(@gate_class) do |connection|
+          begin
+            connection.transaction(requires_new: true) do
+              @gate_class.create! do |g|
+                g.feature_key = feature.key
+                g.key = gate.key
+                g.value = thing.value.to_s
+              end
+            end
+          rescue ::ActiveRecord::RecordNotUnique
+            # already added so move on with life
           end
         end
 
         nil
-      rescue ::ActiveRecord::RecordNotUnique
-        # already added so no need move on with life
       end
 
       def result_for_gates(feature, gates)
@@ -238,13 +241,13 @@ module Flipper
         feature.gates.each do |gate|
           result[gate.key] =
             case gate.data_type
-            when :boolean
+            when :boolean, :integer
               if row = gates.detect { |key, value| !key.nil? && key.to_sym == gate.key }
                 row.last
               end
-            when :integer
+            when :json
               if row = gates.detect { |key, value| !key.nil? && key.to_sym == gate.key }
-                row.last
+                Typecast.from_json(row.last)
               end
             when :set
               gates.select { |key, value| !key.nil? && key.to_sym == gate.key }.map(&:last).to_set
@@ -255,9 +258,46 @@ module Flipper
         result
       end
 
+      # Check if value column is text instead of string
+      # See https://github.com/flippercloud/flipper/pull/692
+      def value_not_text?
+        with_connection(@gate_class) do |connection|
+          @gate_class.column_for_attribute(:value).type != :text
+        end
+      rescue ::ActiveRecord::ActiveRecordError => error
+        # If the table doesn't exist, the column doesn't exist either
+        warn "#{error.message}. You likely need to run `rails g flipper:active_record` and/or `rails db:migrate`."
+      end
+
       def with_connection(model = @feature_class, &block)
+        warn VALUE_TO_TEXT_WARNING if !warned_about_value_not_text? && value_not_text?
         model.connection_pool.with_connection(&block)
       end
+
+      def with_write_connection(model = @feature_class, &block)
+        # Use Rails' built-in method to find the class that controls the connection
+        # This walks up the inheritance chain to find which class called connects_to
+        if model.respond_to?(:connection_class_for_self)
+          connection_class = model.connection_class_for_self
+
+          # Only use connected_to if this class actually has connects_to configured
+          # connection_class? returns true when connects_to was called on the class
+          if connection_class.respond_to?(:connection_class?) && connection_class.connection_class?
+            connection_class.connected_to(role: :writing) do
+              with_connection(model, &block)
+            end
+          else
+            with_connection(model, &block)
+          end
+        else
+          with_connection(model, &block)
+        end
+      end
+
+      def warned_about_value_not_text?
+        return @warned_about_value_not_text if defined?(@warned_about_value_not_text)
+        @warned_about_value_not_text = true
+      end
     end
   end
 end

data/lib/flipper/version.rb

@@ -1,3 +1,13 @@
 module Flipper
-  VERSION = '1.0.0'.freeze
+  VERSION = '1.4.0'.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/lib/generators/flipper/templates/migration.erb

@@ -1,5 +1,5 @@
 class CreateFlipperTables < ActiveRecord::Migration<%= migration_version %>
-  def self.up
+  def up
     create_table :flipper_features do |t|
       t.string :key, null: false
       t.timestamps null: false
@@ -9,13 +9,13 @@ class CreateFlipperTables < ActiveRecord::Migration<%= migration_version %>
     create_table :flipper_gates do |t|
       t.string :feature_key, null: false
       t.string :key, null: false
-      t.string :value
+      t.text :value
       t.timestamps null: false
     end
-    add_index :flipper_gates, [:feature_key, :key, :value], unique: true
+    add_index :flipper_gates, [:feature_key, :key, :value], unique: true, length: { value: 255 }
   end
 
-  def self.down
+  def down
     drop_table :flipper_gates
     drop_table :flipper_features
   end

data/spec/flipper/adapters/active_record_spec.rb

@@ -1,182 +1,381 @@
-require 'flipper/adapters/active_record'
+SpecHelpers.silence { require 'flipper/adapters/active_record' }
 
 # Turn off migration logging for specs
 ActiveRecord::Migration.verbose = false
+ActiveRecord::Tasks::DatabaseTasks.root = File.dirname(__FILE__)
 
 RSpec.describe Flipper::Adapters::ActiveRecord do
   subject { described_class.new }
 
   before(:all) do
-    ActiveRecord::Base.establish_connection(adapter: 'sqlite3',
-                                            database: ':memory:')
+    # Eval migration template so we can run migration against each database
+    template_path = File.join(File.dirname(__FILE__), '../../../lib/generators/flipper/templates/migration.erb')
+    migration = ERB.new(File.read(template_path))
+    migration_version = "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
+    eval migration.result_with_hash(migration_version: migration_version) # defines CreateFlipperTables
   end
 
-  before(:each) do
-    ActiveRecord::Base.connection.execute <<-SQL
-      CREATE TABLE flipper_features (
-        id integer PRIMARY KEY,
-        key text NOT NULL UNIQUE,
-        created_at datetime NOT NULL,
-        updated_at datetime NOT NULL
-      )
-    SQL
-
-    ActiveRecord::Base.connection.execute <<-SQL
-      CREATE TABLE flipper_gates (
-        id integer PRIMARY KEY,
-        feature_key text NOT NULL,
-        key text NOT NULL,
-        value text DEFAULT NULL,
-        created_at datetime NOT NULL,
-        updated_at datetime NOT NULL
-      )
-    SQL
-
-    ActiveRecord::Base.connection.execute <<-SQL
-      CREATE UNIQUE INDEX index_gates_on_keys_and_value on flipper_gates (feature_key, key, value)
-    SQL
-  end
+  [
+    {
+      "adapter" => "sqlite3",
+      "database" => ":memory:"
+    },
 
-  after(:each) do
-    ActiveRecord::Base.connection.execute("DROP table IF EXISTS `flipper_features`")
-    ActiveRecord::Base.connection.execute("DROP table IF EXISTS `flipper_gates`")
-  end
+    {
+      "adapter" => "mysql2",
+      "encoding" => "utf8mb4",
+      "host" => ENV["MYSQL_HOST"],
+      "username" => ENV["MYSQL_USER"] || "root",
+      "password" => ENV["MYSQL_PASSWORD"] || "",
+      "database" => ENV["MYSQL_DATABASE"] || "flipper_test",
+      "port" => ENV["DB_PORT"] || 3306
+    },
 
-  it_should_behave_like 'a flipper adapter'
+    {
+      "adapter" => "postgresql",
+      "encoding" => "unicode",
+      "host" => "127.0.0.1",
+      "username" => ENV["POSTGRES_USER"] || "",
+      "password" => ENV["POSTGRES_PASSWORD"] || "",
+      "database" => ENV["POSTGRES_DATABASE"] || "flipper_test",
+    }
+  ].each do |config|
+    context "with #{config['adapter']}" do
+      context "with tables created" do
+        before(:all) do
+          skip_on_error(ActiveRecord::ConnectionNotEstablished, "#{config['adapter']} not available") do
+            silence do
+              ActiveRecord::Tasks::DatabaseTasks.create(config)
+            end
+          end
 
-  context 'requiring "flipper-active_record"' do
-    before do
-      Flipper.configuration = nil
-      Flipper.instance = nil
+          Flipper.configuration = nil
+        end
 
-      load 'flipper/adapters/active_record.rb'
-      ActiveSupport.run_load_hooks(:active_record, ActiveRecord::Base)
-    end
+        before(:each) do
+          silence do
+            ActiveRecord::Tasks::DatabaseTasks.purge(config)
+            CreateFlipperTables.migrate(:up)
+          end
+        end
 
-    it 'configures itself' do
-      expect(Flipper.adapter.adapter).to be_a(Flipper::Adapters::ActiveRecord)
-    end
-  end
+        after(:all) do
+          silence { ActiveRecord::Tasks::DatabaseTasks.drop(config) } unless $skip
+        end
 
-  context "ActiveRecord connection_pool" do
-    before do
-      ActiveRecord::Base.clear_active_connections!
-    end
+        it_should_behave_like 'a flipper adapter'
 
-    context "#features" do
-      it "does not hold onto connections" do
-        expect(ActiveRecord::Base.connection_handler.active_connections?).to be(false)
-        subject.features
-        expect(ActiveRecord::Base.connection_handler.active_connections?).to be(false)
-      end
+        it "should load actor ids fine" do
+          flipper.enable_percentage_of_time(:foo, 1)
 
-      it "does not release previously held connection" do
-        ActiveRecord::Base.connection # establish a new connection
-        expect(ActiveRecord::Base.connection_handler.active_connections?).to be(true)
-        subject.features
-        expect(ActiveRecord::Base.connection_handler.active_connections?).to be(true)
-      end
-    end
+          Flipper::Adapters::ActiveRecord::Gate.create!(
+            feature_key: "foo",
+            key: "actors",
+            value: "Organization;4",
+          )
 
-    context "#get_all" do
-      it "does not hold onto connections" do
-        expect(ActiveRecord::Base.connection_handler.active_connections?).to be(false)
-        subject.get_all
-        expect(ActiveRecord::Base.connection_handler.active_connections?).to be(false)
-      end
+          flipper = Flipper.new(subject)
+          flipper.preload([:foo])
+        end
 
-      it "does not release previously held connection" do
-        ActiveRecord::Base.connection # establish a new connection
-        expect(ActiveRecord::Base.connection_handler.active_connections?).to be(true)
-        subject.get_all
-        expect(ActiveRecord::Base.connection_handler.active_connections?).to be(true)
-      end
-    end
+        it 'should not poison wrapping transactions' do
+          flipper = Flipper.new(subject)
 
-    context "#add / #remove / #clear" do
-      let(:feature) { Flipper::Feature.new(:search, subject) }
-
-      it "does not hold onto connections" do
-        expect(ActiveRecord::Base.connection_handler.active_connections?).to be(false)
-        subject.add(feature)
-        expect(ActiveRecord::Base.connection_handler.active_connections?).to be(false)
-        subject.remove(feature)
-        expect(ActiveRecord::Base.connection_handler.active_connections?).to be(false)
-        subject.clear(feature)
-        expect(ActiveRecord::Base.connection_handler.active_connections?).to be(false)
-      end
+          actor = Struct.new(:flipper_id).new('flipper-id-123')
+          flipper.enable_actor(:foo, actor)
 
-      it "does not release previously held connection" do
-        ActiveRecord::Base.connection # establish a new connection
-        expect(ActiveRecord::Base.connection_handler.active_connections?).to be(true)
-        subject.add(feature)
-        expect(ActiveRecord::Base.connection_handler.active_connections?).to be(true)
-        subject.remove(feature)
-        expect(ActiveRecord::Base.connection_handler.active_connections?).to be(true)
-        subject.clear(feature)
-        expect(ActiveRecord::Base.connection_handler.active_connections?).to be(true)
-      end
-    end
+          ActiveRecord::Base.transaction do
+            flipper.enable_actor(:foo, actor)
+            # any read on the next line is fine, just need to ensure that
+            # poisoned transaction isn't raised
+            expect(Flipper::Adapters::ActiveRecord::Gate.count).to eq(1)
+          end
+        end
 
-    context "#get_multi" do
-      let(:feature) { Flipper::Feature.new(:search, subject) }
+        context "ActiveRecord connection_pool" do
+          before do
+            clear_active_connections!
+          end
 
-      it "does not hold onto connections" do
-        expect(ActiveRecord::Base.connection_handler.active_connections?).to be(false)
-        subject.get_multi([feature])
-        expect(ActiveRecord::Base.connection_handler.active_connections?).to be(false)
-      end
+          context "#features" do
+            it "does not hold onto connections" do
+              expect(active_connections?).to be(false)
+              subject.features
+              expect(active_connections?).to be(false)
+            end
 
-      it "does not release previously held connection" do
-        ActiveRecord::Base.connection # establish a new connection
-        expect(ActiveRecord::Base.connection_handler.active_connections?).to be(true)
-        subject.get_multi([feature])
-        expect(ActiveRecord::Base.connection_handler.active_connections?).to be(true)
-      end
-    end
+            it "does not release previously held connection" do
+              ActiveRecord::Base.connection # establish a new connection
+              expect(active_connections?).to be(true)
+              subject.features
+              expect(active_connections?).to be(true)
+            end
+          end
 
-    context "#enable/#disable boolean" do
-      let(:feature) { Flipper::Feature.new(:search, subject) }
-      let(:gate) { feature.gate(:boolean)}
+          context "#get_all" do
+            it "does not hold onto connections" do
+              expect(active_connections?).to be(false)
+              subject.get_all
+              expect(active_connections?).to be(false)
+            end
 
-      it "does not hold onto connections" do
-        expect(ActiveRecord::Base.connection_handler.active_connections?).to be(false)
-        subject.enable(feature, gate, gate.wrap(true))
-        expect(ActiveRecord::Base.connection_handler.active_connections?).to be(false)
-        subject.disable(feature, gate, gate.wrap(false))
-        expect(ActiveRecord::Base.connection_handler.active_connections?).to be(false)
-      end
+            it "does not release previously held connection" do
+              ActiveRecord::Base.connection # establish a new connection
+              expect(active_connections?).to be(true)
+              subject.get_all
+              expect(active_connections?).to be(true)
+            end
+          end
 
-      it "does not release previously held connection" do
-        ActiveRecord::Base.connection # establish a new connection
-        expect(ActiveRecord::Base.connection_handler.active_connections?).to be(true)
-        subject.enable(feature, gate, gate.wrap(true))
-        expect(ActiveRecord::Base.connection_handler.active_connections?).to be(true)
-        subject.disable(feature, gate, gate.wrap(false))
-        expect(ActiveRecord::Base.connection_handler.active_connections?).to be(true)
-      end
-    end
+          context "#add / #remove / #clear" do
+            let(:feature) { Flipper::Feature.new(:search, subject) }
+
+            it "does not hold onto connections" do
+              expect(active_connections?).to be(false)
+              subject.add(feature)
+              expect(active_connections?).to be(false)
+              subject.remove(feature)
+              expect(active_connections?).to be(false)
+              subject.clear(feature)
+              expect(active_connections?).to be(false)
+            end
+
+            it "does not release previously held connection" do
+              ActiveRecord::Base.connection # establish a new connection
+              expect(active_connections?).to be(true)
+              subject.add(feature)
+              expect(active_connections?).to be(true)
+              subject.remove(feature)
+              expect(active_connections?).to be(true)
+              subject.clear(feature)
+              expect(active_connections?).to be(true)
+            end
+          end
+
+          context "#get_multi" do
+            let(:feature) { Flipper::Feature.new(:search, subject) }
+
+            it "does not hold onto connections" do
+              expect(active_connections?).to be(false)
+              subject.get_multi([feature])
+              expect(active_connections?).to be(false)
+            end
+
+            it "does not release previously held connection" do
+              ActiveRecord::Base.connection # establish a new connection
+              expect(active_connections?).to be(true)
+              subject.get_multi([feature])
+              expect(active_connections?).to be(true)
+            end
+          end
+
+          context "#enable/#disable boolean" do
+            let(:feature) { Flipper::Feature.new(:search, subject) }
+            let(:gate) { feature.gate(:boolean)}
+
+            it "does not hold onto connections" do
+              expect(active_connections?).to be(false)
+              subject.enable(feature, gate, gate.wrap(true))
+              expect(active_connections?).to be(false)
+              subject.disable(feature, gate, gate.wrap(false))
+              expect(active_connections?).to be(false)
+            end
+
+            it "does not release previously held connection" do
+              ActiveRecord::Base.connection # establish a new connection
+              expect(active_connections?).to be(true)
+              subject.enable(feature, gate, gate.wrap(true))
+              expect(active_connections?).to be(true)
+              subject.disable(feature, gate, gate.wrap(false))
+              expect(active_connections?).to be(true)
+            end
+          end
+
+          context "#enable/#disable set" do
+            let(:feature) { Flipper::Feature.new(:search, subject) }
+            let(:gate) { feature.gate(:group) }
+
+            it "does not hold onto connections" do
+              expect(active_connections?).to be(false)
+              subject.enable(feature, gate, gate.wrap(:admin))
+              expect(active_connections?).to be(false)
+              subject.disable(feature, gate, gate.wrap(:admin))
+              expect(active_connections?).to be(false)
+            end
 
-    context "#enable/#disable set" do
-      let(:feature) { Flipper::Feature.new(:search, subject) }
-      let(:gate) { feature.gate(:group) }
+            it "does not release previously held connection" do
+              ActiveRecord::Base.connection # establish a new connection
+              expect(active_connections?).to be(true)
+              subject.enable(feature, gate, gate.wrap(:admin))
+              expect(active_connections?).to be(true)
+              subject.disable(feature, gate, gate.wrap(:admin))
+              expect(active_connections?).to be(true)
+            end
+          end
+        end
 
-      it "does not hold onto connections" do
-        expect(ActiveRecord::Base.connection_handler.active_connections?).to be(false)
-        subject.enable(feature, gate, gate.wrap(:admin))
-        expect(ActiveRecord::Base.connection_handler.active_connections?).to be(false)
-        subject.disable(feature, gate, gate.wrap(:admin))
-        expect(ActiveRecord::Base.connection_handler.active_connections?).to be(false)
+        if ActiveRecord.version >= Gem::Version.new('7.1')
+          context 'with read/write roles' do
+            before do
+              skip "connected_to with roles is not supported on #{config['adapter']}" if config["adapter"] == "sqlite3"
+            end
+
+            let(:abstract_class) do
+              # Create a named abstract class (Rails requires names for connects_to)
+              klass = Class.new(ActiveRecord::Base) do
+                self.abstract_class = true
+              end
+              stub_const('TestApplicationRecord', klass)
+
+              # Now configure connects_to with the same database for both roles
+              # In production, these would be different (primary/replica)
+              klass.connects_to database: {
+                writing: config,
+                reading: config
+              }
+
+              klass
+            end
+
+            after do
+              # Disconnect role-based connections to avoid interfering with database cleanup
+              clear_all_connections!
+            end
+
+            let(:feature_class) do
+              klass = Class.new(abstract_class) do
+                self.table_name = 'flipper_features'
+                validates :key, presence: true
+              end
+              stub_const('TestFeature', klass)
+              klass
+            end
+
+            let(:gate_class) do
+              klass = Class.new(abstract_class) do
+                self.table_name = 'flipper_gates'
+              end
+              stub_const('TestGate', klass)
+              klass
+            end
+
+            let(:adapter_with_roles) do
+              described_class.new(
+                feature_class: feature_class,
+                gate_class: gate_class
+              )
+            end
+
+            it 'can perform write operations when forced to reading role' do
+              abstract_class.connected_to(role: :reading) do
+                flipper = Flipper.new(adapter_with_roles)
+
+                feature = flipper[:test_feature]
+                expect { feature.enable }.not_to raise_error
+                expect(feature.enabled?).to be(true)
+                expect { feature.disable }.not_to raise_error
+                expect(feature.enabled?).to be(false)
+
+                feature = flipper[:actor_test]
+                actor = Struct.new(:flipper_id).new(123)
+                expect { feature.enable_actor(actor) }.not_to raise_error
+                expect(feature.enabled?(actor)).to be(true)
+                expect { feature.disable_actor(actor) }.not_to raise_error
+                expect(feature.enabled?(actor)).to be(false)
+
+                feature = flipper[:gate_test]
+                expect { feature.enable_percentage_of_time(50) }.not_to raise_error
+                expect { feature.disable_percentage_of_time }.not_to raise_error
+                feature.enable
+                expect { feature.remove }.not_to raise_error
+
+                feature = flipper[:expression_test]
+                expression = Flipper.property(:plan).eq("premium")
+                expect { feature.enable_expression(expression) }.not_to raise_error
+                expect(feature.expression).to eq(expression)
+                expect { feature.disable_expression }.not_to raise_error
+                expect(feature.expression).to be_nil
+              end
+            end
+
+            it 'does not hold onto connections during write operations' do
+              clear_active_connections!
+
+              abstract_class.connected_to(role: :reading) do
+                flipper = Flipper.new(adapter_with_roles)
+                feature = flipper[:connection_test]
+
+                feature.enable
+                expect(active_connections?).to be(false)
+              end
+            end
+          end
+        end
+
+        context 'requiring "flipper-active_record"' do
+          before do
+            Flipper.configuration = nil
+            Flipper.instance = nil
+
+            silence { load 'flipper/adapters/active_record.rb' }
+          end
+
+          it 'configures itself' do
+            expect(Flipper.adapter.adapter).to be_a(Flipper::Adapters::ActiveRecord)
+          end
+        end
       end
 
-      it "does not release previously held connection" do
-        ActiveRecord::Base.connection # establish a new connection
-        expect(ActiveRecord::Base.connection_handler.active_connections?).to be(true)
-        subject.enable(feature, gate, gate.wrap(:admin))
-        expect(ActiveRecord::Base.connection_handler.active_connections?).to be(true)
-        subject.disable(feature, gate, gate.wrap(:admin))
-        expect(ActiveRecord::Base.connection_handler.active_connections?).to be(true)
+      context "without tables created" do
+        before(:all) do
+          skip_on_error(ActiveRecord::ConnectionNotEstablished, "#{config['adapter']} not available") do
+            silence do
+              ActiveRecord::Tasks::DatabaseTasks.create(config)
+            end
+          end
+
+          Flipper.configuration = nil
+        end
+
+        before(:each) do
+          ActiveRecord::Base.establish_connection(config)
+        end
+
+        after(:each) do
+          ActiveRecord::Base.connection.close
+        end
+
+        after(:all) do
+          silence { ActiveRecord::Tasks::DatabaseTasks.drop(config) } unless $skip
+        end
+
+        it "does not raise an error" do
+          Flipper.configuration = nil
+          Flipper.instance = nil
+
+          silence do
+            expect {
+              load 'flipper/adapters/active_record.rb'
+              Flipper::Adapters::ActiveRecord.new
+            }.not_to raise_error
+          end
+        end
       end
     end
   end
+
+  def active_connections?
+    method = ActiveRecord::Base.connection_handler.method(:active_connections?)
+    method.arity == 0 ? method.call : method.call(:all)
+  end
+
+  def clear_active_connections!
+    method = ActiveRecord::Base.connection_handler.method(:clear_active_connections!)
+    method.arity == 0 ? method.call : method.call(:all)
+  end
+
+  def clear_all_connections!
+    method = ActiveRecord::Base.connection_handler.method(:clear_all_connections!)
+    method.arity == 0 ? method.call : method.call(:all)
+  end
 end

data/test/adapters/active_record_test.rb

@@ -11,8 +11,6 @@ class ActiveRecordTest < MiniTest::Test
                                           database: ':memory:')
 
   def setup
-    @adapter = Flipper::Adapters::ActiveRecord.new
-
     ActiveRecord::Base.connection.execute <<-SQL
       CREATE TABLE flipper_features (
         id integer PRIMARY KEY,
@@ -36,6 +34,8 @@ class ActiveRecordTest < MiniTest::Test
     ActiveRecord::Base.connection.execute <<-SQL
       CREATE UNIQUE INDEX index_gates_on_keys_and_value on flipper_gates (feature_key, key, value)
     SQL
+
+    @adapter = Flipper::Adapters::ActiveRecord.new
   end
 
   def teardown
@@ -47,9 +47,16 @@ class ActiveRecordTest < MiniTest::Test
     ActiveRecord::Base.table_name_prefix = :foo_
     ActiveRecord::Base.table_name_suffix = :_bar
 
-    Flipper::Adapters::ActiveRecord.send(:remove_const, :Feature)
-    Flipper::Adapters::ActiveRecord.send(:remove_const, :Gate)
+    # Remove constants so they get redefined with new prefix/suffix
+    Flipper::Adapters::ActiveRecord.send(:remove_const, :Model) if Flipper::Adapters::ActiveRecord.const_defined?(:Model)
+    Flipper::Adapters::ActiveRecord.send(:remove_const, :Feature) if Flipper::Adapters::ActiveRecord.const_defined?(:Feature)
+    Flipper::Adapters::ActiveRecord.send(:remove_const, :Gate) if Flipper::Adapters::ActiveRecord.const_defined?(:Gate)
+    Flipper::Adapters.send(:remove_const, :ActiveRecord)
+
     load("flipper/adapters/active_record.rb")
+    load("flipper/adapters/active_record/model.rb")
+    load("flipper/adapters/active_record/feature.rb")
+    load("flipper/adapters/active_record/gate.rb")
 
     assert_equal "foo_flipper_features_bar", Flipper::Adapters::ActiveRecord::Feature.table_name
     assert_equal "foo_flipper_gates_bar", Flipper::Adapters::ActiveRecord::Gate.table_name
@@ -58,8 +65,15 @@ class ActiveRecordTest < MiniTest::Test
     ActiveRecord::Base.table_name_prefix = ""
     ActiveRecord::Base.table_name_suffix = ""
 
-    Flipper::Adapters::ActiveRecord.send(:remove_const, :Feature)
-    Flipper::Adapters::ActiveRecord.send(:remove_const, :Gate)
+    # Remove constants so they get redefined with reset prefix/suffix
+    Flipper::Adapters::ActiveRecord.send(:remove_const, :Model) if Flipper::Adapters::ActiveRecord.const_defined?(:Model)
+    Flipper::Adapters::ActiveRecord.send(:remove_const, :Feature) if Flipper::Adapters::ActiveRecord.const_defined?(:Feature)
+    Flipper::Adapters::ActiveRecord.send(:remove_const, :Gate) if Flipper::Adapters::ActiveRecord.const_defined?(:Gate)
+    Flipper::Adapters.send(:remove_const, :ActiveRecord)
+
     load("flipper/adapters/active_record.rb")
+    load("flipper/adapters/active_record/model.rb")
+    load("flipper/adapters/active_record/feature.rb")
+    load("flipper/adapters/active_record/gate.rb")
   end
 end

data/test_rails/generators/flipper/active_record_generator_test.rb

@@ -1,6 +1,4 @@
 require 'helper'
-require 'active_record'
-require 'rails/generators/test_case'
 require 'generators/flipper/active_record_generator'
 
 class FlipperActiveRecordGeneratorTest < Rails::Generators::TestCase
@@ -17,7 +15,7 @@ class FlipperActiveRecordGeneratorTest < Rails::Generators::TestCase
                         end
     assert_migration 'db/migrate/create_flipper_tables.rb', <<~MIGRATION
       class CreateFlipperTables < ActiveRecord::Migration#{migration_version}
-        def self.up
+        def up
           create_table :flipper_features do |t|
             t.string :key, null: false
             t.timestamps null: false
@@ -27,13 +25,13 @@ class FlipperActiveRecordGeneratorTest < Rails::Generators::TestCase
           create_table :flipper_gates do |t|
             t.string :feature_key, null: false
             t.string :key, null: false
-            t.string :value
+            t.text :value
             t.timestamps null: false
           end
-          add_index :flipper_gates, [:feature_key, :key, :value], unique: true
+          add_index :flipper_gates, [:feature_key, :key, :value], unique: true, length: { value: 255 }
         end
 
-        def self.down
+        def down
           drop_table :flipper_gates
           drop_table :flipper_features
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: flipper-active_record
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.4.0
 platform: ruby
 authors:
 - John Nunemaker
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-08-23 00:00:00.000000000 Z
+date: 2026-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: flipper
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: 1.4.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: 1.4.0
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -33,7 +33,7 @@ dependencies:
         version: '4.2'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '8'
+        version: '9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -43,7 +43,7 @@ dependencies:
         version: '4.2'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '8'
+        version: '9'
 description:
 email: support@flippercloud.io
 executables: []
@@ -56,10 +56,14 @@ files:
 - examples/active_record/ar_setup.rb
 - examples/active_record/basic.rb
 - examples/active_record/cached.rb
+- examples/active_record/group_migration.rb
 - examples/active_record/internals.rb
 - flipper-active_record.gemspec
 - lib/flipper-active_record.rb
 - lib/flipper/adapters/active_record.rb
+- lib/flipper/adapters/active_record/feature.rb
+- lib/flipper/adapters/active_record/gate.rb
+- lib/flipper/adapters/active_record/model.rb
 - lib/flipper/version.rb
 - lib/generators/flipper/active_record_generator.rb
 - lib/generators/flipper/templates/migration.erb
@@ -74,7 +78,8 @@ metadata:
   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/blob/main/Changelog.md
+  changelog_uri: https://github.com/flippercloud/flipper/releases/tag/v1.4.0
+  funding_uri: https://github.com/sponsors/flippercloud
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -90,10 +95,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
-summary: ActiveRecord adapter for Flipper
-test_files:
-- spec/flipper/adapters/active_record_spec.rb
-- test/adapters/active_record_test.rb
+summary: ActiveRecord feature flag adapter for Flipper
+test_files: []