sneakers_retry_handler 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9054e59d5824086b0d673bcc5107653a15851aa673e4d71acf810d37c871dd53
+  data.tar.gz: 25b8ce8110ff9e371bbbfd1aeed00f7d9fc8567ac297324e081da02c732b7225
+SHA512:
+  metadata.gz: 8496d96901358047ff1f29ad7354727ebdc7373cf97e84b6c760093f5f5e837ed03885513232ec6526b05134ac70b8f366c7eb6c96e64e7d8411521cd6d521ee
+  data.tar.gz: e0db7b566d7003932d05cf3aba339fb2cfb223258fb27cf9b1851c37be54b6893e10cee6bbb8a276476c7030069bf4fff167e48ec5eb91e5144ee2a7e7de5c21

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+*.rbc
+/.config
+/tmp/
+/log/
+build/

data/CHANGELOG.md

@@ -0,0 +1,4 @@
+0.1.0
+#  
+* Added basic functionality
+#

data/Gemfile

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+source 'http://rubygems.org'
+gemspec

data/Gemfile.lock

@@ -0,0 +1,56 @@
+PATH
+  remote: .
+  specs:
+    sneakers_retry_handler (0.1.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    amq-protocol (2.3.0)
+    bunny (2.14.3)
+      amq-protocol (~> 2.3, >= 2.3.0)
+    coderay (1.1.2)
+    concurrent-ruby (1.1.5)
+    diff-lcs (1.3)
+    json (2.2.0)
+    method_source (0.9.2)
+    pry (0.12.2)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    rake (13.0.1)
+    rspec (3.9.0)
+      rspec-core (~> 3.9.0)
+      rspec-expectations (~> 3.9.0)
+      rspec-mocks (~> 3.9.0)
+    rspec-core (3.9.0)
+      rspec-support (~> 3.9.0)
+    rspec-expectations (3.9.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-mocks (3.9.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-support (3.9.0)
+    serverengine (2.0.7)
+      sigdump (~> 0.2.2)
+    sigdump (0.2.4)
+    sneakers (2.11.0)
+      bunny (~> 2.12)
+      concurrent-ruby (~> 1.0)
+      rake
+      serverengine (~> 2.0.5)
+      thor
+    thor (0.20.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  json (~> 2.2)
+  pry (~> 0.12)
+  rspec (~> 3.9)
+  sneakers (~> 2.11)
+  sneakers_retry_handler!
+
+BUNDLED WITH
+   1.17.3

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Restaurant Cheetah
+
+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,59 @@
+## SneakersRetryHandler
+
+Run your worker with delayed retrying.
+Define `on_retry` and `on_error` callbacks.
+
+## Install
+
+```ruby
+gem install sneakers_retry_handler
+```
+## Usage of the `DelayedRetry`
+
+The `DelayedRetry` handler is an extension of the default `MaxRetry` handler.
+It will try to process the message specified number of times.
+When the maximum number of retries is reached it will put the message on an error queue.
+
+When defining your worker, you have to define these extra arguments:
+
+- `number_of_retries`: Specifies how many times to retry.
+
+- `sleep_before_retry`: Retrying delay.
+
+- `retriable_errors`: The list of errors. Puts the message on an error queue otherwise.
+
+- `x-dead-letter-exchange`: The name of the dead-letter exchange where failed messages will be published to.
+
+- `on_retry` and `on_error`: Callbacks.
+
+
+Here's an example:
+
+```diff
+class BusyWorker
+  include Sneakers::Worker
+
+  from_queue(
+    'busy_worker_queue',
++   exchange: 'retry_exchange',
++   exchange_type: :topic,
++   handler: Sneakers::Handlers::DelayedRetry,
++   arguments: {
++     'x-dead-letter-exchange': 'retry_exchange'
++   },
++   number_of_retries: 3,
++   sleep_before_retry: 2,
++   retriable_errors: [Faraday::TimeoutError],
++   on_retry: proc do |error, payload, tries|
++     /* put your logic here */
++   end,
++   on_error: proc do |error, payload, tries|
++     /* put your logic here */
++   end
+  )
+
+  def work(*args)
+    ack!
+  end
+end
+```

data/lib/sneakers/handlers/delayed_retry.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Sneakers
+  module Handlers
+    class DelayedRetry
+      def initialize(channel, queue, opts)
+        @worker_queue_name = queue.name
+        Sneakers.logger.debug do
+          "#{log_prefix} creating handler, opts=#{opts}"
+        end
+
+        @channel = channel
+        @opts = opts
+
+        error_exchange_name = @opts[:error_exchange_name] || 'error_exchange'
+        Sneakers.logger.debug do
+          "#{log_prefix} creating exchange=#{error_exchange_name}"
+        end
+        @error_exchange = @channel.exchange(
+          error_exchange_name,
+          type: 'direct',
+          durable: exchange_durable?
+        )
+
+        error_queue_name = @opts[:error_queue_name] || "error.#{@worker_queue_name}"
+        Sneakers.logger.debug do
+          "#{log_prefix} creating queue=#{error_queue_name}"
+        end
+        error_queue = @channel.queue(
+          error_queue_name,
+          durable: queue_durable?
+        )
+
+        error_queue.bind(@error_exchange, routing_key: @worker_queue_name)
+
+        @max_retries = @opts[:number_of_retries] || 5
+        @sleep_before_retry = @opts[:sleep_before_retry] || 0
+        @retriable_errors = @opts[:retriable_errors] || []
+        @on_retry = @opts[:on_retry] || proc {}
+        @on_error = @opts[:on_error] || proc {}
+      end
+
+      def acknowledge(hdr, _props, _msg)
+        @channel.acknowledge(hdr.delivery_tag, false)
+      end
+
+      def reject(hdr, props, msg, requeue = false)
+        if requeue
+          @channel.reject(hdr.delivery_tag, requeue)
+        else
+          handle_retry(hdr, props, msg, :reject)
+        end
+      end
+
+      def error(hdr, props, msg, err)
+        handle_retry(hdr, props, msg, err)
+      end
+
+      def noop(hdr, props, msg); end
+
+      private
+
+      def handle_retry(hdr, props, msg, reason)
+        num_attempts = failure_count(props[:headers]) + 1
+
+        if (num_attempts <= @max_retries) && retriable_on?(reason)
+          Sneakers.logger.info do
+            "#{log_prefix} msg=retrying, count=#{num_attempts}, headers=#{props[:headers]}"
+          end
+
+          sleep(@sleep_before_retry)
+
+          @on_retry.call(reason, msg, num_attempts)
+
+          @channel.reject(hdr.delivery_tag, false)
+        else
+          Sneakers.logger.info do
+            "#{log_prefix} msg=failing, retry_count=#{num_attempts}, reason=#{reason}"
+          end
+
+          @on_error.call(reason, msg, num_attempts)
+
+          error_data = {
+            error: reason.to_s,
+            num_attempts: num_attempts,
+            failed_at: Time.now.iso8601,
+            properties: props
+          }.tap do |hash|
+            if reason.is_a?(Exception)
+              hash[:error_class] = reason.class.to_s
+              hash[:error_message] = reason.to_s
+              if reason.backtrace
+                hash[:backtrace] = reason.backtrace.take(10).join(', ')
+              end
+            end
+          end
+
+          data =
+            begin
+              JSON.parse(msg).merge(error_data: error_data).to_json
+            rescue
+              error_data.merge(payload: msg).to_json
+            end
+
+          @error_exchange.publish(data, routing_key: hdr.routing_key)
+          @channel.acknowledge(hdr.delivery_tag, false)
+        end
+      end
+
+      def retriable_on?(exception)
+        @retriable_errors.map { |error_class| exception.is_a?(error_class) }.any?
+      end
+
+      def failure_count(headers)
+        if headers.nil? || headers['x-death'].nil?
+          0
+        else
+          x_death_array = headers['x-death'].select do |x_death|
+            x_death['queue'] == @worker_queue_name
+          end
+          if x_death_array.count > 0 && x_death_array.first['count']
+            x_death_array.inject(0) { |sum, x_death| sum + x_death['count'] }
+          else
+            x_death_array.count
+          end
+        end
+      end
+
+      def log_prefix
+        "DelayedRetry handler [queue=#{@worker_queue_name}]"
+      end
+
+      def queue_durable?
+        @opts.fetch(:queue_options, {}).fetch(:durable, false)
+      end
+
+      def exchange_durable?
+        queue_durable?
+      end
+    end
+  end
+end

data/lib/sneakers_retry_handler.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative 'sneakers/handlers/delayed_retry'
+
+module SneakersRetryHandler
+  VERSION = '0.1.0'
+end

data/sneakers_retry_handler.gemspec

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require File.expand_path('../lib/sneakers_retry_handler', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = 'sneakers_retry_handler'
+  s.version     = SneakersRetryHandler::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.licenses    = %w[MIT]
+  s.authors     = ['Ivan Bondarenko', 'Alex Stepanenko']
+  s.email       = ['bondarenko.dev@gmail.com', 'stepanenko.aleksander@gmail.com']
+  s.summary     = 'Sneakers handler with delayed retrying'
+  s.description = 'Retries in specified time interval. Supports `on_retry` and `on_error` callbacks'
+  s.homepage = 'https://github.com/restaurant-cheetah/sneakers_retry_handler'
+
+  s.add_development_dependency 'json', '~> 2.2'
+  s.add_development_dependency 'pry', '~> 0.12'
+  s.add_development_dependency 'rspec', '~> 3.9'
+  s.add_development_dependency 'sneakers', '~> 2.11'
+
+  all_files  = `git ls-files`.split("\n")
+  test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+
+  s.files         = all_files - test_files
+  s.test_files    = test_files
+  s.require_paths = %w[lib]
+end

data/spec/sneakers/handlers/delayed_retry_spec.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Sneakers::Handlers::DelayedRetry do
+  describe 'as handler of the worker' do
+    class HandledError < StandardError; end
+    class UnhandledError < StandardError; end
+
+    class BusyWorker
+      include Sneakers::Worker
+
+      def work(msg)
+        perform(msg)
+
+        ack!
+      end
+
+      private
+
+      def perform(msg); end
+    end
+
+    Sneakers.configure(daemonize: true, log: 'log/test.log')
+    Sneakers::Worker.configure_logger(Logger.new('/dev/null'))
+    Sneakers::Worker.configure_metrics
+
+    let(:handler) { described_class.new(channel, queue, opts) }
+
+    let(:channel) do
+      double(:channel, exchange: error_exchange, queue: queue, acknowledge: 'ack', reject: 'reject')
+    end
+
+    let(:queue) { double(:queue, name: 'queue_name', bind: nil, opts: {}) }
+    let(:error_exchange) { double(:error_exchange, publish: 'publish') }
+    let(:delivery_info) do
+      double(:delivery_info, routing_key: 'routing.key', delivery_tag: 'delivery.tag', reject: {}, each: [])
+    end
+    let(:metadata) { { headers: { retry_info: {}.to_json } } }
+    let(:test_pool) { Concurrent::ImmediateExecutor }
+    let(:msg) { { key: :value }.to_json }
+    let(:opts) { { on_retry: on_retry_cb, on_error: on_error_cb } }
+    let(:on_retry_cb) { proc {} }
+    let(:on_error_cb) { proc {} }
+
+    subject do
+      BusyWorker.new(
+        queue,
+        test_pool.new
+      ).do_work(
+        delivery_info,
+        metadata,
+        msg,
+        handler
+      )
+    end
+
+    context 'without errors' do
+      before do
+        allow_any_instance_of(BusyWorker).to receive(:perform).with(msg).and_return(msg)
+      end
+
+      it 'calls acknowledge' do
+        expect(handler).to receive(:acknowledge).once
+        subject
+      end
+    end
+
+    context 'with an unhandlen error' do
+      before do
+        allow_any_instance_of(BusyWorker).to receive(:perform).with(msg).and_raise(UnhandledError)
+      end
+
+      it 'calls handle_retry method' do
+        expect(handler).to receive(:error).once
+        subject
+      end
+
+      it 'calls on_error callback' do
+        expect(on_error_cb).to receive(:call).once
+        subject
+      end
+    end
+
+    context 'with a handled error' do
+      let(:opts) { super().merge(retriable_errors: [HandledError]) }
+
+      before do
+        allow_any_instance_of(BusyWorker).to receive(:perform).with(msg).and_raise(HandledError)
+      end
+
+      it 'calls handle_retry method' do
+        expect(handler).to receive(:error).once
+        subject
+      end
+
+      it 'calls on_retry_cb callback' do
+        expect(on_retry_cb).to receive(:call).once
+        subject
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'sneakers'
+require 'json'
+require_relative '../lib/sneakers/handlers/delayed_retry'

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: sneakers_retry_handler
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ivan Bondarenko
+- Alex Stepanenko
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-11-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+- !ruby/object:Gem::Dependency
+  name: sneakers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.11'
+description: Retries in specified time interval. Supports `on_retry` and `on_error`
+  callbacks
+email:
+- bondarenko.dev@gmail.com
+- stepanenko.aleksander@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- lib/sneakers/handlers/delayed_retry.rb
+- lib/sneakers_retry_handler.rb
+- sneakers_retry_handler.gemspec
+- spec/sneakers/handlers/delayed_retry_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/restaurant-cheetah/sneakers_retry_handler
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.6
+signing_key: 
+specification_version: 4
+summary: Sneakers handler with delayed retrying
+test_files:
+- spec/sneakers/handlers/delayed_retry_spec.rb
+- spec/spec_helper.rb