snail_trail 1.0.0 → 1.1.0.rc.pre.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 39efcc6e2abb6e5e4b2b6ec7db282ee45e1f3532774bee5ce6a02ed877552fdd
-  data.tar.gz: 2b99c3c9ee205071668045cf89f25afa30c7c143d090a1ae59304cd4a7951a99
+  metadata.gz: 9615c601651c566fd33af08844a5aa454394269af10c4b955c95864ccf364963
+  data.tar.gz: 4656e2e38cfb1ed9155ec37b676e46e4cd8533c5db54118c69e55177d95223d2
 SHA512:
-  metadata.gz: dd558bd7231683b7a20a8536be9b823137001011b3665f6ef50d5ab3f1cee0370624a97547a64679470e5f66f1697fc6800a55df23f4c8797caf0b682b0c60f2
-  data.tar.gz: adefeb14072c54f5b8e629c8ae8d50b5d87dd78f6e8adc2ad061e7d8e51077c224fed26c28cec37a0a6668123c1e23e406bd1913fc6632879a745959fcce8848
+  metadata.gz: 32cb46bf800abafcf3b16efd74ace9e398cf7cb366310ed48bdc2cd14ec375036543e3699d9f97359cfa4a2c42882c67d555fab442bfd93ae3902f54ff020547
+  data.tar.gz: 3377f9f5af34d50de4dcaca784fb1b6d6cb8190801496418b02a7aefc7494801f92bac6172b5c0d83c13dd3b976f0dc285868c1fa24556f71d89dedb9cdb4ab6

data/lib/snail_trail/frameworks/rails/controller.rb

@@ -89,6 +89,16 @@ module SnailTrail
         end
       end
 
+      # Tells SnailTrail to run in performance mode.
+      #
+      # @api public
+      #
+      def set_snail_trail_performance_mode
+        if ::SnailTrail.request.enabled?
+          ::SnailTrail.request.performance_mode!
+        end
+      end
+
       # Tells SnailTrail any information from the controller you want to store
       # alongside any changes that occur.
       #

data/lib/snail_trail/model_config.rb

@@ -126,8 +126,18 @@ module SnailTrail
 
       # Reset the transaction id when the transaction is closed.
       def setup_transaction_callbacks
-        @model_class.after_commit { ::SnailTrail.request.clear_transaction_id }
-        @model_class.after_rollback { ::SnailTrail.request.clear_transaction_id }
+        @model_class.after_commit do |r|
+          ::SnailTrail.request.clear_transaction_id
+          
+          r.snail_trail.record_performance_data
+
+          ::SnailTrail.request.clear_performance_mode
+        end
+
+        @model_class.after_rollback do
+          ::SnailTrail.request.clear_transaction_id
+          ::SnailTrail.request.clear_performance_mode
+        end
       end
 
     # @api private

data/lib/snail_trail/record_trail.rb

@@ -58,17 +58,23 @@ module SnailTrail
     def record_create
       return unless enabled?
 
-      build_version_on_create(in_after_callback: true).tap do |version|
-        version.save!
+      version = build_version_on_create(in_after_callback: true)
 
-        update_transaction_id(version)
+      if ::SnailTrail.request.performance_mode?
+        ::SnailTrail.request.performance_mode_data << version.attributes
+      else
+        begin
+          version.save!
 
-        # Because the version object was created using version_class.new instead
-        # of versions_assoc.build?, the association cache is unaware. So, we
-        # invalidate the `versions` association cache with `reset`.
-        versions.reset
-      rescue StandardError => e
-        handle_version_errors e, version, :create
+          update_transaction_id(version)
+
+          # Because the version object was created using version_class.new instead
+          # of versions_assoc.build?, the association cache is unaware. So, we
+          # invalidate the `versions` association cache with `reset`.
+          versions.reset
+        rescue StandardError => e
+          handle_version_errors e, version, :create
+        end
       end
     end
 
@@ -82,22 +88,25 @@ module SnailTrail
       in_after_callback = recording_order == "after"
       event = Events::Destroy.new(@record, in_after_callback)
 
-      # Merge data from `Event` with data from ST-AT. We no longer use
-      # `data_for_destroy` but ST-AT still does.
       data = event.data.merge(data_for_destroy)
 
       version = @record.class.snail_trail.version_class.new(data)
-      begin
-        version.save!
-        assign_and_reset_version_association(version)
 
-        if version && version.respond_to?(:errors) && version.errors.empty?
-          update_transaction_id(version)
-        end
+      if ::SnailTrail.request.performance_mode?
+        ::SnailTrail.request.performance_mode_data << version.attributes
+      else
+        begin
+          version.save!
+          assign_and_reset_version_association(version)
+
+          if version && version.respond_to?(:errors) && version.errors.empty?
+            update_transaction_id(version)
+          end
 
-        version
-      rescue StandardError => e
-        handle_version_errors e, version, :destroy
+          version
+        rescue StandardError => e
+          handle_version_errors e, version, :destroy
+        end
       end
     end
 
@@ -119,20 +128,50 @@ module SnailTrail
       )
       return unless version
 
-      begin
-        version.save!
-        # Because the version object was created using version_class.new instead
-        # of versions_assoc.build?, the association cache is unaware. So, we
-        # invalidate the `versions` association cache with `reset`.
-        versions.reset
+      if ::SnailTrail.request.performance_mode?
+        ::SnailTrail.request.performance_mode_data << version.attributes
+      else
+        begin
+          version.save!
+          # Because the version object was created using version_class.new instead
+          # of versions_assoc.build?, the association cache is unaware. So, we
+          # invalidate the `versions` association cache with `reset`.
+          versions.reset
+
+          if version && version.respond_to?(:errors) && version.errors.empty?
+            update_transaction_id(version)
+          end
+
+          version
+        rescue StandardError => e
+          handle_version_errors e, version, :update
+        end
+      end
+    end
+
+    def record_performance_data
+      return unless ::SnailTrail.request.performance_mode?
+
+      all_data = ::SnailTrail.request.performance_mode_data
+      first_data = all_data.shift
+      version = @record.class.snail_trail.version_class.create(first_data)
+      update_transaction_id(version)
+      all_data.each_slice(1_000) do |datas|
+        timestamp = Time.now.utc.strftime("%Y-%m-%d %H:%M:%S")
+        datas.each do |d|
+          add_transaction_id_to(d)
+          d['created_at'] = timestamp
+          d['event'] = "batch_#{d['event']}"
+        end
 
-        if version && version.respond_to?(:errors) && version.errors.empty?
-          update_transaction_id(version)
+        sql = ["INSERT INTO #{version.class.table_name} (#{datas.first.keys.join(", ")}) VALUES"]
+        datas.map do |data|
+          values = data.map { |k, v| @record.class.connection.quote(v.is_a?(Hash) ? JSON.generate(v) : v) }
+          sql << "(#{values.join(", ")}),"
         end
+        sql.last.chop!
 
-        version
-      rescue StandardError => e
-        handle_version_errors e, version, :update
+        @record.class.snail_trail.version_class.connection.execute(sql.join("\n"))
       end
     end
 
@@ -218,7 +257,6 @@ module SnailTrail
         data[:transaction_id] = ::SnailTrail.request.transaction_id
       end
 
-
       def update_transaction_id(version)
         return unless @record.class.snail_trail.version_class.column_names.include?("transaction_id")
         if ::SnailTrail.transaction? && ::SnailTrail.request.transaction_id.nil?
@@ -228,148 +266,148 @@ module SnailTrail
         end
       end
 
-    # @api private
-    def assign_and_reset_version_association(version)
-      @record.send(:"#{@record.class.version_association_name}=", version)
-      @record.send(@record.class.versions_association_name).reset
-    end
-
-    # @api private
-    def build_version_on_create(in_after_callback:)
-      event = Events::Create.new(@record, in_after_callback)
+      # @api private
+      def assign_and_reset_version_association(version)
+        @record.send(:"#{@record.class.version_association_name}=", version)
+        @record.send(@record.class.versions_association_name).reset
+      end
 
-      # Merge data from `Event` with data from ST-AT. We no longer use
-      # `data_for_create` but ST-AT still does.
-      data = event.data.merge!(data_for_create)
+      # @api private
+      def build_version_on_create(in_after_callback:)
+        event = Events::Create.new(@record, in_after_callback)
 
-      # Pure `version_class.new` reduces memory usage compared to `versions_assoc.build`
-      @record.class.snail_trail.version_class.new(data)
-    end
+        # Merge data from `Event` with data from ST-AT. We no longer use
+        # `data_for_create` but ST-AT still does.
+        data = event.data.merge!(data_for_create)
 
-    # @api private
-    def build_version_on_update(force:, in_after_callback:, is_touch:)
-      event = Events::Update.new(@record, in_after_callback, is_touch, nil)
-      return unless force || event.changed_notably?
-      data = event.data
-
-      # Copy the (recently set) `updated_at` from the record to the `created_at`
-      # of the `Version`. Without this feature, these two timestamps would
-      # differ by a few milliseconds. To some people, it seems a little
-      # unnatural to tamper with creation timestamps in this way. But, this
-      # feature has existed for a long time, almost a decade now, and some users
-      # may rely on it now.
-      if @record.respond_to?(:updated_at) &&
-          @record.snail_trail_options[:synchronize_version_creation_timestamp] != false
-        data[:created_at] = @record.updated_at
+        # Pure `version_class.new` reduces memory usage compared to `versions_assoc.build`
+        @record.class.snail_trail.version_class.new(data)
       end
 
-      # Merge data from `Event` with data from ST-AT. We no longer use
-      # `data_for_update` but ST-AT still does. To save memory, we use `merge!`
-      # instead of `merge`.
-      data.merge!(data_for_update)
+      # @api private
+      def build_version_on_update(force:, in_after_callback:, is_touch:)
+        event = Events::Update.new(@record, in_after_callback, is_touch, nil)
+        return unless force || event.changed_notably?
+        data = event.data
+
+        # Copy the (recently set) `updated_at` from the record to the `created_at`
+        # of the `Version`. Without this feature, these two timestamps would
+        # differ by a few milliseconds. To some people, it seems a little
+        # unnatural to tamper with creation timestamps in this way. But, this
+        # feature has existed for a long time, almost a decade now, and some users
+        # may rely on it now.
+        if @record.respond_to?(:updated_at) &&
+           @record.snail_trail_options[:synchronize_version_creation_timestamp] != false
+          data[:created_at] = @record.updated_at
+        end
 
-      # Using `version_class.new` reduces memory usage compared to
-      # `versions_assoc.build`. It's a trade-off though. We have to clear
-      # the association cache (see `versions.reset`) and that could cause an
-      # additional query in certain applications.
-      @record.class.snail_trail.version_class.new(data)
-    end
+        # Merge data from `Event` with data from ST-AT. We no longer use
+        # `data_for_update` but ST-AT still does. To save memory, we use `merge!`
+        # instead of `merge`.
+        data.merge!(data_for_update)
 
-    # @api public
-    def data_for_create
-      data = {}
-      add_transaction_id_to(data)
-      data
-    end
+        # Using `version_class.new` reduces memory usage compared to
+        # `versions_assoc.build`. It's a trade-off though. We have to clear
+        # the association cache (see `versions.reset`) and that could cause an
+        # additional query in certain applications.
+        @record.class.snail_trail.version_class.new(data)
+      end
 
-    # @api public
-    def data_for_destroy
-      data = {}
-      add_transaction_id_to(data)
-      data
-    end
+      # @api public
+      def data_for_create
+        data = {}
+        add_transaction_id_to(data)
+        data
+      end
 
-    # @api public
-    def data_for_update
-      data = {}
-      add_transaction_id_to(data)
-      data
-    end
+      # @api public
+      def data_for_destroy
+        data = {}
+        add_transaction_id_to(data)
+        data
+      end
 
-    # @api public
-    def data_for_update_columns
-      data = {}
-      add_transaction_id_to(data)
-      data
-    end
+      # @api public
+      def data_for_update
+        data = {}
+        add_transaction_id_to(data)
+        data
+      end
 
-    # Is ST enabled for this particular record?
-    # @api private
-    def enabled?
-      SnailTrail.enabled? &&
-        SnailTrail.request.enabled? &&
-        SnailTrail.request.enabled_for_model?(@record.class)
-    end
+      # @api public
+      def data_for_update_columns
+        data = {}
+        add_transaction_id_to(data)
+        data
+      end
 
-    def log_version_errors(version, action)
-      version.logger&.warn(
-        "Unable to create version for #{action} of #{@record.class.name}" \
-        "##{@record.id}: " + version.errors.full_messages.join(", ")
-      )
-    end
+      # Is ST enabled for this particular record?
+      # @api private
+      def enabled?
+        SnailTrail.enabled? &&
+          SnailTrail.request.enabled? &&
+          SnailTrail.request.enabled_for_model?(@record.class)
+      end
 
