active_version 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d52287aa8ea68e0c77baff3065a3140d397c2e638460967880b0b0dbc904b42c
-  data.tar.gz: aff296230f04d04d90bafe26e12fe0876fc2cd292cd07e6083d71a595a9ea6f6
+  metadata.gz: 89fbcf4b5aebb3bd2fcbbedfafb3f6575edd6f22571080ce310005f3e6f27a28
+  data.tar.gz: 4a90af0cfcee066886ce989f11b8347303db945036ea57cc0a3f6d7b00bcfeee
 SHA512:
-  metadata.gz: 35c7b1c96056c61e5c36a72166d2be067504da0fa922fd439ad4a6b1a09a7630ae80734fb2ad8e97dfb81fd3302c75ed168cb92adb22669f222e5cd6aa363a90
-  data.tar.gz: db6759859ffd1139a818c45a23ae486e819e035553b32762f586465cbef3a2597507a80ea424036ecc0718fe6a9dbf25cb11fe5c8e4e6c7556d27e124e13704f
+  metadata.gz: 965f5ffcea61f3d8024d9ba0aaa7a0e3c514b1ce7b48a6f01f89bec05469ab481e82d894e3527a6b35c5f0830fa2cbf8b1947a7936b96e187ad31a228848d333
+  data.tar.gz: d8a5bc8d85a017998917086917d3a88c731cdc9bff9cab6ccf4cfe89d78c53d7b2bcd192ee31b4570a8fcbc532c67287e3399ebf89dd172806acd440fb1283b9

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 # 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`.

data/README.md

@@ -12,7 +12,7 @@ Design changes go through `rfcs/` (RFC 0001).
 - 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
 
@@ -307,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
 
@@ -503,7 +503,7 @@ Environment knobs:
 
 ## Requirements
 
-- Ruby >= 3.0.0
+- 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)
 

data/SECURITY.md

@@ -2,26 +2,24 @@
 
 ## Reporting a Vulnerability
 
-Do not open a public 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/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
@@ -216,7 +216,7 @@ module ActiveVersion
               return nil
             end
 
-            auditable_type_for_query = audited_options[:class_name] || self.class.name
+            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
@@ -273,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

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/version.rb

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

data/lib/active_version.rb

@@ -69,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
 
@@ -100,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)
@@ -112,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?
 
@@ -129,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)
 
@@ -217,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!
 
@@ -227,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
@@ -255,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
@@ -357,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: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Andrei Makarov
@@ -97,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
@@ -443,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:
   - - ">="