rollout-active_record-adapter 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ecefa7e74cc8b39f614ae2e2cb1a33e7072aa13ded266d394052356c41139492
+  data.tar.gz: 1e2cccffc216f98f7a10507fc90d9b9f27612135e878919d1296ace3f35e859b
+SHA512:
+  metadata.gz: abf00af86c57f1340d03ef90d33c4225b6f82a183aee526c35c5f6f6e4ed479597579fe7e5c74ab06e793ab65d2ca00d234c30125b26c5eedef1707ff28682f5
+  data.tar.gz: 5c597704919dfdd503bfdcbd9a28175cc94ab49454d49045ead229e18315c6f48493a4f66e8d27511fbcd320c801a418b8caf9b0aec3f9369310b49af272785c

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010-InfinityAndBeyond BitLove, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/generators/rollout/active_record/install_generator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/active_record"
+
+class Rollout
+  module ActiveRecord
+    class InstallGenerator < ::Rails::Generators::Base
+      include ::ActiveRecord::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      class_option :database, type: :string, desc: "Database key to generate the migration for"
+
+      def self.next_migration_number(dirname)
+        ::ActiveRecord::Generators::Base.next_migration_number(dirname)
+      end
+
+      def copy_migration
+        migration_template(
+          "create_rollout_tables.rb.tt",
+          File.join(db_migrate_path, "create_rollout_tables.rb"),
+        )
+      end
+    end
+  end
+end

data/lib/generators/rollout/active_record/templates/create_rollout_tables.rb.tt

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+class CreateRolloutTables < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+  def change
+    name_options = { null: false }
+    name_options[:collation] = "utf8mb4_bin" if connection.adapter_name.match?(/mysql/i)
+    payload_options = { null: false }
+    payload_options[:limit] = 16_777_215 if connection.adapter_name.match?(/mysql/i)
+
+    create_table :rollout_features do |t|
+      t.string :name, **name_options
+      t.float :percentage, limit: 53, null: false, default: 0.0
+      t.text :users, **payload_options
+      t.text :groups, **payload_options
+      t.text :data, **payload_options
+      t.timestamps
+    end
+
+    add_index :rollout_features, :name, unique: true
+
+    create_table :rollout_events do |t|
+      t.string :feature_name, **name_options
+      t.string :event_name, null: false
+      t.text :data, **payload_options
+      t.text :context, **payload_options
+      t.boolean :feature_visible, null: false, default: true
+      t.boolean :global_visible, null: false, default: true
+      t.datetime :occurred_at, null: false, precision: 6
+    end
+
+    add_index :rollout_events,
+      [:feature_name, :feature_visible, :occurred_at],
+      name: "index_rollout_events_for_feature_history"
+    add_index :rollout_events,
+      [:global_visible, :occurred_at],
+      name: "index_rollout_events_for_global_history"
+    add_index :rollout_events,
+      [:feature_visible, :global_visible],
+      name: "index_rollout_events_for_hidden_cleanup"
+  end
+end

data/lib/rollout/active_record/codec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'rollout/feature_state'
+require 'rollout/logging'
+
+class Rollout
+  module ActiveRecord
+    class Codec
+      def self.dump(value)
+        JSON.generate(value)
+      end
+
+      def self.load_array(payload)
+        JSON.parse(payload)
+      end
+
+      def self.load_hash(payload)
+        JSON.parse(payload)
+      end
+
+      def self.load_event_hash(payload)
+        JSON.parse(payload, symbolize_names: true)
+      end
+
+      def self.feature_state(name, record)
+        if record.nil?
+          return FeatureState.new(
+            name: name,
+            percentage: 0.0,
+            users: [],
+            groups: [],
+            data: {},
+          )
+        end
+
+        FeatureState.new(
+          name: name,
+          percentage: record.percentage,
+          users: load_array(record.users),
+          groups: load_array(record.groups),
+          data: load_hash(record.data),
+        )
+      end
+
+      def self.event(record)
+        Logging::Event.new(
+          feature: record.feature_name,
+          name: record.event_name,
+          data: load_event_hash(record.data),
+          context: load_event_hash(record.context),
+          created_at: record.occurred_at,
+        )
+      end
+    end
+  end
+end

data/lib/rollout/active_record/feature_cache.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+class Rollout
+  module ActiveRecord
+    class FeatureCache
+      DEFAULT_MAX_SIZE = 4096
+
+      def initialize(ttl_seconds:, clock: nil, max_size: DEFAULT_MAX_SIZE)
+        unless ttl_seconds.is_a?(Integer) && ttl_seconds > 0
+          raise ArgumentError, "cache_ttl_seconds must be an Integer > 0"
+        end
+        unless max_size.is_a?(Integer) && max_size > 0
+          raise ArgumentError, "max_size must be an Integer > 0"
+        end
+
+        @ttl_seconds = ttl_seconds
+        @max_size = max_size
+        @clock = clock || -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) }
+        @entries = {}
+        @generation = 0
+        @mutex = Mutex.new
+      end
+
+      def generation
+        @mutex.synchronize { @generation }
+      end
+
+      def read(name, context: nil)
+        key = entry_key(name, context)
+        @mutex.synchronize do
+          entry = @entries[key]
+          return nil unless entry
+          if entry[:expires_at] <= now
+            @entries.delete(key)
+            return nil
+          end
+
+          entry[:state].deep_clone
+        end
+      end
+
+      def fill(generation, states, context: nil)
+        clones = states.map { |state| [state.name.to_s, state.deep_clone] }
+        @mutex.synchronize do
+          return if generation != @generation
+
+          clones.each do |name, clone|
+            store_locked(name, clone, context)
+          end
+        end
+      end
+
+      def delete(*names, context: nil)
+        keys = names.map { |name| entry_key(name, context) }
+        @mutex.synchronize do
+          @generation += 1
+          keys.each { |key| @entries.delete(key) }
+        end
+      end
+
+      def clear
+        @mutex.synchronize do
+          @generation += 1
+          @entries.clear
+        end
+      end
+
+      private
+
+      def store_locked(name, clone, context)
+        key = entry_key(name, context)
+        @entries.delete(key)
+        if @entries.size >= @max_size
+          prune_expired_locked
+          @entries.shift while @entries.size >= @max_size
+        end
+        @entries[key] = { state: clone, expires_at: now + @ttl_seconds }
+      end
+
+      def prune_expired_locked
+        t = now
+        @entries.delete_if { |_key, entry| entry[:expires_at] <= t }
+      end
+
+      def entry_key(name, context)
+        [context, name.to_s]
+      end
+
+      def now
+        @clock.call
+      end
+    end
+  end
+end

data/lib/rollout/active_record/migration.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+class Rollout
+  module ActiveRecord
+    class Migration
+      class Difference
+        attr_reader :name, :kind, :field, :source, :destination
+
+        def initialize(name:, kind:, field: nil, source: nil, destination: nil)
+          @name = name
+          @kind = kind
+          @field = field
+          @source = source
+          @destination = destination
+        end
+
+        def ==(other)
+          other.is_a?(self.class) &&
+            name == other.name &&
+            kind == other.kind &&
+            field == other.field &&
+            source == other.source &&
+            destination == other.destination
+        end
+      end
+
+      class Result
+        attr_reader :status, :feature_count, :history_count, :missing_names, :unregistered_names, :differences
+
+        def initialize(
+          status:,
+          feature_count: 0,
+          history_count: 0,
+          missing_names: [],
+          unregistered_names: [],
+          differences: []
+        )
+          @status = status
+          @feature_count = feature_count
+          @history_count = history_count
+          @missing_names = missing_names
+          @unregistered_names = unregistered_names
+          @differences = differences
+        end
+
+        def success?
+          status == :ok || status == :ready
+        end
+
+        def summary
+          case status
+          when :ready
+            ready_summary("Ready to import")
+          when :ok
+            ready_summary("Imported")
+          when :source_invalid
+            "Source invalid: missing=#{missing_names.inspect} unregistered=#{unregistered_names.inspect}"
+          when :destination_conflict
+            "Destination already has rollout data"
+          when :verification_failed
+            verification_failed_summary
+          else
+            "Migration failed (#{status})"
+          end
+        end
+
+        private
+
+        def ready_summary(prefix)
+          features = "#{feature_count} feature#{'s' unless feature_count == 1}"
+          if history_count > 0
+            events = "#{history_count} history event#{'s' unless history_count == 1}"
+            "#{prefix} #{features} and #{events}"
+          else
+            "#{prefix} #{features}"
+          end
+        end
+
+        def verification_failed_summary
+          message = "Imported data did not match the source"
+          difference = differences.first
+          return message unless difference
+
+          details = [difference.kind, difference.name, difference.field].compact.join(" ")
+          "#{message}: #{details}"
+        end
+      end
+
+      def initialize(source:, destination:, include_history: false)
+        @source = source
+        @destination = destination
+        @include_history = include_history
+      end
+
+      def dry_run
+        execute(write: false)
+      end
+
+      def run
+        execute(write: true)
+      end
+
+      private
+
+      def execute(write:)
+        export = @source.export_features(include_history: @include_history)
+        history = @include_history ? Array(export.history) : []
+        counts = { feature_count: export.states.size, history_count: history.size }
+
+        unless export.valid?
+          return Result.new(
+            status: :source_invalid,
+            missing_names: export.missing_names,
+            unregistered_names: export.unregistered_names,
+            **counts,
+          )
+        end
+
+        if @destination.occupied?
+          return Result.new(status: :destination_conflict, **counts)
+        end
+
+        return Result.new(status: :ready, **counts) unless write
+
+        failed = nil
+        begin
+          @destination.import_features(export.states, history: history) do
+            differences = compare_states(export.states, imported_states) +
+              compare_history(history)
+            next if differences.empty?
+
+            failed = Result.new(status: :verification_failed, differences: differences, **counts)
+            raise ::ActiveRecord::Rollback
+          end
+        rescue ::Rollout::Adapters::ActiveRecord::DestinationNotEmpty
+          return Result.new(status: :destination_conflict, **counts)
+        end
+
+        failed || Result.new(status: :ok, **counts)
+      end
+
+      def imported_states
+        @destination.fetch_features(@destination.feature_names)
+      end
+
+      def compare_states(source_states, destination_states)
+        source_by_name = source_states.to_h { |state| [state.name, state] }
+        destination_by_name = destination_states.to_h { |state| [state.name, state] }
+        names = (source_by_name.keys | destination_by_name.keys).sort
+        differences = []
+
+        names.each do |name|
+          source = source_by_name[name]
+          destination = destination_by_name[name]
+
+          if source.nil?
+            differences << Difference.new(name: name, kind: :extra)
+            next
+          end
+
+          if destination.nil?
+            differences << Difference.new(name: name, kind: :missing)
+            next
+          end
+
+          next if source == destination
+
+          %i[percentage users groups data].each do |field|
+            source_value = source.public_send(field)
+            destination_value = destination.public_send(field)
+            next if source_value == destination_value
+
+            differences << Difference.new(
+              name: name,
+              kind: :changed,
+              field: field,
+              source: source_value,
+              destination: destination_value,
+            )
+          end
+        end
+
+        differences
+      end
+
+      def compare_history(source_entries)
+        source_by_feature = Hash.new { |hash, name| hash[name] = [] }
+        source_global = []
+
+        source_entries.each do |entry|
+          event = entry.event
+          source_by_feature[event.feature.to_s] << event if entry.feature_visible
+          source_global << event if entry.global_visible
+        end
+
+        names = (source_by_feature.keys | history_feature_names).sort
+        differences = []
+
+        names.each do |name|
+          differences.concat(
+            event_differences(
+              name,
+              source_by_feature[name],
+              @destination.feature_events(name),
+            ),
+          )
+        end
+        differences.concat(event_differences("_global_", source_global, @destination.global_events))
+        differences
+      end
+
+      def history_feature_names
+        @destination.global_events.map { |event| event.feature.to_s } |
+          @destination.feature_names.map(&:to_s)
+      end
+
+      def event_differences(name, source_events, destination_events)
+        source_signatures = source_events.map { |event| event_signature(event) }
+        destination_signatures = destination_events.map { |event| event_signature(event) }
+        return [] if source_signatures == destination_signatures
+
+        [Difference.new(
+          name: name,
+          kind: :history,
+          field: :events,
+          source: source_signatures,
+          destination: destination_signatures,
+        )]
+      end
+
+      def event_signature(event)
+        {
+          feature: event.feature.to_s,
+          name: event.name.to_s,
+          data: event.data,
+          context: event.context,
+          timestamp: (event.created_at.to_r * 1_000_000).round,
+        }
+      end
+    end
+  end
+end

