trx_ext 1.0.5 → 2.0.0

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

data/dummy_app/config/boot.rb

@@ -0,0 +1,4 @@
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
+
+require "bundler/setup" # Set up gems listed in the Gemfile.
+require "bootsnap/setup" # Speed up boot time by caching expensive operations.

data/dummy_app/config/database.yml

@@ -0,0 +1,70 @@
+# SQLite. Versions 3.8.0 and up are supported.
+#   gem install sqlite3
+#
+#   Ensure the SQLite 3 gem is defined in your Gemfile
+#   gem "sqlite3"
+#
+default_pg: &default_pg
+  adapter: 'postgresql'
+  username: postgres
+  password: postgres
+  host: localhost
+  port: 5532
+  pool: <%= Etc.nprocessors + 1 %>
+  timeout: 5000
+  prepared_statements: false
+
+default_sqlite: &default_sqlite
+  adapter: 'sqlite3'
+  pool: <%= Etc.nprocessors + 1 %>
+  timeout: 1000
+  prepared_statements: false
+  migrations_paths: db/primary_sqlite
+
+default_mysql: &default_mysql
+  adapter: 'mysql2'
+  username: root
+  host: 127.0.0.1
+  port: 3406
+  pool: <%= Etc.nprocessors + 1 %>
+  timeout: 5000
+  prepared_statements: false
+  migrations_paths: db/primary_mysql
+
+default_trilogy: &default_trilogy
+  adapter: 'trilogy'
+  username: root
+  host: 127.0.0.1
+  port: 3406
+  pool: <%= Etc.nprocessors + 1 %>
+  timeout: 5000
+  prepared_statements: false
+  migrations_paths: db/primary_trilogy
+
+development:
+  primary_pg:
+    <<: *default_pg
+    database: trx_ext
+  primary_sqlite:
+    <<: *default_sqlite
+    database: db/trx_ext.sqlite3
+  primary_mysql:
+    <<: *default_mysql
+    database: trx_ext
+  primary_trilogy:
+    <<: *default_trilogy
+    database: trx_ext_trilogy
+
+test:
+  primary_pg:
+    <<: *default_pg
+    database: trx_ext_test
+  primary_sqlite:
+    <<: *default_sqlite
+    database: db/trx_ext_test.sqlite3
+  primary_mysql:
+    <<: *default_mysql
+    database: trx_ext_test
+  primary_trilogy:
+    <<: *default_trilogy
+    database: trx_ext_trilogy_test

data/dummy_app/config/environment.rb

@@ -0,0 +1,5 @@
+# Load the Rails application.
+require_relative "application"
+
+# Initialize the Rails application.
+Rails.application.initialize!

data/dummy_app/config/environments/development.rb

@@ -0,0 +1,66 @@
+require "active_support/core_ext/integer/time"
+
+Rails.application.configure do
+  # Settings specified here will take precedence over those in config/application.rb.
+
+  # In the development environment your application's code is reloaded any time
+  # it changes. This slows down response time but is perfect for development
+  # since you don't have to restart the web server when you make code changes.
+  config.cache_classes = false
+
+  # Do not eager load code on boot.
+  config.eager_load = false
+
+  # Show full error reports.
+  config.consider_all_requests_local = true
+
+  # Enable server timing
+  config.server_timing = true
+
+  # Enable/disable caching. By default caching is disabled.
+  # Run rails dev:cache to toggle caching.
+  if Rails.root.join("tmp/caching-dev.txt").exist?
+    config.cache_store = :memory_store
+    config.public_file_server.headers = {
+      "Cache-Control" => "public, max-age=#{2.days.to_i}"
+    }
+  else
+    config.action_controller.perform_caching = false
+
+    config.cache_store = :null_store
+  end
+
+  # Store uploaded files on the local file system (see config/storage.yml for options).
+  # config.active_storage.service = :local
+
+  # Don't care if the mailer can't send.
+  # config.action_mailer.raise_delivery_errors = false
+
+  # config.action_mailer.perform_caching = false
+
+  # Print deprecation notices to the Rails logger.
+  config.active_support.deprecation = :log
+
+  # Raise exceptions for disallowed deprecations.
+  config.active_support.disallowed_deprecation = :raise
+
+  # Tell Active Support which deprecation messages to disallow.
+  config.active_support.disallowed_deprecation_warnings = []
+
+  # Raise an error on page load if there are pending migrations.
+  config.active_record.migration_error = :page_load
+
+  # Highlight code that triggered database queries in logs.
+  config.active_record.verbose_query_logs = true
+
+
+  # Raises error for missing translations.
+  # config.i18n.raise_on_missing_translations = true
+
+  # Annotate rendered view with file names.
+  # config.action_view.annotate_rendered_view_with_filenames = true
+
+  # Uncomment if you wish to allow Action Cable access from any origin.
+  # config.action_cable.disable_request_forgery_protection = true
+  config.logger = ActiveSupport::Logger.new(File.expand_path('../../../log/development.log', __dir__))
+end

data/dummy_app/config/environments/test.rb

@@ -0,0 +1,61 @@
+require "active_support/core_ext/integer/time"
+
+# The test environment is used exclusively to run your application's
+# test suite. You never need to work with it otherwise. Remember that
+# your test database is "scratch space" for the test suite and is wiped
+# and recreated between test runs. Don't rely on the data there!
+
+Rails.application.configure do
+  # Settings specified here will take precedence over those in config/application.rb.
+
+  # Turn false under Spring and add config.action_view.cache_template_loading = true.
+  config.cache_classes = true
+
+  # Eager loading loads your whole application. When running a single test locally,
+  # this probably isn't necessary. It's a good idea to do in a continuous integration
+  # system, or in some way before deploying your code.
+  config.eager_load = ENV["CI"].present?
+
+  # Configure public file server for tests with Cache-Control for performance.
+  config.public_file_server.enabled = true
+  config.public_file_server.headers = {
+    "Cache-Control" => "public, max-age=#{1.hour.to_i}"
+  }
+
+  # Show full error reports and disable caching.
+  config.consider_all_requests_local       = true
+  config.action_controller.perform_caching = false
+  config.cache_store = :null_store
+
+  # Raise exceptions instead of rendering exception templates.
+  config.action_dispatch.show_exceptions = false
+
+  # Disable request forgery protection in test environment.
+  config.action_controller.allow_forgery_protection = false
+
+  # Store uploaded files on the local file system in a temporary directory.
+  # config.active_storage.service = :test
+
+  # config.action_mailer.perform_caching = false
+
+  # Tell Action Mailer not to deliver emails to the real world.
+  # The :test delivery method accumulates sent emails in the
+  # ActionMailer::Base.deliveries array.
+  # config.action_mailer.delivery_method = :test
+
+  # Print deprecation notices to the stderr.
+  config.active_support.deprecation = :stderr
+
+  # Raise exceptions for disallowed deprecations.
+  config.active_support.disallowed_deprecation = :raise
+
+  # Tell Active Support which deprecation messages to disallow.
+  config.active_support.disallowed_deprecation_warnings = []
+
+  # Raises error for missing translations.
+  # config.i18n.raise_on_missing_translations = true
+
+  # Annotate rendered view with file names.
+  # config.action_view.annotate_rendered_view_with_filenames = true
+  config.logger = ActiveSupport::Logger.new(File.expand_path('../../../log/test.log', __dir__))
+end

data/dummy_app/config/locales/en.yml

@@ -0,0 +1,2 @@
+en:
+  welcome: 'Hi there'

data/dummy_app/config/locales/fr-CH.yml

@@ -0,0 +1,2 @@
+fr-CH:
+  welcome: 'Bonjour, monsieur'

data/dummy_app/config/puma.rb

