retriable 2.0.0.beta3 → 2.0.0.beta4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e3b8d447babc7584997f6e2756375d2d48d3b4dc
-  data.tar.gz: 3c14a6becbd1708ee8dc4f2cb83c10fb74489141
+  metadata.gz: 6fb94b8f9e411a4f0939d03f213928e28e002375
+  data.tar.gz: 703fe21cb7abce08770c7cd5d308099233e8c614
 SHA512:
-  metadata.gz: f04b74b90611da941a4bf425ef06383aa9140043d8b32bebec64fab29d2445db0819be5c1a40e135dee0ff0289c5c56a7061793fd46b1a307bcfc6ade287e5d7
-  data.tar.gz: 18282a856bb96a2dd2b32a564ab2093c3620c09a38f95fdc58054084e4410626ecf18daf2a8f275a81d7893d02b0cac06e0a3cba8f818d90c3388866ff62dbc6
+  metadata.gz: d5ed763d75076b92d366854009dd0a0a2df4eeafa184a664c13ba3a01d74968274bff2a61d9a66d201d3c0ad3d913c6e4caf4c75761ba74de447f6aa9eed3d86
+  data.tar.gz: 06b33e84de325d990cf32790460dfc30dc5eb765db574c344fa64762463ad668ec47d23db41646f748fdb8d658fd3feff069cfac0f748c7ddf238a84479a188b

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 2.0.0.beta4
+* Change #retry back to #retriable. Didn't like the idea of defining a method that is also a reserved word.
+* Add ability for `:on` argument to accept a `Hash` where the keys are exception types and the values are a single or list of `Regexp` pattern(s) to match against exception messages for retrial.
+
 ## 2.0.0.beta3
 * Accept `intervals` array argument to provide your own custom intervals.
 * Refactor the exponential backoff code into it's own class.

data/README.md

