trx_ext 1.0.6 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0215abbca618956a55b181c88c6d1658ae5e12a0133f9797c0171b8b9f93e56e
-  data.tar.gz: 47c9e6c5158adf4ef735de356de2fa613394546a056dde43c1e252873271b790
+  metadata.gz: b300fb55d7310a3e3f4d3a8860044f48deec84791caf6303d7a6b01a2e2728b7
+  data.tar.gz: 2e6d704c74c209b515dfc3a04d06ca549322a0e33d1037a414d779df1c063afd
 SHA512:
-  metadata.gz: bd0d01be3aa27dff5752d91317101915db9e58ea1eb89adff6027bf43739328098d4dbd6c849be2f2c095f959fa2ded3c8d8338ee45e31931cc48f0066d641d2
-  data.tar.gz: f21e6e927d86119a2d08dab98dce1a9acf2ed528e0773a9241c3dde75f429b2f643612efc6d67494e9c3ceb4c5eaa075d78b83ea98fa5c25a6f396e1b461debb
+  metadata.gz: 45c7190466168fe05b18ad69f084152b638235f9fab14edaa0eb6962449a2012b71e6e2b991fb319f73080cd7e3aba2f6700203a362cd86483d91f8ca606b66c
+  data.tar.gz: ce496ee423f04d12b9f92af4373e460edc31048d90908333f8449d98d70eb61053fd675c94f2345e767c5a43ae5535fa6b0e964f179dce604513aa782a8466e4

data/.rspec

@@ -1,3 +1,3 @@
 --format Fivemat
---require spec_helper
+--require rails_helper
 --require fivemat

data/.ruby-version

@@ -1 +1 @@
-3.2.2
+3.3.0

data/CHANGELOG.md

@@ -1,8 +1,30 @@
 ## [Unreleased]
 
-Nothing new yet
+## [2.0.1] - 2024-09-20
+- Restrict rails version to `< 7.2`. Rails v7.2 has suddenly released its own transaction callbacks which interferes with `trx_ext` transaction callbacks. Example of rails v7.2 transaction callbacks:
 
-## [1.0.5] - 2022-01-27
+```ruby
+Article.transaction do |transaction|
+  article.update(published: true)
+  transaction.after_commit do
+    PublishNotificationMailer.with(article: article).deliver_later
+  end
+end
+```
+
+Next major version of `trx_ext` will drop its own transaction callbacks implementation and will start relying on rails' transaction callbacks.
+
+## [2.0.0] - 2024-04-14
+
+- `trx_ext` now supports any adapter(except `mysql`; `mysql2` is supported though), supported by rails
+- **Requirement is rails v7.1+ now**. This is because rails v7.1 introduced unification of connection adapters which allowed to implement the integration with all of them
+- Support multiple databases configurations
+
+## [1.0.6] - 2023-08-25
+
+- Refactoring the retry implementation
+
+## [1.0.5] - 2023-05-11
 
 - Load `Object` extension earlier
 

data/Gemfile

@@ -5,12 +5,29 @@ source "https://rubygems.org"
 # Specify your gem's dependencies in trx_ext.gemspec
 gemspec
 
-gem "rake", "~> 13.0"
-
 if ENV['AR_VERSION']
   # Given ENV['AR_VERSION'] to equal "6.0" will produce
   # ```ruby
   # gem 'activerecord', "~> 6.0", "< 6.1"
   # ```
-  gem 'activerecord', "~> #{ENV['AR_VERSION']}", "< #{ENV['AR_VERSION'].next}"
+  gem 'rails', "~> #{ENV['AR_VERSION']}", "< #{ENV['AR_VERSION'].next}"
+else
+  gem 'rails'
 end
