rt-tackle 1.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: de0f2580c2937c203f50d01d0a8e7a66c8ad4cbe
-  data.tar.gz: 249a5fabc8c8dc812a69d8541ae3ab7c8e046d3e
+  metadata.gz: 2b957a205e2dd52731c5a94cd871aa56e2f6a3e8
+  data.tar.gz: 2457adef2b1e810c72a5eee49706ce9ea5b5d483
 SHA512:
-  metadata.gz: 784cb5cfec47ace9f60d6ddabdb5b7d117f31e76cba8c38b6960b318ca73cca851ec39f5d84c16f64df9485db5b63b24db467c83f89e155e80aab007a8712b3b
-  data.tar.gz: 099fac7e24bc267a4c6556e1706c46fde7d823a007215b66e5842d077add917b48d8830d2b75aa50d0efb69a946b31fa1a7e11bdc765db90e3f3a7b5ac40ddc8
+  metadata.gz: bf96bfc2e3acde0a9b3351c602136322063e44344ecb01e46fd2d9e5732508db36807eb562dc79232b767ee40a406d87779f6c30bd73d439fb4d63cfaa859917
+  data.tar.gz: 88220350832e5214e7120089828ebb4d174b420247e89a29b8b5c0a2c092d353036ec6de66899511951dc9b21d5bd4eeb3f13b7a31766c87953e404f20bd6a90

data/README.md

@@ -5,6 +5,15 @@
 Tackles the problem of processing asynchronous jobs in reliable manner
 by relying on RabbitMQ.
 
+You should also take a look at [Elixir Tackle](https://github.com/renderedtext/ex-tackle).
+
+## Why should I use tackle?
+
+- It is ideal for fast microservice prototyping
+- It uses sane defaults for queue and exchange creation
+- It retries messages that fail to be processed
+- It stores unprocessed messages into a __dead__ queue for later inspection
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -13,9 +22,7 @@ Add this line to your application's Gemfile:
 gem "rt-tackle", :require => "tackle"
 ```
 
-## Usage
-
-### Publishing a message
+## Publishing messages
 
 With tackle, you can publish a message to an AMQP exchange. For example, to
 publish `"Hello World!"` do the following:
@@ -44,10 +51,12 @@ options = {
 Tackle.publish("Hello World!", options)
 ```
 
-### Consume messages
+## Consume messages
 
 Tackle enables you to connect to an AMQP exchange and consume messages from it.
 
+![Tackle consumer](docs/consumer.png)
+
 ```ruby
 require "tackle"
 
@@ -80,8 +89,6 @@ The above code snippet creates the following AMQP resources:
    where your service can't consume the message, tackle will store them in a
    dedicated dead queue. You can consume this messages manually.
 
-![Tackle consumer](docs/consumer.png)
-
 You can pass additional configuration to tackle in order to control the number
 of retries, and the delay between each retry.
 
@@ -125,6 +132,66 @@ Tackle.consume(options) do |message|
 end
 ```
 
+## Manually ack-ing messages
+
+By default, Tackle assumes that a message was successfully processed if no
+exceptions were raised in the consume block. This behaviour is well suited for
+handling unknown exceptions.
+
+Sometimes however, we want to send a message to the retry queue without raising
+an exception (and polluting our exception tracker with false positives).
+
+For this purpose, tackle can be configured to consume messages in a "manual ack"
+fashion. Pass `:manual_ack => true` to the consumer to activate the manual_ack
+mode.
+
+```ruby
+require "tackle"
+
+options = {
+  :url => "amqp://localhost",
+  :exchange => "users",
+  :routing_key => "signed-up",
+  :service => "user-mailer"
+  :manual_ack => true
+}
+
+Tackle.consume(options) do |message|
+  puts message
+
+  Tackle::ACK
+end
+```
+
+When Tackle consumes messages in the manual_ack mode, the return value of the
+consumer block must be either `Tackle::ACK` or `Tackle::NACK`. In case the
+response is `Tackle::NACK` the message is put on the retry queue.
+
+```ruby
+require "tackle"
+
+options = {
+  :url => "amqp://localhost",
+  :exchange => "numbers",
+  :routing_key => "positive-numbers",
+  :service => "number-processor",
+  :manual_ack => true
+}
+
+Tackle.consume(options) do |message|
+  # accept only positive numbers
+
+  if message["value"].even?
+    Tackle::ACK
+  else
+    Tackle::NACK
+  end
+end
+```
+
+If neither Tackle::ACK nor Tackle::NACK are returned, tackle assumes
+that the response is negative.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then,

data/lib/tackle/consumer/params.rb

@@ -10,6 +10,7 @@ module Tackle
       attr_reader :retry_delay
       attr_reader :logger
       attr_reader :exception_handler
+      attr_reader :manual_ack
 
       def initialize(params = {})
         # required
@@ -22,10 +23,15 @@ module Tackle
         @retry_limit = params[:retry_limit] || 8
         @retry_delay = params[:retry_delay] || 30
         @logger      = params[:logger] || Logger.new(STDOUT)
+        @manual_ack  = params.fetch(:manual_ack, false)
 
         @exception_handler = params[:exception_handler]
       end
 
+      def manual_ack?
+        @manual_ack == true
+      end
+
     end
   end
 end

data/lib/tackle/consumer.rb

@@ -43,20 +43,28 @@ module Tackle
     def process_message(message, &block)
       message.log_info "Calling message processor"
 
-      block.call(message.payload)
+      response = block.call(message.payload)
 
-      message.ack
-    rescue Exception => ex
-      message.log_error "Failed to process message. Received exception '#{ex}'"
-
-      redeliver_message(message)
+      unless @params.manual_ack?
+        response = Tackle::ACK
+      end
 
-      message.nack
+      case response
+      when Tackle::ACK
+        message.ack
+      when Tackle::NACK
+        redeliver_message(message, "Received Tackle::NACK")
+      else
+        raise "Response must be either Tackle::ACK or Tackle::NACK"
+      end
+    rescue Exception => ex
+      redeliver_message(message, "Received exception '#{ex}'")
 
       raise ex
     end
 
-    def redeliver_message(message)
+    def redeliver_message(message, reason)
+      message.log_error "Failed to process message. #{reason}"
       message.log_error "Retry count #{message.retry_count}/#{@params.retry_limit}"
 
       if message.retry_count < @params.retry_limit
@@ -64,6 +72,8 @@ module Tackle
       else
         @dead_queue.publish(message)
       end
+
+      message.nack
     end
 
   end

data/lib/tackle/version.rb

@@ -1,3 +1,3 @@
 module Tackle
-  VERSION = "1.0"
+  VERSION = "1.1.0".freeze
 end

data/lib/tackle.rb

@@ -7,6 +7,9 @@ module Tackle
   require "tackle/publisher"
   require "tackle/consumer"
 
+  ACK = :ack
+  NACK = :nack
+
   module_function
 
   def consume(params = {}, &block)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rt-tackle
 version: !ruby/object:Gem::Version
-  version: '1.0'
+  version: 1.1.0
 platform: ruby
 authors:
 - Rendered Text
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-09-10 00:00:00.000000000 Z
+date: 2017-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny