hutch-retry 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f1b47c78fb252a30d64de64be86b59c036554ddceb2a45b9b89d5e0fc76d8a58
+  data.tar.gz: ab438ad77125d26465b2d6d04026c03fd6ccc045a5156337923b8bc7e18089ad
+SHA512:
+  metadata.gz: 917bd4a35967e52376e254775ab4365e4a056e53eb7c8562f8ff8611cd5cf6326d18280ff472d7946657fee932c89c99bb531d1d0456ed69107b38e641aceea4
+  data.tar.gz: fd568586e828a2d3931e26397cf40e82cabd54977fed88a88c7c8947118c8da7de558a49ff5af5e1c955459514bd03e18815316e13ef3fb8562868dd9a4c03ac

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+## [Unreleased]
+
+## [0.1.0] - 2022-11-03
+
+- Initial release
+
+---
+
+## [0.2.0] - 2023-02-07
+
+### Changed
+
+- Set Hutch version to 1.2.0

data/Gemfile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in hutch-retry.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+group :test do
+  gem "rspec", "~> 3.0"
+  gem "timecop"
+end

data/Gemfile.lock

@@ -0,0 +1,67 @@
+PATH
+  remote: .
+  specs:
+    hutch-retry (0.2.0)
+      hutch (= 1.2.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (7.0.4.2)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+    amq-protocol (2.3.2)
+    bunny (2.20.3)
+      amq-protocol (~> 2.3, >= 2.3.1)
+      sorted_set (~> 1, >= 1.0.2)
+    carrot-top (0.0.7)
+      json
+    concurrent-ruby (1.2.0)
+    diff-lcs (1.5.0)
+    hutch (1.2.0)
+      activesupport (>= 4.2, < 8)
+      bunny (>= 2.19, < 3.0)
+      carrot-top (~> 0.0.7)
+      multi_json (~> 1.15)
+    i18n (1.12.0)
+      concurrent-ruby (~> 1.0)
+    json (2.6.3)
+    minitest (5.17.0)
+    multi_json (1.15.0)
+    rake (13.0.6)
+    rbtree (0.4.6)
+    rspec (3.12.0)
+      rspec-core (~> 3.12.0)
+      rspec-expectations (~> 3.12.0)
+      rspec-mocks (~> 3.12.0)
+    rspec-core (3.12.1)
+      rspec-support (~> 3.12.0)
+    rspec-expectations (3.12.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-mocks (3.12.3)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-support (3.12.0)
+    set (1.0.3)
+    sorted_set (1.0.3)
+      rbtree
+      set (~> 1.0)
+    timecop (0.9.6)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+
+PLATFORMS
+  arm64-darwin-21
+  x86_64-linux
+
+DEPENDENCIES
+  hutch-retry!
+  rake (~> 13.0)
+  rspec (~> 3.0)
+  timecop
+
+BUNDLED WITH
+   2.3.14

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Kahoot
+
+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,54 @@
+# Hutch retry
+
+Hutch-retry is an extension for [hutch](https://github.com/ruby-amqp/hutch) framework. It allows consumers to reprocess failed messages using an exponential backoff algorithm.
+
+## Requirements
+
+- `hutch 1.2.0` - this library uses monkey patch to add retry mechanism
+
+## Installation
+
+Install the gem and add it to the application's Gemfile by executing:
+
+    $ bundle add hutch-retry
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install hutch-retry
+
+## Usage
+
+To use hutch-retry replace `Hutch::Consumer` with `Hutch::Retry::Consumer` in your class.
+
+```ruby
+class ExampleConsumer
+  include Hutch::Retry::Consumer
+
+  consume "hutch.example"
+  max_retries 3
+  retry_on [TimeoutError]
+  retry_exchange_options name: "example.retry",
+                         durable: false
+end
+```
+
+| Option name                      | Default value      | Type    |
+|----------------------------------|--------------------|---------|
+| max_retries                      | 5                  | Integer |
+| retry_on                         | [StandardError]    | Array   |
+| retry_exchange_options[:name]    | <queue_name>.retry | String  |
+| retry_exchange_options[:durable] | true               | Boolean |
+
+## Development
+
+After checking out the repo, run `bundle install` to install dependencies. Then, run `rake spec` to run the tests.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/Motimate/hutch-retry.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/hutch-retry.gemspec

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require File.expand_path('../lib/hutch/retry/version', __FILE__)
+
+Gem::Specification.new do |spec|
+  spec.name = "hutch-retry"
+  spec.version = Hutch::Retry::VERSION
+  spec.authors = ["Michał Marcinkowski"]
+  spec.email = ["michal@marcinkowski.io"]
+
+  spec.summary = "Reprocess failed messages using an exponential backoff algorithm"
+  spec.description = "Reprocess failed messages using an exponential backoff algorithm"
+  spec.homepage = "https://www.github.com/Motimate/hutch-retry"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.6.0"
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "hutch", "1.2.0"
+end

data/lib/hutch/retry/consumer.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Hutch
+  module Retry
+    module Consumer
+      module ClassMethods
+        include Hutch::Logging
+
+        def max_retries(counter)
+          @max_retries = counter
+        end
+
+        def retry_on(array)
+          @retry_on = array
+        end
+
+        def get_max_retries
+          @max_retries || 5
+        end
+
+        def get_retry_on
+          @retry_on || [StandardError]
+        end
+
+        def exp_backoff(retry_count)
+          ((retry_count + 1)**4) + 30 + (retry_count + 2)
+        end
+
+        def retry_exchange_options(options = {})
+          @retry_exchange_options = options
+        end
+
+        def retry_exchange_name
+          (@retry_exchange_options || {}).fetch(:name, "#{get_queue_name}.retry")
+        end
+
+        def retry_exchange_durable?
+          (@retry_exchange_options || {}).fetch(:durable, true)
+        end
+        alias retry_query_durable? retry_exchange_durable?
+
+        def channel
+          @broker.channel
+        end
+
+        def retry_exchange
+          @retry_exchange ||= Hutch::Adapter.new_exchange(
+            channel,
+            "headers",
+            retry_exchange_name,
+            durable: retry_exchange_durable?
+          )
+        end
+
+        def create_retry_queues!(broker)
+          logger.info "setting up retry queues for #{retry_exchange_name} exchange"
+
+          @broker = broker
+
+          (0...get_max_retries)
+            .map(&method(:exp_backoff))
+            .each(&method(:create_retry_queue!))
+        end
+
+        def create_retry_queue!(delay)
+          channel.queue(
+            "#{retry_exchange_name}.#{delay}",
+            durable: retry_query_durable?,
+            arguments: {
+              "x-dead-letter-exchange": @broker.exchange.name,
+              "x-message-ttl": delay * 1_000
+            }
+          ).bind(retry_exchange, arguments: { "backoff-delay": delay, "x-match": "all" })
+        end
+      end
+
+      def self.included(base)
+        base.include(Hutch::Consumer)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/hutch/retry/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Hutch
+  module Retry
+    VERSION = "0.2.0"
+  end
+end

data/lib/hutch/retry/worker_extension.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Hutch
+  module Retry
+    module WorkerExtension
+      def setup_queue(consumer)
+        logger.info "setting up queue: #{consumer.get_queue_name}"
+
+        queue = @broker.queue(consumer.get_queue_name, consumer.get_options)
+        @broker.bind_queue(queue, consumer.routing_keys)
+
+        consumer.create_retry_queues!(@broker) if consumer.include?(Hutch::Retry::Consumer)
+
+        queue.subscribe(consumer_tag: unique_consumer_tag, manual_ack: true) do |*args|
+          delivery_info, properties, payload = Hutch::Adapter.decode_message(*args)
+          handle_message(consumer, delivery_info, properties, payload)
+        end
+      end
+
+      def handle_message(consumer, delivery_info, properties, payload)
+        serializer = consumer.get_serializer || Hutch::Config[:serializer]
+        logger.debug {
+          spec = serializer.binary? ? "#{payload.bytesize} bytes" : "#{payload}"
+          "message(#{properties.message_id || '-'}): " +
+          "routing key: #{delivery_info.routing_key}, " +
+          "consumer: #{consumer}, " +
+          "payload: #{spec}"
+        }
+
+        message = Message.new(delivery_info, properties, payload, serializer)
+        consumer_instance = consumer.new.tap { |c| c.broker, c.delivery_info = @broker, delivery_info }
+        with_tracing(consumer_instance).handle(message)
+        @broker.ack(delivery_info.delivery_tag) unless consumer_instance.message_rejected?
+      rescue => ex
+        if consumer.include?(Hutch::Retry::Consumer)
+          handle_retry(consumer, delivery_info, properties, payload, ex)
+        else
+          acknowledge_error(delivery_info, properties, @broker, ex)
+        end
+        handle_error(properties, payload, consumer, ex)
+      end
+
+      def handle_retry(consumer, delivery_info, properties, payload, ex)
+        case ex
+        when *consumer.get_retry_on
+          current_retry_count = (properties[:headers] || {}).fetch("backoff-delay-count", 0)
+
+          if current_retry_count < consumer.get_max_retries
+            logger.debug "Retry message_id=#{properties[:message_id]} counter=#{current_retry_count + 1}"
+
+            @broker.ack(delivery_info.delivery_tag)
+            consumer.retry_exchange.publish(
+              payload,
+              routing_key: delivery_info.routing_key,
+              message_id: properties[:message_id],
+              timestamp: Time.now.to_i,
+              headers: {
+                "backoff-delay": consumer.exp_backoff(current_retry_count),
+                "backoff-delay-count": current_retry_count + 1
+              }
+            )
+          else
+            logger.debug "Max retries exceeded message_id=#{properties[:message_id]}"
+
+            acknowledge_error(delivery_info, properties, @broker, ex)
+          end
+        else
+          acknowledge_error(delivery_info, properties, @broker, ex)
+        end
+      end
+    end
+  end
+
+  class Worker
+    prepend ::Hutch::Retry::WorkerExtension
+  end
+end

data/lib/hutch/retry.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "hutch"
+require_relative "retry/worker_extension"
+
+module Hutch
+  module Retry
+    autoload :Consumer, ::File.expand_path(::File.dirname(__FILE__)) + "/retry/consumer"
+    autoload :VERSION,  ::File.expand_path(::File.dirname(__FILE__)) + "/retry/version"
+  end
+end

data/lib/hutch-retry.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "hutch/retry"

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: hutch-retry
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Michał Marcinkowski
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2023-02-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: hutch
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+description: Reprocess failed messages using an exponential backoff algorithm
+email:
+- michal@marcinkowski.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- hutch-retry.gemspec
+- lib/hutch-retry.rb
+- lib/hutch/retry.rb
+- lib/hutch/retry/consumer.rb
+- lib/hutch/retry/version.rb
+- lib/hutch/retry/worker_extension.rb
+homepage: https://www.github.com/Motimate/hutch-retry
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: Reprocess failed messages using an exponential backoff algorithm
+test_files: []