@@ -0,0 +1,43 @@
+# Puma can serve each request in a thread from an internal thread pool.
+# The `threads` method setting takes two numbers: a minimum and maximum.
+# Any libraries that use thread pools should be configured to match
+# the maximum value specified for Puma. Default is set to 5 threads for minimum
+# and maximum; this matches the default thread size of Active Record.
+#
+max_threads_count = ENV.fetch("RAILS_MAX_THREADS") { 5 }
+min_threads_count = ENV.fetch("RAILS_MIN_THREADS") { max_threads_count }
+threads min_threads_count, max_threads_count
+
+# Specifies the `worker_timeout` threshold that Puma will use to wait before
+# terminating a worker in development environments.
+#
+worker_timeout 3600 if ENV.fetch("RAILS_ENV", "development") == "development"
+
+# Specifies the `port` that Puma will listen on to receive requests; default is 3000.
+#
+port ENV.fetch("PORT") { 3000 }
+
+# Specifies the `environment` that Puma will run in.
+#
+environment ENV.fetch("RAILS_ENV") { "development" }
+
+# Specifies the `pidfile` that Puma will use.
+pidfile ENV.fetch("PIDFILE") { "tmp/pids/server.pid" }
+
+# Specifies the number of `workers` to boot in clustered mode.
+# Workers are forked web server processes. If using threads and workers together
+# the concurrency of the application would be max `threads` * `workers`.
+# Workers do not work on JRuby or Windows (both of which do not support
+# processes).
+#
+# workers ENV.fetch("WEB_CONCURRENCY") { 2 }
+
+# Use the `preload_app!` method when specifying a `workers` number.
+# This directive tells Puma to first boot the application and load code
+# before forking the application. This takes advantage of Copy On Write
+# process behavior so workers use less memory.
+#
+# preload_app!
+
+# Allow puma to be restarted by `bin/rails restart` command.
+plugin :tmp_restart

data/dummy_app/config/routes.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Rails.application.routes.draw do
+
+end

data/dummy_app/config.ru

@@ -0,0 +1,6 @@
+# This file is used by Rack-based servers to start the application.
+
+require_relative "config/environment"
+
+run Rails.application
+Rails.application.load_server

data/dummy_app/db/migrate/20240128111549_create_dummy_record.rb

@@ -0,0 +1,10 @@
+class CreateDummyRecord < ActiveRecord::Migration[6.1]
+  def change
+    create_table :dummy_pg_records do |t|
+      t.string :name
+      t.string :unique_name
+      t.datetime :created_at, precision: 6, null: false
+    end
+    add_index :dummy_pg_records, :unique_name, unique: true
+  end
+end

data/dummy_app/db/primary_mysql/20240128111549_create_dummy_mysql_record.rb

@@ -0,0 +1,10 @@
+class CreateDummyMysqlRecord < ActiveRecord::Migration[6.1]
+  def change
+    create_table :dummy_mysql_records do |t|
+      t.string :name
+      t.string :unique_name
+      t.datetime :created_at, precision: 6, null: false
+    end
+    add_index :dummy_mysql_records, :unique_name, unique: true
+  end
+end

data/dummy_app/db/primary_sqlite/20240128111549_create_dummy_sqlite_record.rb

@@ -0,0 +1,10 @@
+class CreateDummySqliteRecord < ActiveRecord::Migration[6.1]
+  def change
+    create_table :dummy_sqlite_records do |t|
+      t.string :name
+      t.string :unique_name
+      t.datetime :created_at, precision: 6, null: false
+    end
+    add_index :dummy_sqlite_records, :unique_name, unique: true
+  end
+end

data/dummy_app/db/primary_trilogy/20240128111549_create_dummy_trilogy_record.rb

@@ -0,0 +1,10 @@
+class CreateDummyTrilogyRecord < ActiveRecord::Migration[6.1]
+  def change
+    create_table :dummy_trilogy_records do |t|
+      t.string :name
+      t.string :unique_name
+      t.datetime :created_at, precision: 6, null: false
+    end
+    add_index :dummy_trilogy_records, :unique_name, unique: true
+  end
+end

