active_version 1.4.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '08398a92e326503be43e704b7681562a6c3c4d220bd7cf934e295ff3afada135'
-  data.tar.gz: a3678d669239918343732b02b8ff8285b32e549bb44ae6eae1cffde75abf0ae1
+  metadata.gz: 89fbcf4b5aebb3bd2fcbbedfafb3f6575edd6f22571080ce310005f3e6f27a28
+  data.tar.gz: 4a90af0cfcee066886ce989f11b8347303db945036ea57cc0a3f6d7b00bcfeee
 SHA512:
-  metadata.gz: 158e15ac369fcbe7f730cf6e11ef638f888b5e14fb996be1f555321ddb0b08f11975c96809df18980d66b32402175dd660651791ffd8f3959798cb66b285a882
-  data.tar.gz: d0b501f02a783beaab992849dd91420980ccb592d2f56b8b7c810f49ff0952c1e61bc60cb8b8a202cc8af269928924f947243b15349606b8ddc0c4a0f33d414c
+  metadata.gz: 965f5ffcea61f3d8024d9ba0aaa7a0e3c514b1ce7b48a6f01f89bec05469ab481e82d894e3527a6b35c5f0830fa2cbf8b1947a7936b96e187ad31a228848d333
+  data.tar.gz: d8a5bc8d85a017998917086917d3a88c731cdc9bff9cab6ccf4cfe89d78c53d7b2bcd192ee31b4570a8fcbc532c67287e3399ebf89dd172806acd440fb1283b9

data/CHANGELOG.md

@@ -1,5 +1,29 @@
 # CHANGELOG
 
+## 2.1.0 (2026-10-29)
+
+- Record PostgreSQL audit updates as changed-field pairs and support quoted table and column names.
+- Copy source table columns into generated revision tables so custom attributes retain their values.
+- Keep inherited model audits visible through ActiveRecord polymorphic associations.
+
+- Fix `without_auditing` and `without_revisions` to use per-fiber/thread depth so other threads keep writing history.
+- Restore only request-scoped context after `with_context` so persistent keys do not shadow a later `with_context!`; clear persistent context via the Railtie executor `to_complete` hook on request end.
+- Honor `with_context(..., transactional: false)` by skipping the PostgreSQL `SET LOCAL` path.
+- Fix `at(time:)` / `revision_at` to return the live state between updates (earliest revision after the time), matching pre-change snapshot semantics.
+- Keep the earliest pre-change revision payload when debounce merges callback-driven updates inside the window.
+- Skip pending-save columns when refreshing default-function attributes during revision snapshots.
+- Map `action` and optional user/address/request fields in `Migrators::Audited`.
+- Skip `redacted` and `encrypted_attributes` when copying shared columns for `:mirror_columns` storage.
+- Validate `audit_error_behavior` and `revision_error_behavior` in `Configuration#validate!`.
+- Require `Rails::Railtie` before loading the railtie; raise `required_ruby_version` to `>= 3.1` to match Active Support 7.2+.
+- Document sharding as host-connection follow-through, not gem-owned routing.
+
+## 2.0.0 (2026-08-21)
+
+- BREAKING: Require Active Support and Active Record `>= 7.2.3.2` and `< 9.0`.
+- Retry unique version collisions so a revision snapshot or audit still writes after a concurrent insert, including inside an open PostgreSQL transaction.
+- Add `rfcs/` starter pack: process (RFC 0001), positioning (RFC 0002), and Standards Track design RFCs 0003–0006 for translations, revisions, audits, and generators.
+
 ## 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.

data/README.md

@@ -1,16 +1,18 @@
 # ActiveVersion
 
