active_version 1.2.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fc38a55e873e8ea603bef6bb4bb15350b03582214fc1a48856a05cb35498b845
-  data.tar.gz: 34f0c43fb603e0109729c2254ae6d7ee1f95f14f56f3a0b408ffdb1429efdb48
+  metadata.gz: '08398a92e326503be43e704b7681562a6c3c4d220bd7cf934e295ff3afada135'
+  data.tar.gz: a3678d669239918343732b02b8ff8285b32e549bb44ae6eae1cffde75abf0ae1
 SHA512:
-  metadata.gz: e13a251346e48e51c617961f433f7384f4cb1dce283f41b1cda977180feb1a116a83a83bf39e241bf15d5f7f67daa926dacb19774ee6c496981e9fbc6c49efb7
-  data.tar.gz: 0cd3cfe32df95ac78d6591f5127f1a44c340cb69238b77471029fb5827c4d3c946a44c62b7734fe065bbe75db208162b206919254e4ad33addf5f4a3dab39b2c
+  metadata.gz: 158e15ac369fcbe7f730cf6e11ef638f888b5e14fb996be1f555321ddb0b08f11975c96809df18980d66b32402175dd660651791ffd8f3959798cb66b285a882
+  data.tar.gz: d0b501f02a783beaab992849dd91420980ccb592d2f56b8b7c810f49ff0952c1e61bc60cb8b8a202cc8af269928924f947243b15349606b8ddc0c4a0f33d414c

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 # CHANGELOG
 
+## 1.4.0 (2026-07-13)
+
+- Add `revision_error_behavior` configuration (`:exception`, `:log`, `:silent`) and per-model `has_revisions error_behavior:` override for revision snapshot failures.
+- Skip post-update revision bookkeeping when snapshot creation returns nil under `:log` or `:silent` revision error handling.
+- Route audit warning output through `ActiveVersion.logger` so non-Rails apps and custom log sinks receive audit write failures consistently.
+- Align audit writer fallback error behavior with the configuration default (`:exception`) when neither per-model nor global audit error behavior is set.
+- Fix audit combining to refresh the cached audits association instead of reloading the auditable record, and bound combiner queries with COUNT and LIMIT instead of loading the full audit history each iteration.
+- Fix thread-local audited options reader installation on Rails 6.1 models with delegated class methods.
+- Log debug detail for deferred audit setup, instrumentation probes, and unparseable audit payloads when `ActiveVersion.logger` supports debug output.
+
+## 1.3.0 (2026-04-15)
+
+- Add `polyrun` `~> 1.3.0` development dependency; `bin/polyrun`, `bin/rspec`, `polyrun.yml`, and `config/polyrun_coverage.yml` for parallel RSpec and merged coverage.
+- Add `script/create_postgres_shard_databases.sh` for CI and local Postgres shard databases; document in `spec/README.md`; set job-level `DATABASE_URL` in GitHub Actions test workflow.
+- Add internal library logger.
+- Fix audits, Sequel foreign keys, revision debounce, and versions walk edge cases.
+- Adjust RSpec and RuboCop test configuration; update spec coverage.
+
 ## 1.2.0 (2026-03-27)
 
 - Fixed SQL generation for audit creation to avoid duplicate `created_at` and `updated_at` columns (or other possible duplicate columns)

data/README.md

@@ -305,6 +305,8 @@ rails g active_version:triggers Post --type=audit
 rails g active_version:triggers Post --type=revision
 ```
 
+PostgreSQL audit triggers capture the full row as JSON. They do not apply Ruby-side `only`, `except`, or `redacted` filters from `has_audits`. Use triggers only when you want complete row snapshots at the database layer, or generate custom trigger SQL that matches your column policy.
+
 ### Infrastructure Ownership
 
 ```ruby