+
+gem "rake", "~> 13.0"
+gem 'rspec', '~> 3.12'
+gem 'timecop', '~> 0.9.8'
+# To support postgresql adapter
+gem 'pg', '~> 1.5', '>= 1.5.4'
+# To support sqlite3 adapter
+gem 'sqlite3', '~> 1.7', '>= 1.7.1'
+# To support mysql2 adapter
+gem 'mysql2', '~> 0.5.5'
+# To support trilogy adapter
+gem 'trilogy', '~> 2.8'
+gem 'factory_bot_rails', '~> 6.4', '>= 6.4.3'
+gem 'fivemat', '~> 1.3', '>= 1.3.7'
+gem 'rspec-its', '~> 1.3'
+gem "bootsnap", require: false
+gem 'rspec-rails',  '~> 6.0'

data/README.md

@@ -1,20 +1,22 @@
 # TrxExt
 
-Extends functionality of ActiveRecord's transaction to auto-retry failed SQL transaction in case of deadlock, serialization error or unique constraint error. It also allows you to define `on_complete` callback that is being executed after SQL transaction is finished(either COMMIT-ed or ROLLBACK-ed).
+Extends functionality of ActiveRecord's transaction to auto-retry failed SQL transaction in case of deadlock, serialization error or unique constraint error. It also allows you to define `on_complete` callback that is being executed after SQL transaction is finished(either COMMIT-ed or ROLLBACK-ed). The implementation is not bound to any database, but relies on the rails connection adapters instead. Thus, if your database is supported by rails out of the box, then the gem's features will just work. Currently supported adapters:
 
-Currently, the implementation only works for ActiveRecord PostgreSQL adapter. Feel free to improve it.
+- `postgresql`
+- `mysql2`
+- `sqlite3`
+- `trilogy`
 
 **WARNING!**
 
-Because the implementation of this gem is a patch for `ActiveRecord::ConnectionAdapters::PostgreSQLAdapter` - carefully test its integration into your project. For example, if your project patches ActiveRecord or if some of your gems patches ActiveRecord - there might be conflicts in the implementation which could potentially lead to the data loss.
+Because the implementation of this gem patches ActiveRecord - carefully test its integration into your project. For example, if your application patches ActiveRecord or if some of your gems patches ActiveRecord - there might be conflicts in the implementation which could potentially lead to the data loss.
 
-Currently, the implementation is tested for rails v6+.
+Currently, the implementation is tested for rails v7.1+. **If you need the support of rails v6.0, v6.1, v7.0 - please use v1.x of this gem, but it works with PostgreSQL only.**
 
 ## Requirements
 
-- ActiveRecord 6+
+- ActiveRecord 7.1+
 - Ruby 3
-- PostgreSQL 9.1+
 
 ## Installation
 
@@ -36,7 +38,6 @@ Or install it yourself as:
 
 ```ruby
 require 'trx_ext'
-require 'active_record'
 
 # Object#trx is a shorthand of ActiveRecord::Base.transaction
 trx do
@@ -66,6 +67,27 @@ class DummyRecord
 end
 ```
 
