sneakers_exponential_retry 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: af906d8bafee5024ee77370c828d92a22628ecdc
-  data.tar.gz: 20a9007c85f5317d311f65a9a4f7a4988aebe6ae
+  metadata.gz: 383c16547be12323af1e50d4a68895cf6b9b0468
+  data.tar.gz: 4791aa18b3aa580856516226dc6bf5f440e281d3
 SHA512:
-  metadata.gz: a6df19505aeff4c55d4c13d32686543da6ad73a4ee4b2fe2ac7de38eb44c911c8b2becf996acbc01e31ac6734b3c98a4a43b184bfe1ab2b5d00d020cb7b5a9c0
-  data.tar.gz: f6ec2b59258761e81d0ca4f378762aa6129f278fcde47204ddd0b07c132dc4ae74ac1466730f0bd223dfec7752ae5c691fade4e74444bc9ab7a52c9fe4916037
+  metadata.gz: f33ce2504df5dc2bf284dbb38aa45a9605f5146e95915439ecb91f4eaac3315303da7ef6692e6cd7ad13bdc28963569bae827f295a63f3c99269eb5f818c7ab0
+  data.tar.gz: d8597d129e0a9bb472dec754f6181f1a13956204444dc3c7df3b0cf58941fbb404a349cc5b76b947a1680ebc1058a7474d345b8d31d9d4b5ad441adbec7bdbd3

data/README.md