-    # Centralized handler for version errors
-    # @api private
-    def handle_version_errors(e, version, action)
-      case SnailTrail.config.version_error_behavior
-      when :legacy
-        # legacy behavior was to raise on create and log on update/delete
-        if action == :create
-          raise e
-        else
+      def log_version_errors(version, action)
+        version.logger&.warn(
+          "Unable to create version for #{action} of #{@record.class.name}" \
+            "##{@record.id}: " + version.errors.full_messages.join(", ")
+        )
+      end
+
+      # Centralized handler for version errors
+      # @api private
+      def handle_version_errors(e, version, action)
+        case SnailTrail.config.version_error_behavior
+        when :legacy
+          # legacy behavior was to raise on create and log on update/delete
+          if action == :create
+            raise e
+          else
+            log_version_errors(version, action)
+          end
+        when :log
           log_version_errors(version, action)
+        when :exception
+          raise e
+        when :silent
+          # noop
         end
-      when :log
-        log_version_errors(version, action)
-      when :exception
-        raise e
-      when :silent
-        # noop
       end
-    end
-
-    # @api private
-    # @return - The created version object, so that plugins can use it, e.g.
-    # snail_trail-association_tracking
-    def record_update_columns(changes)
-      return unless enabled?
-      data = Events::Update.new(@record, false, false, changes).data
-
-      # Merge data from `Event` with data from ST-AT. We no longer use
-      # `data_for_update_columns` but ST-AT still does.
-      data.merge!(data_for_update_columns)
-
-      versions_assoc = @record.send(@record.class.versions_association_name)
-      version = versions_assoc.new(data)
-      begin
-        version.save!
 
-        if version && version.respond_to?(:errors) && version.errors.empty?
-          update_transaction_id(version)
+      # @api private
+      # @return - The created version object, so that plugins can use it, e.g.
+      # snail_trail-association_tracking
+      def record_update_columns(changes)
+        return unless enabled?
+        data = Events::Update.new(@record, false, false, changes).data
+
+        # Merge data from `Event` with data from ST-AT. We no longer use
+        # `data_for_update_columns` but ST-AT still does.
+        data.merge!(data_for_update_columns)
+
+        versions_assoc = @record.send(@record.class.versions_association_name)
+        version = versions_assoc.new(data)
+        begin
+          version.save!
+
+          if version && version.respond_to?(:errors) && version.errors.empty?
+            update_transaction_id(version)
+          end
+
+          version
+        rescue StandardError => e
+          handle_version_errors e, version, :update
         end
-
-        version
-      rescue StandardError => e
-        handle_version_errors e, version, :update
       end
-    end
 
-    def version
-      @record.public_send(@record.class.version_association_name)
-    end
+      def version
+        @record.public_send(@record.class.version_association_name)
+      end
 
-    def versions
-      @record.public_send(@record.class.versions_association_name)
-    end
+      def versions
+        @record.public_send(@record.class.versions_association_name)
+      end
   end
 end

data/lib/snail_trail/reifier.rb

@@ -57,7 +57,7 @@ module SnailTrail
         # The `dup` option and destroyed version always returns a new object,
         # otherwise we should attempt to load item or to look for the item
         # outside of default scope(s).
-        model = if options[:dup] == true || version.event == "destroy"
+        model = if options[:dup] == true || version.event == "destroy" || version.event == "batch_destroy"
                   klass.new
                 else
                   version.item || init_model_by_finding_item_id(klass, version) || klass.new

data/lib/snail_trail/request.rb

@@ -3,7 +3,7 @@
 require "request_store"
 
 module SnailTrail
-  # Manages variables that affect the current HTTP request, such as `whodunnit`.
+  # Manages variables that affect the current HTTP request, such as `whodunnit` and `performance_mode`.
   #
   # Please do not use `SnailTrail::Request` directly, use `SnailTrail.request`.
   # Currently, `Request` is a `Module`, but in the future it is quite possible
@@ -96,7 +96,7 @@ module SnailTrail
         return unless block_given?
         validate_public_options(options)
         before = to_h
-        merge(options)
+        merge({ performance_mode: false, performance_mode_data: nil }.merge(options))
         yield
       ensure
         set(before)
@@ -124,57 +124,91 @@ module SnailTrail
         who.respond_to?(:call) ? who.call : who
       end
 
-      private
+      # Enables performance mode for this request
+      def performance_mode!
+        self.performance_mode = true
+      end
 
-      # @api private
-      def merge(options)
-        options.to_h.each do |k, v|
-          store[k] = v
-        end
+      def clear_performance_mode
+        self.performance_mode = false
+        self.performance_mode_data = nil
       end
 