+If you are using non-primary connection for your model - you have to explicitly call `trx` method over that class:
+
+```ruby
+DummyRecord.trx do
+  DummyRecord.first || DummyRecord.create
+end
+```
+In general, you should know about this if you are using multi-databases configuration.
+
+If you want to wrap some method into a transaction using `wrap_in_trx` outside the ActiveRecord model context, you can pass a model name as a second argument explicitly:
+
+```ruby
+class MyAwesomeLib
+  # Wrap method in transaction
+  def some_method_with_quieries
+    DummyRecord.first || DummyRecord.create    
+  end
+  wrap_in_trx :some_method_with_quieries, 'DummyRecord'
+end
+```
+
 ## Configuration
 
 ```ruby
@@ -77,15 +99,11 @@ end
 
 ## How it works?
 
-Your either every single AR SQL query or whole AR transaction is retried whenever it throws deadlock error, serialization error or unique constraint error. In case of AR transaction - the block of code that the AR transaction belongs to is re-executed, thus the transaction is retried.
+When an ActiveRecord SQL query fails due to deadlock error, serialization error or unique constraint error - it is automatically retried. In case of ActiveRecord transaction - the block of code the AR transaction belongs to is re-executed, thus the transaction query is retried.
 
 ## Rules you have to stick when using this gem
 
-> "Don't put more into a single transaction than needed for integrity purposes."
->
-> — [PostgreSQL documentation]
-
-Since `ActiveRecord::ConnectionAdapters::PostgreSQLAdapter` is now patched with `TrxExt::Retry.with_retry_until_serialized`, there's no need to wrap every AR query in a `trx` block to ensure integrity. Wrap code in an explicit `trx` block if and only if it can or does produce two or more SQL queries *and* it is important to run those queries together atomically.
+**Don't put into a single transaction more than needed for integrity purposes.**
 
 There is "On complete" feature that allows you to define callbacks(blocks of code) that will be executed after transaction is complete. See `On complete callbacks` section bellow for the docs. See `On complete callbacks integrity` section bellow to be aware about different situations with them.
 
@@ -583,8 +601,14 @@ end
 
 ### Setup
 
-  - After checking out the repo, run `bin/setup` to install dependencies.
-  - run docker-compose using `docker-compose up` command - it starts necessary services 
+- After checking out the repo, run `bundle install` to install dependencies.
+- Run docker-compose using `docker-compose up` command - it starts necessary services
+- Run next command to create dev and test databases:
+
+```shell
+bundle exec rails db:create db:migrate
+RAILS_ENV=test bundle exec rails db:migrate
+```
     
 Now you can run `bin/console` for an interactive prompt that will allow you to experiment.
 

data/bin/console

@@ -13,14 +13,5 @@ require "trx_ext"
 # Pry.start
 
 require "irb"
-require "logger"
-require 'active_record'
-require_relative '../spec/support/config'
-require_relative '../spec/support/dummy_record'
-
-ActiveRecord::Base.logger = ActiveSupport::Logger.new(STDOUT)
-TrxExt.logger = ActiveSupport::Logger.new(STDOUT)
-
-DummyRecord.setup
 
 IRB.start(__FILE__)

data/bin/rails

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+Dir.chdir(File.expand_path("../dummy_app", __dir__))
+ENV['BUNDLE_GEMFILE'] = "#{__dir__}/Gemfile"
+
+APP_PATH = File.expand_path("../dummy_app/config/application", __dir__)
+require_relative "../dummy_app/config/boot"
+
+require "rails/commands"

data/bin/test_all_ar_versions

@@ -2,7 +2,7 @@
 
 # frozen_string_literal: true
 
-%w[6.0 6.1 7.0].each do |ar_version|
+%w[7.1].each do |ar_version|
   `rm Gemfile.lock`
   Process.waitpid(Kernel.spawn({ 'AR_VERSION' => ar_version }, "bundle install --quiet", close_others: true))
   Process.waitpid(Kernel.spawn({ 'AR_VERSION' => ar_version }, "rspec", close_others: true))

data/docker/my.cnf

@@ -0,0 +1,13 @@
+[mysqld]
+# Log General
+general_log = 1
+general_log_file = /var/log/mysql_general.log
+
+# Log Error
+log_error = /var/log/mysql_error.log
+
+# Log Slow
+slow_query_log = 1
+slow_query_log_file = /var/log/mysql_slow_query.log
+long_query_time = 0  # 0 has the effect of logging all queries
+log_queries_not_using_indexes = 1

data/docker/mysqld.sh

@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+##
+# This script exists to work-around the fact that
+# mysql does not support logging to stdout
+#
+# This will tail the file logs configured in ./my.cnf
+##
+
+LOG_PATHS=(
+  '/var/log/mysql_general.log'
+  '/var/log/mysql_error.log'
+  '/var/log/mysql_slow_query.log'
+)
+for LOG_PATH in "${LOG_PATHS[@]}"; do
+  # https://serverfault.com/a/599209
+  ( umask 0 && truncate -s0 "$LOG_PATH" )
+  tail --pid $$ -n0 -F "$LOG_PATH" &
+done
+
+docker-entrypoint.sh mysqld

data/docker-compose.yml

@@ -2,9 +2,21 @@ version: "3.5"
 
 services:
   postgres:
-    image: trx_ext/postgres
-    build: .
+    image: postgres:16
+    command: ["postgres", "-c", "log_statement=all", "-c", "default_transaction_isolation=serializable"]
     ports:
       - 5532:5432
     environment:
       - POSTGRES_PASSWORD=postgres
+  mysql:
+    image: mysql:8.3
+    command:
+      - /usr/local/bin/mysqld.sh
+    volumes:
+      - ./docker/my.cnf:/etc/mysql/conf.d/my.cnf
+      - ./docker/mysqld.sh:/usr/local/bin/mysqld.sh
+    ports:
+      - 3406:3306
+      - 34060:33060
+    environment:
+      - MYSQL_ALLOW_EMPTY_PASSWORD=true

data/dummy_app/.gitattributes

@@ -0,0 +1,7 @@
+# See https://git-scm.com/docs/gitattributes for more about git attribute files.
+
+# Mark the database schema as having been generated.
+db/schema.rb linguist-generated
+
+# Mark any vendored files as having been vendored.
+vendor/* linguist-vendored

data/dummy_app/.gitignore

@@ -0,0 +1,38 @@
+# See https://help.github.com/articles/ignoring-files for more about ignoring files.
+#
+# If you find yourself ignoring temporary files generated by your text editor
+# or operating system, you probably want to add a global ignore instead:
+#   git config --global core.excludesfile '~/.gitignore_global'
+
+# Ignore bundler config.
+/.bundle
+
+# Ignore the default SQLite database.
+/db/*.sqlite3
+/db/*.sqlite3-*
+
+# Ignore all logfiles and tempfiles.
+/log/*
+/tmp/*
+!/log/.keep
+!/tmp/.keep
+
+# Ignore pidfiles, but keep the directory.
+/tmp/pids/*
+!/tmp/pids/
+!/tmp/pids/.keep
+
+# Ignore uploaded files in development.
+/storage/*
+!/storage/.keep
+/tmp/storage/*
+!/tmp/storage/
+!/tmp/storage/.keep
+
+# Ignore master key for decrypting credentials and more.
+/config/master.key
+Gemfile.lock
+db/schema.rb
+db/primary_sqlite_schema.rb
+db/primary_mysql_schema.rb
+db/primary_trilogy_schema.rb

data/dummy_app/README.md

@@ -0,0 +1,24 @@
+# README
+
+This README would normally document whatever steps are necessary to get the
+application up and running.
+
+Things you may want to cover:
+
+* Ruby version
+
+* System dependencies
+
+* Configuration
+
+* Database creation
+
+* Database initialization
+
+* How to run the test suite
+
+* Services (job queues, cache servers, search engines, etc.)
+
+* Deployment instructions
+
+* ...

data/dummy_app/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require_relative "config/application"
+
+Rails.application.load_tasks

data/dummy_app/app/controllers/application_controller.rb

@@ -0,0 +1,2 @@
+class ApplicationController < ActionController::API
+end

data/dummy_app/app/models/application_mysql_record.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class ApplicationMysqlRecord < ActiveRecord::Base
+  self.abstract_class = true
+
+  connects_to database: { writing: :primary_mysql, reading: :primary_mysql }
+end

data/dummy_app/app/models/application_pg_record.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class ApplicationPgRecord < ActiveRecord::Base
+  self.abstract_class = true
+
+  connects_to database: { writing: :primary_pg, reading: :primary_pg }
+end

data/dummy_app/app/models/application_sqlite_record.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class ApplicationSqliteRecord < ActiveRecord::Base
+  self.abstract_class = true
+
+  connects_to database: { writing: :primary_sqlite, reading: :primary_sqlite }
+end

data/dummy_app/app/models/application_trilogy_record.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class ApplicationTrilogyRecord < ActiveRecord::Base
+  self.abstract_class = true
+
+  connects_to database: { writing: :primary_trilogy, reading: :primary_trilogy }
+end

data/dummy_app/app/models/dummy_mysql_record.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# Dummy record. It is used to test transaction integration.
+class DummyMysqlRecord < ApplicationMysqlRecord
+  class << self
+    def find_or_create_by(attributes, &block)
+      find_by(attributes) || create(attributes, &block)
+    end
+    wrap_in_trx :find_or_create_by
+  end
+end

data/dummy_app/app/models/dummy_pg_record.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# Dummy record. It is used to test transaction integration.
+class DummyPgRecord < ApplicationPgRecord
+  class << self
+    def find_or_create_by(attributes, &block)
+      find_by(attributes) || create(attributes, &block)
+    end
+    wrap_in_trx :find_or_create_by
+  end
+end

data/dummy_app/app/models/dummy_sqlite_record.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# Dummy record. It is used to test transaction integration.
+class DummySqliteRecord < ApplicationSqliteRecord
+  class << self
+    def find_or_create_by(attributes, &block)
+      find_by(attributes) || create(attributes, &block)
+    end
+    wrap_in_trx :find_or_create_by
+  end
+end

data/dummy_app/app/models/dummy_trilogy_record.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# Dummy record. It is used to test transaction integration.
+class DummyTrilogyRecord < ApplicationTrilogyRecord
+  class << self
+    def find_or_create_by(attributes, &block)
+      find_by(attributes) || create(attributes, &block)
+    end
+    wrap_in_trx :find_or_create_by
+  end
+end

data/dummy_app/bin/bundle

@@ -0,0 +1,109 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'bundle' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "rubygems"
+
+m = Module.new do
+  module_function
+
+  def invoked_as_script?
+    File.expand_path($0) == File.expand_path(__FILE__)
+  end
+
+  def env_var_version
+    ENV["BUNDLER_VERSION"]
+  end
+
+  def cli_arg_version
+    return unless invoked_as_script? # don't want to hijack other binstubs
+    return unless "update".start_with?(ARGV.first || " ") # must be running `bundle update`
+    bundler_version = nil
+    update_index = nil
+    ARGV.each_with_index do |a, i|
+      if update_index && update_index.succ == i && a =~ Gem::Version::ANCHORED_VERSION_PATTERN
+        bundler_version = a
+      end
+      next unless a =~ /\A--bundler(?:[= ](#{Gem::Version::VERSION_PATTERN}))?\z/
+      bundler_version = $1
+      update_index = i
+    end
+    bundler_version
+  end
+
+  def gemfile
+    gemfile = ENV["BUNDLE_GEMFILE"]
+    return gemfile if gemfile && !gemfile.empty?
+
+    File.expand_path("../Gemfile", __dir__)
+  end
+
+  def lockfile
+    lockfile =
+      case File.basename(gemfile)
+      when "gems.rb" then gemfile.sub(/\.rb$/, ".locked")
+      else "#{gemfile}.lock"
+      end
+    File.expand_path(lockfile)
+  end
+
+  def lockfile_version
+    return unless File.file?(lockfile)
+    lockfile_contents = File.read(lockfile)
+    return unless lockfile_contents =~ /\n\nBUNDLED WITH\n\s{2,}(#{Gem::Version::VERSION_PATTERN})\n/
+    Regexp.last_match(1)
+  end
+
+  def bundler_requirement
+    @bundler_requirement ||=
+      env_var_version ||
+      cli_arg_version ||
+      bundler_requirement_for(lockfile_version)
+  end
+
+  def bundler_requirement_for(version)
+    return "#{Gem::Requirement.default}.a" unless version
+
+    bundler_gem_version = Gem::Version.new(version)
+
+    bundler_gem_version.approximate_recommendation
+  end
+
+  def load_bundler!
+    ENV["BUNDLE_GEMFILE"] ||= gemfile
+
+    activate_bundler
+  end
+
+  def activate_bundler
+    gem_error = activation_error_handling do
+      gem "bundler", bundler_requirement
+    end
+    return if gem_error.nil?
+    require_error = activation_error_handling do
+      require "bundler/version"
+    end
+    return if require_error.nil? && Gem::Requirement.new(bundler_requirement).satisfied_by?(Gem::Version.new(Bundler::VERSION))
+    warn "Activating bundler (#{bundler_requirement}) failed:\n#{gem_error.message}\n\nTo install the version of bundler this project requires, run `gem install bundler -v '#{bundler_requirement}'`"
+    exit 42
+  end
+
+  def activation_error_handling
+    yield
+    nil
+  rescue StandardError, LoadError => e
+    e
+  end
+end
+
+m.load_bundler!
+
+if m.invoked_as_script?
+  load Gem.bin_path("bundler", "bundle")
+end

data/dummy_app/bin/rails

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+APP_PATH = File.expand_path("../config/application", __dir__)
+require_relative "../config/boot"
+require "rails/commands"

data/dummy_app/bin/rake

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require_relative "../config/boot"
+require "rake"
+Rake.application.run

data/dummy_app/bin/setup

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+require "fileutils"
+
+# path to your application root.
+APP_ROOT = File.expand_path("..", __dir__)
+
+def system!(*args)
+  system(*args) || abort("\n== Command #{args} failed ==")
+end
+
+FileUtils.chdir APP_ROOT do
+  # This script is a way to set up or update your development environment automatically.
+  # This script is idempotent, so that you can run it at any time and get an expectable outcome.
+  # Add necessary setup steps to this file.
+
+  puts "== Installing dependencies =="
+  system! "gem install bundler --conservative"
+  system("bundle check") || system!("bundle install")
+
+  # puts "\n== Copying sample files =="
+  # unless File.exist?("config/database.yml")
+  #   FileUtils.cp "config/database.yml.sample", "config/database.yml"
+  # end
+
+  puts "\n== Preparing database =="
+  system! "bin/rails db:prepare"
+
+  puts "\n== Removing old logs and tempfiles =="
+  system! "bin/rails log:clear tmp:clear"
+
+  puts "\n== Restarting application server =="
+  system! "bin/rails restart"
+end

data/dummy_app/config/application.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "boot"
+
+require "rails"
+
+%w(
+  active_record/railtie
+  action_controller/railtie
+  action_view/railtie
+).each do |railtie|
+  begin
+    require railtie
+  rescue LoadError
+  end
+end
+
+
+# Require the gems listed in Gemfile, including any gems
+# you've limited to :test, :development, or :production.
+Bundler.require(*Rails.groups)
+
+module DummyApp
+  class Application < Rails::Application
+    rails_version = Gem::Specification.find_by_name('rails').version
+    # Initialize configuration defaults for originally generated Rails version.
+    config.load_defaults rails_version.segments[0..1].join('.')
+
+    # Configuration for the application, engines, and railties goes here.
+    #
+    # These settings can be overridden in specific environments using the files
+    # in config/environments, which are processed later.
+    #
+    # config.time_zone = "Central Time (US & Canada)"
+    # config.eager_load_paths << Rails.root.join("extras")
+
+    # Only loads a smaller set of middleware suitable for API only apps.
+    # Middleware like session, flash, cookies can be added back manually.
+    # Skip views, helpers and assets when generating a new resource.
+    config.api_only = true
+    if rails_version < Gem::Version.new('7.0.0')
+      config.active_record.legacy_connection_handling = false
+    end
+    # config.active_job.queue_adapter = :async
+
+
+    if defined?(FactoryBotRails)
+      config.factory_bot.definition_file_paths += [File.expand_path('../../spec/factories', __dir__)]
+    end
+  end
+end