openstax_transaction_retry 1.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1c9efa231f44b802b7971bc7f31fb06e0f01bb47c40d16fd56a4c0843f99c72f
+  data.tar.gz: 8b415b5023c270aa9dec5000eb0c60f2d2dbb0f26fd5b4f489b20c7d6842b9f9
+SHA512:
+  metadata.gz: 155c201291db2070d61814d2ea73dbdc69c58d284552a7bd84c1be367a3b33aa5e9dfc78cd8be24aa8e1d51f1cac15f74087da33b1314d91d72b19bd7682c28b
+  data.tar.gz: 5ca4998b159bf2a83a9839d4cb2f57aeb20a16c33730320e233a7733af712189fea737b969628937c88c97c553520a062042a913ab0d65dc43c31930be85447e

data/.github/workflows/ci.yml

@@ -0,0 +1,39 @@
+name: Tests
+
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+
+env:
+  DB_NAME: oxtr_test
+  DB_USERNAME: oxtr
+  DB_PASSWORD: oxtr_pass
+  DB_HOST: localhost
+  DB_PORT: 5432
+
+jobs:
+  lint-and-test:
+    timeout-minutes: 10
+    runs-on: ubuntu-22.04
+    services:
+      db:
+        image: postgres:12
+        ports:
+        - 5432:5432
+        env:
+          POSTGRES_DB: oxtr_test
+          POSTGRES_USER: oxtr
+          POSTGRES_PASSWORD: oxtr_pass
+        options: --health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5
+
+    steps:
+      - uses: actions/checkout@v3
+      - uses: ruby/setup-ruby@v1
+        with:
+          bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+      - name: Run Tests
+        run: |
+          bundle exec rubocop
+          db=postgresql bundle exec rake test

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.idea
+test/log/*.log

data/.rubocop.yml

@@ -0,0 +1,95 @@
+AllCops:
+  TargetRubyVersion: 2.6
+  SuggestExtensions: false
+  NewCops: enable
+  Exclude:
+    - 'db/**/*.rb'
+    - 'app/bindings/**/*.rb'
+    - 'node_modules/**/*'
+    - 'tmp/**/*'
+    - 'vendor/**/*'
+    - '.git/**/*'
+
+Layout/EmptyLinesAroundClassBody:
+  Enabled: false
+
+Layout/EmptyLinesAroundBlockBody:
+  Enabled: false
+
+Layout/LineLength:
+  Max: 100
+  AllowedPatterns: ['(\A|\s)#']
+  Exclude:
+    - '*.gemspec'
+
+Metrics/AbcSize:
+  Max: 50
+
+Naming/PredicateName:
+  Enabled: false
+
+Metrics/ClassLength:
+  Max: 500
+  CountAsOne: ['heredoc']
+
+Metrics/MethodLength:
+  Max: 50
+  CountAsOne: ['heredoc']
+
+Metrics/BlockLength:
+  CountAsOne: ['heredoc']
+  Max: 30
+  Exclude:
+    - '**/*_open_api.rb'
+    - '**/*.rake'
+    - 'lib/patches/api/**/*.rb'
+
+Metrics/ModuleLength:
+  CountAsOne: ['heredoc']
+
+Style/Alias:
+  EnforcedStyle: prefer_alias_method
+
+Style/Documentation:
+  Enabled: false
+
+Style/OpenStructUse:
+  Enabled: false
+
+Style/StringLiterals:
+  ConsistentQuotesInMultiline: true
+
+Layout/SpaceAroundEqualsInParameterDefault:
+  EnforcedStyle: no_space
+
+Style/AccessorGrouping:
+  EnforcedStyle: separated
+
+Style/SingleLineMethods:
+  Enabled: false # don't abuse it, but sometimes it is right
+
+Style/RegexpLiteral:
+  AllowInnerSlashes: true
+
+Style/SymbolProc:
+  AllowedMethods:
+    - respond_to
+    - define_method
+
+Layout/ClosingParenthesisIndentation:
+  Enabled: false # when true hanging parens look weird
+
+Layout/MultilineMethodCallBraceLayout:
+  Enabled: false
+
+Layout/MultilineMethodCallIndentation:
+  EnforcedStyle: indented_relative_to_receiver
+
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+Style/SymbolArray:
+  EnforcedStyle: brackets
+
+Style/Lambda:
+  Enabled: false