data/lib/rollout/active_record/schema.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+class Rollout
+  module ActiveRecord
+    module Schema
+      def self.create(connection, features_table: "rollout_features", events_table: "rollout_events")
+        name_options = name_column_options(connection)
+        payload_options = payload_column_options(connection)
+
+        connection.create_table(features_table) do |table|
+          table.string :name, **name_options
+          table.float :percentage, limit: 53, null: false, default: 0.0
+          table.text :users, **payload_options
+          table.text :groups, **payload_options
+          table.text :data, **payload_options
+          table.timestamps
+        end
+        connection.add_index(features_table, :name, unique: true)
+
+        connection.create_table(events_table) do |table|
+          table.string :feature_name, **name_options
+          table.string :event_name, null: false
+          table.text :data, **payload_options
+          table.text :context, **payload_options
+          table.boolean :feature_visible, null: false, default: true
+          table.boolean :global_visible, null: false, default: true
+          table.datetime :occurred_at, null: false, precision: 6
+        end
+        connection.add_index(
+          events_table,
+          [:feature_name, :feature_visible, :occurred_at],
+          name: "index_#{events_table}_for_feature_history",
+        )
+        connection.add_index(
+          events_table,
+          [:global_visible, :occurred_at],
+          name: "index_#{events_table}_for_global_history",
+        )
+        connection.add_index(
+          events_table,
+          [:feature_visible, :global_visible],
+          name: "index_#{events_table}_for_hidden_cleanup",
+        )
+      end
+
+      def self.drop(connection, features_table: "rollout_features", events_table: "rollout_events")
+        connection.drop_table(events_table, if_exists: true)
+        connection.drop_table(features_table, if_exists: true)
+      end
+
+      def self.name_column_options(connection)
+        options = { null: false }
+        options[:collation] = "utf8mb4_bin" if connection.adapter_name.match?(/mysql/i)
+        options
+      end
+
+      def self.payload_column_options(connection)
+        options = { null: false }
+        options[:limit] = 16_777_215 if connection.adapter_name.match?(/mysql/i)
+        options
+      end
+    end
+  end
+end

data/lib/rollout/adapters/active_record.rb

