within_new_transaction

# File activerecord/lib/active_record/connection_adapters/abstract/transaction.rb, line 531
      def within_new_transaction(isolation: nil, joinable: true)
        @connection.lock.synchronize do
          transaction = begin_transaction(isolation: isolation, joinable: joinable)
          begin
            ret = yield
            completed = true
            ret
          rescue Exception => error
            rollback_transaction
            after_failure_actions(transaction, error)

            raise
          ensure
            unless error
              # In 7.1 we enforce timeout >= 0.4.0 which no longer use throw, so we can
              # go back to the original behavior of committing on non-local return.
              # If users are using throw, we assume it's not an error case.
              completed = true if ActiveRecord.commit_transaction_on_non_local_return

              if Thread.current.status == "aborting"
                rollback_transaction
              elsif !completed && transaction.written
                ActiveRecord.deprecator.warn(<<~EOW)
                  A transaction is being rolled back because the transaction block was
                  exited using `return`, `break` or `throw`.
                  In Rails 7.2 this transaction will be committed instead.
                  To opt-in to the new behavior now and suppress this warning
                  you can set:

                    Rails.application.config.active_record.commit_transaction_on_non_local_return = true
                EOW
                rollback_transaction
              else
                begin
                  commit_transaction
                rescue ActiveRecord::ConnectionFailed
                  transaction.invalidate! unless transaction.state.completed?
                  raise
                rescue Exception
                  rollback_transaction(transaction) unless transaction.state.completed?
                  raise
                end
              end
            end
          end
        ensure
          unless transaction&.state&.completed?
            @connection.throw_away!
            transaction&.incomplete!
          end
        end
      end