data/.ruby-version

@@ -0,0 +1 @@
+3.2.1

data/.semaphore/semaphore.yml

@@ -0,0 +1,15 @@
+version: v1.0
+name: Initial Pipeline
+agent:
+  machine:
+    type: e1-standard-2
+    os_image: ubuntu1804
+blocks:
+  - name: 'Block #1'
+    task:
+      jobs:
+        - name: 'Job #1'
+          commands:
+            - checkout
+            - bundle install --path vendor/bundle
+            - db=sqlite3 bundle exec rake test

data/CHANGELOG.md

@@ -0,0 +1,16 @@
+### Unreleased
+
+### 1.2.0 - 2023-08-24
+* Forked and renamed to OpenStaxTransactionRetry
+* Fix bug with calling overloaded transaction with a hash
+
+
+### 1.1.0 - 2019-06-17
+
+* Add `TransactionRetry.before_retry` configuration option to run Proc before transaction retry
+* Add `TransactionRetry.retry_on` configuration option to include more Errors to retry on
+* Update dependency activerecord >= 5.1
+* Update dependency ruby 2.2.2
+* Upgrade dependency transaction_isolation to 1.0.5
+* Adapt gemspec info
+* Forked gem from [transaction_retry 1.0.3](https://github.com/qertoip/transaction_retry)

data/Gemfile

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+source 'http://rubygems.org'
+
+# Specify your gem's dependencies in kontolib.gemspec
+gemspec
+
+group :test do
+  # Use the gem instead of a dated version bundled with Ruby
+  gem 'minitest'
+
+  gem 'simplecov', require: false
+
+  gem 'mysql2'
+  gem 'pg'
+  gem 'rubocop'
+  gem 'sqlite3'
+end
+
+group :development do
+  gem 'rake'
+  # enhance irb
+  gem 'awesome_print', require: false
+  gem 'pry', require: false
+end

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2012 Piotr 'Qertoip' Włodarek
+
+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,114 @@
+# transaction_retry
+
+Retries database transaction on deadlock and transaction serialization errors. Supports MySQL, PostgreSQL, and SQLite.
+
+This is a forked project from
+
+  * otimalworkshop: https://github.com/optimalworkshop/transaction_retry
+  * qertoip: https://github.com/qertoip/transaction_retry
+
+OpenStax forked the project to correct a bug with Ruby version 3 or above that caused
+an **ArgumentError**: wrong number of arguments (given 1, expected 0)
+
+when calling ActiveRecord::Base.transaction with a hash such as:
+
+`ActiveRecord::Base.transaction(requires_new: true)`
+
+Details of the fix are in commit https://github.com/openstax/transaction_retry/commit/9184c88ab917271026e08d6dd5e890740f7fdd48
+
+## Example
+
+The gem works automatically by rescuing ActiveRecord::TransactionIsolationConflict and retrying the transaction.
+
+## Installation
+
+Add this to your Gemfile:
+
+    gem 'transaction_retry', git: 'https://github.com/optimalworkshop/transaction_retry.git'
+
+Then run:
+
+    bundle
+
+__It works out of the box with Ruby on Rails__.
+
+If you have a standalone ActiveRecord-based project you'll need to call:
+
+    OpenStaxTransactionRetry.apply_activerecord_patch     # after connecting to the database
+
+__after__ connecting to the database.
+
+## Database deadlock and serialization errors that are retried
+
+#### MySQL
+
+ * Deadlock found when trying to get lock
+ * Lock wait timeout exceeded
+
+#### PostgreSQL
+
+ * deadlock detected
+ * could not serialize access
+
+#### SQLite
+
+ * The database file is locked
+ * A table in the database is locked
+ * Database lock protocol error
+
+## Configuration
+
+You can optionally configure transaction_retry gem in your config/initializers/transaction_retry.rb (or anywhere else):
+
+```
+    OpenStaxTransactionRetry.max_retries = 3
+    OpenStaxTransactionRetry.wait_times = [0, 1, 2, 4, 8, 16, 32]   # seconds to sleep after retry n
+    OpenStaxTransactionRetry.retry_on = CustomErrorClass # To add another error class to retry on (ActiveRecord::TransactionIsolationConflict always included)
+  or
+    OpenStaxTransactionRetry.retry_on = [<custom error classes>]
+    OpenStaxTransactionRetry.before_retry = ->(retry_num, error) { ... }
+```
+
+## Features
+
+ * Supports MySQL, PostgreSQL, and SQLite (as long as you are using new drivers mysql2, pg, sqlite3).
+ * Exponential sleep times between retries (0, 1, 2, 4 seconds).
+ * Logs every retry as a warning.
+ * Intentionally does not retry nested transactions.
+ * Configurable number of retries and sleep time between them.
+ * Configure a custom hook to run before every retry.
+ * Use it in your Rails application or a standalone ActiveRecord-based project.
+
+## Testimonials
+
+This gem was initially developed for and successfully works in production at [Kontomierz.pl](http://kontomierz.pl) - the finest Polish personal finance app.
+
+## Requirements
+
+ * ruby 2.2.2+
+ * activerecord 5.1+
+
+## Running tests
+
+Run tests on the selected database (mysql2 by default):
+
+    db=mysql2 DB_USERNAME=<db user> DB_PASSWORD=<db password> bundle exec rake test
+    db=postgresql DB_USERNAME=<db user> DB_PASSWORD=<db password> bundle exec rake test
+    db=sqlite3 bundle exec rake test
+
+Run tests on all supported databases:
+
+    ./tests
+
+## How intrusive is this gem?
+
+You should be very suspicious about any gem that monkey patches your stock Ruby on Rails framework.
+
+This gem is carefully written to not be more intrusive than it needs to be:
+
+ * wraps ActiveRecord::Base#transaction class method using alias_method to add new behaviour
+ * introduces two new private class methods in ActiveRecord::Base (with names that should never collide)
+
+## License
+
+Released under the MIT license. Copyright (C) 2012 Piotr 'Qertoip' Włodarek.

data/Rakefile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs += %w[test lib]
+  t.pattern = 'test/integration/**/*_test.rb'
+  t.verbose = true
+end
+
+task default: [:test]

data/d

@@ -0,0 +1 @@
+bundle exec ruby test/test_console.rb

data/lib/open_stax_transaction_retry/active_record/base.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'active_record/base'
+
+module OpenStaxTransactionRetry
+  module ActiveRecord
+    module Base
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.class_eval do
+          class << self
+            alias_method :transaction_without_retry, :transaction
+            alias_method :transaction, :transaction_with_retry
+          end
+        end
+      end
+
+      module ClassMethods
+        # rubocop:todo Metrics/PerceivedComplexity
+        def transaction_with_retry(**objects, &block) # rubocop:todo Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          retry_count = 0
+
+          opts = if objects.is_a? Hash
+                   objects
+                 elsif objects.is_a?(Array) && objects.last.is_a?(Hash)
+                   objects.last
+                 else
+                   {}
+                 end
+
+          retry_on = opts.delete(:retry_on) || OpenStaxTransactionRetry.retry_on
+          max_retries = opts.delete(:max_retries) || OpenStaxTransactionRetry.max_retries
+          before_retry = opts.delete(:before_retry) || OpenStaxTransactionRetry.before_retry
+
+          begin
+            transaction_without_retry(**objects, &block)
+          rescue ::ActiveRecord::TransactionIsolationConflict, *retry_on => e
+            raise if retry_count >= max_retries
+            raise if tr_in_nested_transaction?
+
+            retry_count += 1
+            logger&.warn "#{e.class.name} detected. Retry num #{retry_count}..."
+            before_retry&.call(retry_count, e)
+            tr_exponential_pause(retry_count)
+            retry
+          end
+        end
+        # rubocop:enable Metrics/PerceivedComplexity
+
+        private
+
+        # Sleep 0, 1, 2, 4, ... seconds up to the OpenStaxTransactionRetry.max_retries.
+        # Cap the sleep time at 32 seconds.
+        # An ugly tr_ prefix is used to minimize the risk of method clash in the future.
+        def tr_exponential_pause(count)
+          seconds = OpenStaxTransactionRetry.wait_times[count - 1] || 32
+
+          if OpenStaxTransactionRetry.fuzz
+            fuzz_factor = [seconds * 0.25, 1].max
+
+            seconds += (rand * (fuzz_factor * 2)) - fuzz_factor
+          end
+
+          sleep(seconds) if seconds.positive?
+        end
+
+        # Returns true if we are in the nested transaction (the one with :requires_new => true).
+        # Returns false otherwise.
+        # An ugly tr_ prefix is used to minimize the risk of method clash in the future.
+        def tr_in_nested_transaction?
+          connection.open_transactions != 0
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.include OpenStaxTransactionRetry::ActiveRecord::Base

data/lib/open_stax_transaction_retry/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module OpenStaxTransactionRetry
+  VERSION = '1.2.0'
+end

data/lib/open_stax_transaction_retry.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'active_record'
+require 'transaction_isolation'
+require_relative 'open_stax_transaction_retry/version'
+
+module OpenStaxTransactionRetry
+  # Must be called after ActiveRecord established a connection.
+  # Only then we know which connection adapter is actually loaded and can be enhanced.
+  # Please note ActiveRecord does not load unused adapters.
+  def self.apply_activerecord_patch
+    TransactionIsolation.apply_activerecord_patch
+    require_relative 'open_stax_transaction_retry/active_record/base'
+  end
+
+  if defined?(::Rails)
+    # Setup applying the patch after Rails is initialized.
+    class Railtie < ::Rails::Railtie
+      config.after_initialize do
+        OpenStaxTransactionRetry.apply_activerecord_patch
+      end
+    end
+  end
+
+  def self.before_retry=(lambda_block)
+    @@before_retry = lambda_block # rubocop:todo Style/ClassVars
+  end
+
+  def self.before_retry
+    @@before_retry ||= nil # rubocop:todo Style/ClassVars
+  end
+
+  def self.retry_on=(error_classes)
+    @@retry_on = Array(error_classes) # rubocop:todo Style/ClassVars
+  end
+
+  def self.retry_on
+    @@retry_on ||= [] # rubocop:todo Style/ClassVars
+  end
+
+  def self.max_retries
+    @@max_retries ||= 3 # rubocop:todo Style/ClassVars
+  end
+
+  def self.max_retries=(n) # rubocop:todo Naming/MethodParameterName
+    @@max_retries = n # rubocop:todo Style/ClassVars
+  end
+
+  def self.wait_times
+    @@wait_times ||= [0, 1, 2, 4, 8, 16, 32] # rubocop:todo Style/ClassVars
+  end
+
+  def self.wait_times=(array_of_seconds)
+    @@wait_times = array_of_seconds # rubocop:todo Style/ClassVars
+  end
+
+  def self.fuzz
+    @@fuzz ||= true # rubocop:todo Style/ClassVars
+  end
+
+  def self.fuzz=(val)
+    @@fuzz = val # rubocop:todo Style/ClassVars
+  end
+end

data/open_stax_transaction_retry.gemspec

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.push File.expand_path('lib', __dir__)
+require 'open_stax_transaction_retry/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'openstax_transaction_retry'
+  s.version     = OpenStaxTransactionRetry::VERSION
+  s.authors     = ['Nathan Stitt', 'Optimal Workshop', 'Piotr \'Qertoip\' Włodarek']
+  s.email       = []
+  s.homepage    = 'https://github.com/openstax/transaction_retry'
+  s.summary     = 'Retries database transaction on deadlock and transaction serialization errors. Supports MySQL, PostgreSQL and SQLite.'
+  s.description = 'Retries database transaction on deadlock and transaction serialization errors. Supports MySQL, PostgreSQL and SQLite (as long as you are using new drivers mysql2, pg, sqlite3).'
+  s.required_ruby_version = '>= 2.6'
+
+  s.files         = `git ls-files`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  s.add_runtime_dependency 'activerecord', '>= 5.1'
+  s.add_runtime_dependency 'transaction_isolation', '>= 1.0.5'
+  s.metadata['rubygems_mfa_required'] = 'true'
+end

data/test/db/all.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'active_record'
+require_relative 'db'
+require_relative 'migrations'
+require_relative 'queued_job'

data/test/db/db.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module OpenStaxTransactionRetry
+  module Test
+    module Db
+      def self.connect_to_mysql2
+        ::ActiveRecord::Base.establish_connection(
+          adapter: 'mysql2',
+          database: 'transaction_retry_test',
+          username: ENV.fetch('DB_USERNAME'),
+          password: ENV.fetch('DB_PASSWORD', nil)
+        )
+      end
+
+      def self.connect_to_postgresql
+        ::ActiveRecord::Base.establish_connection(
+          adapter: 'postgresql',
+          host: ENV.fetch('DB_HOST', nil),
+          port: ENV.fetch('DB_PORT', nil),
+          database: ENV.fetch('DB_NAME', nil),
+          user: ENV.fetch('DB_USERNAME', nil),
+          password: ENV.fetch('DB_PASSWORD', nil)
+        )
+      end
+
+      def self.connect_to_sqlite3
+        ActiveRecord::Base.establish_connection(
+          adapter: 'sqlite3',
+          database: ':memory:',
+          verbosity: 'silent'
+        )
+      end
+    end
+  end
+end

data/test/db/migrations.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module OpenStaxTransactionRetry
+  module Test
+    module Migrations
+      def self.run!
+        c = ::ActiveRecord::Base.connection
+
+        # Queued Jobs
+
+        c.create_table 'queued_jobs', force: true do |t|
+          t.text     'job', null: false
+          t.integer  'status', default: 0, null: false
+          t.timestamps
+        end
+      end
+    end
+  end
+end

data/test/db/queued_job.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class QueuedJob < ActiveRecord::Base
+end

data/test/integration/active_record/base/transaction_with_retry_test.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TransactionWithRetryTest < Minitest::Test
+  class CustomError < StandardError
+  end
+
+  def setup
+    @original_max_retries = OpenStaxTransactionRetry.max_retries
+    @original_wait_times = OpenStaxTransactionRetry.wait_times
+    @original_retry_on = OpenStaxTransactionRetry.retry_on
+    @original_before_retry = OpenStaxTransactionRetry.before_retry
+  end
+
+  def teardown
+    OpenStaxTransactionRetry.max_retries = @original_max_retries
+    OpenStaxTransactionRetry.wait_times = @original_wait_times
+    OpenStaxTransactionRetry.retry_on = @original_retry_on
+    OpenStaxTransactionRetry.before_retry = @original_before_retry
+    QueuedJob.delete_all
+  end
+
+  def test_does_not_break_transaction
+    ActiveRecord::Base.transaction do
+      QueuedJob.create!(job: 'is fun!')
+      assert_equal(1, QueuedJob.count)
+    end
+    assert_equal(1, QueuedJob.count)
+    QueuedJob.first.destroy
+  end
+
+  def test_does_not_break_transaction_rollback
+    ActiveRecord::Base.transaction do
+      QueuedJob.create!(job: 'gives money!')
+      raise ActiveRecord::Rollback
+    end
+    assert_equal(0, QueuedJob.count)
+  end
+
+  def test_retries_transaction_on_transaction_isolation_conflict
+    first_run = true
+
+    ActiveRecord::Base.transaction do
+      if first_run
+        first_run = false
+        message = 'Deadlock found when trying to get lock'
+        raise ActiveRecord::TransactionIsolationConflict, message
+      end
+      QueuedJob.create!(job: 'is cool!')
+    end
+    assert_equal(1, QueuedJob.count)
+
+    QueuedJob.first.destroy
+  end
+
+  def test_does_not_retry_on_unknown_error
+    first_run = true
+
+    assert_raises(CustomError) do
+      ActiveRecord::Base.transaction do
+        if first_run
+          first_run = false
+          raise CustomError, 'random error'
+        end
+        QueuedJob.create!(job: 'is cool!')
+      end
+    end
+    assert_equal(0, QueuedJob.count)
+  end
+
+  def test_retries_on_custom_error
+    first_run = true
+    ActiveRecord::Base.transaction(retry_on: CustomError) do
+      if first_run
+        first_run = false
+        raise CustomError, 'random error'
+      end
+      QueuedJob.create!(job: 'is cool!')
+    end
+    assert_equal(1, QueuedJob.count)
+    QueuedJob.first.destroy
+  end
+
+  def test_retries_on_configured_retry_on
+    OpenStaxTransactionRetry.retry_on = CustomError
+    first_run = true
+    ActiveRecord::Base.transaction do
+      if first_run
+        first_run = false
+        raise CustomError, 'random error'
+      end
+      QueuedJob.create!(job: 'is cool!')
+    end
+    assert_equal(1, QueuedJob.count)
+    QueuedJob.first.destroy
+  end
+
+  def test_retries_transaction_on_transaction_isolation_when_retry_on_set
+    OpenStaxTransactionRetry.retry_on = CustomError
+    first_run = true
+    ActiveRecord::Base.transaction do
+      if first_run
+        first_run = false
+        message = 'Deadlock found when trying to get lock'
+        raise ActiveRecord::TransactionIsolationConflict, message
+      end
+      QueuedJob.create!(job: 'is cool!')
+    end
+    assert_equal(1, QueuedJob.count)
+    QueuedJob.first.destroy
+  end
+
+  def test_does_not_retry_transaction_more_than_max_retries_times
+    OpenStaxTransactionRetry.max_retries = 1
+    run = 0
+
+    assert_raises(ActiveRecord::TransactionIsolationConflict) do
+      ActiveRecord::Base.transaction do
+        run += 1
+        message = 'Deadlock found when trying to get lock'
+        raise ActiveRecord::TransactionIsolationConflict, message
+      end
+    end
+
+    assert_equal(2, run)  # normal run + one retry
+
+    OpenStaxTransactionRetry.max_retries = 3
+
+    run = 0
+
+    assert_raises(ActiveRecord::TransactionIsolationConflict) do
+      ActiveRecord::Base.transaction(max_retries: 1) do
+        run += 1
+        message = 'Deadlock found when trying to get lock'
+        raise ActiveRecord::TransactionIsolationConflict, message
+      end
+    end
+
+    assert_equal(2, run)  # normal run + one retry
+  end
+
+  def test_does_not_retry_nested_transaction
+    first_try = true
+
+    ActiveRecord::Base.transaction do
+      assert_raises(ActiveRecord::TransactionIsolationConflict) do
+        ActiveRecord::Base.transaction(requires_new: true) do
+          if first_try
+            first_try = false
+            message = 'Deadlock found when trying to get lock'
+            raise ActiveRecord::TransactionIsolationConflict, message
+          end
+          QueuedJob.create!(job: 'is cool!')
+        end
+      end
+    end
+
+    assert_equal(0, QueuedJob.count)
+  end
+
+  def test_run_custom_lambda_before_retry
+    code_run = false
+    retry_id = nil
+    error_instance = nil
+    first_try = true
+    lambda_code = lambda do |retry_num, error|
+      code_run = true
+      retry_id = retry_num
+      error_instance = error
+    end
+
+    ActiveRecord::Base.transaction(before_retry: lambda_code) do
+      if first_try
+        first_try = false
+        raise ActiveRecord::TransactionIsolationConflict
+      end
+      QueuedJob.create!(job: 'is cool!')
+    end
+    assert_equal 1, QueuedJob.count
+    assert code_run
+    assert_equal 1, retry_id
+    assert_equal ActiveRecord::TransactionIsolationConflict, error_instance.class
+  end
+
+  def test_run_custom_global_lambda_before_retry
+    code_run = false
+    retry_id = nil
+    error_instance = nil
+    OpenStaxTransactionRetry.before_retry = lambda { |retry_num, error|
+      code_run = true
+      retry_id = retry_num
+      error_instance = error
+    }
+    first_try = true
+
+    ActiveRecord::Base.transaction do
+      if first_try
+        first_try = false
+        raise ActiveRecord::TransactionIsolationConflict
+      end
+      QueuedJob.create!(job: 'is cool!')
+    end
+    assert_equal 1, QueuedJob.count
+    assert code_run
+    assert_equal 1, retry_id
+    assert_equal ActiveRecord::TransactionIsolationConflict, error_instance.class
+  end
+end

data/test/library_setup.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# Prepares application to be tested (requires files, connects to db, resets schema and data, applies patches, etc.)
+
+# Initialize database
+require 'db/all'
+
+case ENV.fetch('db', 'sqlite3')
+when 'mysql2'
+  OpenStaxTransactionRetry::Test::Db.connect_to_mysql2
+when 'postgresql'
+  OpenStaxTransactionRetry::Test::Db.connect_to_postgresql
+when 'sqlite3'
+  OpenStaxTransactionRetry::Test::Db.connect_to_sqlite3
+else
+  raise "Unknown database: #{ENV.fetch('db', nil)}"
+end
+
+require 'logger'
+ActiveRecord::Base.logger = Logger.new(File.expand_path("#{File.dirname(__FILE__)}/log/test.log"))
+
+OpenStaxTransactionRetry::Test::Migrations.run!
+
+# Load the code that will be tested
+require 'open_stax_transaction_retry'
+
+OpenStaxTransactionRetry.apply_activerecord_patch

data/test/test_console.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Ensure that LOAD_PATH is the same as when running "rake test"; normally rake takes care of that
+$LOAD_PATH << File.expand_path('.', File.dirname(__FILE__))
+$LOAD_PATH << File.expand_path('./lib', File.dirname(__FILE__))
+$LOAD_PATH << File.expand_path('./test', File.dirname(__FILE__))
+
+# Boot the app
+require_relative 'library_setup'
+
+# Fire the console
+require 'pry'
+
+binding.pry # rubocop:disable Lint/Debugger

data/test/test_helper.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Load test coverage tool (must be loaded before any code)
+# require 'simplecov'
+# SimpleCov.start do
+#  add_filter '/test/'
+#  add_filter '/config/'
+# end
+
+# Load and initialize the application to be tested
+require 'library_setup'
+
+# Load test frameworks
+require 'minitest/autorun'

data/test/test_runner.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+# Load all tests
+Dir.glob('./**/*_test.rb').sort.each { |test_file| require test_file }

data/tests

@@ -0,0 +1,6 @@
+
+db=mysql2 bundle exec rake
+
+db=postgresql bundle exec rake
+
+db=sqlite3 bundle exec rake

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: openstax_transaction_retry
+version: !ruby/object:Gem::Version
+  version: 1.2.0
+platform: ruby
+authors:
+- Nathan Stitt
+- Optimal Workshop
+- Piotr 'Qertoip' Włodarek
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-08-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.1'
+- !ruby/object:Gem::Dependency
+  name: transaction_isolation
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.5
+description: Retries database transaction on deadlock and transaction serialization
+  errors. Supports MySQL, PostgreSQL and SQLite (as long as you are using new drivers
+  mysql2, pg, sqlite3).
+email: []
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/ci.yml"
+- ".gitignore"
+- ".rubocop.yml"
+- ".ruby-version"
+- ".semaphore/semaphore.yml"
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- d
+- lib/open_stax_transaction_retry.rb
+- lib/open_stax_transaction_retry/active_record/base.rb
+- lib/open_stax_transaction_retry/version.rb
+- open_stax_transaction_retry.gemspec
+- test/db/all.rb
+- test/db/db.rb
+- test/db/migrations.rb
+- test/db/queued_job.rb
+- test/integration/active_record/base/transaction_with_retry_test.rb
+- test/library_setup.rb
+- test/log/.gitkeep
+- test/test_console.rb
+- test/test_helper.rb
+- test/test_runner.rb
+- tests
+homepage: https://github.com/openstax/transaction_retry
+licenses: []
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.6'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.7
+signing_key:
+specification_version: 4
+summary: Retries database transaction on deadlock and transaction serialization errors.
+  Supports MySQL, PostgreSQL and SQLite.
+test_files: []