@@ -2,22 +2,6 @@
 
 Exponential Retry Handler for [Sneakers](https://github.com/jondot/sneakers) that just works.
 
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'sneakers_exponential_retry'
-```
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install sneakers_exponential_retry
-
 ## Usage
 
 Configure your Sneakers by the following:
@@ -25,7 +9,7 @@ Configure your Sneakers by the following:
 ```ruby
 require 'sneakers_exponential_retry'
 
-Sneakers.configure :handler => SneakersExponentialRetry,
+Sneakers.configure :handler => SneakersExponentialRetry::Handler,
                    :handler_options => {
                      :max_retry_count => 3,
                      :logger => Sneakers.logger
@@ -41,9 +25,44 @@ Sneakers.configure :handler => SneakersExponentialRetry,
   - `max_retry_count`: (optional) Max retry count, default to 14
   - `logger`: (optional) logger instance, default to nil, which would not log anything related to retrying.
 
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'sneakers_exponential_retry'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sneakers_exponential_retry
+
+
 ## How it works:
 
-TODO
+(`SneakersExponentialRetry` is inspired by [this blogpost](https://gagnechris.wordpress.com/2015/09/19/easy-retries-with-rabbitmq/))
+
+`SneakersExponentialRetry` handles the behavior of retrying failed jobs exponentially by:
+
+1. On initializing:
+  - Create a retry exchange, which is named as `#{queue_name}-retry-ex`
+  - Create a retry queue, which is named as `#{queue_name}-retry-queue`
+    - Set the `x-dead-letter-exchange` of retry queue to the original job exchange
+  - Bind the retry queue to the retry exchange
+
+2. Whenever a job fails, `SneakersExponentialRetry` would:
+  - if retry count <= `max_retry_count`
+    - publish the job to retry exchange, with an exponential expiration timeout
+    - the retry exchange would push the job into our retry queue
+    - after the timeout, the job would be published back to the `dead-letter-exchange` of the retry queue, which is our original exchange, so that the job would be retried
+
+  - if retry count > `max_retry_count`
+    - reject the job
 
 ## Testing:
 

data/lib/sneakers_exponential_retry.rb

@@ -1,97 +1,100 @@
 require "sneakers_exponential_retry/version"
 
-class ExponentialRetry
-  MINUTE = 60 * 1000
-  DEFAULT_MAX_RETRY_COUNT = 14
-
-  def initialize(channel, queue, opts)
-    @channel = channel
-    @max_retry_count = calculate_max_retry_count(opts)
-    @retry_exchange = create_retry_exchange(queue.name)
-    @logger = opts[:handler_options] ? opts[:handler_options][:logger] : nil
-
-    create_retry_queue(queue.name, opts[:exchange])
-      .bind(@retry_exchange, :routing_key => '#')
-  end
-
-  def calculate_max_retry_count opts
-    handler_options = opts[:handler_options] || {}
-    ( handler_options[:max_retry_count] || DEFAULT_MAX_RETRY_COUNT ).to_i
-  end
-  private :calculate_max_retry_count
-
-  def create_retry_exchange queue_name
-    @channel.exchange("#{queue_name}-retry-ex",
-                      :type => 'topic',
-                      :durable => true)
-  end
-  private :create_retry_exchange
-
-  def create_retry_queue queue_name, exchange_name
-    @channel.queue(
-      "#{queue_name}-retry-queue",
-      durable: true,
-      arguments: {
-        :'x-dead-letter-exchange' => exchange_name
-      }
-    )
-  end
-  private :create_retry_queue
+module SneakersExponentialRetry
+  class Handler
+    MINUTE = 60 * 1000
+    DEFAULT_MAX_RETRY_COUNT = 14
+
+    def initialize(channel, queue, opts)
+      @channel = channel
+      @max_retry_count = calculate_max_retry_count(opts)
+      @retry_exchange = create_retry_exchange(queue.name)
+      @logger = opts[:handler_options] ? opts[:handler_options][:logger] : nil
+
+      create_retry_queue(queue.name, opts[:exchange])
+        .bind(@retry_exchange, :routing_key => '#')
+    end
 
-  def acknowledge(hdr, props, msg)
-    @channel.acknowledge(hdr.delivery_tag, false)
-  end
+    def calculate_max_retry_count opts
+      handler_options = opts[:handler_options] || {}
+      ( handler_options[:max_retry_count] || DEFAULT_MAX_RETRY_COUNT ).to_i
+    end
+    private :calculate_max_retry_count
 
-  def reject(hdr, props, msg, requeue=false)
-    @channel.reject(hdr.delivery_tag, requeue)
-  end
+    def create_retry_exchange queue_name
+      @channel.exchange("#{queue_name}-retry-ex",
+                        :type => 'topic',
+                        :durable => true)
+    end
+    private :create_retry_exchange
+
+    def create_retry_queue queue_name, exchange_name
+      @channel.queue(
+        "#{queue_name}-retry-queue",
+        durable: true,
+        arguments: {
+          :'x-dead-letter-exchange' => exchange_name
+        }
+      )
+    end
+    private :create_retry_queue
 
-  def error(hdr, props, msg, err)
-    handle_failing_message(hdr, props, msg, err)
-  end
+    def acknowledge(hdr, props, msg)
+      @channel.acknowledge(hdr.delivery_tag, false)
+    end
 
-  def handle_failing_message hdr, props, msg, error
-    retry_count = get_retry_count(props[:headers])
-    if retry_count >= @max_retry_count
-      reject(hdr, props, msg)
-      return
+    def reject(hdr, props, msg, requeue=false)
+      @channel.reject(hdr.delivery_tag, requeue)
     end
 
+    def error(hdr, props, msg, err)
+      handle_failing_message(hdr, props, msg, err)
+    end
 
-    @retry_exchange.publish(msg,
-                            :headers => {
-                              'retry-count' => retry_count + 1
-                            },
-                            :routing_key => hdr.routing_key,
-                            :expiration => expiration_time(retry_count))
-    log_retry(retry_count)
-    acknowledge(hdr, props, msg)
-  end
-  private :handle_failing_message
+    def handle_failing_message hdr, props, msg, error
+      retry_count = get_retry_count(props[:headers])
+      if retry_count >= @max_retry_count
+        reject(hdr, props, msg)
+        return
+      end
+
+
+      @retry_exchange.publish(msg,
+                              :headers => {
+                                'retry-count' => retry_count + 1
+                              },
+                              :routing_key => hdr.routing_key,
+                              :expiration => expiration_time(retry_count))
+      log_retry(retry_count)
+      acknowledge(hdr, props, msg)
+    end
+    private :handle_failing_message
 
-  def log_retry count
-    return unless @logger
-    @logger.info do
-      "retry_count: #{count + 1}"
+    def log_retry count
+      return unless @logger
+      @logger.info do
+        "retry_count: #{count + 1}"
+      end
     end
-  end
-  private :log_retry
+    private :log_retry
 
-  def get_retry_count headers
-    return 0 unless headers
-    headers['retry-count'].to_i
-  end
-  private :get_retry_count
+    def get_retry_count headers
+      return 0 unless headers
+      headers['retry-count'].to_i
+    end
+    private :get_retry_count
 
-  def expiration_time retry_count
-    (2 ** retry_count) * MINUTE
-  end
-  private :expiration_time
+    def expiration_time retry_count
+      (2 ** retry_count) * MINUTE
+    end
+    private :expiration_time
 
-  def timeout(hdr, props, msg)
-    reject(hdr, props, msg)
-  end
+    def timeout(hdr, props, msg)
+      reject(hdr, props, msg)
+    end
 
-  def noop(hdr, props, msg)
+    def noop(hdr, props, msg)
+    end
   end
 end
+

data/lib/sneakers_exponential_retry/version.rb

@@ -1,3 +1,3 @@
 module SneakersExponentialRetry
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sneakers_exponential_retry
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Yang-Hsing Lin
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-08-18 00:00:00.000000000 Z
+date: 2016-09-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler