pwwka 0.6.0 → 0.7.0.RC1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 374c2180b982d19cd0dcc1d6dd73abf3d80f493b
-  data.tar.gz: fb315b10d90d96cbb250c034fdf4a8d2f1186ac3
+  metadata.gz: 86fe2875f9d9221237358a25d30bcecee224554a
+  data.tar.gz: c1cad94e3a3d146b18480354297b5214544ecca8
 SHA512:
-  metadata.gz: c6fa81ed74d72ec9f7739d8e7e4cd6de94ef172b5e7d11900e3ec32f03cc3c7f13a466fefc1107d43668b29a4c123d60838839de4fd8222d2a2284b25befd2b9
-  data.tar.gz: 885daa6a5d3615f113064c5a906d608d76aa1916f6174665221c12dd9270dfb553c4d9c3bbc0a36879a3aec335daeec22a1132f7e7375ab69508faf477146dd8
+  metadata.gz: b56b412dc2ce73c3dec1ca1ca1f20432bbea8565699aff56e006fa00df9605e627a58db4a6aca9db248890d5cf70a2e69e5bbe4fb093f066d65a2c706584f4ea
+  data.tar.gz: 154f1b930db5502349df6b0c8b15723ce4f726c95b4d742db5b277078c097afb529b17639634a9b31b079497bf1b4dfe171e55b9e903ea924d55a9746f83947d

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    pwwka (0.6.0)
+    pwwka (0.7.0.RC1)
       activemodel
       activesupport
       bunny
@@ -10,23 +10,20 @@ PATH
 GEM
   remote: https://www.rubygems.org/
   specs:
-    activemodel (4.2.6)
-      activesupport (= 4.2.6)
-      builder (~> 3.1)
-    activesupport (4.2.6)
+    activemodel (5.0.0.1)
+      activesupport (= 5.0.0.1)
+    activesupport (5.0.0.1)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (~> 0.7)
-      json (~> 1.7, >= 1.7.7)
       minitest (~> 5.1)
-      thread_safe (~> 0.3, >= 0.3.4)
       tzinfo (~> 1.1)
     amq-protocol (2.0.1)
-    builder (3.2.2)
-    bunny (2.3.1)
+    bunny (2.6.1)
       amq-protocol (>= 2.0.1)
+    concurrent-ruby (1.0.2)
     diff-lcs (1.2.5)
     i18n (0.7.0)
-    json (1.8.3)
-    minitest (5.8.4)
+    minitest (5.10.1)
     mono_logger (1.1.0)
     multi_json (1.11.2)
     rack (1.6.4)
@@ -76,4 +73,4 @@ DEPENDENCIES
   rspec
 
 BUNDLED WITH
-   1.12.5
+   1.13.6

data/README.md

@@ -98,12 +98,12 @@ send_message!(payload, routing_key)
 ```
 
 ### Error Handling
+
 This method accepts several strategies for handling errors, pass in using the `on_error` parameter:
 
   * `:raise`: Log the error and raise the exception received from Bunny. (default strategy)
   * `:ignore`: Log the error and return false.
-  * `:resque`: Log the error and return false. Also, enqueue a job with Resque 
-    to send the message. See `send_message_async` below.
+  * `:resque`: Log the error and return false. Also, enqueue a job with Resque to send the message. See `send_message_async` below. **Note, this doesn't guarantee the message will actually be sent—it just guarantees an attempt is made to queue a Resque job [which could fail]**
 
 ### Delayed Messages
 You might want to delay sending a message (for example, if you have just created a database 
@@ -217,6 +217,32 @@ class ClientIndexMessageHandler
 
 end
 ```
+#### Handling Errors
+
+By default, if your handler raises an uncaught exception, the message will be Nacked, **but not requeued**.  This means
+it's dropped on the floor and likely won't have been completely processed.
+
+You can configure `requeue_on_error` in the configuration to change this behavior:
+
+```ruby
+require 'pwwka'
+Pwwka.configure do |config|
+
+  # ...
+
+  config.requeue_on_error = true
+end
+```
+
+This will requeue the message **exactly once**.  It uses the headers to check if the message has been retried.  If it
+hasn't, and your handler raises an exception, it will be placed back on the queue.  The second time your handler
+processes it, there is a header indicating it's been retried, so if a failure happens again, the message **is not
+requeued**.
+
+Because requeuing puts the message at the head of the queue, a hard failure will result in an infinite loop, which will
+lead to filling up your queue. Nevertheless, this should address intermittent failures.
+
+**It is recommended that you set this option**.  It's off for backwards compatibility.
 
 #### Handling Messages with Resque
 

data/lib/pwwka/channel_connector.rb

@@ -27,6 +27,18 @@ module Pwwka
     end
 
     def delayed_queue
+      # This works by hacking the dead letter exchange concept with a timeout.
+      # We set up a delayed exchange that has a delayed queue.  This queue, configured below,
+      # sets its dead letter exchange to be the main exchange (topic_exchange above).
+      #
+      # This means that when a message send to the delayed queue is either nack'ed with no retry OR
+      # it's TTL expires, it will be sent to the configured dead letter exchange, which is the main topic_exchange.
+      #
+      # Since nothing is actually consuming messages on the delayed queue, the only way messages can be removed and
+      # sent back to the main exchange is if their TTL expires.  As you can see in Pwwka::Transmitter#send_delayed_message!
+      # we set an expiration on the message and send it to the delayed exchange.  This means that the delay time is the TTL,
+      # so the messages sits in the delayed queue until its TTL/delay expires, and then it's sent onto the 
+      # main exchange for everyone to consume.  Thus creating a delay.
       raise_if_delayed_not_allowed
       @delayed_queue ||= begin
         queue = channel.queue("pwwka_delayed_#{Pwwka.environment}", durable: true,
@@ -35,7 +47,7 @@ module Pwwka
         })
         queue.bind(delayed_exchange)
         queue
-      end 
+      end
     end
     alias :create_delayed_queue :delayed_queue
 

data/lib/pwwka/configuration.rb

@@ -10,6 +10,7 @@ module Pwwka
     attr_accessor :logger
     attr_accessor :options
     attr_accessor :send_message_resque_backoff_strategy
+    attr_accessor :requeue_on_error
 
     def initialize
       @rabbit_mq_host        = nil
@@ -20,6 +21,7 @@ module Pwwka
       @send_message_resque_backoff_strategy = [5,                  #intermittent glitch?
                                                60,                 # quick interruption
                                                600, 600, 600] # longer-term outage?
+      @requeue_on_error = false
     end
 
     def payload_logging

data/lib/pwwka/receiver.rb

@@ -29,9 +29,13 @@ module Pwwka
             receiver.ack(delivery_info.delivery_tag)
             logf "Processed Message on %{queue_name} -> %{payload}, %{routing_key}", queue_name: queue_name, payload: payload, routing_key: delivery_info.routing_key
           rescue => e
-            logf "Error Processing Message on %{queue_name} -> %{payload}, %{routing_key}: %{exception}", queue_name: queue_name, payload: payload, routing_key: delivery_info.routing_key, exception: e, at: :error
-            # no requeue
-            receiver.nack(delivery_info.delivery_tag)
+            if Pwwka.configuration.requeue_on_error && !delivery_info.redelivered
+              logf "Retrying an Error Processing Message on %{queue_name} -> %{payload}, %{routing_key}: %{exception}: %{backtrace}", queue_name: queue_name, payload: payload, routing_key: delivery_info.routing_key, exception: e, backtrace: e.backtrace.join(';'), at: :error
+              receiver.nack_requeue(delivery_info.delivery_tag)
+            else
+              logf "Error Processing Message on %{queue_name} -> %{payload}, %{routing_key}: %{exception}: %{backtrace}", queue_name: queue_name, payload: payload, routing_key: delivery_info.routing_key, exception: e, backtrace: e.backtrace.join(';'), at: :error
+              receiver.nack(delivery_info.delivery_tag)
+            end
           end
         end
       rescue Interrupt => _
@@ -44,7 +48,7 @@ module Pwwka
 
     def topic_queue
       @topic_queue ||= begin
-        queue = channel.queue(queue_name, durable: true)
+        queue = channel.queue(queue_name, durable: true, arguments: {})
         queue.bind(topic_exchange, routing_key: routing_key)
         queue
       end
@@ -63,14 +67,14 @@ module Pwwka
     end
 
     def drop_queue
-      topic_queue.purge  
+      topic_queue.purge
       topic_queue.delete
     end
 
     def test_teardown
       drop_queue
       topic_exchange.delete
-      channel_connector.connection_close 
+      channel_connector.connection_close
     end
 
   end

data/lib/pwwka/test_handler.rb

@@ -30,7 +30,7 @@ module Pwwka
                        end
     end
 