-[![Gem Version](https://badge.fury.io/rb/active_version.svg)](https://badge.fury.io/rb/active_version) [![Test Status](https://github.com/amkisko/active_version.rb/actions/workflows/test.yml/badge.svg)](https://github.com/amkisko/active_version.rb/actions/workflows/test.yml) [![codecov](https://codecov.io/gh/amkisko/active_version.rb/graph/badge.svg?token=2U6NXJOVVM)](https://codecov.io/gh/amkisko/active_version.rb)
+[![Gem Version](https://badge.fury.io/rb/active_version.svg)](https://badge.fury.io/rb/active_version) [![Test Status](https://github.com/amkisko/active_version.rb/actions/workflows/test.yml/badge.svg)](https://github.com/amkisko/active_version.rb/actions/workflows/test.yml) [![codecov](https://codecov.io/gh/amkisko/active_version.rb/graph/badge.svg?token=2U6NXJOVVM)](https://app.codecov.io/github/amkisko/active_version.rb)
 
 A unified versioning library for ActiveRecord that handles translations, revisions, and audits in a single, extensible architecture.
 
+Design changes go through `rfcs/` (RFC 0001).
+
 ## Features
 
 - Translations: Locale-based versioning with automatic value copying
 - Revisions: Schema-aligned snapshots for workflow management
 - Audits: `:json_column`, `:yaml_column`, or `:mirror_columns` change tracking
 - Database Triggers: Optional PostgreSQL triggers for zero-overhead versioning
-- Sharding Support: Route version tables to separate databases
+- Sharding: Follows the host app connection; this gem does not route shards
 - SQL Generation: Batch operations via SQL generation
 - Configurable: Flexible column naming and per-model configuration
 
@@ -305,7 +307,7 @@ 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.
+PostgreSQL audit triggers capture complete rows on create and destroy, and changed-field old/new pairs on update. Disable the matching Ruby callbacks with `has_audits auto: false` or `has_revisions auto: false` before installing triggers so each change has one history writer. 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
 
@@ -501,8 +503,8 @@ Environment knobs:
 
 ## Requirements
 
-- Ruby >= 3.0.0
-- ActiveRecord >= 6.0.0 (default runtime)
+- Ruby >= 3.1.0
+- ActiveRecord >= 7.2.3.2 and < 9.0 (default runtime)
 - SQLite or MySQL or PostgreSQL (optional, for triggers and JSONB support)
 
 ## Contributing
@@ -511,6 +513,19 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/amkisk
 
 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).
 
+## Links
+
+- [GitHub](https://github.com/amkisko/active_version.rb)
+- [GitLab](https://gitlab.com/amkisko/active_version.rb)
+- [RubyGems](https://rubygems.org/gems/active_version)
+- [Versions Atom](https://rubygems.org/gems/active_version/versions.atom) (feed id `10668858017926`)
+- [libraries.io](https://libraries.io/rubygems/active_version)
+- [Deps.dev](https://deps.dev/rubygems/active_version)
+- [SonarCloud](https://sonarcloud.io/project/overview?id=amkisko_active_version.rb)
+- [Snyk](https://snyk.io/test/github/amkisko/active_version.rb)
+- [Codecov](https://app.codecov.io/github/amkisko/active_version.rb)
+- [OpenSSF Scorecard](https://scorecard.dev/viewer/?uri=github.com/amkisko/active_version.rb)
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/SECURITY.md

@@ -2,28 +2,24 @@
 
 ## Reporting a Vulnerability
 
-Do NOT open a public GitHub issue for security vulnerabilities.
-
 Email security details to: security@kiskolabs.com
 
-Include: description, steps to reproduce, potential impact, and suggested fix (if available).
+Send the report only to that address. Include description, steps to reproduce, potential impact, and a suggested fix when you have one.
 
 ### Response Timeline
 
-- We will acknowledge receipt of your report
-- We will provide an initial assessment
-- We will keep you informed of our progress and resolution timeline
+- We will acknowledge receipt of your report.
+- We will provide an initial assessment.
+- We will keep you informed of our progress and resolution timeline.
 
 ### Disclosure Policy
 
-- We will work with you to understand and resolve the issue
-- We will credit you for the discovery (unless you prefer to remain anonymous)
-- We will publish a security advisory after the vulnerability is patched
-- We will coordinate public disclosure with you
+- We will work with you to understand and resolve the issue.
+- We will credit you for the discovery unless you prefer to remain anonymous.
+- We will publish a security advisory after the vulnerability is patched.
+- We will coordinate public disclosure with you.
 
 ## Automation Security
 
-* Context Isolation: It is strictly forbidden to include production credentials, API keys, or Personally Identifiable Information (PII) in prompts sent to third-party LLMs or automation services.
-
-* Supply Chain: All automated dependencies must be verified.
-
+- Keep production credentials, API keys, and personal data out of prompts sent to third-party models or automation services.
+- Verify automated dependencies.

data/lib/active_version/adapters/active_record/audits.rb

@@ -11,7 +11,7 @@ module ActiveVersion
         module ClassMethods
           # Declare that a model has audits
           def has_audits(options = {})
-            include ActiveVersion::Audits::HasAudits unless included_modules.include?(ActiveVersion::Audits::HasAudits)
+            include ActiveVersion::Audits::HasAudits unless include?(ActiveVersion::Audits::HasAudits)
 
             # Call the HasAudits implementation once included
             ActiveVersion::Audits::HasAudits::ClassMethods.instance_method(:has_audits)
@@ -30,7 +30,7 @@ end
 
 # If ActiveRecord::Base is already loaded, include immediately
 if defined?(ActiveRecord::Base) && ActiveRecord::Base.respond_to?(:include)
-  unless ActiveRecord::Base.included_modules.include?(ActiveVersion::Adapters::ActiveRecord::Audits)
+  unless ActiveRecord::Base.include?(ActiveVersion::Adapters::ActiveRecord::Audits)
     ActiveSupport.on_load(:active_record) { include ActiveVersion::Adapters::ActiveRecord::Audits }
   end
 end

data/lib/active_version/adapters/active_record/revisions.rb

@@ -43,7 +43,7 @@ end
 
 # If ActiveRecord::Base is already loaded, include immediately
 if defined?(ActiveRecord::Base) && ActiveRecord::Base.respond_to?(:include)
-  unless ActiveRecord::Base.included_modules.include?(ActiveVersion::Adapters::ActiveRecord::Revisions)
+  unless ActiveRecord::Base.include?(ActiveVersion::Adapters::ActiveRecord::Revisions)
     ActiveSupport.on_load(:active_record) { include ActiveVersion::Adapters::ActiveRecord::Revisions }
   end
 end

data/lib/active_version/adapters/active_record/translations.rb

@@ -39,7 +39,7 @@ end
 
 # If ActiveRecord::Base is already loaded, include immediately
 if defined?(ActiveRecord::Base) && ActiveRecord::Base.respond_to?(:include)
-  unless ActiveRecord::Base.included_modules.include?(ActiveVersion::Adapters::ActiveRecord::Translations)
+  unless ActiveRecord::Base.include?(ActiveVersion::Adapters::ActiveRecord::Translations)
     ActiveSupport.on_load(:active_record) { include ActiveVersion::Adapters::ActiveRecord::Translations }
   end
 end

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

@@ -30,7 +30,7 @@ module ActiveVersion
               association(:audits).reset
             end
 
-            auditable_type = audited_options[:class_name] || self.class.name
+            auditable_type = audited_options[:class_name] || self.class.polymorphic_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 = combiner_audit_klass

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

@@ -116,7 +116,7 @@ module ActiveVersion
               insert_attrs.merge!(identity_map)
               # Use class_name from options if provided (for dynamically created classes)
               # Otherwise use the actual class name
-              auditable_type = audited_options[:class_name] || self.class.name
+              auditable_type = audited_options[:class_name] || self.class.polymorphic_name
               if auditable_type.nil?
                 raise ConfigurationError, "Cannot determine class name for dynamically created class. Please specify class_name option in has_audits (e.g., has_audits as: PostAudit, class_name: 'Post')"
               end
@@ -187,42 +187,46 @@ module ActiveVersion
                 return nil
               end
 
-              begin
-                audit_class.create!(insert_attrs)
-                combine_audits_if_needed if attrs[:action] != "create"
-                association(:audits).reset if association_cached?(:audits)
-                nil
-              rescue ActiveRecord::RecordNotUnique => e
-                # Handle unique constraint violation (likely version conflict)
-                # Retry once with recalculated version
-                if e.message.include?("version") && attrs[:action] != "create"
-                  # Recalculate version and retry
-                  # Use class_name from options if provided (for dynamically created classes)
-                  auditable_type_for_query = audited_options[:class_name] || self.class.name
-                  if auditable_type_for_query.nil?
-                    raise ConfigurationError, "Cannot determine class name for dynamically created class. Please specify class_name option in has_audits"
-                  end
-                  max_version = audit_class.where({"#{auditable_column}_type" => auditable_type_for_query}.merge(active_version_audit_identity_map))
-                    .maximum(version_column) || 0
-                  insert_attrs[version_column] = max_version + 1
-                  begin
-                    audit_class.create!(insert_attrs)
-                    combine_audits_if_needed if attrs[:action] != "create"
-                    association(:audits).reset if association_cached?(:audits)
-                    nil
-                  rescue => retry_error
-                    handle_audit_errors(retry_error, attrs[:action])
-                    nil
-                  end
-                else
-                  handle_audit_errors(e, attrs[:action])
-                  nil
-                end
-              rescue => e
-                handle_audit_errors(e, attrs[:action])
-                nil
-              end
+              create_audit_record_with_version_retry!(
+                insert_attrs,
+                version_column: version_column,
+                auditable_column: auditable_column,
+                action: attrs[:action]
+              )
+            end
+          end
+        end
+
+        # One retry on unique (version) collision. Each insert uses a savepoint so
+        # PostgreSQL can continue the outer update/lock transaction after a unique violation.
+        def create_audit_record_with_version_retry!(insert_attrs, version_column:, auditable_column:, action:)
+          attempt = 0
+          begin
+            attempt += 1
+            self.class.transaction(requires_new: true) do
+              audit_class.create!(insert_attrs)
+            end
+            combine_audits_if_needed if action != "create"
+            association(:audits).reset if association_cached?(:audits)
+            nil
+          rescue => error
+            unless ActiveVersion::UniqueVersionCollision.match?(error, version_column: version_column) &&
+                action != "create" && attempt < 2
+              handle_audit_errors(error, action)
+              return nil
+            end
+
+            auditable_type_for_query = audited_options[:class_name] || self.class.polymorphic_name
+            if auditable_type_for_query.nil?
+              raise ConfigurationError, "Cannot determine class name for dynamically created class. Please specify class_name option in has_audits"
+            end
+
+            max_version = audit_class.uncached do
+              audit_class.where({"#{auditable_column}_type" => auditable_type_for_query}.merge(active_version_audit_identity_map))
+                .maximum(version_column) || 0
             end
+            insert_attrs[version_column] = max_version + 1
+            retry
           end
         end
 
@@ -269,7 +273,9 @@ module ActiveVersion
             ActiveVersion.column_mapper.column_for(self.class, :audits, :version).to_s,
             ActiveVersion.column_mapper.column_for(self.class, :audits, :action).to_s
           ]
-          shared_columns -= excluded
+          redacted = Array(audited_options[:redacted]).map(&:to_s)
+          encrypted = respond_to?(:encrypted_attributes) ? Array(encrypted_attributes).map(&:to_s) : []
+          shared_columns -= (excluded + redacted + encrypted)
 
           shared_columns.each do |column_name|
             next if insert_attrs.key?(column_name)

data/lib/active_version/audits/has_audits.rb

@@ -100,18 +100,21 @@ module ActiveVersion
           audited_options.present?
         end
 
-        # Disable auditing for a block
+        # Disable auditing for this fiber/thread only (does not silence other threads)
         def without_auditing
-          auditing_was_enabled = class_auditing_enabled?
-          disable_auditing
+          key = auditing_disabled_depth_store_key
+          depth = ActiveVersion.store_get(key).to_i + 1
+          ActiveVersion.store_set(key, depth)
           yield
         ensure
-          enable_auditing if auditing_was_enabled
+          depth = ActiveVersion.store_get(key).to_i - 1
+          depth = 0 if depth.negative?
+          ActiveVersion.store_set(key, depth)
         end
 
-        # Enable auditing for a block
+        # Enable auditing for a block even when class auditing was disabled permanently
         def with_auditing
-          auditing_was_enabled = class_auditing_enabled?
+          auditing_was_enabled = class_auditing_enabled_without_skip?
           enable_auditing
           yield
         ensure
@@ -506,10 +509,22 @@ module ActiveVersion
         end
 
         def class_auditing_enabled?
-          @class_auditing_enabled != false
+          return false if ActiveVersion.store_get(auditing_disabled_depth_store_key).to_i.positive?
+
+          class_auditing_enabled_without_skip?
         end
         public :class_auditing_enabled?
 
+        def class_auditing_enabled_without_skip?
+          @class_auditing_enabled != false
+        end
+        private :class_auditing_enabled_without_skip?
+
+        def auditing_disabled_depth_store_key
+          :"active_version_#{name}_auditing_disabled_depth"
+        end
+        private :auditing_disabled_depth_store_key
+
         def disable_auditing
           @class_auditing_enabled = false
         end
@@ -808,7 +823,7 @@ module ActiveVersion
       # Use active_audits for filtered results
       def audits
         # Use class_name from options if provided (for dynamically created classes)
-        auditable_type = audited_options[:class_name] || self.class.name
+        auditable_type = audited_options[:class_name] || self.class.polymorphic_name
         if auditable_type.nil?
           raise ConfigurationError, "Cannot determine class name for dynamically created class. Please specify class_name option in has_audits (e.g., has_audits as: PostAudit, class_name: 'Post')"
         end

data/lib/active_version/audits/sql_builder.rb

@@ -169,7 +169,7 @@ module ActiveVersion
           end
           return nil if identity_map.values.any?(&:nil?)
           attrs.merge!(identity_map)
-          attrs["#{auditable_column}_type"] = record.class.name
+          attrs["#{auditable_column}_type"] = record.class.polymorphic_name
 
           # Set version
           version_column = ActiveVersion.column_mapper.column_for(record.class, :audits, :version)

data/lib/active_version/configuration.rb

@@ -78,10 +78,13 @@ module ActiveVersion
       @debounce_time = nil  # Time in seconds to merge revisions within window
     end
 
+    ERROR_BEHAVIORS = %i[exception log silent].freeze
+
     # Validate configuration
     def validate!
       validate_storage_type!
       validate_execution_scope!
+      validate_error_behaviors!
       validate_column_names!
     end
 
@@ -101,6 +104,18 @@ module ActiveVersion
         "execution_scope must be :fiber or :thread, got: #{@execution_scope.inspect}"
     end
 
+    def validate_error_behaviors!
+      unless ERROR_BEHAVIORS.include?(@audit_error_behavior)
+        raise ConfigurationError,
+          "audit_error_behavior must be one of #{ERROR_BEHAVIORS.inspect}, got: #{@audit_error_behavior.inspect}"
+      end
+
+      unless ERROR_BEHAVIORS.include?(@revision_error_behavior)
+        raise ConfigurationError,
+          "revision_error_behavior must be one of #{ERROR_BEHAVIORS.inspect}, got: #{@revision_error_behavior.inspect}"
+      end
+    end
+
     def validate_column_names!
       # Ensure column names are symbols or strings
       column_attrs = [

data/lib/active_version/database/triggers/postgresql.rb

@@ -10,12 +10,14 @@ module ActiveVersion
           # @param options [Hash] Trigger options
           # @return [String] SQL for trigger function
           def generate_audit_trigger_function(table_name, audit_table_name, options = {})
-            function_name = "active_version_audit_#{table_name}"
-            auditable_type = options[:auditable_type] || table_name.classify
-            version_column = options[:version_column] || "version"
-            changes_column = options[:changes_column] || "audited_changes"
-            context_column = options[:context_column] || "audited_context"
-            action_column = options[:action_column] || "action"
+            function_name = quote_identifier("active_version_audit_#{table_name.tr(".", "_")}")
+            auditable_type = (options[:auditable_type] || table_name.classify).gsub("'", "''")
+            version_column = quote_identifier(options[:version_column] || "version")
+            changes_column = quote_identifier(options[:changes_column] || "audited_changes")
+            context_column = quote_identifier(options[:context_column] || "audited_context")
+            action_column = quote_identifier(options[:action_column] || "action")
+
+            audit_table_name = quote_table(audit_table_name)
 
             <<~SQL
               CREATE OR REPLACE FUNCTION #{function_name}()
@@ -32,10 +34,13 @@ module ActiveVersion
                   changes := to_jsonb(NEW.*);
                 ELSIF TG_OP = 'UPDATE' THEN
                   action_type := 'update';
-                  changes := jsonb_build_object(
-                    'old', to_jsonb(OLD.*),
-                    'new', to_jsonb(NEW.*)
-                  );
+                  SELECT COALESCE(jsonb_object_agg(item.key, jsonb_build_array(to_jsonb(OLD.*) -> item.key, item.value)), '{}'::jsonb)
+                  INTO changes
+                  FROM jsonb_each(to_jsonb(NEW.*)) AS item
+                  WHERE item.value IS DISTINCT FROM to_jsonb(OLD.*) -> item.key;
+                  IF changes = '{}'::jsonb THEN
+                    RETURN NEW;
+                  END IF;
                 ELSIF TG_OP = 'DELETE' THEN
                   action_type := 'destroy';
                   changes := to_jsonb(OLD.*);
@@ -54,7 +59,7 @@ module ActiveVersion
 
                 -- Get context from session variables (if set)
                 context_data := COALESCE(
-                  current_setting('active_version.context', true)::jsonb,
+                  NULLIF(current_setting('active_version.context', true), '')::jsonb,
                   '{}'::jsonb
                 );
 
@@ -112,15 +117,19 @@ module ActiveVersion
           # @param options [Hash] Trigger options
           # @return [String] SQL for CREATE TRIGGER statement
           def generate_audit_trigger(table_name, options = {})
-            function_name = "active_version_audit_#{table_name}"
-            trigger_name = options[:trigger_name] || "active_version_audit_on_#{table_name}"
+            function_name = quote_identifier("active_version_audit_#{table_name.tr(".", "_")}")
+            trigger_name = quote_identifier(options[:trigger_name] || "active_version_audit_on_#{table_name.tr(".", "_")}")
             events = options[:events] || [:insert, :update, :delete]
 
-            event_clause = events.map(&:upcase).join(" OR ")
+            event_names = events.map { |event| event.to_s.upcase }
+            unless event_names.any? && (event_names - %w[INSERT UPDATE DELETE]).empty?
+              raise ArgumentError, "audit trigger events must be insert, update, or delete"
+            end
+            event_clause = event_names.join(" OR ")
 
             <<~SQL
               CREATE TRIGGER #{trigger_name}
-              AFTER #{event_clause} ON #{table_name}
+              AFTER #{event_clause} ON #{quote_table(table_name)}
               FOR EACH ROW
               WHEN (coalesce(current_setting('active_version.disabled', true), '') <> 'on')
               EXECUTE FUNCTION #{function_name}();
@@ -133,9 +142,10 @@ module ActiveVersion
           # @param options [Hash] Trigger options
           # @return [String] SQL for trigger function
           def generate_revision_trigger_function(table_name, revision_table_name, options = {})
-            function_name = "active_version_revision_#{table_name}"
-            foreign_key = options[:foreign_key] || "#{table_name.singularize}_id"
-            version_column = options[:version_column] || "version"
+            function_name = quote_identifier("active_version_revision_#{table_name.tr(".", "_")}")
+            foreign_key = quote_identifier(options[:foreign_key] || "#{table_name.singularize}_id")
+            revision_table_name = quote_table(revision_table_name)
+            version_column = quote_identifier(options[:version_column] || "version")
 
             <<~SQL
               CREATE OR REPLACE FUNCTION #{function_name}()
@@ -186,12 +196,12 @@ module ActiveVersion
           # @param options [Hash] Trigger options
           # @return [String] SQL for CREATE TRIGGER statement
           def generate_revision_trigger(table_name, options = {})
-            function_name = "active_version_revision_#{table_name}"
-            trigger_name = options[:trigger_name] || "active_version_revision_on_#{table_name}"
+            function_name = quote_identifier("active_version_revision_#{table_name.tr(".", "_")}")
+            trigger_name = quote_identifier(options[:trigger_name] || "active_version_revision_on_#{table_name.tr(".", "_")}")
 
             <<~SQL
               CREATE TRIGGER #{trigger_name}
-              BEFORE UPDATE ON #{table_name}
+              BEFORE UPDATE ON #{quote_table(table_name)}
               FOR EACH ROW
               WHEN (coalesce(current_setting('active_version.disabled', true), '') <> 'on')
               EXECUTE FUNCTION #{function_name}();
@@ -202,7 +212,7 @@ module ActiveVersion
           # @param function_name [String] Name of the function
           # @return [String] SQL for DROP FUNCTION statement
           def drop_trigger_function(function_name)
-            "DROP FUNCTION IF EXISTS #{function_name}() CASCADE;"
+            "DROP FUNCTION IF EXISTS #{quote_identifier(function_name)}() CASCADE;"
           end
 
           # Drop trigger
@@ -210,19 +220,27 @@ module ActiveVersion
           # @param table_name [String] Name of the table
           # @return [String] SQL for DROP TRIGGER statement
           def drop_trigger(trigger_name, table_name)
-            "DROP TRIGGER IF EXISTS #{trigger_name} ON #{table_name} CASCADE;"
+            "DROP TRIGGER IF EXISTS #{quote_identifier(trigger_name)} ON #{quote_table(table_name)} CASCADE;"
           end
 
           private
 
+          def quote_identifier(name)
+            %("#{name.to_s.gsub('"', '""')}")
+          end
+
+          def quote_table(name)
+            name.to_s.split(".").map { |part| quote_identifier(part) }.join(".")
+          end
+
           def build_revision_columns(table_name, options)
             columns = normalize_revision_columns(options)
-            columns.join(", ")
+            columns.map { |column| quote_identifier(column) }.join(", ")
           end
 
           def build_revision_values(record_prefix, table_name, options)
             columns = normalize_revision_columns(options)
-            columns.map { |column| "#{record_prefix}.#{column}" }.join(", ")
+            columns.map { |column| "#{record_prefix}.#{quote_identifier(column)}" }.join(", ")
           end
 
           def normalize_revision_columns(options)

data/lib/active_version/migrators/audited.rb

@@ -66,8 +66,9 @@ module ActiveVersion
           changes_column = ActiveVersion.column_mapper.column_for(model_class, :audits, :changes).to_s
           context_column = ActiveVersion.column_mapper.column_for(model_class, :audits, :context).to_s
           comment_column = ActiveVersion.column_mapper.column_for(model_class, :audits, :comment).to_s
+          action_column = ActiveVersion.column_mapper.column_for(model_class, :audits, :action).to_s
 
-          {
+          data = {
             "#{auditable_column}_id" => old_audit.auditable_id,
             "#{auditable_column}_type" => old_audit.auditable_type,
             version_column => old_audit.version,
@@ -77,6 +78,22 @@ module ActiveVersion
             :created_at => old_audit.created_at,
             :updated_at => old_audit.updated_at || old_audit.created_at
           }
+
+          copy_optional_audit_field(data, old_audit, :action, action_column)
+          copy_optional_audit_field(data, old_audit, :user_id, ActiveVersion.config.audit_user_column)
+          copy_optional_audit_field(data, old_audit, :user_type, :user_type)
+          copy_optional_audit_field(data, old_audit, :remote_address, ActiveVersion.config.audit_remote_address_column)
+          copy_optional_audit_field(data, old_audit, :request_uuid, ActiveVersion.config.audit_request_uuid_column)
+          copy_optional_audit_field(data, old_audit, :associated_id, :"#{ActiveVersion.config.audit_associated_column}_id")
+          copy_optional_audit_field(data, old_audit, :associated_type, :"#{ActiveVersion.config.audit_associated_column}_type")
+
+          data
+        end
+
+        def copy_optional_audit_field(data, old_audit, source_method, destination_column)
+          return unless old_audit.respond_to?(source_method)
+
+          data[destination_column.to_s] = old_audit.public_send(source_method)
         end
       end
     end

data/lib/active_version/railtie.rb

@@ -9,6 +9,14 @@ module ActiveVersion
     # Expose configuration in Rails config
     config.active_version = ActiveVersion.config
 
+    # Drop fiber/thread persistent context when the request or job unit ends so a
+    # reused Puma/Sidekiq thread does not stamp the previous actor onto later audits.
+    initializer "active_version.clear_context_on_complete" do |app|
+      app.executor.to_complete do
+        ActiveVersion.clear_context!
+      end
+    end
+
     # Add rake tasks
     rake_tasks do
       load "active_version/tasks/active_version.rake"

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

@@ -37,17 +37,28 @@ module ActiveVersion
             current_version + 1
           end
 
-          # Refresh only columns with default functions (query optimization)
+          # Refresh only columns with default functions (query optimization).
+          # Never overwrite attributes the caller is about to save.
           refreshable_columns = refreshable_column_names
           if refreshable_columns.any?
-            refreshed = self.class.select(refreshable_columns).find(id)
-            refreshable_columns.each do |col|
-              refreshed_value = if refreshed.respond_to?(col)
-                refreshed.public_send(col)
-              elsif refreshed.respond_to?(:[])
-                refreshed[col]
+            pending_changes = if respond_to?(:changes_to_save) && changes_to_save.present?
+              changes_to_save.keys.map(&:to_s)
+            elsif respond_to?(:changed)
+              Array(changed).map(&:to_s)
+            else
+              []
+            end
+            columns_to_refresh = refreshable_columns - pending_changes
+            if columns_to_refresh.any?
+              refreshed = self.class.select(columns_to_refresh).find(id)
+              columns_to_refresh.each do |col|
+                refreshed_value = if refreshed.respond_to?(col)
+                  refreshed.public_send(col)
+                elsif refreshed.respond_to?(:[])
+                  refreshed[col]
+                end
+                self[col] = refreshed_value
               end
-              self[col] = refreshed_value
             end
           end
 
@@ -370,7 +381,16 @@ module ActiveVersion
           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)
+          # Callback path stores pre-change state. Keep the earliest pre-state and
+          # only extend the debounce window; overwriting would drop history (A -> B
+          # then B -> C within the window must leave A, not replace it with B).
+          if use_old_values
+            last_revision.class.where(id: last_revision.id).update_all(updated_at: timestamp)
+            revisions.reset
+            return
+          end
+
+          # Update last revision with current attributes (filtered by only/except)
           base_attrs = snapshot_base_attributes(use_old_values)
 
           snapshot_attrs = if only_attrs
@@ -421,16 +441,20 @@ module ActiveVersion
           revisions.reset
         end
 
-        # One retry on unique (version) violation, matching audit_writer behavior when a DB unique index exists.
+        # One retry on unique (version) collision. Each insert uses a savepoint so
+        # PostgreSQL can continue the outer update/lock transaction after a unique violation.
         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
+            self.class.transaction(requires_new: true) do
+              revisions.create!(revision_attrs)
+            end
+          rescue => error
+            raise error unless ActiveVersion::UniqueVersionCollision.match?(error, version_column: version_column_sym)
             raise error if attempt >= 2
 
-            max_version = revisions_scope.maximum(version_column_sym) || 0
+            max_version = revisions_scope.uncached { revisions_scope.maximum(version_column_sym) } || 0
             revision_attrs[version_column_sym] = max_version + 1
             retry
           end

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

@@ -13,7 +13,9 @@ module ActiveVersion
           at_version(version)
         end
 
-        # Get revision at specific time
+        # Get revision row that encodes state at specific time.
+        # Revision N stores pre-update state and is stamped at that update, so the
+        # state after an update is the next revision's payload (or current self).
         def revision_at(time: nil)
           return nil unless time
 
@@ -21,10 +23,7 @@ module ActiveVersion
           raise ActiveVersion::FutureTimeError, "Future state cannot be known" if time_obj.future?
 
           version_column = revision_version_column
-          revision_entry = revisions_scope.where("created_at <= ?", time_obj).order(version_column => :desc).first
-          # If requested time is before the first revision, return the earliest revision if present.
-          revision_entry ||= revisions_scope.order(version_column => :asc).first
-          revision_entry
+          revisions_scope.where("created_at > ?", time_obj).order(version_column => :asc).first
         end
 
         # Return a copy of record at specified time (read-only)
@@ -133,7 +132,9 @@ module ActiveVersion
 
         def find_revision_by_time(time)
           version_column = revision_version_column
-          revisions_scope.where("created_at <= ?", time).order(version_column => :desc).first
+          # Earliest revision after +time+ holds the live state as of +time+
+          # (that row's payload is the pre-state of the next change).
+          revisions_scope.where("created_at > ?", time).order(version_column => :asc).first
         end
 
         def revisions_scope

data/lib/active_version/revisions/has_revisions.rb

@@ -190,27 +190,21 @@ module ActiveVersion
           end
         end
 
-        # Disable revisions for a block
+        # Disable revisions for this fiber/thread only (does not mutate callback chains)
         def without_revisions
-          callbacks = if respond_to?(:_update_callbacks)
-            _update_callbacks.select { |cb| cb.filter == :create_revision_before_update }
-          else
-            []
-          end
-          callback_installed = callbacks.any?
-
-          skip_callback(:update, :before, :create_revision_before_update) if callback_installed
+          key = revision_disabled_depth_store_key
+          depth = ActiveVersion.store_get(key).to_i + 1
+          ActiveVersion.store_set(key, depth)
           yield
         ensure
-          # Restore callback if it was set up
-          if callback_installed && revision_options && revision_options[:auto] != false && revision_options[:on].include?(:update)
-            set_callback(:update, :before, :create_revision_before_update, if: :should_create_revision?)
-          end
+          depth = ActiveVersion.store_get(key).to_i - 1
+          depth = 0 if depth.negative?
+          ActiveVersion.store_set(key, depth)
         end
 
-        # Enable revisions for a block
+        # Enable revisions for a block even when class revisions were disabled permanently
         def with_revisions
-          revision_was_enabled = class_revision_enabled?
+          revision_was_enabled = class_revision_enabled_without_skip?
           enable_revisions
           yield
         ensure
@@ -218,10 +212,22 @@ module ActiveVersion
         end
 
         def class_revision_enabled?
-          @class_revision_enabled != false
+          return false if ActiveVersion.store_get(revision_disabled_depth_store_key).to_i.positive?
+
+          class_revision_enabled_without_skip?
         end
         public :class_revision_enabled?
 
+        def class_revision_enabled_without_skip?
+          @class_revision_enabled != false
+        end
+        private :class_revision_enabled_without_skip?
+
+        def revision_disabled_depth_store_key
+          :"active_version_#{name}_revision_disabled_depth"
+        end
+        private :revision_disabled_depth_store_key
+
         private
 
         def disable_revisions
@@ -362,17 +368,10 @@ module ActiveVersion
           return false
         end
 
-        # Check class-level enabled state (default to true if not set)
-        class_enabled = if self.class.instance_variable_defined?(:@class_revision_enabled)
-          self.class.instance_variable_get(:@class_revision_enabled)
-        else
-          true # Default to enabled
-        end
-        return false unless class_enabled != false
+        return false unless self.class.class_revision_enabled?
 
-        # Check global enabled state
-        # Note: We use config.auditing_enabled for both audits and revisions
-        return false unless ActiveVersion.config.auditing_enabled
+        # Check global enabled state (respects per-fiber without_auditing depth)
+        return false unless ActiveVersion.auditing_enabled
 
         # Get revision options (with defaults if not set)
         options = self.class.revision_options || {auto: true, on: [:update]}

data/lib/active_version/unique_version_collision.rb

@@ -0,0 +1,38 @@
+module ActiveVersion
+  module UniqueVersionCollision
+    module_function
+
+    def match?(error, version_column: nil)
+      return true if version_uniqueness_invalid?(error, version_column)
+
+      unique_constraint_names_version?(error, version_column)
+    end
+
+    def version_uniqueness_invalid?(error, version_column)
+      return false unless error.is_a?(ActiveRecord::RecordInvalid)
+      return false if version_column.nil?
+
+      details = error.record&.errors&.details
+      return false unless details
+
+      Array(details[version_column.to_sym]).any? { |detail| detail[:error] == :taken }
+    end
+
+    def unique_constraint_names_version?(error, version_column)
+      needle = version_column.to_s
+      return false if needle.empty?
+      return false unless unique_constraint_error?(error)
+
+      [error.message, error.cause&.message].compact.any? { |text| text.include?(needle) }
+    end
+
+    def unique_constraint_error?(error)
+      return true if error.is_a?(ActiveRecord::RecordNotUnique)
+      return false unless defined?(PG)
+
+      error.is_a?(ActiveRecord::StatementInvalid) && error.cause.is_a?(PG::UniqueViolation)
+    end
+
+    private_class_method :version_uniqueness_invalid?, :unique_constraint_names_version?, :unique_constraint_error?
+  end
+end

data/lib/active_version/version.rb

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

data/lib/active_version.rb

@@ -12,6 +12,7 @@ require "active_version/column_mapper"
 require "active_version/version_registry"
 require "active_version/instrumentation"
 require "active_version/runtime"
+require "active_version/unique_version_collision"
 
 # Main entry point for ActiveVersion
 module ActiveVersion
@@ -68,8 +69,11 @@ module ActiveVersion
     config
   end
 
-  # Convenience methods for accessing configuration
+  # Convenience methods for accessing configuration.
+  # +without_auditing+ uses a per-fiber/thread depth so concurrent callers are not silenced.
   def self.auditing_enabled
+    return false if store_get(:active_version_auditing_disabled_depth).to_i.positive?
+
     config.auditing_enabled
   end
 
@@ -99,7 +103,10 @@ module ActiveVersion
   end
 
   def self.context
-    # Merge persistent context with request-scoped context
+    # Merge persistent context (fiber/thread store) with request-scoped context.
+    # with_context ensure must restore only RequestStore.version_context so
+    # persistent keys are not copied into the request store and cannot shadow
+    # a later with_context!.
     persistent = store_get(:active_version_persistent_context) || {}
     request_scoped = RequestStore.version_context || {}
     persistent.merge(request_scoped)
@@ -111,7 +118,8 @@ module ActiveVersion
   end
 
   # Transaction-aware context (uses PostgreSQL session variables)
-  # Accepts either a hash as first argument or keyword arguments
+  # Accepts either a hash as first argument or keyword arguments.
+  # Pass transactional: false to skip SET LOCAL even when PostgreSQL supports it.
   def self.with_context(context = nil, transactional: true, **kwargs, &block)
     raise ArgumentError, "with_context requires a block" unless block_given?
 
@@ -128,16 +136,15 @@ module ActiveVersion
       raise ArgumentError, "context must be a hash or keyword arguments"
     end
 
-    if transactional_context_supported?
-      # Use PostgreSQL session variables for transaction-aware context
+    if transactional && transactional_context_supported?
       with_transactional_context(context_hash, &block)
     else
-      # Fallback to thread-local context
       with_thread_local_context(context_hash, &block)
     end
   end
 
-  # Persistent context (connection-level, persists across operations)
+  # Persistent context for the current fiber/thread (use clear_context! or the
+  # Railtie executor hook so a reused server thread does not leak actors).
   def self.with_context!(context)
     raise ArgumentError, "context must be a hash" unless context.is_a?(Hash)
 
@@ -216,7 +223,7 @@ module ActiveVersion
 
   def self.with_transactional_context(context, &block)
     connection = Runtime.adapter.base_connection
-    old_context = self.context.dup
+    old_request_context = RequestStore.version_context
     old_block_context = store_get(:active_version_block_context)
     enter_context_block!
 
@@ -226,15 +233,15 @@ module ActiveVersion
       connection.execute("SET LOCAL active_version.context = #{encoded_context}")
     end
 
-    # Also update thread-local for immediate access
-    self.context = old_context.merge(context)
+    # Merge into request-scoped store only (not persistent), so ensure restores cleanly
+    RequestStore.version_context = (old_request_context || {}).merge(context)
     store_set(:active_version_block_context, context)
 
     yield
   ensure
     # Context is automatically cleared on transaction rollback
-    # But we still restore thread-local context
-    self.context = old_context
+    # Restore request-scoped context only (do not copy persistent keys into RequestStore)
+    RequestStore.version_context = old_request_context
     store_set(:active_version_block_context, old_block_context)
     leave_context_block!
   end
@@ -254,25 +261,27 @@ module ActiveVersion
   end
 
   def self.with_thread_local_context(context, &block)
-    old_context = self.context.dup
+    old_request_context = RequestStore.version_context
     old_block_context = store_get(:active_version_block_context)
     enter_context_block!
-    self.context = old_context.merge(context)
+    RequestStore.version_context = (old_request_context || {}).merge(context)
     store_set(:active_version_block_context, context)
     yield
   ensure
-    self.context = old_context
+    RequestStore.version_context = old_request_context
     store_set(:active_version_block_context, old_block_context)
     leave_context_block!
   end
 
-  # Disable versioning globally
+  # Disable auditing for this fiber/thread only (nested-safe depth counter)
   def self.without_auditing
-    auditing_was_enabled = auditing_enabled
-    disable_auditing
+    depth = store_get(:active_version_auditing_disabled_depth).to_i + 1
+    store_set(:active_version_auditing_disabled_depth, depth)
     yield
   ensure
-    enable_auditing if auditing_was_enabled
+    depth = store_get(:active_version_auditing_disabled_depth).to_i - 1
+    depth = 0 if depth.negative?
+    store_set(:active_version_auditing_disabled_depth, depth)
   end
 
   def self.disable_auditing
@@ -356,6 +365,6 @@ module ActiveVersion
 end
 
 # Load Rails integration if available
-if defined?(Rails)
+if defined?(Rails::Railtie)
   require "active_version/railtie"
 end

data/lib/generators/active_version/revisions/templates/migration.rb.erb

@@ -4,13 +4,12 @@ class Create<%= revision_class_name.pluralize %> < ActiveRecord::Migration<%= mi
       t.references :<%= file_name %>, null: false, foreign_key: true, index: false
       t.integer :<%= version_column %>, null: false
 
-      # Copy all columns from source table
-      # Note: This is a simplified version - in production, you'd want to
-      # inspect the actual source table columns dynamically
-      # For now, we'll add common columns that can be customized
-      t.text :title
-      t.text :body
-      # Add other columns as needed
+      source_primary_key = connection.primary_key(:<%= source_table_name %>)
+      connection.columns(:<%= source_table_name %>).each do |column|
+        next if [source_primary_key, "created_at", "updated_at"].include?(column.name)
+
+        t.column column.name, column.sql_type, limit: column.limit, precision: column.precision, scale: column.scale
+      end
 
       t.timestamps
     end

data/sig/active_version/configuration.rbs

@@ -1,5 +1,7 @@
 module ActiveVersion
   class Configuration
+    ERROR_BEHAVIORS: Array[Symbol]
+
     attr_accessor auditing_enabled: bool
     attr_accessor current_user_method: Symbol | String
     attr_accessor ignored_attributes: Array[String]
@@ -13,6 +15,7 @@ module ActiveVersion
     attr_accessor revision_version_column: Symbol | String
     attr_accessor revision_foreign_key_suffix: String
 
+    attr_accessor default_audit_class: Class?
     attr_accessor audit_storage: :json_column | :yaml_column | :mirror_columns
     attr_accessor audit_action_column: Symbol | String
     attr_accessor audit_changes_column: Symbol | String
@@ -32,7 +35,6 @@ module ActiveVersion
     attr_accessor audit_error_behavior: Symbol
     attr_accessor revision_error_behavior: Symbol
     attr_accessor debounce_time: Numeric?
-    attr_accessor partition_schema_guards_enabled: bool
 
     def validate!: () -> void
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_version
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Andrei Makarov
@@ -15,14 +15,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: 7.2.3.2
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: 7.2.3.2
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -43,14 +49,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: 7.2.3.2
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: 7.2.3.2
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -85,14 +97,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.9.5
+        version: 2.9.6
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.9.5
+        version: 2.9.6
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -253,14 +265,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.8'
+        version: '3.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.8'
+        version: '3.9'
 - !ruby/object:Gem::Dependency
   name: rubocop-thread_safety
   requirement: !ruby/object:Gem::Requirement
@@ -317,6 +329,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3'
+- !ruby/object:Gem::Dependency
+  name: parallel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.26'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.26'
 description: 'ActiveVersion is a language-agnostic versioning library that unifies
   three core use cases: translations (locale-based), revisions/drafts (workflow snapshots),
   and audits (change tracking).'
@@ -373,6 +399,7 @@ files:
 - lib/active_version/translations.rb
 - lib/active_version/translations/has_translations.rb
 - lib/active_version/translations/translation_record.rb
+- lib/active_version/unique_version_collision.rb
 - lib/active_version/version.rb
 - lib/active_version/version_registry.rb
 - lib/generators/active_version/audits/audits_generator.rb
@@ -416,7 +443,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.0'
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="