transaction_retry 1.0.1

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,22 @@
+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', '2.8.1'
+  
+  gem 'simplecov', :require => false
+
+  gem 'mysql2'
+  gem 'pg'
+  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,73 @@
+# transaction_retry
+
+Retries database transaction on deadlock and transaction serialization errors. Supports MySQL, PostgreSQL, and SQLite.
+
+## Example
+
+The gem works automatically by rescuing ActiveRecord::TransactionIsolationConflict and retrying the transaction.
+
+## Installation
+
+Add this to your Gemfile:
+
+    gem 'transaction_retry'
+
+Then run:
+
+    bundle
+
+__With Rails it works out of the box__.
+
+If you have a standalone ActiveRecord-based project you'll need to call:
+
+    TransactionRetry.apply_activerecord_patch     # after connecting to the database
+
+__after__ connecting to the database.
+
+## Configuration
+
+You can optionally configure transaction_retry gem in your config/initializers/transaction_retry.rb (or anywhere else):
+
+    TransactionRetry.max_retries = 3
+    TransactionRetry.wait_times = [0, 1, 2, 4, 8, 16, 32]   # seconds to sleep after retry n
+
+## 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.
+ * Use it in your Rails application or a standalone ActiveRecord-based project.
+
+## Requirements
+
+ * ruby 1.9.2
+ * activerecord 3.0.11+
+
+## Running tests
+
+Run tests on the selected database (mysql2 by default):
+
+    db=mysql2 bundle exec rake test
+    db=postgresql bundle exec rake test
+    db=sqlite3 bundle exec rake test
+
+Run tests on all supported databases:
+
+    ./tests
+
+Database configuration is hardcoded in test/db/db.rb; feel free to improve this and submit a pull request.
+
+## 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,11 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs += ["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/transaction_retry.rb

@@ -0,0 +1,41 @@
+require "active_record"
+require "transaction_isolation"
+
+require_relative "transaction_retry/version"
+
+module TransactionRetry
+
+  # 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 '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
+        TransactionRetry.apply_activerecord_patch
+      end
+    end
+  end
+
+  def self.max_retries
+    @@max_retries ||= 3
+  end
+
+  def self.max_retries=( n )
+    @@max_retries = n
+  end
+
+  def self.wait_times
+    @@wait_times ||= [0, 1, 2, 4, 8, 16, 32]
+  end
+
+  def self.wait_times=( array_of_seconds )
+    @@wait_times = array_of_seconds
+  end
+
+end

data/lib/transaction_retry/active_record/base.rb

@@ -0,0 +1,58 @@
+require 'active_record/base'
+
+module TransactionRetry
+  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
+        
+        def transaction_with_retry(*objects, &block)
+          retry_count = 0
+
+          begin
+            transaction_without_retry(*objects, &block)
+          rescue ::ActiveRecord::TransactionIsolationConflict
+            raise if retry_count >= TransactionRetry.max_retries
+            raise if tr_in_nested_transaction?
+            
+            retry_count += 1
+            postfix = { 1 => 'st', 2 => 'nd', 3 => 'rd' }[retry_count] || 'th'
+            logger.warn "Transaction isolation conflict detected. Retrying for the #{retry_count}-#{postfix} time..." if logger
+            tr_exponential_pause( retry_count )
+            retry
+          end
+        end
+        
+        private
+
+          # Sleep 0, 1, 2, 4, ... seconds up to the TransactionRetry.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 = TransactionRetry.wait_times[count-1] || 32
+            sleep( seconds ) if seconds > 0
+          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.send( :include, TransactionRetry::ActiveRecord::Base )

data/lib/transaction_retry/version.rb

@@ -0,0 +1,3 @@
+module TransactionRetry
+  VERSION = "1.0.1"
+end

data/test/db/all.rb

@@ -0,0 +1,4 @@
+require 'active_record'
+require_relative 'db'
+require_relative 'migrations'
+require_relative 'queued_job'

data/test/db/db.rb

@@ -0,0 +1,35 @@
+require 'fileutils'
+
+module TransactionRetry
+  module Test
+    module Db
+
+      def self.connect_to_mysql2
+        ::ActiveRecord::Base.establish_connection(
+          :adapter => "mysql2",
+          :database => "transaction_retry_test",
+          :user => 'root',
+          :password => ''
+        )
+      end
+      
+      def self.connect_to_postgresql
+        ::ActiveRecord::Base.establish_connection(
+          :adapter => "postgresql",
+          :database => "transaction_retry_test",
+          :user => 'qertoip',
+          :password => 'test123'
+        )
+      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,20 @@
+module TransactionRetry
+  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,2 @@
+class QueuedJob < ActiveRecord::Base
+end

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

@@ -0,0 +1,87 @@
+# -*- encoding : utf-8 -*-
+
+require 'test_helper'
+
+class TransactionWithRetryTest < MiniTest::Unit::TestCase
+
+  def setup
+    @original_max_retries = TransactionRetry.max_retries
+    @original_wait_times = TransactionRetry.wait_times
+  end
+
+  def teardown
+    TransactionRetry.max_retries = @original_max_retries
+    TransactionRetry.wait_times = @original_wait_times
+    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.new( ActiveRecord::StatementInvalid.new( message ), 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
+    TransactionRetry.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.new( ActiveRecord::StatementInvalid.new( message ), 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.new( ActiveRecord::StatementInvalid.new( message ), message )
+          end
+          QueuedJob.create!( :job => 'is cool!' )
+        end
+      end
+      
+    end
+      
+    assert_equal( 0, QueuedJob.count )
+  end
+
+end

data/test/library_setup.rb

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

data/test/test_console.rb

@@ -0,0 +1,11 @@
+# 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

data/test/test_helper.rb

@@ -0,0 +1,12 @@
+# 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,4 @@
+require 'test_helper'
+
+# Load all tests
+Dir.glob( "./**/*_test.rb" ).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

data/transaction_retry.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "transaction_retry/version"
+
+Gem::Specification.new do |s|
+  s.name        = "transaction_retry"
+  s.version     = TransactionRetry::VERSION
+  s.authors     = ["Piotr 'Qertoip' Włodarek"]
+  s.email       = ["qertoip@gmail.com"]
+  s.homepage    = "https://github.com/qertoip/transaction_retry"
+  s.summary     = %q{Retries database transaction on deadlock and transaction serialization errors. Supports MySQL, PostgreSQL and SQLite.}
+  s.description = %q{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 = '>= 1.9.2'
+  
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency "activerecord", ">= 3.0.11"
+  s.add_runtime_dependency "transaction_isolation", ">= 1.0.2"
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: transaction_retry
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Piotr 'Qertoip' Włodarek
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &16526380 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.11
+  type: :runtime
+  prerelease: false
+  version_requirements: *16526380
+- !ruby/object:Gem::Dependency
+  name: transaction_isolation
+  requirement: &16525880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: *16525880
+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:
+- qertoip@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- d
+- lib/transaction_retry.rb
+- lib/transaction_retry/active_record/base.rb
+- lib/transaction_retry/version.rb
+- 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
+- transaction_retry.gemspec
+homepage: https://github.com/qertoip/transaction_retry
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Retries database transaction on deadlock and transaction serialization errors.
+  Supports MySQL, PostgreSQL and SQLite.
+test_files: []