data/dummy_app/db/seeds.rb

@@ -0,0 +1,7 @@
+# This file should contain all the record creation needed to seed the database with its default values.
+# The data can then be loaded with the bin/rails db:seed command (or created alongside the database with db:setup).
+#
+# Examples:
+#
+#   movies = Movie.create([{ name: "Star Wars" }, { name: "Lord of the Rings" }])
+#   Character.create(name: "Luke", movie: movies.first)

data/dummy_app/public/robots.txt

@@ -0,0 +1 @@
+# See https://www.robotstxt.org/robotstxt.html for documentation on how to use the robots.txt file

data/lib/trx_ext/object_ext.rb

@@ -22,16 +22,17 @@ module TrxExt
     #   #   (0.2ms)  COMMIT
     #
     # @param method [Symbol] a name of the method
+    # @param class_name [String, nil] pass an ActiveRecord model class name to define the appropriate connection of the
+    #   transaction
     # @return [Symbol]
-    def wrap_in_trx(method)
+    def wrap_in_trx(method, class_name = nil)
       module_to_prepend = Module.new do
-        class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def #{method}(...)
-            trx do
-              super
-            end
+        define_method(method) do |*args, **kwargs, &blk|
+          context = class_name&.constantize || self
+          context.trx do
+            super(*args, **kwargs, &blk)
           end
-        RUBY
+        end
       end
       prepend module_to_prepend
       method
@@ -39,6 +40,10 @@ module TrxExt
 
     # A shorthand version of <tt>ActiveRecord::Base.transaction</tt>
     def trx(...)
+      # If trx method is called over AR model - we should take this into account. Otherwise - call it over
+      # ActiveRecord::Base class. This ensures proper connection picking in sharded environment.
+      return transaction(...) if respond_to?(:transaction)
+
       ActiveRecord::Base.transaction(...)
     end
   end

data/lib/trx_ext/retry.rb

@@ -11,7 +11,7 @@ module TrxExt
         module_to_prepend = Module.new do
           klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def #{method}(...)
-              ::TrxExt::Retry.retry_until_serialized do
+              ::TrxExt::Retry.retry_until_serialized(self) do
                 super
               end
             end
@@ -22,42 +22,32 @@ module TrxExt
       end
 
       # Retries block execution until serialization errors are no longer raised
-      def retry_until_serialized
+      def retry_until_serialized(connection)
         retries_count = 0
         begin
           yield
-        rescue => error
-          error_classification = error_classification(error)
-          if retry_query?(error, retries_count)
-            if error_classification == :record_not_unique
-              retries_count += 1
-            end
-            TrxExt.log("Detected transaction rollback condition. Reason - #{error_classification}. Retrying...")
+        rescue ActiveRecord::SerializationFailure, ActiveRecord::Deadlocked => error
+          if connection.open_transactions == 0
+            TrxExt.log("Detected transaction rollback condition. Reason - #{error.inspect}. Retrying...")
             retry
-          else
-            raise error
           end
+          raise
+        rescue ActiveRecord::RecordNotUnique => error
+          raise unless retry_query?(connection, retries_count)
+
+          retries_count += 1
+          TrxExt.log("Detected transaction rollback condition. Reason - #{error.inspect}. Retrying...")
+          retry
         end
       end
 
       private
 
-      def error_classification(error)
-        case
-        when error.message.index('deadlock detected')
-          :deadlock
-        when error.message.index('could not serialize')
-          :serialization_error
-        when error.class == ActiveRecord::RecordNotUnique
-          :record_not_unique
-        end
-      end
-
-      def retry_query?(error, retryies_count)
-        classification = error_classification(error)
-        ActiveRecord::Base.connection.open_transactions == 0 &&
-          (%i(deadlock serialization_error).include?(classification) ||
-            classification == :record_not_unique && retryies_count < TrxExt.config.unique_retries)
+      # @param connection
+      # @param retries_count [Integer]
+      # @return [Boolean]
+      def retry_query?(connection, retries_count)
+        connection.open_transactions == 0 && retries_count < TrxExt.config.unique_retries
       end
     end
   end

data/lib/trx_ext/transaction.rb

@@ -7,7 +7,7 @@ module TrxExt
     # for available params
     def transaction(**kwargs, &blk)
       pool = nil
-      TrxExt::Retry.retry_until_serialized do
+      TrxExt::Retry.retry_until_serialized(self) do
         super(**kwargs) do
           pool = TrxExt::CallbackPool.add(previous: current_callbacks_chain_link)
           self.current_callbacks_chain_link = pool

data/lib/trx_ext/version.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
 module TrxExt
-  VERSION = "1.0.5"
-  SUPPORTED_AR_VERSIONS = ['~> 6.0', '~> 6.1', '~> 7.0'].freeze
+  VERSION = "2.0.0"
 end

data/lib/trx_ext.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'active_support'
+require 'active_record'
 require_relative "trx_ext/callback_pool"
 require_relative "trx_ext/object_ext"
 require_relative "trx_ext/retry"
@@ -16,25 +16,15 @@ module TrxExt
     def integrate!
       # Allow to use #wrap_in_trx and #trx methods everywhere
       Object.prepend(TrxExt::ObjectExt)
-
-      ActiveSupport.on_load(:active_record) do
-        require 'active_record/connection_adapters/postgresql_adapter'
-
-        # Patch #transaction
-        ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.prepend(TrxExt::Transaction)
-
-        # Single SELECT/UPDATE/DELETE queries should also be retried even if they are not a part of explicit transaction
-        TrxExt::Retry.with_retry_until_serialized(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter, :exec_query)
-        TrxExt::Retry.with_retry_until_serialized(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter, :exec_update)
-        TrxExt::Retry.with_retry_until_serialized(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter, :exec_delete)
-      end
+      ActiveSupport.on_load(:active_record_mysql2adapter, &method(:integrate_into_class))
+      ActiveSupport.on_load(:active_record_postgresqladapter, &method(:integrate_into_class))
+      ActiveSupport.on_load(:active_record_sqlite3adapter, &method(:integrate_into_class))
+      ActiveSupport.on_load(:active_record_trilogyadapter, &method(:integrate_into_class))
     end
 
     # @return [void]
     def log(msg)
-      return unless logger
-
-      logger.info(msg)
+      logger&.info(msg)
     end
 
     # @return [TrxExt::Config]
@@ -45,11 +35,18 @@ module TrxExt
     def configure
       yield config
     end
+
+    private
+
+    def integrate_into_class(klass)
+      klass.prepend TrxExt::Transaction
+      TrxExt::Retry.with_retry_until_serialized(klass, :exec_query)
+      TrxExt::Retry.with_retry_until_serialized(klass, :exec_insert)
+      TrxExt::Retry.with_retry_until_serialized(klass, :exec_delete)
+      TrxExt::Retry.with_retry_until_serialized(klass, :exec_update)
+      TrxExt::Retry.with_retry_until_serialized(klass, :exec_insert_all)
+    end
   end
 end
 
-if defined?(Rails::Railtie)
-  require_relative "trx_ext/railtie"
-else
-  TrxExt.integrate!
-end
+TrxExt.integrate!

data/trx_ext.gemspec

@@ -31,11 +31,5 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency 'activerecord', '>= 6'
-  spec.add_dependency 'pg', '~> 1.2'
-  spec.add_development_dependency 'rspec', "~> 3.10"
-  spec.add_development_dependency 'timecop', "~> 0.9.4"
-  spec.add_development_dependency 'factory_bot', "~> 6.2"
-  spec.add_development_dependency 'fivemat', '~> 1.3'
-  spec.add_development_dependency 'rspec-its', '~> 1.3'
+  spec.add_dependency 'activerecord', '>= 7.1'
 end