@@ -447,8 +449,8 @@ The report includes per-record overhead vs ActiveRecord baseline (`p5`, `mean`,
 The report also separates ActiveRecord and Sequel benchmark groups to avoid cross-ORM baseline mixing.
 
 ```bash
-# Normal test run (benchmarks excluded)
-bundle exec rspec
+# Normal test run (benchmarks excluded) — parallel OS processes via Polyrun (same as CI)
+./bin/polyrun
 
 # Explicit benchmark run
 usr/bin/benchmark.rb
@@ -507,6 +509,8 @@ Environment knobs:
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/amkisko/active_version.rb.
 
+Development dependencies include [polyrun](https://rubygems.org/gems/polyrun) (declared in `active_version.gemspec`) for **parallel RSpec** (`./bin/polyrun`), coverage, and CI report formats—see [spec/README.md](spec/README.md).
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/active_version/adapters/sequel/versioning.rb

@@ -1,4 +1,5 @@
 require "json"
+require "active_support/core_ext/string/inflections"
 
 module ActiveVersion
   module Adapters
@@ -51,7 +52,7 @@ module ActiveVersion
 
         module InstanceMethods
           def active_version_foreign_key
-            self.class.active_version_config[:foreign_key] || :"#{model_name.singular}_id"
+            self.class.active_version_config[:foreign_key] || :"#{model_name.singularize}_id"
           end
 
           def active_version_tracked_columns

data/lib/active_version/audits/audit_record/serializers.rb

@@ -16,7 +16,10 @@ module ActiveVersion
             return value unless value.is_a?(String)
 
             JSON.parse(value)
-          rescue JSON::ParserError
+          rescue JSON::ParserError => error
+            ActiveVersion.log_debug(
+              "[ActiveVersion::Audits::AuditRecord::Serializers::Json] failed to parse audit payload: #{error.message}"
+            )
             value
           end
 
@@ -35,7 +38,10 @@ module ActiveVersion
             return value unless value.is_a?(String)
 
             YAML.safe_load(value, permitted_classes: PERMITTED_CLASSES, aliases: false)
-          rescue Psych::SyntaxError, Psych::DisallowedClass, Psych::AliasesNotEnabled, ArgumentError
+          rescue Psych::SyntaxError, Psych::DisallowedClass, Psych::AliasesNotEnabled, ArgumentError => error
+            ActiveVersion.log_debug(
+              "[ActiveVersion::Audits::AuditRecord::Serializers::Yaml] failed to parse audit payload: #{error.message}"
+            )
             value
           end
 

data/lib/active_version/audits/audit_record.rb

@@ -125,10 +125,10 @@ module ActiveVersion
               attribute changes_column, :text unless attribute_names.include?(changes_column.to_s)
               attribute context_column, :text unless attribute_names.include?(context_column.to_s)
             end
-          rescue *ActiveVersion::Runtime.active_record_connection_errors => e
-            if defined?(Rails) && Rails.respond_to?(:logger)
-              Rails.logger&.debug("[ActiveVersion] Deferred audit attribute setup for #{name}: #{e.class}: #{e.message}")
-            end
+          rescue *ActiveVersion::Runtime.active_record_connection_errors => error
+            ActiveVersion.log_debug(
+              "[ActiveVersion] Deferred audit attribute setup for #{name}: #{error.class}: #{error.message}"
+            )
           end
 
           begin
@@ -156,10 +156,10 @@ module ActiveVersion
             end
           rescue NameError
             # Source class not yet defined, will be set up later
-          rescue *ActiveVersion::Runtime.active_record_connection_errors => e
-            if defined?(Rails) && Rails.respond_to?(:logger)
-              Rails.logger&.debug("[ActiveVersion] Deferred audit association setup for #{name}: #{e.class}: #{e.message}")
-            end
+          rescue *ActiveVersion::Runtime.active_record_connection_errors => error
+            ActiveVersion.log_debug(
+              "[ActiveVersion] Deferred audit association setup for #{name}: #{error.class}: #{error.message}"
+            )
           end
         end
 

data/lib/active_version/audits/has_audits/audit_combiner.rb

@@ -24,54 +24,27 @@ module ActiveVersion
             iteration += 1
             break if iteration > max_iterations
 
-            # Force reload from database to see any updates
-            if persisted?
-              reload
-            end
-
-            # Clear association cache to ensure we get fresh data from database.
-            # Avoid calling audits reader directly here to prevent AR 6.1
-            # delegation edge cases on dynamic models.
+            # Clear association cache so the direct audit query below sees SQL updates
+            # from prior combine rounds without reloading the auditable record.
             if respond_to?(:association) && association_cached?(:audits)
               association(:audits).reset
             end
 
-            # Get all audits fresh from database (not from cache)
-            # Query directly to ensure we get updated values after SQL updates
             auditable_type = audited_options[:class_name] || self.class.name
             auditable_column = ActiveVersion.column_mapper.column_for(self.class, :audits, :auditable)
             version_column = ActiveVersion.column_mapper.column_for(self.class, :audits, :version)
-            audit_klass =
-              if self.class.reflect_on_association(:audits)
-                association(:audits).klass
-              else
-                self.class.audit_class
-              end
-            if audit_klass.nil? && self.class.respond_to?(:resolve_audit_class_option, true)
-              audit_klass = self.class.send(:resolve_audit_class_option, audited_options[:as])
-            end
+            audit_klass = combiner_audit_klass
             break unless audit_klass
-            all_audits = audit_klass.where({"#{auditable_column}_type" => auditable_type}.merge(active_version_audit_identity_map))
-              .order(version_column => :asc)
-              .to_a
 
-            # Filter out combined audits (those with empty changes)
-            # Check raw column value first (before JSON parsing) for "{}" string
-            active_audits = all_audits.reject do |audit|
-              # Check raw column value first - combined audits have "{}" as string
-              raw_changes = audit.read_attribute(changes_column)
-
-              # If raw value is exactly "{}", it's a combined audit
-              if raw_changes.is_a?(String) && raw_changes.strip == "{}"
-                true
-              else
-                # Otherwise check parsed value
-                changes = audit.audited_changes
-                changes.nil? || (changes.is_a?(Hash) && changes.empty?) || (changes.is_a?(String) && changes.strip.empty?)
-              end
-            end
+            active_scope = active_audits_scope_for_combiner(
+              audit_klass,
+              auditable_type,
+              auditable_column,
+              version_column,
+              changes_column
+            )
 
-            audits_count = active_audits.length
+            audits_count = active_scope.count
             break if audits_count <= max_audits
 
             # Calculate how many extra audits we have
@@ -79,7 +52,11 @@ module ActiveVersion
 
             # Get the oldest active audits to combine (first extra_count + 1)
             # The +1 is because we'll merge into the last one in this set
-            audits_to_combine = active_audits.first(extra_count + 1)
+            audits_to_combine = active_scope
+              .limit(extra_count + 1)
+              .to_a
+              .reject { |audit| combined_audit_record?(audit, changes_column) }
+              .first(extra_count + 1)
 
             # Safety check to prevent infinite loops
             break if audits_to_combine.empty? || audits_to_combine.length <= 1
@@ -89,6 +66,39 @@ module ActiveVersion
           end
         end
 
+        def combiner_audit_klass
+          audit_klass =
+            if self.class.reflect_on_association(:audits)
+              association(:audits).klass
+            else
+              self.class.audit_class
+            end
+          if audit_klass.nil? && self.class.respond_to?(:resolve_audit_class_option, true)
+            audit_klass = self.class.send(:resolve_audit_class_option, audited_options[:as])
+          end
+          audit_klass
+        end
+
+        def active_audits_scope_for_combiner(audit_klass, auditable_type, auditable_column, version_column, changes_column)
+          audit_klass
+            .where({"#{auditable_column}_type" => auditable_type}.merge(active_version_audit_identity_map))
+            .where.not(changes_column => nil)
+            .where.not(changes_column => "")
+            .where.not(changes_column => "{}")
+            .order(version_column => :asc)
+        end
+
+        def combined_audit_record?(audit, changes_column)
+          raw_changes = audit.read_attribute(changes_column)
+
+          if raw_changes.is_a?(String) && raw_changes.strip == "{}"
+            true
+          else
+            changes = audit.audited_changes
+            changes.nil? || (changes.is_a?(Hash) && changes.empty?) || (changes.is_a?(String) && changes.strip.empty?)
+          end
+        end
+
         def evaluate_max_audits
           max_audits = case (option = audited_options[:max_audits])
           when Proc then option.call

data/lib/active_version/audits/has_audits/audit_writer.rb

@@ -228,7 +228,7 @@ module ActiveVersion
 
         def handle_audit_errors(error, action)
           ActiveVersion::Instrumentation.instrument_audit_write_failed(self, error: error, action: action)
-          behavior = audited_options[:error_behavior] || ActiveVersion.config.audit_error_behavior || :log
+          behavior = audited_options[:error_behavior] || ActiveVersion.config.audit_error_behavior || :exception
 
           case behavior
           when :log
@@ -241,7 +241,7 @@ module ActiveVersion
         end
 
         def log_audit_errors(error, action)
-          Rails.logger&.warn(
+          ActiveVersion.logger.warn(
             "Unable to create audit for #{action} of #{self.class.name}" \
             "##{id}: #{error.message}"
           )

data/lib/active_version/audits/has_audits.rb

@@ -22,7 +22,13 @@ module ActiveVersion
           false
         end
 
-        # Get audit class name
+        # Class attributes (must be declared before the custom .audit_class reader below —
+        # otherwise class_attribute :audit_class overwrites the resolver and leaves it dead code.)
+        class_attribute :audit_associated_with, instance_writer: false
+        class_attribute :audited_options, instance_writer: false
+        class_attribute :audit_class, instance_writer: false
+
+        # Get audit class name (overrides class_attribute reader with resolution logic)
         def self.audit_class
           return @audit_class if @audit_class
 
@@ -53,11 +59,6 @@ module ActiveVersion
           end
         end
 
-        # Class attributes
-        class_attribute :audit_associated_with, instance_writer: false
-        class_attribute :audited_options, instance_writer: false
-        class_attribute :audit_class, instance_writer: false
-
         # Instance attributes
         attr_accessor :audit_version, :audit_comment, :audit_context
 
@@ -121,13 +122,10 @@ module ActiveVersion
         def revisions(from_version = 1)
           return [] unless audits.from_version(from_version).exists?
 
-          version_column = ActiveVersion.column_mapper.column_for(self, :audits, :version)
-          all_audits = audits.to_a
-          targeted_audits = all_audits.select do |audit|
-            audit.read_attribute(version_column).to_i >= from_version
-          end
+          prior_audits = audits.to_version(from_version - 1).ascending.to_a
+          targeted_audits = audits.from_version(from_version).ascending.to_a
 
-          previous_attributes = audit_class.reconstruct_attributes(all_audits - targeted_audits)
+          previous_attributes = audit_class.reconstruct_attributes(prior_audits)
 
           targeted_audits.map do |audit|
             previous_attributes.merge!(audit.new_attributes)
@@ -421,7 +419,7 @@ module ActiveVersion
         private
 
         def install_thread_local_audited_options_reader!
-          unless singleton_class.instance_methods(false).include?(:audited_options_without_thread_local)
+          unless singleton_class.method_defined?(:audited_options_without_thread_local, false)
             singleton_class.alias_method :audited_options_without_thread_local, :audited_options
           end
 

data/lib/active_version/instrumentation.rb

@@ -217,9 +217,7 @@ module ActiveVersion
       end
 
       def log_debug(message)
-        if defined?(Rails) && Rails.respond_to?(:logger)
-          Rails.logger&.debug("[ActiveVersion::Instrumentation] #{message}")
-        end
+        ActiveVersion.log_debug("[ActiveVersion::Instrumentation] #{message}")
       end
     end
   end

data/lib/active_version/query.rb

@@ -92,14 +92,6 @@ module ActiveVersion
         version_column = ActiveVersion.column_mapper.column_for(record.class, :revisions, :version)
         query.order(version_column => :asc)
       end
-
-      private
-
-      def log_debug(message)
-        if defined?(Rails) && Rails.respond_to?(:logger)
-          Rails.logger&.debug("[ActiveVersion::Query] #{message}")
-        end
-      end
     end
   end
 end

data/lib/active_version/revisions/has_revisions/revision_manipulation.rb

@@ -17,10 +17,13 @@ module ActiveVersion
 
           # Check debounce time - merge with previous revision if within window
           debounce_time = opts[:debounce_time] || ActiveVersion.config.debounce_time
-          if !batch_capture_active && debounce_time && should_merge_with_previous?(debounce_time, timestamp)
-            merge_with_previous_revision!(timestamp, only_attrs, except_attrs, use_old_values)
-            version_column = revision_version_column
-            return revisions_scope.order(version_column => :desc).first
+          if !batch_capture_active && debounce_time
+            last_for_merge = last_revision_for_debounce_merge(debounce_time, timestamp)
+            if last_for_merge
+              merge_with_previous_revision!(timestamp, only_attrs, except_attrs, use_old_values, last_revision: last_for_merge)
+              version_column = revision_version_column
+              return revisions_scope.order(version_column => :desc).first
+            end
           end
 
           new_version = if batch_capture_active
@@ -110,30 +113,25 @@ module ActiveVersion
             pseudo.define_singleton_method(:persisted?) { true }
             pseudo
           else
-
-            # Use create! instead of build + save to get better error messages
             begin
-              revision = revisions.create!(revision_attrs)
-            rescue ActiveRecord::RecordInvalid => e
-              ActiveVersion::Instrumentation.instrument_revision_write_failed(self, error: e)
-              error_msg = "Failed to create revision: #{e.class}"
-              error_msg += "\nRevision attribute keys: #{revision_attrs.keys.map(&:to_s).sort.join(", ")}"
-              error_msg += "\nIdentity keys: #{active_version_revision_identity_map.keys.map(&:to_s).sort.join(", ")}"
-              error_msg += "\nVersion column: #{version_column_sym}, New version: #{new_version}"
-              error_msg += "\nRevision class: #{self.class.revision_class.name}"
-              error_msg += "\nSource class: #{self.class.name}"
-              if e.record
-                error_msg += "\nRecord error fields: #{e.record.errors.attribute_names.map(&:to_s).uniq.sort.join(", ")}"
-                error_msg += "\nRecord valid?: #{e.record.valid?}"
-              end
-              raise error_msg
-            rescue => e
-              ActiveVersion::Instrumentation.instrument_revision_write_failed(self, error: e)
-              error_msg = "Failed to create revision: #{e.class}"
-              error_msg += "\nRevision attribute keys: #{revision_attrs.keys.map(&:to_s).sort.join(", ")}"
-              error_msg += "\nIdentity keys: #{active_version_revision_identity_map.keys.map(&:to_s).sort.join(", ")}"
-              error_msg += "\nVersion column: #{version_column_sym}, New version: #{new_version}"
-              raise error_msg
+              revision = create_revision_record_with_version_retry!(revision_attrs, version_column_sym)
+            rescue ActiveRecord::RecordInvalid => error
+              revision = handle_revision_errors(
+                error,
+                revision_attrs: revision_attrs,
+                version_column_sym: version_column_sym,
+                new_version: new_version,
+                invalid_record: error.record
+              )
+              return revision unless revision
+            rescue => error
+              revision = handle_revision_errors(
+                error,
+                revision_attrs: revision_attrs,
+                version_column_sym: version_column_sym,
+                new_version: new_version
+              )
+              return revision unless revision
             end
 
             # Force reload association to ensure it's visible
@@ -251,7 +249,7 @@ module ActiveVersion
             end
 
             # Create the revision using the association (it will set foreign_key automatically)
-            revision = revisions.create!(revision_attrs)
+            revision = create_revision_record_with_version_retry!(revision_attrs, version_column_sym)
             # Ensure it was created and persisted
             raise "Failed to create revision" unless revision.persisted?
             # Reload the post to clear all caches and see the new revision
@@ -350,19 +348,26 @@ module ActiveVersion
         end
 
         def should_merge_with_previous?(debounce_time, timestamp)
-          return false unless revisions_scope.exists?
+          !last_revision_for_debounce_merge(debounce_time, timestamp).nil?
+        end
+
+        # Latest revision row if +timestamp+ falls within +debounce_time+ seconds after that revision; one query.
+        def last_revision_for_debounce_merge(debounce_time, timestamp)
+          return nil unless debounce_time
 
           version_column = ActiveVersion.column_mapper.column_for(self.class, :revisions, :version)
           last_revision = revisions_scope.order(version_column => :desc).first
-          return false unless last_revision
+          return nil unless last_revision
 
           time_diff = timestamp.to_f - last_revision.created_at.to_f
-          time_diff <= debounce_time
+          return nil if time_diff > debounce_time
+
+          last_revision
         end
 
-        def merge_with_previous_revision!(timestamp, only_attrs, except_attrs, use_old_values)
+        def merge_with_previous_revision!(timestamp, only_attrs, except_attrs, use_old_values, last_revision: nil)
           version_column = ActiveVersion.column_mapper.column_for(self.class, :revisions, :version)
-          last_revision = revisions_scope.order(version_column => :desc).first
+          last_revision ||= revisions_scope.order(version_column => :desc).first
           return unless last_revision
 
           # Update last revision with current or persisted attributes (filtered by only/except)
@@ -416,6 +421,67 @@ module ActiveVersion
           revisions.reset
         end
 
+        # One retry on unique (version) violation, matching audit_writer behavior when a DB unique index exists.
+        def create_revision_record_with_version_retry!(revision_attrs, version_column_sym)
+          attempt = 0
+          begin
+            attempt += 1
+            revisions.create!(revision_attrs)
+          rescue ActiveRecord::RecordNotUnique => error
+            raise error if attempt >= 2
+
+            max_version = revisions_scope.maximum(version_column_sym) || 0
+            revision_attrs[version_column_sym] = max_version + 1
+            retry
+          end
+        end
+
+        def handle_revision_errors(error, revision_attrs:, version_column_sym:, new_version:, invalid_record: nil)
+          ActiveVersion::Instrumentation.instrument_revision_write_failed(self, error: error)
+          behavior = self.class.revision_options&.dig(:error_behavior) ||
+            ActiveVersion.config.revision_error_behavior ||
+            :exception
+
+          case behavior
+          when :exception
+            raise build_revision_error_message(
+              error,
+              revision_attrs: revision_attrs,
+              version_column_sym: version_column_sym,
+              new_version: new_version,
+              invalid_record: invalid_record
+            )
+          when :log
+            ActiveVersion.logger.warn(
+              build_revision_error_message(
+                error,
+                revision_attrs: revision_attrs,
+                version_column_sym: version_column_sym,
+                new_version: new_version,
+                invalid_record: invalid_record
+              )
+            )
+            nil
+          when :silent
+            nil
+          end
+        end
+
+        def build_revision_error_message(error, revision_attrs:, version_column_sym:, new_version:, invalid_record: nil)
+          message = "Failed to create revision: #{error.class}"
+          message += "\nRevision attribute keys: #{revision_attrs.keys.map(&:to_s).sort.join(", ")}"
+          message += "\nIdentity keys: #{active_version_revision_identity_map.keys.map(&:to_s).sort.join(", ")}"
+          message += "\nVersion column: #{version_column_sym}, New version: #{new_version}"
+          if invalid_record
+            message += "\nRevision class: #{self.class.revision_class.name}"
+            message += "\nSource class: #{self.class.name}"
+            message += "\nRecord error fields: #{invalid_record.errors.attribute_names.map(&:to_s).uniq.sort.join(", ")}"
+            message += "\nRecord valid?: #{invalid_record.valid?}"
+          end
+          message
+        end
+        private :create_revision_record_with_version_retry!, :handle_revision_errors, :build_revision_error_message
+
         def refreshable_column_names
           @refreshable_column_names ||=
             self.class.columns

data/lib/active_version/revisions/has_revisions/revision_queries.rb

@@ -91,7 +91,9 @@ module ActiveVersion
         # Enumerate all versions (lazy enumerator returning revision instances)
         def versions(reverse: false, include_self: false)
           version_column = revision_version_column
-          version_list = revisions_scope.order(version_column => (reverse ? :desc : :asc)).pluck(version_column)
+          ordered_rows = revisions_scope.order(version_column => (reverse ? :desc : :asc)).to_a
+          entries_by_version = ordered_rows.index_by { |row| row.public_send(version_column) }
+          version_list = ordered_rows.map { |row| row.public_send(version_column) }
 
           # If include_self, prepare current state as a revision instance
           current_self = nil
@@ -104,7 +106,10 @@ module ActiveVersion
 
           Enumerator.new do |yielder|
             version_list.each do |v|
-              revision = at_version(v)
+              revision_entry = entries_by_version[v]
+              next unless revision_entry
+
+              revision = build_revision_dup(revision_entry)
               yielder << revision if revision
             end
             if include_self

data/lib/active_version/revisions/has_revisions.rb

@@ -113,9 +113,6 @@ module ActiveVersion
 
           # Set up callbacks based on options
           setup_revision_callbacks(revision_options)
-
-          # Register with version registry (idempotent)
-          ActiveVersion.registry.register(self, :revisions, revision_options)
         end
 
         # Check if model has revisions configured
@@ -134,7 +131,8 @@ module ActiveVersion
             except: Array.wrap(options[:except] || []).map(&:to_s),
             foreign_key: normalize_identity_columns(options[:foreign_key]),
             identity_resolver: options[:identity_resolver],
-            table_name: options[:table_name]
+            table_name: options[:table_name],
+            error_behavior: options[:error_behavior]
           }
         end
 
@@ -409,6 +407,7 @@ module ActiveVersion
         return if truncated_forward_history && latest_revision_matches_current_state?
 
         result = create_snapshot!(use_old_values: true)
+        return unless result
 
         # Ensure revision is persisted and visible in association
         unless result.persisted?

data/lib/active_version/version.rb

@@ -1,3 +1,3 @@
 module ActiveVersion
-  VERSION = "1.2.0"
+  VERSION = "1.4.0"
 end

data/lib/active_version/version_registry.rb

@@ -17,9 +17,11 @@ module ActiveVersion
 
         # Detect option conflicts
         if existing[:options] != options
-          warn "[ActiveVersion] Re-registering #{model_class.name} with :#{version_type} " \
-               "with different options. Previous: #{existing[:options].inspect}, " \
-               "New: #{options.inspect}. This may indicate a configuration issue."
+          ActiveVersion.logger&.warn(
+            "[ActiveVersion] Re-registering #{model_class.name} with :#{version_type} " \
+            "with different options. Previous: #{existing[:options].inspect}, " \
+            "New: #{options.inspect}. This may indicate a configuration issue."
+          )
         else
           # Same options - likely a double include, but not necessarily a problem
           # Log at debug level if needed

data/lib/active_version.rb

@@ -163,7 +163,7 @@ module ActiveVersion
     elsif Fiber.current.respond_to?(:[])
       Fiber.current[key]
     else
-      Thread.current[key]
+      thread_current_for_fallback_store[key]
     end
   end
 
@@ -173,7 +173,7 @@ module ActiveVersion
     elsif Fiber.current.respond_to?(:[]=)
       Fiber.current[key] = value
     else
-      Thread.current[key] = value
+      thread_current_for_fallback_store[key] = value
     end
   end
 
@@ -184,13 +184,18 @@ module ActiveVersion
   def self.store_keys
     if config.execution_scope == :thread
       Thread.current.thread_variables
-    elsif Thread.current.respond_to?(:keys)
-      Thread.current.keys
+    elsif thread_current_for_fallback_store.respond_to?(:keys)
+      thread_current_for_fallback_store.keys
     else
       []
     end
   end
 
+  def self.thread_current_for_fallback_store
+    Thread.current
+  end
+  private_class_method :thread_current_for_fallback_store
+
   def self.clear_scoped_keys!(pattern)
     store_keys.grep(pattern).each { |key| store_delete(key) }
   end
@@ -322,6 +327,32 @@ module ActiveVersion
   def self.with_connection(model_class, version_type, &block)
     yield(Runtime.adapter.connection_for(model_class, version_type))
   end
+
+  # Library warnings (defaults to stderr). Set to +nil+ to silence; use +Logger.new(File::NULL)+ in tests.
+  class << self
+    attr_writer :logger
+
+    def logger
+      return @logger if defined?(@logger)
+
+      @logger = default_logger
+    end
+
+    def log_debug(message)
+      logger = self.logger
+      return if logger.nil?
+
+      logger.debug(message) if logger.respond_to?(:debug)
+    end
+
+    def default_logger
+      l = Logger.new($stderr)
+      l.level = Logger::WARN
+      l.formatter = proc { |_, _, _, msg| "#{msg}\n" }
+      l
+    end
+    private :default_logger
+  end
 end
 
 # Load Rails integration if available

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_version
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.4.0
 platform: ruby
 authors:
 - Andrei Makarov
@@ -85,14 +85,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: 2.9.5
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: 2.9.5
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -136,61 +136,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.4'
 - !ruby/object:Gem::Dependency
-  name: simplecov
+  name: polyrun
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.22'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.22'
-- !ruby/object:Gem::Dependency
-  name: simplecov-console
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.9'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.9'
-- !ruby/object:Gem::Dependency
-  name: rspec_junit_formatter
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: 2.2.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: 2.2.0
 - !ruby/object:Gem::Dependency
-  name: simplecov-cobertura
+  name: prosopite
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: standard
   requirement: !ruby/object:Gem::Requirement
@@ -317,6 +289,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2'
+- !ruby/object:Gem::Dependency
+  name: bundler-audit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
 - !ruby/object:Gem::Dependency
   name: rbs
   requirement: !ruby/object:Gem::Requirement
@@ -437,7 +423,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Unified versioning library for translations, revisions, and audits
 test_files: []