deadlock_retry_insane 1.2.0

data/.gitignore

@@ -0,0 +1 @@
+*.swp

data/CHANGELOG

@@ -0,0 +1,26 @@
+deadlock_retry changes
+
+== v1.2.0
+
+* Support for postgres (tomhughes)
+* Testing AR versions (kbrock)
+
+== v1.1.2
+
+* Exponential backoff, sleep 0, 1, 2, 4... seconds between retries.
+* Support new syntax for InnoDB status in MySQL 5.5.
+
+== v1.1.1 (2011-05-13)
+
+* Conditionally log INNODB STATUS only if user has permission. (osheroff)
+
+== v1.1.0 (2011-04-20)
+
+* Modernize.
+* Drop support for Rails 2.1 and earlier.
+
+== v1.0 - (2009-02-07)
+
+* Add INNODB status logging for debugging deadlock issues.
+* Clean up so the code will run as a gem plugin. 
+* Small fix for ActiveRecord 2.1.x compatibility.

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+# Copyright (c) 2005 Jamis Buck
+#
+# 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

@@ -0,0 +1,21 @@
+= Deadlock Retry INSANE EDITION (more retries)
+
+Deadlock retry allows the database adapter (currently only tested with the
+MySQLAdapter) to retry transactions that fall into deadlock. It will retry
+such transactions three times before finally failing.
+
+This capability is automatically added to ActiveRecord. No code changes or otherwise are required.
+
+== Installation
+
+Add it to your Rails application by installing the gem:
+
+  gem install deadlock_retry_insane
+
+and including a reference to it in your application's Gemfile:
+
+  gem 'deadlock_retry_insane'
+
+== Original Authors
+
+Jamis Buck and Mike Perham made it. I just changed a number.

data/Rakefile

@@ -0,0 +1,12 @@
+require 'rake'
+require 'rake/testtask'
+
+desc "Default task"
+task :default => [ :test ]
+
+Rake::TestTask.new do |t|
+  t.libs = ['lib', 'test']
+  t.test_files = Dir["test/**/*_test.rb"]
+  t.verbose = true
+  t.warning = true
+end