-    # Get the message on the queue as TestHandler::Message.
+    # Get the message on the queue as TestHandler::Message
     def pop_message
       delivery_info, properties, payload = test_queue.pop
       Message.new(delivery_info,
@@ -70,7 +70,7 @@ module Pwwka
         channel_connector.delayed_exchange.delete
       end
 
-      channel_connector.connection_close 
+      channel_connector.connection_close
     end
 
     # Simple class to hold a popped message.

data/lib/pwwka/version.rb

@@ -1,3 +1,3 @@
 module Pwwka
-  VERSION = '0.6.0'
+  VERSION = '0.7.0.RC1'
 end

data/spec/receiver_spec.rb

@@ -25,6 +25,7 @@ describe Pwwka::Receiver do
 
     after(:each) do
       Pwwka.configuration.logger = @original_logger
+      Pwwka.configuration.requeue_on_error = false
       @receiver.test_teardown rescue nil
     end
 
@@ -37,7 +38,12 @@ describe Pwwka::Receiver do
     end
 
     it "should nack the sent message if an error is raised" do
-      expect(HandyHandler).to receive(:handle!).and_raise("blow up")
+      exception = begin
+                    raise "blow up"
+                  rescue => ex
+                    ex
+                  end
+      expect(HandyHandler).to receive(:handle!).and_raise(ex)
       expect(@receiver).not_to receive(:ack)
       expect(@receiver).to receive(:nack).with(instance_of(Fixnum))
       Pwwka::Transmitter.send_message!(payload, routing_key)
@@ -45,7 +51,48 @@ describe Pwwka::Receiver do
       expect(logger).to have_received(:info).with(/START Transmitting.*#{Regexp.escape(payload.to_s)}/)
       expect(logger).to have_received(:info).with(/END Transmitting.*#{Regexp.escape(payload.to_s)}/)
       expect(logger).to have_received(:info).with(/AFTER Transmitting.*#{Regexp.escape(payload.to_s)}/)
-      expect(logger).to have_received(:error).with(/Error Processing Message.*#{Regexp.escape(payload.to_s)}/)
+      expect(logger).to have_received(:error).with(/Error Processing Message.*#{Regexp.escape(payload.to_s)}.*#{Regexp.escape(exception.backtrace.join(';'))}/)
+    end
+
+    context "when we're configured to requeue on error" do
+      before do
+        Pwwka.configuration.requeue_on_error = true
+      end
+      it "should nack_requeue the sent message if it hasn't been retried before" do
+        exception = begin
+                      raise "blow up"
+                    rescue => ex
+                      ex
+                    end
+        expect(HandyHandler).to receive(:handle!).and_raise(ex)
+        expect(@receiver).not_to receive(:ack)
+        expect(@receiver).to receive(:nack_requeue).with(instance_of(Fixnum))
+        Pwwka::Transmitter.send_message!(payload, routing_key)
+        @receiver.test_teardown # force the message to be processed and exception handled
+        expect(logger).to have_received(:info).with(/START Transmitting.*#{Regexp.escape(payload.to_s)}/)
+        expect(logger).to have_received(:info).with(/END Transmitting.*#{Regexp.escape(payload.to_s)}/)
+        expect(logger).to have_received(:info).with(/AFTER Transmitting.*#{Regexp.escape(payload.to_s)}/)
+        expect(logger).to have_received(:error).with(/Error Processing Message.*#{Regexp.escape(payload.to_s)}.*#{Regexp.escape(exception.backtrace.join(';'))}/)
+      end
+
+      it "should nack the sent message if it HAS been retried before" do
+        # Super cheesy, but I don't see another way to access this
+        allow_any_instance_of(Bunny::DeliveryInfo).to receive(:redelivered).and_return(true)
+        exception = begin
+                      raise "blow up"
+                    rescue => ex
+                      ex
+                    end
+        expect(HandyHandler).to receive(:handle!).and_raise(ex)
+        expect(@receiver).not_to receive(:ack)
+        expect(@receiver).to receive(:nack).with(instance_of(Fixnum))
+        Pwwka::Transmitter.send_message!(payload, routing_key)
+        @receiver.test_teardown # force the message to be processed and exception handled
+        expect(logger).to have_received(:info).with(/START Transmitting.*#{Regexp.escape(payload.to_s)}/)
+        expect(logger).to have_received(:info).with(/END Transmitting.*#{Regexp.escape(payload.to_s)}/)
+        expect(logger).to have_received(:info).with(/AFTER Transmitting.*#{Regexp.escape(payload.to_s)}/)
+        expect(logger).to have_received(:error).with(/Error Processing Message.*#{Regexp.escape(payload.to_s)}.*#{Regexp.escape(exception.backtrace.join(';'))}/)
+      end
     end
 
   end

data/spec/spec_helper.rb

@@ -10,7 +10,7 @@ RSpec.configure do |config|
     c.syntax = :expect
   end
 
-  config.before(:each) do
+  config.before(:all) do
     Pwwka.configure do |c|
       c.topic_exchange_name     = "topics-test"
       c.logger                  = MonoLogger.new("/dev/null")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pwwka
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0.RC1
 platform: ruby
 authors:
 - Stitch Fix Engineering
@@ -15,7 +15,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-14 00:00:00.000000000 Z
+date: 2016-12-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny
@@ -183,12 +183,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.6
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Send and receive messages via RabbitMQ