@@ -2,7 +2,7 @@
 
 [![Build Status](https://secure.travis-ci.org/kamui/retriable.png)](http://travis-ci.org/kamui/retriable)
 
-Retriable is an simple DSL to retry failed code blocks with randomized [exponential backoff](http://en.wikipedia.org/wiki/Exponential_backoff). This is especially useful when interacting external api/services or file system calls.
+Retriable is an simple DSL to retry failed code blocks with randomized [exponential backoff](http://en.wikipedia.org/wiki/Exponential_backoff) time intervals. This is especially useful when interacting external api/services or file system calls.
 
 ## Requirements
 
@@ -34,7 +34,7 @@ gem 'retriable'
 
 ## Usage
 
-Code in a `Retriable.retry` block will be retried if an exception is raised. By default, Retriable will rescue any exception inherited from `StandardError`, make 3 retry attempts before raising the last exception, and also use randomized exponential backoff to calculate each succeeding attempt interval. The default interval table with 10 attempts looks like this (in seconds):
+Code in a `Retriable.retriable` block will be retried if an exception is raised. By default, Retriable will rescue any exception inherited from `StandardError`, make 3 retry attempts before raising the last exception, and also use randomized exponential backoff to calculate each succeeding attempt interval. The default interval table with 10 attempts looks like this (in seconds):
 
 | request# | retry interval | randomized interval |
 | -------- | -------------- | ------------------- |
@@ -55,7 +55,7 @@ require 'retriable'
 class Api
   # Use it in methods that interact with unreliable services
   def get
-    Retriable.retry do
+    Retriable.retriable do
       # code here...
     end
   end
@@ -80,15 +80,15 @@ randomized_interval = retry_interval * (random value in range [1 - randomization
 
 `multiplier` (default: 1.5) - Each successive interval grows by this factor. A multipler of 1.5 means the next interval will be 1.5x the current interval.
 
-`max_elapsed_time`  (default: 900 (15 min)) - The maximum amount of total time that code is allowed to keep being retried
+`max_elapsed_time`  (default: 900 (15 min)) - The maximum amount of total time that code is allowed to keep being retried.
 
 `intervals`  (default: nil) - Skip generated intervals and provide your own array of intervals in seconds. Setting this option will ignore `max_tries`, `base_interval`, `max_interval`, `rand_factor`, and `multiplier` values.
 
 `timeout` (default: 0) - Number of seconds to allow the code block to run before raising a Timeout::Error
 
-`on` (default: [StandardError]) - An array of exceptions to rescue for each attempt, also accepts a single Exception type
+`on` (default: [StandardError]) - An `Array` of exceptions to rescue for each attempt, a `Hash` where the keys are `Exception` classes and the values can be a single `Regexp` pattern or a list of patterns, or a single `Exception` type.
 
-`on_retry` - (default: nil) - Proc to call after each attempt is rescued
+`on_retry` - (default: nil) - Proc to call after each attempt is rescued.
 
 ### Config
 
@@ -103,10 +103,10 @@ end
 
 ### Examples
 
-`Retriable.retry` accepts custom arguments. This example will only retry on a `Timeout::Error`, retry 3 times and sleep for a full second before each attempt.
+`Retriable.retriable` accepts custom arguments. This example will only retry on a `Timeout::Error`, retry 3 times and sleep for a full second before each attempt.
 
 ```ruby
-Retriable.retry on: Timeout::Error, max_tries: 3, base_interval: 1 do
+Retriable.retriable on: Timeout::Error, max_tries: 3, base_interval: 1 do
   # code here...
 end
 ```
@@ -114,7 +114,19 @@ end
 You can also specify multiple errors to retry on by passing an array of exceptions.
 
 ```ruby
-Retriable.retry on: [Timeout::Error, Errno::ECONNRESET] do
+Retriable.retriable on: [Timeout::Error, Errno::ECONNRESET] do
+  # code here...
+end
+```
+
+You can also specify a Hash of exceptions where the values are a list or single Regexp pattern.
+
+```ruby
+Retriable.retriable on: {
+  ActiveRecord::RecordNotUnique => nil,
+  ActiveRecord::RecordInvalid => [/Email has already been taken/, /Username has already been taken/],
+  Mysql2::Error => /Duplicate entry/
+} do
   # code here...
 end
 ```
@@ -122,7 +134,7 @@ end
 You can also specify a timeout if you want the code block to only make an attempt for X amount of seconds. This timeout is per attempt.
 
 ```ruby
-Retriable.retry timeout: 60 do
+Retriable.retriable timeout: 60 do
   # code here...
 end
 ```
@@ -130,7 +142,7 @@ end
 If you need millisecond units of time for the sleep or the timeout:
 
 ```ruby
-Retriable.retry base_interval: (200/1000.0), timeout: (500/1000.0) do
+Retriable.retriable base_interval: (200/1000.0), timeout: (500/1000.0) do
   # code here...
 end
 ```
@@ -140,7 +152,7 @@ end
 You can also bypass the built-in interval generation and provide your own array of intervals. Supplying your own intervals overrides the `max_tries`, `base_interval`, `max_interval`, `rand_factor`, and `multiplier` parameters.
 
 ```ruby
-Retriable.retry intervals: [0.5, 1.0, 2.0, 2.5] do
+Retriable.retriable intervals: [0.5, 1.0, 2.0, 2.5] do
   # code here...
 end
 ```
@@ -150,7 +162,7 @@ end
 Exponential backoff is enabled by default, if you want to simply execute code every second, you can do this:
 
 ```ruby
-Retriable.retry base_interval: 1.0, multiplier: 1.0, rand_factor: 0.0 do
+Retriable.retriable base_interval: 1.0, multiplier: 1.0, rand_factor: 0.0 do
   # code here...
 end
 ```
@@ -158,21 +170,21 @@ end
 If you don't want exponential backoff, but you still want some randomization between intervals, this code will run every 1 seconds with a randomization factor of 0.2, which means each interval will be a random value between 0.8 and 1.2 (1 second +/- 0.2):
 
 ```ruby
-Retriable.retry base_interval: 1.0, multiplier: 1.0, rand_factor: 0.2 do
+Retriable.retriable base_interval: 1.0, multiplier: 1.0, rand_factor: 0.2 do
   # code here...
 end
 ```
 
 ### Callbacks
 
-Retriable.retry also provides a callback called `:on_retry` that will run after an exception is rescued. This callback provides the `exception` that was raised in the current attempt, the `try_number`, the `elapsed_time` for all attempts so far, and the time in seconds of the `next_interval`. As these are specified in a `Proc`, unnecessary variables can be left out of the parameter list.
+`#retriable` also provides a callback called `:on_retry` that will run after an exception is rescued. This callback provides the `exception` that was raised in the current attempt, the `try_number`, the `elapsed_time` for all attempts so far, and the time in seconds of the `next_interval`. As these are specified in a `Proc`, unnecessary variables can be left out of the parameter list.
 
 ```ruby
 do_this_on_each_retry = Proc.new do |exception, try_number, elapsed_time, next_interval|
   log "#{exception.class}: '#{exception.message}' - #{try_number} attempts in #{elapsed_time} seconds and #{next_interval} seconds until the next attempt."}
 end
 
-Retriable.retry on_retry: do_this_on_each_retry do
+Retriable.retriable on_retry: do_this_on_each_retry do
   # code here...
 end
 ```
@@ -183,7 +195,7 @@ What if I want to execute a code block at the end, whether or not an exception w
 
 ```ruby
 begin
-  Retriable.retry do
+  Retriable.retriable do
     # some code
   end
 rescue => e
@@ -197,7 +209,7 @@ end
 
 ## Kernel Extension
 
-If you want to call `Retriable.retry` without the `Retriable` module prefix and you don't mind extending `Kernel`,
+If you want to call `Retriable.retriable` without the `Retriable` module prefix and you don't mind extending `Kernel`,
 there is a kernel extension available for this.
 
 In your ruby script:

data/lib/retriable/core_ext/kernel.rb

@@ -2,6 +2,6 @@ require "retriable"
 
 module Kernel
   def retriable(opts={}, &block)
-    Retriable.retry(opts, &block)
+    Retriable.retriable(opts, &block)
   end
 end

data/lib/retriable/version.rb

@@ -1,3 +1,3 @@
 module Retriable
-  VERSION = "2.0.0.beta3"
+  VERSION = "2.0.0.beta4"
 end

data/lib/retriable.rb

@@ -16,7 +16,7 @@ module Retriable
     @config ||= Config.new
   end
 
-  def retry(
+  def retriable(
     max_tries:         config.max_tries,
     base_interval:     config.base_interval,
     max_interval:      config.max_interval,
@@ -26,35 +26,49 @@ module Retriable
     intervals:         config.intervals,
     timeout:           config.timeout,
     on:                config.on,
-    on_retry:          config.on_retry,
-    &block
+    on_retry:          config.on_retry
     )
 
-    raise LocalJumpError unless block_given?
-
     start_time = Time.now
     elapsed_time = -> { Time.now - start_time }
 
-    max_tries = intervals.size if intervals
-    intervals ||= ExponentialBackoff.new(
-      max_tries: max_tries,
-      base_interval: base_interval,
-      multiplier: multiplier,
-      max_interval: max_interval,
-      rand_factor: rand_factor
-    ).intervals
+    if intervals
+      max_tries = intervals.size
+    else
+      intervals = ExponentialBackoff.new(
+        max_tries: max_tries,
+        base_interval: base_interval,
+        multiplier: multiplier,
+        max_interval: max_interval,
+        rand_factor: rand_factor
+      ).intervals
+    end
+
+    exception_list = on.kind_of?(Hash) ? on.keys : on
 
     intervals.each.with_index(1) do |interval, attempt|
       begin
         if timeout
-          Timeout::timeout(timeout) { return block.call(attempt) }
+          Timeout::timeout(timeout) { return yield(attempt) }
         else
-          return block.call(attempt)
+          return yield(attempt)
         end
-      rescue *[*on] => exception
-        on_retry.call(exception, attempt, Time.now - start_time, interval) if on_retry
+      rescue *[*exception_list] => exception
+        if on.kind_of?(Hash)
+          patterns = [*on[exception.class]]
+          message_match = patterns.empty? ? true : false
+          patterns.each do |pattern|
+            if !!(exception.message =~ pattern)
+              message_match = true
+              break
+            end
+          end
+          raise unless message_match
+        end
+
+        on_retry.call(exception, attempt, elapsed_time.call, interval) if on_retry
         raise if attempt >= max_tries || (elapsed_time.call + interval) > max_elapsed_time
-        sleep interval if interval > 0 && config.sleep_disabled != true
+        sleep interval if config.sleep_disabled != true
       end
     end
   end

data/spec/retriable_spec.rb

@@ -16,24 +16,28 @@ describe Retriable do
 
     it "stops at first attempt if the block does not raise an exception" do
       attempts = 0
-      subject.retry do
+      subject.retriable do
         attempts += 1
       end
 
       attempts.must_equal 1
     end
 
-    it "raises a LocalJumpError if retry is not given a block" do
+    it "raises a LocalJumpError if #retriable is not given a block" do
       -> do
-        subject.retry on: EOFError
+        subject.retriable on: EOFError
+      end.must_raise LocalJumpError
+
+      -> do
+        subject.retriable on: EOFError, timeout: 2
       end.must_raise LocalJumpError
     end
 
-    describe "retry block of code raising EOFError with no arguments" do
+    describe "#retriable block of code raising EOFError with no arguments" do
       before do
         @attempts = 0
 
-        subject.retry do
+        subject.retriable do
           @attempts += 1
           raise EOFError.new if @attempts < 3
         end
@@ -44,18 +48,18 @@ describe Retriable do
       end
     end
 
-    it "retry on custom exception and re-raises the exception" do
+    it "#retriable on custom exception and re-raises the exception" do
       -> do
-        subject.retry on: TestError do
+        subject.retriable on: TestError do
           raise TestError.new
         end
       end.must_raise TestError
     end
 
-    it "retry with 10 max tries" do
+    it "#retriable with 10 max tries" do
       attempts = 0
 
-      subject.retry(
+      subject.retriable(
         max_tries: 10
       ) do
           attempts += 1
@@ -65,9 +69,9 @@ describe Retriable do
       attempts.must_equal 10
     end
 
-    it "retry will timeout after 1 second" do
+    it "#retriable will timeout after 1 second" do
       -> do
-        subject.retry timeout: 1 do
+        subject.retriable timeout: 1 do
           sleep 2
         end
       end.must_raise Timeout::Error
@@ -83,7 +87,7 @@ describe Retriable do
       end
 
       -> do
-        Retriable.retry(
+        Retriable.retriable(
           on: [EOFError, ArgumentError],
           on_retry: handler,
           rand_factor: 0.0,
@@ -105,7 +109,7 @@ describe Retriable do
       @time_table[9].between?(6.403, 19.210).must_equal true
     end
 
-    describe "retries with an on_retry handler, 6 max retries, and a 0.0 rand_factor" do
+    describe "retries with an on_#retriable handler, 6 max retries, and a 0.0 rand_factor" do
       before do
         max_tries = 6
         @attempts = 0
@@ -116,7 +120,7 @@ describe Retriable do
           @time_table[attempt] = next_interval
         end
 
-        Retriable.retry(
+        Retriable.retriable(
           on: [EOFError, ArgumentError],
           on_retry: handler,
           rand_factor: 0.0,
@@ -142,7 +146,7 @@ describe Retriable do
       end
     end
 
-    it "retry has a max interval of 1.5 seconds" do
+    it "#retriable has a max interval of 1.5 seconds" do
       max_tries = 6
       attempts = 0
       time_table = {}
@@ -151,7 +155,7 @@ describe Retriable do
         time_table[attempt] = next_interval
       end
 
-      subject.retry(
+      subject.retriable(
         on: EOFError,
         on_retry: handler,
         rand_factor: 0.0,
@@ -171,7 +175,7 @@ describe Retriable do
       })
     end
 
-    it "retries with defined intervals" do
+    it "#retriable with defined intervals" do
       intervals = [
         0.5,
         0.75,
@@ -186,7 +190,7 @@ describe Retriable do
       end
 
       -> do
-        subject.retry(
+        subject.retriable(
           on: EOFError,
           on_retry: handler,
           intervals: intervals
@@ -204,7 +208,48 @@ describe Retriable do
       })
     end
 
-    it "can call #retriable in the global" do
+    it "#retriable with a hash exception where the value is an exception message pattern" do
+      e = -> do
+        subject.retriable on: { TestError => /something went wrong/ } do
+          raise TestError.new('something went wrong')
+        end
+      end.must_raise TestError
+
+      e.message.must_equal "something went wrong"
+    end
+
+    it "#retriable with a hash exception list where the values are exception message patterns" do
+      attempts = 0
+      tries = []
+      handler = ->(exception, attempt, elapsed_time, next_interval) do
+        tries[attempt] = exception
+      end
+
+      e = -> do
+        subject.retriable max_tries: 4, on: { EOFError => nil, TestError => [/foo/, /bar/] }, on_retry: handler do
+          attempts += 1
+          case attempts
+          when 1
+            raise TestError.new('foo')
+          when 2
+            raise TestError.new('bar')
+          when 3
+            raise EOFError.new
+          else
+            raise TestError.new('crash')
+          end
+        end
+      end.must_raise TestError
+
+      e.message.must_equal "crash"
+      tries[1].class.must_equal TestError
+      tries[1].message.must_equal "foo"
+      tries[2].class.must_equal TestError
+      tries[2].message.must_equal "bar"
+      tries[3].class.must_equal EOFError
+    end
+
+    it "#retriable can be called in the global scope" do
       -> do
         retriable do
           puts "should raise NoMethodError"
@@ -213,16 +258,16 @@ describe Retriable do
 
       require_relative "../lib/retriable/core_ext/kernel"
 
-      i = 0
+      attempts = 0
       retriable do
-        i += 1
-        raise EOFError.new if i < 3
+        attempts += 1
+        raise EOFError.new if attempts < 3
       end
-      i.must_equal 3
+      attempts.must_equal 3
     end
   end
 
-  it "retry runs for a max elapsed time of 2 seconds" do
+  it "#retriable runs for a max elapsed time of 2 seconds" do
     subject.configure do |c|
       c.sleep_disabled = false
     end
@@ -237,7 +282,7 @@ describe Retriable do
     end
 
     -> do
-      subject.retry(
+      subject.retriable(
         base_interval: 1.0,
         multiplier: 1.0,
         rand_factor: 0.0,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: retriable
 version: !ruby/object:Gem::Version
-  version: 2.0.0.beta3
+  version: 2.0.0.beta4
 platform: ruby
 authors:
 - Jack Chu
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-05 00:00:00.000000000 Z
+date: 2014-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake