active_version 1.0.0

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

@@ -0,0 +1,212 @@
+module ActiveVersion
+  module Audits
+    module HasAudits
+      # Methods for combining audits
+      module AuditCombiner
+        extend ActiveSupport::Concern
+
+        private
+
+        def combine_audits_if_needed
+          max_audits = evaluate_max_audits
+          return unless max_audits && max_audits > 0
+          changes_column = ActiveVersion.column_mapper.column_for(self.class, :audits, :changes)
+          return unless self.class.audit_class.column_names.include?(changes_column.to_s)
+
+          # Keep combining until we're under the limit
+          # This handles cases where multiple combinations are needed
+          max_iterations = 10 # Safety limit to prevent infinite loops
+          iteration = 0
+
+          loop do
+            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
+            if respond_to?(:audits)
+              audits.reset
+              if respond_to?(:association)
+                assoc = association(:audits)
+                assoc.reset if assoc.respond_to?(:loaded?) && assoc.loaded?
+              end
+            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
+            if auditable_type != 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)
+              all_audits = self.class.audit_class.where({"#{auditable_column}_type" => auditable_type}.merge(active_version_audit_identity_map))
+                .order(version_column => :asc)
+                .to_a
+            else
+              # Use association but ensure it's not cached
+              all_audits = audits.reload.to_a
+            end
+
+            # 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
+
+            audits_count = active_audits.length
+            break if audits_count <= max_audits
+
+            # Calculate how many extra audits we have
+            extra_count = audits_count - max_audits
+
+            # 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)
+
+            # Safety check to prevent infinite loops
+            break if audits_to_combine.empty? || audits_to_combine.length <= 1
+
+            # Combine them (this will merge into the last audit and mark older ones as combined)
+            combine_audits(audits_to_combine)
+          end
+        end
+
+        def evaluate_max_audits
+          max_audits = case (option = audited_options[:max_audits])
+          when Proc then option.call
+          when Symbol
+            # Try instance method first, then class method
+            if respond_to?(option, true)
+              send(option)
+            elsif self.class.respond_to?(option, true)
+              self.class.send(option)
+            end
+          else
+            option
+          end
+
+          max_audits ||= ActiveVersion.config.max_audits
+          Integer(max_audits).abs if max_audits
+        end
+
+        def combine_audits(audits_to_combine)
+          return if audits_to_combine.empty?
+
+          # Ensure we have an array (might be a relation or array)
+          audits_array = audits_to_combine.is_a?(Array) ? audits_to_combine : audits_to_combine.to_a
+          return if audits_array.empty?
+
+          combine_target = audits_array.last
+          audit_class = combine_target.class
+          version_column = ActiveVersion.column_mapper.column_for(combine_target.class.source_class, :audits, :version)
+          changes_column = ActiveVersion.column_mapper.column_for(combine_target.class.source_class, :audits, :changes)
+          return unless audit_class.column_names.include?(changes_column.to_s)
+          context_column = ActiveVersion.column_mapper.column_for(combine_target.class.source_class, :audits, :context)
+
+          # Get changes from each audit - use read_attribute to get raw JSON, then parse
+          all_changes = audits_array.map do |a|
+            value = a.read_attribute(changes_column)
+            # Parse JSON if it's a string
+            if value.is_a?(String)
+              begin
+                JSON.parse(value)
+              rescue JSON::ParserError
+                {}
+              end
+            else
+              value || {}
+            end
+          end
+
+          # Merge all changes
+          combined_changes = all_changes.reduce({}) { |acc, changes| acc.merge(changes) }
+
+          # Get contexts from each audit
+          all_contexts = audits_array.map do |a|
+            value = a.read_attribute(context_column)
+            if value.is_a?(String)
+              begin
+                JSON.parse(value)
+              rescue JSON::ParserError
+                {}
+              end
+            else
+              value || {}
+            end
+          end.compact
+
+          # Merge contexts
+          combined_context = all_contexts.reduce({}) { |acc, ctx| acc.merge(ctx) } if all_contexts.any?
+
+          combine_target_version = combine_target.read_attribute(version_column)
+
+          # Update combine target and mark old audits as combined (no deletion - safer for audit logs)
+          audits_to_mark_combined = audits_array[0..-2] # All except the target
+
+          # Update combine target with merged changes using raw SQL to bypass readonly
+          conn = audit_class.connection
+          table_name = audit_class.table_name
+          updates = []
+          updates << "#{conn.quote_column_name(changes_column)} = #{conn.quote(combined_changes.to_json)}"
+          if combined_context.any?
+            updates << "#{conn.quote_column_name(context_column)} = #{conn.quote(combined_context.to_json)}"
+          end
+          target_id = conn.quote(combine_target.read_attribute(:id))
+          sql = "UPDATE #{conn.quote_table_name(table_name)} SET #{updates.join(", ")} WHERE id = #{target_id}"
+          conn.execute(sql)
+
+          # Mark old audits as combined (no deletion - safer for audit logs)
+          if audits_to_mark_combined.any?
+            comment_column = ActiveVersion.column_mapper.column_for(combine_target.class.source_class, :audits, :comment)
+            combined_comment = "[COMBINED] This audit was merged into version #{combine_target_version}"
+
+            # Use direct SQL update to bypass readonly enforcement and ensure updates work
+            audit_ids = audits_to_mark_combined.map { |a| a.read_attribute(:id) }
+
+            if audit_ids.any?
+              # Use raw SQL with proper escaping to bypass ActiveRecord's readonly checks
+              conn = audit_class.connection
+              table_name = audit_class.table_name
+              empty_json_str = {}.to_json  # This is "{}"
+              empty_json = conn.quote(empty_json_str)
+              quoted_comment = conn.quote(combined_comment)
+
+              # Update all audits in a single SQL statement for efficiency
+              id_list = audit_ids.map { |id| conn.quote(id) }.join(",")
+              sql = "UPDATE #{conn.quote_table_name(table_name)} SET #{conn.quote_column_name(changes_column)} = #{empty_json}, #{conn.quote_column_name(comment_column)} = #{quoted_comment} WHERE id IN (#{id_list})"
+
+              # Execute the update
+              conn.execute(sql)
+            end
+          end
+
+          # Clear association cache to ensure fresh data is loaded after updates
+          if respond_to?(:audits)
+            # Clear the association cache
+            audits.reset
+            # Also clear any loaded association state
+            if respond_to?(:association)
+              assoc = association(:audits)
+              if assoc.respond_to?(:loaded?) && assoc.loaded?
+                assoc.reset
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,282 @@
+module ActiveVersion
+  module Audits
+    module HasAudits
+      # Methods for writing audits to the database
+      module AuditWriter
+        extend ActiveSupport::Concern
+
+        private
+
+        def write_audit(attrs)
+          # Capture comment and context before clearing them
+          # Use provided context from attrs if available (captured in before_update), otherwise use current
+          # Check if context was explicitly passed before deleting
+          context_was_provided = attrs.key?(:context)
+          provided_context = attrs.delete(:context)
+          provided_comment = attrs.delete(:comment)
+          captured_comment = provided_comment || audit_comment
+
+          # Merge instance context with global context (instance context takes precedence)
+          # Convert keys to strings for consistency
+          block_context = ActiveVersion.store_get(:active_version_block_context)
+          global_context = if block_context.is_a?(Hash)
+            persistent_context = (ActiveVersion.store_get(:active_version_persistent_context) || {}).stringify_keys
+            persistent_context.merge(block_context.stringify_keys)
+          else
+            (ActiveVersion.context || {}).stringify_keys
+          end
+          # Use provided context if available, otherwise use current audit_context
+          # Handle both Hash and other types
+          # If context was explicitly provided (even if nil), use it; otherwise fall back to audit_context
+          raw_instance_context = if context_was_provided
+            provided_context # Could be nil, hash, or other
+          else
+            audit_context # Fall back to instance variable
+          end
+          # Normalize instance context to a hash with string keys
+          instance_context = if raw_instance_context.nil?
+            {}
+          elsif raw_instance_context.is_a?(Hash)
+            raw_instance_context.stringify_keys
+          else
+            {}
+          end
+          # Merge: global context first, then instance context (instance takes precedence)
+          captured_context = global_context.dup.merge(instance_context)
+
+          self.audit_comment = nil
+          self.audit_context = nil
+
+          if auditing_enabled
+            attrs[:associated] = send(audit_associated_with) unless audit_associated_with.nil?
+
+            # Use captured values if not explicitly provided
+            attrs[:comment] ||= captured_comment
+            # Always set audited_context if it has any values or if context was explicitly provided
+            # This ensures instance context is merged with global context even if global context is empty
+            # Set it if we have any context (global or instance) or if context was explicitly provided
+            if captured_context.present? || context_was_provided || global_context.present?
+              attrs[:audited_context] = captured_context
+            end
+
+            run_callbacks(:audit) do
+              # Build insert attributes
+              changes_column = ActiveVersion.column_mapper.column_for(self.class, :audits, :changes)
+              context_column = ActiveVersion.column_mapper.column_for(self.class, :audits, :context)
+              auditable_column = ActiveVersion.column_mapper.column_for(self.class, :audits, :auditable)
+              version_column = ActiveVersion.column_mapper.column_for(self.class, :audits, :version)
+              batch_state = ActiveVersion.store_get(:active_version_audit_batch_state)
+              batch_capture_active = batch_state.is_a?(Hash) && batch_state[:target_audit_class] == audit_class
+
+              insert_attrs = {}
+
+              # Map action
+              insert_attrs[:action] = attrs[:action]
+
+              # Map audited_changes
+              changes_column_exists = audit_class.column_names.include?(changes_column.to_s)
+              if changes_column_exists
+                insert_attrs[changes_column] = attrs[:audited_changes] || attrs[changes_column]
+              end
+
+              # For structured table storage, mirror audited fields into dedicated columns.
+              if audited_options[:storage].to_sym == :mirror_columns
+                # Prefer callback-provided payload so update events use explicit old/new
+                # pairs (we persist the "new" side for table columns).
+                structured_payload = attrs[:audited_changes] || attrs[changes_column]
+                # Fallback for create/destroy or custom flows that do not pass payload.
+                structured_payload ||= audited_attributes
+                map_structured_audit_columns(insert_attrs, structured_payload)
+                copy_shared_source_columns(insert_attrs)
+              end
+
+              # Map comment
+              comment_column = ActiveVersion.column_mapper.column_for(self.class, :audits, :comment)
+              insert_attrs[comment_column] = attrs[:comment] if attrs[:comment].present?
+
+              # Map audited_context
+              if attrs[:audited_context].present? || attrs[context_column].present?
+                insert_attrs[context_column] = attrs[:audited_context] || attrs[context_column]
+              end
+              if batch_capture_active
+                batch_context = batch_state.dig(:options, :context)
+                if batch_context.is_a?(Hash)
+                  merged_context = insert_attrs[context_column]
+                  merged_context = {} unless merged_context.is_a?(Hash)
+                  insert_attrs[context_column] = merged_context.merge(batch_context.stringify_keys)
+                end
+              end
+
+              # Set polymorphic association
+              # In before_update, the record should already have an ID
+              # But ensure we have a valid ID before creating the audit
+              identity_map = active_version_audit_identity_map
+              return nil if identity_map.values.any?(&:nil?) # Skip until identity is fully available
+
+              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
+              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
+              insert_attrs["#{auditable_column}_type"] = auditable_type
+
+              # Calculate version number
+              if batch_capture_active
+                normalized_identity = identity_map.transform_keys(&:to_s).sort.to_h
+                tracker_key = [auditable_type, normalized_identity]
+                tracker = batch_state[:version_tracker] || {}
+                current_version = tracker[tracker_key]
+
+                unless current_version
+                  max_version = audit_class.where({"#{auditable_column}_type" => auditable_type}.merge(identity_map))
+                    .maximum(version_column) || 0
+                  current_version = max_version
+                end
+
+                current_version += 1
+                tracker[tracker_key] = current_version
+                batch_state[:version_tracker] = tracker
+                insert_attrs[version_column] = current_version
+              elsif attrs[:action] == "create"
+                insert_attrs[version_column] = 1
+              else
+                # Get max version for this auditable
+                max_version = audit_class.where({"#{auditable_column}_type" => auditable_type}.merge(identity_map))
+                  .maximum(version_column) || 0
+                insert_attrs[version_column] = max_version + 1
+              end
+
+              # Set user from RequestStore or config
+              user_column = ActiveVersion.column_mapper.column_for(self.class, :audits, :user)
+              if user_column && !insert_attrs.key?(user_column)
+                user = ActiveVersion::RequestStore.audited_user if defined?(ActiveVersion::RequestStore)
+                user ||= begin
+                  user_method = ActiveVersion.config.current_user_method
+                  send(user_method) if respond_to?(user_method, true)
+                end
+                if user
+                  insert_attrs[user_column] = user.respond_to?(:id) ? user.id : user
+                  if user_column.to_s.end_with?("_id") && user.respond_to?(:class, true)
+                    type_column = user_column.to_s.gsub("_id", "_type")
+                    insert_attrs[type_column] = user.class.name if audit_class.column_names.include?(type_column.to_s)
+                  end
+                end
+              end
+
+              # Set request_uuid from RequestStore or generate
+              uuid_column = ActiveVersion.column_mapper.column_for(self.class, :audits, :request_uuid)
+              if uuid_column && audit_class.column_names.include?(uuid_column.to_s) && !insert_attrs.key?(uuid_column)
+                insert_attrs[uuid_column] = ActiveVersion::RequestStore.request_uuid if defined?(ActiveVersion::RequestStore)
+                insert_attrs[uuid_column] ||= SecureRandom.uuid if insert_attrs[uuid_column].blank?
+              end
+
+              # Set remote_address from RequestStore
+              address_column = ActiveVersion.column_mapper.column_for(self.class, :audits, :remote_address)
+              if address_column && audit_class.column_names.include?(address_column.to_s) && !insert_attrs.key?(address_column)
+                insert_attrs[address_column] = ActiveVersion::RequestStore.remote_address if defined?(ActiveVersion::RequestStore)
+              end
+
+              insert_attrs[:created_at] ||= Time.current
+              insert_attrs[:updated_at] ||= Time.current
+
+              if batch_capture_active
+                batch_state[:values] << insert_attrs
+                ActiveVersion.store_set(:active_version_audit_batch_state, batch_state)
+                return nil
+              end
+
+              begin
+                audit_class.create!(insert_attrs)
+                combine_audits_if_needed if attrs[:action] != "create"
+                audits.reset
+                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"
+                    audits.reset
+                    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
+            end
+          end
+        end
+
+        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
+
+          case behavior
+          when :log
+            log_audit_errors(error, action)
+          when :exception
+            raise error
+          when :silent
+            # noop
+          end
+        end
+
+        def log_audit_errors(error, action)
+          Rails.logger&.warn(
+            "Unable to create audit for #{action} of #{self.class.name}" \
+            "##{id}: #{error.message}"
+          )
+        end
+
+        def map_structured_audit_columns(insert_attrs, payload)
+          return unless payload.is_a?(Hash)
+
+          payload.each do |attr, value|
+            column_name = attr.to_s
+            next unless audit_class.column_names.include?(column_name)
+
+            insert_attrs[column_name] = value.is_a?(Array) ? value.last : value
+          end
+        end
+
+        # Ensure table-storage audits can carry source identity/partition columns
+        # even when those attributes did not change in this event.
+        def copy_shared_source_columns(insert_attrs)
+          shared_columns = audit_class.column_names & self.class.column_names
+          excluded = [
+            "id", "created_at", "updated_at",
+            ActiveVersion.column_mapper.column_for(self.class, :audits, :changes).to_s,
+            ActiveVersion.column_mapper.column_for(self.class, :audits, :context).to_s,
+            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
+
+          shared_columns.each do |column_name|
+            next if insert_attrs.key?(column_name)
+            insert_attrs[column_name] = self[column_name] if has_attribute?(column_name)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+module ActiveVersion
+  module Audits
+    module HasAudits
+      # Methods for filtering and processing changes
+      module ChangeFilters
+        extend ActiveSupport::Concern
+
+        private
+
+        def audited_changes(for_touch: false, exclude_readonly_attrs: false)
+          all_changes = if for_touch
+            # For touch operations, use changes that will be saved
+            respond_to?(:changes_to_save) ? changes_to_save : changes
+          elsif persisted?
+            # For updates to persisted records, use changes that will be saved
+            (respond_to?(:changes_to_save) && !changes_to_save.empty?) ? changes_to_save : changes
+          else
+            # For new records, use all changes
+            changes
+          end
+
+          all_changes = all_changes.except(*self.class.readonly_attributes.to_a) if exclude_readonly_attrs
+
+          # Filter by only/except options
+          filtered_changes = if audited_options[:only].present?
+            all_changes.slice(*audited_options[:only])
+          else
+            all_changes.except(*non_audited_columns)
+          end
+
+          # Normalize, redact, and filter
+          filtered_changes = normalize_enum_changes(filtered_changes)
+          filtered_changes = redact_values(filtered_changes)
+          filtered_changes = filter_encrypted_attrs(filtered_changes)
+          filtered_changes.to_hash
+        end
+
+        def audited_attributes
+          attrs = attributes.except(*non_audited_columns)
+          attrs = redact_values(attrs)
+          attrs = filter_encrypted_attrs(attrs)
+          normalize_enum_changes(attrs)
+        end
+
+        def non_audited_columns
+          @non_audited_columns ||= begin
+            default_ignored = [self.class.primary_key, self.class.inheritance_column] | ActiveVersion.config.ignored_attributes.map(&:to_s)
+            if audited_options[:only].present?
+              (self.class.column_names | default_ignored) - audited_options[:only]
+            elsif audited_options[:except].present?
+              default_ignored | audited_options[:except]
+            else
+              default_ignored
+            end
+          end
+        end
+
+        def normalize_enum_changes(changes)
+          return changes if ActiveVersion.config.store_synthesized_enums
+
+          self.class.defined_enums.each do |name, values|
+            next unless changes.has_key?(name)
+
+            changes[name] = if changes[name].is_a?(Array)
+              changes[name].map { |v| values[v] }
+            else
+              values[changes[name]]
+            end
+          end
+          changes
+        end
+
+        def redact_values(filtered_changes)
+          filter_attr_values(
+            audited_changes: filtered_changes,
+            attrs: audited_options[:redacted],
+            placeholder: audited_options[:redaction_value] || REDACTED
+          )
+        end
+
+        def filter_encrypted_attrs(filtered_changes)
+          return filtered_changes unless respond_to?(:encrypted_attributes)
+
+          filter_attr_values(
+            audited_changes: filtered_changes,
+            attrs: Array(encrypted_attributes).map(&:to_s),
+            placeholder: "[FILTERED]"
+          )
+        end
+
+        def filter_attr_values(audited_changes: {}, attrs: [], placeholder: "[FILTERED]")
+          attrs.each do |attr|
+            next unless audited_changes.key?(attr)
+
+            changes = audited_changes[attr]
+            values = changes.is_a?(Array) ? changes.map { placeholder } : placeholder
+
+            audited_changes[attr] = values
+          end
+
+          audited_changes
+        end
+
+        def prepare_sql_values(changes)
+          changes.each_with_object({}) do |(k, v), h|
+            h[k] = v.last if v.is_a?(Array)
+            h[k] = v unless v.is_a?(Array)
+            h[k] = h[k].to_json if h[k].is_a?(Hash)
+          end
+        end
+      end
+    end
+  end
+end