rollwire 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 51f4628ad7b1e91fb06fe1c63f926f5e7fb72ba9cbb868440ac3c2f8b859f59e
+  data.tar.gz: 4c0b9675985c3c78b9ef0c527d5d570c10ec567937c389f9c7793b19d7f1d350
+SHA512:
+  metadata.gz: c7d2c77865c9e37b670d7e3f2cde3437ae029d27f0e836a2d51279cd87044d59973f80088a733c4f2bda6e862b8659bcbed2dca3aa785bb1dc0023a164934bf1
+  data.tar.gz: 6407b944791b314bb5cfefa109a57e646a7e56ef65d11b163d0281c1cac018de037ca06a1b413b9e99b1915ef94491394b497b483213a5f45afc7d05db094742

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 ydah
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,232 @@
+# Rollwire
+
+Rollwire detects `ActiveRecord::Rollback` exceptions that Rails
+silently ignores when a nested transaction joins its parent without creating a
+savepoint.
+
+## The problem
+
+Both records are committed in this example:
+
+```ruby
+User.transaction do
+  User.create!(name: "Kotori")
+
+  User.transaction do
+    User.create!(name: "Nemu")
+    raise ActiveRecord::Rollback
+  end
+end
+```
+
+The inner call joins the existing transaction. Rails catches
+`ActiveRecord::Rollback`, but there is no savepoint to roll back and the
+exception does not reach the outer block. This is documented behavior in
+[Active Record transactions](https://api.rubyonrails.org/classes/ActiveRecord/Transactions/ClassMethods.html#method-i-transaction).
+
+Rollwire reports this only when the joined block executes a write
+(`INSERT`, `UPDATE`, `DELETE`, or `SELECT ... FOR UPDATE`) before raising the
+rollback.
+
+## Installation
+
+Until version 0.1.0 is published on RubyGems, install from the repository:
+
+```ruby
+gem "rollwire", github: "ydah/rollwire"
+```
+
+Then run:
+
+```console
+bundle install
+```
+
+The gem installs its Active Record patches when required.
+
+## Configuration
+
+Add an initializer:
+
+```ruby
+Rollwire.configure do |config|
+  config.mode = :raise
+  config.min_writes = 1
+  config.count_writes = true
+  config.capture_outer_location = true
+  config.backtrace_lines = 10
+  config.strict_patching = false
+  config.ignore_if = nil
+end
+```
+
+The Railtie defaults to `:raise` in `test` and `:log` in other Rails
+environments. Setting `mode` explicitly overrides the environment default.
+
+| Setting | Default | Purpose |
+| --- | --- | --- |
+| `mode` | `:raise` in test, otherwise `:log` | Select reporting behavior |
+| `min_writes` | `1` | Minimum matching SQL statements before reporting |
+| `count_writes` | `true` | Disable to report even when no write was observed |
+| `capture_outer_location` | `true` | Record the real outer transaction location |
+| `backtrace_lines` | `10` | Control the amount of stack inspected for locations |
+| `strict_patching` | `false` | Raise instead of warning and disabling on an incompatible Active Record API |
+| `ignore_if` | `nil` | Callable that suppresses selected reports |
+
+### Modes
+
+- `:log` writes the report to `Rails.logger` (or stderr). It re-raises the
+  original rollback inside Rails, so application behavior and final database
+  state remain unchanged.
+- `:notify` emits `ignored_rollback.rollwire` with the report in
+  `payload[:report]`. Database behavior is unchanged.
+- `:raise` replaces the ignored rollback with
+  `Rollwire::IgnoredNestedRollback`. This escapes the joined block
+  and rolls back the outer transaction.
+
+`:raise` is intentionally test-only: it changes the final database state. In
+the opening example, `:log` and `:notify` leave both Kotori and Nemu committed;
+`:raise` leaves neither record committed.
+
+Subscribe to notification mode with:
+
+```ruby
+ActiveSupport::Notifications.subscribe(
+  "ignored_rollback.rollwire"
+) do |*, payload|
+  report = payload.fetch(:report)
+  ErrorTracker.notify(report.to_s)
+end
+```
+
+### Suppression
+
+Suppress a known-safe region:
+
+```ruby
+Rollwire.suppress do
+  LegacyImporter.call
+end
+```
+
+Or ignore reports selectively:
+
+```ruby
+Rollwire.configure do |config|
+  config.ignore_if = lambda do |report|
+    report.inner_location&.include?("lib/legacy/")
+  end
+end
+```
+
+`Rollwire.disable!` and `Rollwire.enable!` disable or
+enable detection globally.
+
+## Transactional tests and fixtures
+
+Rails transactional tests use a non-joinable outer transaction. This creates an
+important difference from production:
+
+- An application transaction directly inside the test transaction gets a
+  savepoint. Its rollback works, so there is no ignored rollback for this gem to
+  detect—even if the same single application transaction would be unsafe in
+  production.
+- With two application transaction levels (service A calls service B), the
+  first application transaction is a joinable savepoint and the second joins
+  it. Rollwire detects a rollback in the second level.
+
+Installing this gem therefore does not make a single-transaction fixture test
+prove production behavior. It detects the problem only on execution paths where
+a joined nested transaction actually occurs.
+
+## Reports and safety
+
+A log report identifies the inner and real outer transaction call sites:
+
+```text
+Rollwire::IgnoredNestedRollback
+
+ActiveRecord::Rollback was raised inside a transaction
+that joined an existing transaction.
+
+The 2 writes executed inside this block will not be rolled back.
+
+Inner transaction:
+  app/services/create_user.rb:24
+
+Outer transaction:
+  app/services/import_users.rb:61
+
+Use `requires_new: true` to roll back only the inner block,
+or propagate the failure to the outer transaction.
+```
+
+Write frames are isolated by Active Support execution context and database
+connection. SQL classification uses the payload SQL, not its event name, so
+`update_columns` and raw `execute` writes are included.
+
+Reporting failures are converted to warnings. Other than the dedicated
+exception in `:raise` mode, instrumentation errors do not replace the original
+rollback or change transaction behavior.
+
+## Isolator
+
+[Isolator](https://github.com/palkan/isolator) detects non-atomic side effects
+and can limit nested transaction depth. Rollwire has a narrower
+purpose: it detects a rollback that was specifically ignored because a nested
+Active Record transaction joined its parent. The gems are complementary.
+
+## Compatibility
+
+The CI support matrix is:
+
+| Ruby | Active Record 7.1 | Active Record 7.2 | Active Record 8.0 |
+| --- | :---: | :---: | :---: |
+| 3.1 | ✓ | ✓ | — |
+| 3.2 | ✓ | ✓ | ✓ |
+| 3.3 | ✓ | ✓ | ✓ |
+| 3.4 | ✓ | ✓ | ✓ |
+| 4.0 | ✓ | ✓ | ✓ |
+
+Ruby 3.1 with Active Record 8.0 is excluded because Active Record 8.0 requires
+Ruby 3.2 or newer. PostgreSQL and MySQL each have an Active Record 8.0 smoke
+job. Rails main runs as an allowed-failure forward-compatibility job.
+
+The patches target private Active Record transaction APIs. Unsupported API
+shapes produce a warning and automatically disable detection unless
+`strict_patching` is enabled.
+
+## Performance
+
+The non-nested path only checks whether a transaction is already open and then
+immediately delegates to Active Record.
+
+`benchmark/non_nested_transaction.rb` measured the following on Ruby 4.0.0,
+Active Record 8.0.2, and SQLite3:
+
+| Case | Iterations/second | Time/iteration |
+| --- | ---: | ---: |
+| Without Rollwire | 31,069.5 | 32.19 μs |
+| With Rollwire | 30,310.6 | 32.99 μs |
+
+The approximately 2.4% difference fell within `benchmark-ips` measurement
+error in that run. Reproduce it with:
+
+```console
+bundle exec appraisal rails_8_0 ruby benchmark/non_nested_transaction.rb
+```
+
+## Development
+
+```console
+bundle install
+bundle exec rake
+bundle exec appraisal rails_7_1 rspec
+bundle exec appraisal rails_7_2 rspec
+bundle exec appraisal rails_8_0 rspec
+bundle exec rake build
+```
+
+## License
+
+Rollwire is available under the [MIT License](LICENSE.txt).

data/Rakefile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rubocop/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new(:rubocop)
+
+task default: %i[spec rubocop]

data/lib/rollwire/configuration.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Rollwire
+  class Configuration
+    MODES = %i[log notify raise].freeze
+
+    attr_reader :backtrace_lines, :capture_outer_location, :count_writes, :ignore_if,
+                :min_writes, :mode, :strict_patching
+    attr_accessor :logger
+
+    def initialize
+      @backtrace_lines = 10
+      @capture_outer_location = true
+      @count_writes = true
+      @ignore_if = nil
+      @min_writes = 1
+      @mode = :log
+      @mode_explicitly_configured = false
+      @strict_patching = false
+      @logger = nil
+    end
+
+    def mode=(value)
+      raise ConfigurationError, "mode must be one of: #{MODES.join(', ')}" unless MODES.include?(value)
+
+      @mode = value
+      @mode_explicitly_configured = true
+    end
+
+    def min_writes=(value)
+      raise ConfigurationError, "min_writes must be a non-negative Integer" unless value.is_a?(Integer) && value >= 0
+
+      @min_writes = value
+    end
+
+    def backtrace_lines=(value)
+      unless value.is_a?(Integer) && value.positive?
+        raise ConfigurationError, "backtrace_lines must be a positive Integer"
+      end
+
+      @backtrace_lines = value
+    end
+
+    def count_writes=(value)
+      @count_writes = validate_boolean(:count_writes, value)
+    end
+
+    def capture_outer_location=(value)
+      @capture_outer_location = validate_boolean(:capture_outer_location, value)
+    end
+
+    def strict_patching=(value)
+      @strict_patching = validate_boolean(:strict_patching, value)
+    end
+
+    def ignore_if=(callable)
+      raise ConfigurationError, "ignore_if must be callable or nil" unless callable.nil? || callable.respond_to?(:call)
+
+      @ignore_if = callable
+    end
+
+    def apply_environment_default!(test:)
+      @mode = :raise if test && !@mode_explicitly_configured
+    end
+
+    private
+
+    def validate_boolean(name, value)
+      return value if [true, false].include?(value)
+
+      raise ConfigurationError, "#{name} must be true or false"
+    end
+  end
+end

data/lib/rollwire/errors.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Rollwire
+  class Error < StandardError; end
+  class ConfigurationError < Error; end
+  class PatchingError < Error; end
+
+  class IgnoredNestedRollback < Error
+    attr_reader :report
+
+    def initialize(report)
+      @report = report
+      super(report.to_s)
+    end
+  end
+end

data/lib/rollwire/execution_state.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Rollwire
+  module ExecutionState
+    KEY_PREFIX = "rollwire"
+
+    module_function
+
+    def read(key)
+      backend[storage_key(key)]
+    end
+
+    def write(key, value)
+      backend[storage_key(key)] = value
+    end
+
+    def delete(key)
+      backend.delete(storage_key(key))
+    end
+
+    def backend
+      ActiveSupport::IsolatedExecutionState
+    end
+
+    def storage_key(key)
+      :"#{KEY_PREFIX}.#{key}"
+    end
+  end
+end

data/lib/rollwire/notifier.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "active_support/notifications"
+
+module Rollwire
+  module Notifier
+    module_function
+
+    def call(report)
+      case report.mode
+      when :log
+        log(report)
+      when :notify
+        ActiveSupport::Notifications.instrument(Report::EVENT_NAME, report: report)
+      when :raise
+        raise IgnoredNestedRollback, report
+      end
+    end
+
+    def log(report)
+      logger = Rollwire.configuration.logger
+      logger ||= Rails.logger if defined?(Rails) && Rails.respond_to?(:logger)
+      logger ? logger.warn(report.to_s) : Kernel.warn(report.to_s)
+    end
+  end
+end

data/lib/rollwire/outer_location.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Rollwire
+  module OuterLocation
+    LOCATION_IVAR = :@rollwire_outer_location
+
+    module_function
+
+    def record(transaction, location)
+      transaction.instance_variable_set(LOCATION_IVAR, location)
+    end
+
+    def for(transaction)
+      transaction.instance_variable_get(LOCATION_IVAR)
+    end
+  end
+end

data/lib/rollwire/patcher.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Rollwire
+  module Patcher
+    module_function
+
+    def install!
+      validate!
+      install_database_statements_patch
+      install_transaction_manager_patch
+      WriteCounter.start!
+    end
+
+    def installed?
+      database_statements.ancestors.include?(DatabaseStatementsPatch) &&
+        transaction_manager.ancestors.include?(TransactionManagerPatch)
+    end
+
+    def validate!
+      validate_method(
+        database_statements,
+        :transaction,
+        required_keywords: %i[requires_new isolation joinable],
+        requires_block: true
+      )
+      validate_method(transaction_manager, :begin_transaction, required_keywords: %i[isolation joinable])
+    end
+
+    def install_database_statements_patch
+      return if database_statements.ancestors.include?(DatabaseStatementsPatch)
+
+      database_statements.prepend(DatabaseStatementsPatch)
+    end
+    private_class_method :install_database_statements_patch
+
+    def install_transaction_manager_patch
+      return if transaction_manager.ancestors.include?(TransactionManagerPatch)
+
+      transaction_manager.prepend(TransactionManagerPatch)
+    end
+    private_class_method :install_transaction_manager_patch
+
+    def validate_method(owner, name, required_keywords:, requires_block: false)
+      raise PatchingError, "#{owner}##{name} is unavailable" unless owner.method_defined?(name)
+
+      parameters = owner.instance_method(name).parameters
+      keyword_names = parameters.filter_map { |type, keyword| keyword if %i[key keyreq].include?(type) }
+      accepts_all_keywords = parameters.any? { |type, _| type == :keyrest }
+      keywords_compatible = accepts_all_keywords || (required_keywords - keyword_names).empty?
+      block_compatible = !requires_block || parameters.any? { |type, _| type == :block }
+      return if keywords_compatible && block_compatible
+
+      raise PatchingError, "#{owner}##{name} has an unsupported signature: #{parameters.inspect}"
+    end
+    private_class_method :validate_method
+
+    def database_statements
+      ActiveRecord::ConnectionAdapters::DatabaseStatements
+    end
+    private_class_method :database_statements
+
+    def transaction_manager
+      ActiveRecord::ConnectionAdapters::TransactionManager
+    end
+    private_class_method :transaction_manager
+  end
+end

data/lib/rollwire/patches/database_statements.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Rollwire
+  module DatabaseStatementsPatch
+    def transaction(**options, &block)
+      joined = Rollwire.enabled? &&
+               open_transactions.positive? &&
+               !options[:requires_new] &&
+               current_transaction.joinable?
+
+      return super(**options, &block) unless joined && block
+
+      pushed = false
+      begin
+        inner_location = Rollwire.caller_location
+        WriteCounter.push_frame(self)
+        pushed = true
+      rescue StandardError => e
+        Rollwire.warn_internal_error(e)
+        return super(**options, &block)
+      end
+
+      super(**options) do |*arguments|
+        block.call(*arguments)
+      rescue ActiveRecord::Rollback => e
+        report_ignored_rollback(inner_location)
+        raise e
+      end
+    ensure
+      safely_pop_write_frame if pushed
+    end
+
+    private
+
+    def report_ignored_rollback(inner_location)
+      Rollwire.handle_ignored_rollback(
+        connection: self,
+        inner_location: inner_location,
+        writes: WriteCounter.current_writes(self)
+      )
+    rescue IgnoredNestedRollback
+      raise
+    rescue StandardError => e
+      Rollwire.warn_internal_error(e)
+    end
+
+    def safely_pop_write_frame
+      WriteCounter.pop_frame(self)
+    rescue StandardError => e
+      Rollwire.warn_internal_error(e)
+    end
+  end
+end

data/lib/rollwire/patches/transaction_manager.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Rollwire
+  module TransactionManagerPatch
+    def begin_transaction(...)
+      location = capture_outer_location
+      transaction = super
+      record_outer_location(transaction, location)
+      transaction
+    end
+
+    private
+
+    def capture_outer_location
+      return unless Rollwire.enabled?
+      return unless Rollwire.configuration.capture_outer_location
+
+      Rollwire.caller_location
+    rescue StandardError => e
+      Rollwire.warn_internal_error(e)
+      nil
+    end
+
+    def record_outer_location(transaction, location)
+      OuterLocation.record(transaction, location) if location
+    rescue StandardError => e
+      Rollwire.warn_internal_error(e)
+    end
+  end
+end

data/lib/rollwire/railtie.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Rollwire
+  class Railtie < Rails::Railtie
+    initializer "rollwire.configure" do
+      Rollwire.configuration.apply_environment_default!(test: Rails.env.test?)
+
+      ActiveSupport.on_load(:active_record) do
+        Rollwire.install!
+      end
+    end
+  end
+end

data/lib/rollwire/report.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Rollwire
+  class Report
+    EVENT_NAME = "ignored_rollback.rollwire"
+
+    attr_reader :inner_location, :mode, :outer_location, :writes
+
+    def initialize(inner_location:, mode:, outer_location:, writes:)
+      @inner_location = inner_location
+      @mode = mode
+      @outer_location = outer_location
+      @writes = writes
+    end
+
+    def to_s
+      <<~REPORT.chomp
+        Rollwire::IgnoredNestedRollback
+
+        ActiveRecord::Rollback was raised inside a transaction
+        that joined an existing transaction.
+
+        #{write_consequence}
+
+        Inner transaction:
+          #{inner_location || '(unknown)'}
+
+        Outer transaction:
+          #{outer_location || '(not captured)'}
+
+        Use `requires_new: true` to roll back only the inner block,
+        or propagate the failure to the outer transaction.
+      REPORT
+    end
+
+    private
+
+    def write_consequence
+      subject = writes == 1 ? "The 1 write" : "The #{writes} writes"
+      if mode == :raise
+        "#{subject} executed inside this block would not have been rolled back " \
+          "(this raise rolled back the outer transaction instead)."
+      else
+        "#{subject} executed inside this block will not be rolled back."
+      end
+    end
+  end
+end

data/lib/rollwire/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Rollwire
+  VERSION = "0.1.0"
+end

data/lib/rollwire/write_counter.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "active_support/notifications"
+
+module Rollwire
+  module WriteCounter
+    Frame = Struct.new(:connection, :writes, keyword_init: true)
+
+    IGNORED_EVENT_NAMES = %w[SCHEMA TRANSACTION].freeze
+    MUTATION_SQL = /\A(?:INSERT|UPDATE|DELETE)\b/i
+    LOCKING_READ_SQL = /\ASELECT\b.*\bFOR\s+UPDATE\b/im
+    LEADING_COMMENTS = %r{\A(?:\s|/\*.*?\*/|--[^\n]*(?:\n|\z))*}m
+
+    module_function
+
+    def start!
+      return if @subscription
+
+      @subscription_mutex ||= Mutex.new
+      @subscription_mutex.synchronize do
+        return if @subscription
+
+        @subscription = ActiveSupport::Notifications.subscribe("sql.active_record") do |*arguments|
+          record(arguments.last)
+        rescue StandardError => e
+          Rollwire.warn_internal_error(e)
+        end
+      end
+    end
+
+    def push_frame(connection)
+      current_frames! << Frame.new(connection: connection, writes: 0)
+    end
+
+    def pop_frame(connection)
+      frames = current_frames
+      return unless frames
+
+      index = frames.rindex { |frame| frame.connection.equal?(connection) }
+      frame = frames.delete_at(index) if index
+      ExecutionState.delete(:write_counter_frames) if frames.empty?
+      frame
+    end
+
+    def current_writes(connection)
+      frame = current_frames&.reverse_each&.find { |candidate| candidate.connection.equal?(connection) }
+      frame&.writes || 0
+    end
+
+    def record(payload)
+      return unless Rollwire.configuration.count_writes
+      return unless current_frames&.any?
+      return unless write_event?(payload)
+
+      current_frames.each do |frame|
+        frame.writes += 1 if frame.connection.equal?(payload[:connection])
+      end
+    end
+
+    def reset!
+      ExecutionState.delete(:write_counter_frames)
+    end
+
+    def frame_count
+      current_frames&.length || 0
+    end
+
+    def current_frames
+      ExecutionState.read(:write_counter_frames)
+    end
+    private_class_method :current_frames
+
+    def current_frames!
+      current_frames || ExecutionState.write(:write_counter_frames, [])
+    end
+    private_class_method :current_frames!
+
+    def write_event?(payload)
+      return false unless payload.is_a?(Hash)
+      return false if IGNORED_EVENT_NAMES.include?(payload[:name])
+      return false unless payload[:connection]
+
+      sql = payload[:sql].to_s.sub(LEADING_COMMENTS, "")
+      MUTATION_SQL.match?(sql) || LOCKING_READ_SQL.match?(sql)
+    end
+    private_class_method :write_event?
+  end
+end

data/lib/rollwire.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "active_support/isolated_execution_state"
+require "pathname"
+
+require_relative "rollwire/version"
+require_relative "rollwire/configuration"
+require_relative "rollwire/errors"
+require_relative "rollwire/execution_state"
+require_relative "rollwire/outer_location"
+require_relative "rollwire/report"
+require_relative "rollwire/notifier"
+require_relative "rollwire/write_counter"
+require_relative "rollwire/patches/database_statements"
+require_relative "rollwire/patches/transaction_manager"
+require_relative "rollwire/patcher"
+
+module Rollwire
+  class << self
+    attr_reader :configuration
+
+    def configure
+      yield configuration
+      configuration
+    end
+
+    def enable!
+      @enabled = true
+      install!
+    end
+
+    def disable!
+      @enabled = false
+    end
+
+    def enabled?
+      @enabled && !suppressed?
+    end
+
+    def suppress
+      previous_depth = suppression_depth
+      ExecutionState.write(:suppression_depth, previous_depth + 1)
+      yield
+    ensure
+      restore_suppression_depth(previous_depth)
+    end
+
+    def install!
+      Patcher.install!
+      @enabled = true if @enabled.nil?
+      true
+    rescue StandardError => e
+      raise if configuration.strict_patching
+
+      @enabled = false
+      warn_internal_error(e)
+      false
+    end
+
+    def handle_ignored_rollback(connection:, inner_location:, writes:)
+      return if configuration.count_writes && writes < configuration.min_writes
+
+      report = Report.new(
+        inner_location: inner_location,
+        mode: configuration.mode,
+        outer_location: OuterLocation.for(connection.current_transaction),
+        writes: writes
+      )
+      return if configuration.ignore_if&.call(report)
+
+      Notifier.call(report)
+      report
+    end
+
+    def caller_location
+      locations = caller_locations(2, [configuration.backtrace_lines * 20, 20].max)
+      location = locations.find { |candidate| application_location?(candidate.path) }
+      format_location(location)
+    end
+
+    def warn_internal_error(error)
+      message = "[Rollwire] internal error: #{error.class}: #{error.message}"
+      logger = configuration.logger || rails_logger
+      logger ? logger.warn(message) : Kernel.warn(message)
+    rescue StandardError
+      Kernel.warn(message)
+    rescue Exception # rubocop:disable Lint/RescueException
+      nil
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+      @enabled = true
+    end
+
+    private
+
+    def application_location?(path)
+      !path.include?("/active_record/") &&
+        !path.include?("/active_support/") &&
+        !path.include?("/lib/rollwire")
+    end
+
+    def format_location(location)
+      return unless location
+
+      path = Pathname.new(location.absolute_path || location.path)
+      root = Pathname.new(Dir.pwd)
+      path = path.relative_path_from(root) if path.to_s.start_with?("#{root}/")
+      "#{path}:#{location.lineno}"
+    rescue ArgumentError
+      "#{location.path}:#{location.lineno}"
+    end
+
+    def rails_logger
+      Rails.logger if defined?(Rails) && Rails.respond_to?(:logger)
+    end
+
+    def restore_suppression_depth(depth)
+      if depth.zero?
+        ExecutionState.delete(:suppression_depth)
+      else
+        ExecutionState.write(:suppression_depth, depth)
+      end
+    end
+
+    def suppressed?
+      suppression_depth.positive?
+    end
+
+    def suppression_depth
+      ExecutionState.read(:suppression_depth) || 0
+    end
+  end
+
+  reset_configuration!
+end
+
+require_relative "rollwire/railtie" if defined?(Rails::Railtie)
+
+Rollwire.install!

metadata

@@ -0,0 +1,175 @@
+--- !ruby/object:Gem::Specification
+name: rollwire
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yudai Takada
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+- !ruby/object:Gem::Dependency
+  name: benchmark
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: benchmark-ips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.70'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.70'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.7'
+description: |
+  Rollwire detects ActiveRecord::Rollback exceptions that are
+  silently ignored when a nested transaction joins its parent without a
+  savepoint.
+email:
+- t.yudai92@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/rollwire.rb
+- lib/rollwire/configuration.rb
+- lib/rollwire/errors.rb
+- lib/rollwire/execution_state.rb
+- lib/rollwire/notifier.rb
+- lib/rollwire/outer_location.rb
+- lib/rollwire/patcher.rb
+- lib/rollwire/patches/database_statements.rb
+- lib/rollwire/patches/transaction_manager.rb
+- lib/rollwire/railtie.rb
+- lib/rollwire/report.rb
+- lib/rollwire/version.rb
+- lib/rollwire/write_counter.rb
+homepage: https://github.com/ydah/rollwire
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/ydah/rollwire
+  source_code_uri: https://github.com/ydah/rollwire
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: Detect ignored ActiveRecord rollbacks in joined nested transactions
+test_files: []