data/deadlock_retry_insane.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+
+$:.push File.expand_path("../lib", __FILE__)
+
+require "deadlock_retry/version"
+
+Gem::Specification.new do |s|
+  s.name = %q{deadlock_retry_insane}
+  s.version = DeadlockRetry::VERSION
+  s.authors = ["Jamis Buck", "Mike Perham", "Jason Coene"]
+  s.description = s.summary = %q{Provides automatic deadlock retry and logging functionality for ActiveRecord and MySQL}
+  s.email = %q{jcoene@gmail.com}
+  s.files = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.homepage = %q{http://github.com/jcoene/deadlock_retry}
+  s.require_paths = ["lib"]
+  s.add_development_dependency 'mocha'
+  s.add_development_dependency 'activerecord', ENV['ACTIVERECORD_VERSION'] || ' ~>3.0'
+end

data/lib/deadlock_retry.rb

@@ -0,0 +1,107 @@
+require 'active_support/core_ext/module/attribute_accessors'
+
+module DeadlockRetry
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.class_eval do
+      class << self
+        alias_method_chain :transaction, :deadlock_handling
+      end
+    end
+  end
+
+  mattr_accessor :innodb_status_cmd
+
+  module ClassMethods
+    DEADLOCK_ERROR_MESSAGES = [
+      "Deadlock found when trying to get lock",
+      "Lock wait timeout exceeded",
+      "deadlock detected"
+    ]
+
+    MAXIMUM_RETRIES_ON_DEADLOCK = 10
+
+
+    def transaction_with_deadlock_handling(*objects, &block)
+      retry_count = 0
+
+      check_innodb_status_available
+
+      begin
+        transaction_without_deadlock_handling(*objects, &block)
+      rescue ActiveRecord::StatementInvalid => error
+        raise if in_nested_transaction?
+        if DEADLOCK_ERROR_MESSAGES.any? { |msg| error.message =~ /#{Regexp.escape(msg)}/ }
+          raise if retry_count >= MAXIMUM_RETRIES_ON_DEADLOCK
+          retry_count += 1
+          logger.info "Deadlock detected on retry #{retry_count}, restarting transaction"
+          log_innodb_status if DeadlockRetry.innodb_status_cmd
+          exponential_pause(retry_count)
+          retry
+        else
+          raise
+        end
+      end
+    end
+
+    private
+
+    WAIT_TIMES = [0, 1, 2, 4, 8, 16, 32]
+
+    def exponential_pause(count)
+      sec = WAIT_TIMES[count-1] || 32
+      # sleep 0, 1, 2, 4, ... seconds up to the MAXIMUM_RETRIES.
+      # Cap the pause time at 32 seconds.
+      sleep(sec) if sec != 0
+    end
+
+    def in_nested_transaction?
+      # open_transactions was added in 2.2's connection pooling changes.
+      connection.open_transactions != 0
+    end
+
+    def show_innodb_status
+       self.connection.select_value(DeadlockRetry.innodb_status_cmd)
+    end
+
+    # Should we try to log innodb status -- if we don't have permission to,
+    # we actually break in-flight transactions, silently (!)
+    def check_innodb_status_available
+      return unless DeadlockRetry.innodb_status_cmd == nil
+
+      if self.connection.adapter_name == "MySQL"
+        begin
+          mysql_version = self.connection.select_rows('show variables like \'version\'')[0][1]
+          cmd = if mysql_version < '5.5'
+            'show innodb status'
+          else
+            'show engine innodb status'
+          end
+          self.connection.select_value(cmd)
+          DeadlockRetry.innodb_status_cmd = cmd
+        rescue
+          logger.info "Cannot log innodb status: #{$!.message}"
+          DeadlockRetry.innodb_status_cmd = false
+        end
+      else
+        DeadlockRetry.innodb_status_cmd = false
+      end
+    end
+
+    def log_innodb_status
+      # show innodb status is the only way to get visiblity into why
+      # the transaction deadlocked.  log it.
+      lines = show_innodb_status
+      logger.warn "INNODB Status follows:"
+      lines.each_line do |line|
+        logger.warn line
+      end
+    rescue => e
+      # Access denied, ignore
+      logger.info "Cannot log innodb status: #{e.message}"
+    end
+
+  end
+end
+
+ActiveRecord::Base.send(:include, DeadlockRetry) if defined?(ActiveRecord)

data/lib/deadlock_retry/version.rb

@@ -0,0 +1,3 @@
+module DeadlockRetry
+  VERSION = '1.2.0'
+end

data/test/deadlock_retry_test.rb

@@ -0,0 +1,118 @@
+require 'rubygems'
+
+# Change the version if you want to test a different version of ActiveRecord
+gem 'activerecord', ENV['ACTIVERECORD_VERSION'] || ' ~>3.0'
+require 'active_record'
+require 'active_record/version'
+puts "Testing ActiveRecord #{ActiveRecord::VERSION::STRING}"
+
+require 'test/unit'
+require 'mocha'
+require 'logger'
+require "deadlock_retry"
+
+class MockModel
+  @@open_transactions = 0
+
+  def self.transaction(*objects)
+    @@open_transactions += 1
+    yield
+  ensure
+    @@open_transactions -= 1
+  end
+
+  def self.open_transactions
+    @@open_transactions
+  end
+
+  def self.connection
+    self
+  end
+
+  def self.logger
+    @logger ||= Logger.new(nil)
+  end
+
+  def self.show_innodb_status
+    []
+  end
+
+  def self.select_rows(sql)
+    [['version', '5.1.45']]
+  end
+
+  def self.select_value(sql)
+    true
+  end
+
+  def self.adapter_name
+    "MySQL"
+  end
+
+  include DeadlockRetry
+end
+
+class DeadlockRetryTest < Test::Unit::TestCase
+  DEADLOCK_ERROR = "MySQL::Error: Deadlock found when trying to get lock"
+  TIMEOUT_ERROR = "MySQL::Error: Lock wait timeout exceeded"
+
+  def setup
+    MockModel.stubs(:exponential_pause)
+  end
+
+  def test_no_errors
+    assert_equal :success, MockModel.transaction { :success }
+  end
+
+  def test_no_errors_with_deadlock
+    errors = [ DEADLOCK_ERROR ] * 3
+    assert_equal :success, MockModel.transaction { raise ActiveRecord::StatementInvalid, errors.shift unless errors.empty?; :success }
+    assert errors.empty?
+  end
+
+  def test_no_errors_with_lock_timeout
+    errors = [ TIMEOUT_ERROR ] * 3
+    assert_equal :success, MockModel.transaction { raise ActiveRecord::StatementInvalid, errors.shift unless errors.empty?; :success }
+    assert errors.empty?
+  end
+
+  def test_error_if_limit_exceeded
+    assert_raise(ActiveRecord::StatementInvalid) do
+      MockModel.transaction { raise ActiveRecord::StatementInvalid, DEADLOCK_ERROR }
+    end
+  end
+
+  def test_error_if_unrecognized_error
+    assert_raise(ActiveRecord::StatementInvalid) do
+      MockModel.transaction { raise ActiveRecord::StatementInvalid, "Something else" }
+    end
+  end
+
+  def test_included_by_default
+    assert ActiveRecord::Base.respond_to?(:transaction_with_deadlock_handling)
+  end
+
+  def test_innodb_status_availability
+    DeadlockRetry.innodb_status_cmd = nil
+    MockModel.transaction {}
+    assert_equal "show innodb status", DeadlockRetry.innodb_status_cmd
+  end
+
+
+  def test_error_in_nested_transaction_should_retry_outermost_transaction
+    tries = 0
+    errors = 0
+
+    MockModel.transaction do
+      tries += 1
+      MockModel.transaction do
+        MockModel.transaction do
+          errors += 1
+          raise ActiveRecord::StatementInvalid, "MySQL::Error: Lock wait timeout exceeded" unless errors > 3
+        end
+      end
+    end
+
+    assert_equal 4, tries
+  end
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: deadlock_retry_insane
+version: !ruby/object:Gem::Version
+  version: 1.2.0
+  prerelease: 
+platform: ruby
+authors:
+- Jamis Buck
+- Mike Perham
+- Jason Coene
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: &70332997754400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70332997754400
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &70332997753680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: *70332997753680
+description: Provides automatic deadlock retry and logging functionality for ActiveRecord
+  and MySQL
+email: jcoene@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- CHANGELOG
+- Gemfile
+- LICENSE
+- README
+- Rakefile
+- deadlock_retry_insane.gemspec
+- lib/deadlock_retry.rb
+- lib/deadlock_retry/version.rb
+- test/deadlock_retry_test.rb
+homepage: http://github.com/jcoene/deadlock_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: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Provides automatic deadlock retry and logging functionality for ActiveRecord
+  and MySQL
+test_files:
+- test/deadlock_retry_test.rb