@@ -0,0 +1,386 @@
+# frozen_string_literal: true
+
+require 'active_record'
+require 'rollout'
+require 'rollout/active_record/schema'
+require 'rollout/active_record/codec'
+require 'rollout/active_record/migration'
+require 'rollout/active_record/feature_cache'
+
+class Rollout
+  module Adapters
+    class ActiveRecord
+      class DestinationNotEmpty < ArgumentError
+      end
+
+      def initialize(
+        base_record_class: ::ActiveRecord::Base,
+        features_table_name: "rollout_features",
+        events_table_name: "rollout_events",
+        cache_ttl_seconds: nil
+      )
+        @base_record_class = base_record_class
+        @features_table_name = features_table_name
+        @events_table_name = events_table_name
+        @feature_record = build_record_class(@features_table_name)
+        @event_record = build_record_class(@events_table_name)
+        @feature_cache = cache_ttl_seconds.nil? ? nil : ::Rollout::ActiveRecord::FeatureCache.new(ttl_seconds: cache_ttl_seconds)
+      end
+
+      def fetch_feature(name)
+        if use_feature_cache?
+          context = cache_context
+          cached = @feature_cache.read(name, context: context)
+          return cached if cached
+
+          generation = @feature_cache.generation
+          state = load_feature(name)
+          @feature_cache.fill(generation, [state], context: context)
+          return state
+        end
+
+        load_feature(name)
+      end
+
+      def fetch_features(names)
+        return [] if names.empty?
+        return load_features(names) unless use_feature_cache?
+
+        context = cache_context
+        hits, misses = partition_cached_features(names, context)
+        fill_feature_cache(hits, misses, context) unless misses.empty?
+        names.map { |name| hits[name.to_s].deep_clone }
+      end
+
+      def feature_names
+        @feature_record.order(:id).pluck(:name)
+      end
+
+      def feature_exists?(name)
+        @feature_record.exists?(name: name.to_s)
+      end
+
+      def save_feature(state)
+        @feature_record.transaction do
+          persist_state(locked_feature(state.name), state)
+          invalidate_features_after_commit(state.name)
+        end
+      end
+
+      def delete_feature(name)
+        @feature_record.where(name: name.to_s).delete_all
+        invalidate_features_after_commit(name)
+      end
+
+      def clear_features
+        @feature_record.delete_all
+        invalidate_all_features_after_commit
+      end
+
+      def occupied?
+        @feature_record.uncached do
+          @feature_record.exists? || @event_record.exists?
+        end
+      end
+
+      def import_features(states, history: [])
+        raise ArgumentError, "states must be an Array" unless states.is_a?(Array)
+        raise ArgumentError, "history must be an Array" unless history.is_a?(Array)
+
+        states.each do |state|
+          next if state.is_a?(::Rollout::FeatureState)
+
+          raise ArgumentError, "states must contain FeatureState objects"
+        end
+
+        @feature_record.transaction(requires_new: true) do
+          if occupied?
+            raise DestinationNotEmpty, "destination already has rollout data"
+          end
+
+          states.each { |state| persist_state(nil, state) }
+          history.each { |entry| insert_imported_event(entry) }
+          yield if block_given?
+          invalidate_all_features_after_commit
+        end
+      end
+
+      def mutate_feature(name)
+        rollback_error = nil
+        mutation = nil
+
+        @feature_record.transaction(requires_new: true) do
+          record = locked_feature(name)
+          begin
+            mutation = yield ::Rollout::ActiveRecord::Codec.feature_state(name, record)
+          rescue ::ActiveRecord::Rollback => error
+            rollback_error = error
+            raise
+          end
+          persist_mutation(record, mutation)
+          invalidate_features_after_commit(name)
+        end
+
+        raise rollback_error if rollback_error
+
+        mutation
+      end
+
+      def feature_events(name, limit: nil)
+        events_from(
+          @event_record.where(feature_name: name.to_s, feature_visible: true),
+          limit: limit,
+        )
+      end
+
+      def global_events(limit: nil)
+        events_from(
+          @event_record.where(global_visible: true),
+          limit: limit,
+        )
+      end
+
+      def feature_updated_at(name)
+        @event_record
+          .where(feature_name: name.to_s, feature_visible: true)
+          .order(occurred_at: :desc, id: :desc)
+          .limit(1)
+          .pick(:occurred_at)
+      end
+
+      def delete_feature_events(name)
+        @feature_record.transaction do
+          @event_record.where(feature_name: name.to_s, feature_visible: true)
+            .update_all(feature_visible: false)
+          delete_hidden_events
+        end
+      end
+
+      private
+
+      def partition_cached_features(names, context)
+        hits = {}
+        misses = []
+        names.map(&:to_s).uniq.each do |name|
+          cached = @feature_cache.read(name, context: context)
+          if cached
+            hits[name] = cached
+          else
+            misses << name
+          end
+        end
+        [hits, misses]
+      end
+
+      def fill_feature_cache(hits, misses, context)
+        generation = @feature_cache.generation
+        load_features(misses).each do |state|
+          hits[state.name] = state
+        end
+        @feature_cache.fill(generation, misses.map { |name| hits[name] }, context: context)
+      end
+
+      def load_feature(name)
+        record = with_query_cache_bypass { find_feature(name) }
+        ::Rollout::ActiveRecord::Codec.feature_state(name, record)
+      end
+
+      def load_features(names)
+        return [] if names.empty?
+
+        unique_names = names.map(&:to_s).uniq
+        records = with_query_cache_bypass do
+          @feature_record.where(name: unique_names).index_by(&:name)
+        end
+        names.map { |name| ::Rollout::ActiveRecord::Codec.feature_state(name, records[name.to_s]) }
+      end
+
+      def with_query_cache_bypass
+        return yield unless @feature_cache
+
+        @feature_record.uncached { yield }
+      end
+
+      def use_feature_cache?
+        @feature_cache && !@feature_record.connection.transaction_open?
+      end
+
+      def cache_context
+        @feature_record.connection_pool.object_id
+      end
+
+      def invalidate_features_after_commit(*names)
+        return unless @feature_cache
+
+        context = cache_context
+        after_outer_commit { @feature_cache.delete(*names, context: context) }
+      end
+
+      def invalidate_all_features_after_commit
+        return unless @feature_cache
+
+        after_outer_commit { @feature_cache.clear }
+      end
+
+      def after_outer_commit(&block)
+        txn = outermost_open_transaction
+        if txn.nil?
+          block.call
+        elsif txn.respond_to?(:after_commit)
+          txn.after_commit(&block)
+        else
+          txn.add_record(AfterCommitCallback.new(&block))
+        end
+      end
+
+      def outermost_open_transaction
+        connection = @feature_record.connection
+        return nil unless connection.transaction_open?
+
+        stack = connection.transaction_manager.instance_variable_get(:@stack)
+        stack&.first
+      end
+
+      def build_record_class(table_name)
+        Class.new(@base_record_class) do
+          self.table_name = table_name
+          self.inheritance_column = :_type_disabled
+        end
+      end
+
+      def find_feature(name)
+        @feature_record.find_by(name: name.to_s)
+      end
+
+      def locked_feature(name)
+        @feature_record.uncached do
+          @feature_record.lock.find_by(name: name.to_s)
+        end
+      end
+
+      def persist_mutation(record, mutation)
+        persist_state(record, mutation.fetch(:state))
+        event = mutation[:event]
+        return unless event
+
+        history_length = mutation.fetch(:history_length)
+        validate_history_length!(history_length)
+        insert_event(event, global: mutation[:global])
+        prune_feature_events(event.feature, history_length)
+        prune_global_events(history_length) if mutation[:global]
+      end
+
+      def persist_state(record, state)
+        attributes = {
+          percentage: state.percentage,
+          users: ::Rollout::ActiveRecord::Codec.dump(state.users),
+          groups: ::Rollout::ActiveRecord::Codec.dump(state.groups),
+          data: ::Rollout::ActiveRecord::Codec.dump(state.data),
+        }
+
+        if record
+          record.update!(attributes)
+        else
+          @feature_record.create!(attributes.merge(name: state.name.to_s))
+        end
+      end
+
+      def insert_event(event, global:)
+        @event_record.create!(
+          feature_name: event.feature.to_s,
+          event_name: event.name.to_s,
+          data: ::Rollout::ActiveRecord::Codec.dump(event.data),
+          context: ::Rollout::ActiveRecord::Codec.dump(event.context),
+          feature_visible: true,
+          global_visible: global ? true : false,
+          occurred_at: event.created_at,
+        )
+      end
+
+      def insert_imported_event(entry)
+        event = entry.event
+        @event_record.create!(
+          feature_name: event.feature.to_s,
+          event_name: event.name.to_s,
+          data: ::Rollout::ActiveRecord::Codec.dump(event.data),
+          context: ::Rollout::ActiveRecord::Codec.dump(event.context),
+          feature_visible: !!entry.feature_visible,
+          global_visible: !!entry.global_visible,
+          occurred_at: event.created_at,
+        )
+      end
+
+      def prune_feature_events(name, history_length)
+        hide_excess(
+          @event_record.where(feature_name: name.to_s, feature_visible: true),
+          :feature_visible,
+          history_length,
+        )
+        delete_hidden_events
+      end
+
+      def prune_global_events(history_length)
+        hide_excess(
+          @event_record.where(global_visible: true),
+          :global_visible,
+          history_length,
+        )
+        delete_hidden_events
+      end
+
+      def hide_excess(scope, column, history_length)
+        if history_length == 0
+          scope.update_all(column => false)
+          return
+        end
+
+        keep_ids = scope.order(occurred_at: :desc, id: :desc).limit(history_length).pluck(:id)
+        return if keep_ids.empty?
+
+        scope.where.not(id: keep_ids).update_all(column => false)
+      end
+
+      def delete_hidden_events
+        @event_record.where(feature_visible: false, global_visible: false).delete_all
+      end
+
+      def events_from(scope, limit:)
+        unless limit.nil?
+          raise ArgumentError, "limit must be an Integer" unless limit.is_a?(Integer)
+          raise ArgumentError, "limit must be >= 0" if limit < 0
+          return [] if limit.zero?
+        end
+
+        records = scope.order(occurred_at: :desc, id: :desc)
+        records = records.limit(limit) unless limit.nil?
+        records.to_a.reverse.map { |record| ::Rollout::ActiveRecord::Codec.event(record) }
+      end
+
+      def validate_history_length!(history_length)
+        unless history_length.is_a?(Integer) && history_length >= 0
+          raise ArgumentError, "history_length must be an Integer >= 0"
+        end
+      end
+
+      class AfterCommitCallback
+        def initialize(&block)
+          @block = block
+        end
+
+        def committed!(*)
+          @block.call
+        end
+
+        def before_committed!
+        end
+
+        def rolledback!(*)
+        end
+
+        def trigger_transactional_callbacks?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/rollout-active_record-adapter.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "rollout/adapters/active_record"

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: rollout-active_record-adapter
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- FetLife
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+- !ruby/object:Gem::Dependency
+  name: rollout
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
+description: Active Record adapter for the rollout gem.
+email:
+- dev@fetlife.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- lib/generators/rollout/active_record/install_generator.rb
+- lib/generators/rollout/active_record/templates/create_rollout_tables.rb.tt
+- lib/rollout-active_record-adapter.rb
+- lib/rollout/active_record/codec.rb
+- lib/rollout/active_record/feature_cache.rb
+- lib/rollout/active_record/migration.rb
+- lib/rollout/active_record/schema.rb
+- lib/rollout/adapters/active_record.rb
+homepage: https://github.com/FetLife/rollout
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Active Record adapter for the rollout gem.
+test_files: []