-      # @api private
-      def set(options)
-        store.clear
-        merge(options)
+      def performance_mode= val
+        store[:performance_mode] = !!val
+
+        if performance_mode?
+          self.performance_mode_data = []
+        end
+
+        performance_mode?
       end
 
-      # Returns a Hash, initializing with default values if necessary.
-      # @api private
-      def store
-        RequestStore.store[:snail_trail] ||= {
-          enabled: true
-        }
+      # Returns whether or not performance mode is enabled for this request
+      # Default: disabled
+      #
+      # @api public
+      #
+      def performance_mode?
+        !!store[:performance_mode]
       end
 
-      # Returns a deep copy of the internal hash from our RequestStore. Keys are
-      # all symbols. Values are mostly primitives, but whodunnit can be a Proc.
-      # We cannot use Marshal.dump here because it doesn't support Proc. It is
-      # unclear exactly how `deep_dup` handles a Proc, but it doesn't complain.
-      # @api private
-      def to_h
-        store.deep_dup
+      def performance_mode_data
+        store[:performance_mode_data]
       end
 
-      # Provide a helpful error message if someone has a typo in one of their
-      # option keys. We don't validate option values here. That's traditionally
-      # been handled with casting (`to_s`, `!!`) in the accessor method.
-      # @api private
-      def validate_public_options(options)
-        options.each do |k, _v|
-          case k
-          when :controller_info,
-              /enabled_for_/,
-              :enabled,
-              :whodunnit
-            next
-          when :transaction_id
-            raise ::SnailTrail::Request::InvalidOption, "Cannot set private option: transaction_id"
-          else
-            raise InvalidOption, "Invalid option: #{k}"
+      private
+
+        def performance_mode_data= val
+          store[:performance_mode_data] = val
+        end
+
+        # @api private
+        def merge(options)
+          options.to_h.each do |k, v|
+            store[k] = v
+          end
+        end
+
+        # @api private
+        def set(options)
+          store.clear
+          merge(options)
+        end
+
+        # Returns a Hash, initializing with default values if necessary.
+        # @api private
+        def store
+          RequestStore.store[:snail_trail] ||= {
+            enabled: true
+          }
+        end
+
+        # Returns a deep copy of the internal hash from our RequestStore. Keys are
+        # all symbols. Values are mostly primitives, but whodunnit can be a Proc.
+        # We cannot use Marshal.dump here because it doesn't support Proc. It is
+        # unclear exactly how `deep_dup` handles a Proc, but it doesn't complain.
+        # @api private
+        def to_h
+          store.deep_dup
+        end
+
+        # Provide a helpful error message if someone has a typo in one of their
+        # option keys. We don't validate option values here. That's traditionally
+        # been handled with casting (`to_s`, `!!`) in the accessor method.
+        # @api private
+        def validate_public_options(options)
+          options.each do |k, _v|
+            case k
+            when :controller_info, /enabled_for_/, :enabled, :whodunnit, :performance_mode, :performance_mode_data
+              next
+            when :transaction_id
+              raise ::SnailTrail::InvalidOption, "Cannot set private option: transaction_id"
+            else
+              raise InvalidOption, "Invalid option: #{k}"
+            end
           end
         end
-      end
     end
   end
 end

data/lib/snail_trail/version_concern.rb

@@ -35,15 +35,15 @@ module SnailTrail
       end
 
       def creates
-        where event: "create"
+        where event: %w[create batch_create]
       end
 
       def updates
-        where event: "update"
+        where event: %w[update batch_update]
       end
 
       def destroys
-        where event: "destroy"
+        where event: %w[destroy batch_destroy]
       end
 
       def not_creates

data/lib/snail_trail/version_number.rb

@@ -8,11 +8,11 @@ module SnailTrail
   # People are encouraged to use `SnailTrail.gem_version` instead.
   module VERSION
     MAJOR = 1
-    MINOR = 0
+    MINOR = 1
     TINY = 0
 
     # Set PRE to nil unless it's a pre-release (beta, rc, etc.)
-    PRE = nil
+    PRE = 'rc.pre.1'
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".").freeze
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: snail_trail
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0.rc.pre.1
 platform: ruby
 authors:
 - Brands Insurance
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-09 00:00:00.000000000 Z
+date: 2025-05-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -411,9 +411,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.4.10
 signing_key: