pwwka 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f3fc992f47050fe4d47c782fd18224ea2b7224e3
-  data.tar.gz: ab6505f1e72cad5d540afc2974ecc5406998bfd8
+  metadata.gz: ebd965b855d451ed7c107bb135c3f7097cf39abf
+  data.tar.gz: 1154aa6d2f93f73aae83ecc599c9602bb5bcea89
 SHA512:
-  metadata.gz: d0d3b3b3525731676f81ad2bfd591c6357887cc0f77e40f66114545462ef7dcd4ba672f8cbbf60eb8ac7aafb26a0eb5f77ce7f9b83df7f947393b45fc4dbdb32
-  data.tar.gz: ac7bcd1642cae8facd0f24305f777868b1da15681701d389836f3bcaa55c7abd7d270e0770f8c388fd03e38838c427d8cf19d5f60c04e2c54aa6ca22162f58c4
+  metadata.gz: c598d6f9af0d610cfc54fc92af86664abd6cb39473c43e8a42f799a09fafc6c03be1319aa2c19e96afd1710e0429f09110bbe6db7c8bbd08c90fe00b31a8979d
+  data.tar.gz: cfe0a633ff667cb19c855ccbb8b206df3122dda399f6a195a4b3d844817d56b307730a2cf8c050b4218bc51f4610c1bc0c5f64ec22aae759f88697a3fc7626d8

data/.travis.yml

@@ -1,6 +1,8 @@
 language: ruby
 rvm:
   - 2.1.0
+  - 2.2.0
+  - 2.0.0
   - ruby-head
 services:
   - rabbitmq

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,6 @@
+# Code of Conduct
+
+We are committed to keeping our community open and inclusive.
+
+**Our Code of Conduct can be found here**:
+http://opensource.stitchfix.com/code-of-conduct.html

data/CONTRIBUTING.md

@@ -1,15 +1,23 @@
-
-## Contributing
+# Contributing
+Thanks for using and improving *pwwka*! If you'd like to help out, check out [the project's issues list](https://github.com/stitchfix/pwwka/issues) for ideas on what could be improved.  
 
 We're actively using Pwwka in production here at [Stitch Fix](http://technology.stitchfix.com/) and look forward to seeing Pwwka grow and improve with your help. Contributions are warmly welcomed.
 
-To contribute, 
-1. make a fork of the project
-2. write some code (with tests please!) 
-3. open a Pull Request	
-4. bask in the warm fuzzy Open Source hug from us
+If there's an idea you'd like to propose, or a design change, feel free to file a new issue or send a pull request:
+
+1. [Fork][fork] the repo.
+1. [Create a topic branch.][branch]
+1. Write tests.
+1. Implement your feature or fix bug.
+1. Add, commit, and push your changes.
+1. [Submit a pull request.][pr]
+
+[fork]: https://help.github.com/articles/fork-a-repo/
+[branch]: https://help.github.com/articles/creating-and-deleting-branches-within-your-repository/
+[pr]: https://help.github.com/articles/using-pull-requests/
 
-## Testing
-<a name="testing"></a>
+## General Guidelines
 
-You must be running RabbitMQ locally on the default port in order for the tests to work.
+* You must be running RabbitMQ locally on the default port in order for the tests to work.
+* When in doubt, test it.  If you can't test it, re-think what you are doing.
+* Code formatting and internal application architecture should be consistent.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    pwwka (0.4.2)
+    pwwka (0.5.0)
       activemodel
       activesupport
       bunny
@@ -10,10 +10,10 @@ PATH
 GEM
   remote: https://www.rubygems.org/
   specs:
-    activemodel (4.2.1)
-      activesupport (= 4.2.1)
+    activemodel (4.2.4)
+      activesupport (= 4.2.4)
       builder (~> 3.1)
-    activesupport (4.2.1)
+    activesupport (4.2.4)
       i18n (~> 0.7)
       json (~> 1.7, >= 1.7.7)
       minitest (~> 5.1)
@@ -21,15 +21,15 @@ GEM
       tzinfo (~> 1.1)
     amq-protocol (1.9.2)
     builder (3.2.2)
-    bunny (1.7.0)
+    bunny (2.0.0)
       amq-protocol (>= 1.9.2)
     diff-lcs (1.2.5)
     i18n (0.7.0)
-    json (1.8.2)
-    minitest (5.6.1)
+    json (1.8.3)
+    minitest (5.8.1)
     mono_logger (1.1.0)
-    multi_json (1.11.0)
-    rack (1.6.0)
+    multi_json (1.11.2)
+    rack (1.6.4)
     rack-protection (1.5.3)
       rack
     rake (10.4.2)
@@ -42,19 +42,19 @@ GEM
       redis-namespace (~> 1.3)
       sinatra (>= 0.9.2)
       vegas (~> 0.1.2)
-    rspec (3.2.0)
-      rspec-core (~> 3.2.0)
-      rspec-expectations (~> 3.2.0)
-      rspec-mocks (~> 3.2.0)
-    rspec-core (3.2.2)
-      rspec-support (~> 3.2.0)
-    rspec-expectations (3.2.0)
+    rspec (3.3.0)
+      rspec-core (~> 3.3.0)
+      rspec-expectations (~> 3.3.0)
+      rspec-mocks (~> 3.3.0)
+    rspec-core (3.3.2)
+      rspec-support (~> 3.3.0)
+    rspec-expectations (3.3.1)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.2.0)
-    rspec-mocks (3.2.1)
+      rspec-support (~> 3.3.0)
+    rspec-mocks (3.3.2)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.2.0)
-    rspec-support (3.2.2)
+      rspec-support (~> 3.3.0)
+    rspec-support (3.3.0)
     sinatra (1.4.6)
       rack (~> 1.4)
       rack-protection (~> 1.4)

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License (MIT)
+
+Copyright (c) 2014 Stitch Fix
+
+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

@@ -84,7 +84,8 @@ The payload should be a simple hash containing primitives. Don't send objects be
 Pwwka::Transmitter.send_message_safely(payload, routing_key)
 ```
 
-You can also use the two convenience methods for sending a message. To include these methods in your class use:
+You can also use the two convenience methods for sending a message. To include these methods 
+in your class use:
 
 ```ruby
 include Pwwka::Handling
@@ -96,16 +97,18 @@ Then you can call:
 send_message!(payload, routing_key)
 ```
 
-This method will blow up if something goes wrong. If you want to send safely then use:
+### Error Handling
+This method accepts several strategies for handling errors, pass in using the `on_error` parameter:
 
-```ruby
-send_message_safely(payload, routing_key)
-```
-
-The messages are not transaction safe so for updates do your best to send them after the transaction commits. You must send create messages after the transaction commits or the receivers will probably not find the persisted records.
+  * `: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.
 
 ### Delayed Messages
-You might want to delay sending a message (for example, if you have just created a database record and a race condition keeps catching you out). In that case you can use delayed message options:
+You might want to delay sending a message (for example, if you have just created a database 
+record and a race condition keeps catching you out). In that case you can use delayed message 
+options:
 
 ```ruby
 payload = {client_id: '13452564'}
@@ -117,8 +120,25 @@ Pwwka::Transmitter.send_message!(payload, routing_key, delayed: true, delay_by:
 
 These extra arguments work for all message sending methods - the safe ones, the handling, and the `message_queuer` methods (see below).
 
+
+### Sending message Async with Resque
+
+To enqueue a message in a background Resque job, use `Transmitter.send_message_async` 
+```ruby
+Pwwka::Transmitter.send_message_async(payload, routing_key, delay_by_ms: 5000) # default delay is 0
+```
+
+If `Resque::Plugins::ExponentialBackoff` is available, the job will use it.
+Customize the backoff intervals using the configuration `send_message_resque_backoff_strategy`.
+The default backoff will retry quickly in case of an intermittent glitch, and then every ten 
+minutes for half an hour.
+ 
+The name of the queue created is `pwwka_send_message_async`.
+
+
 ### Message Queuer
-You can queue up messages and send them in a batch. This is most useful when multiple messages need to sent from within a transaction block.
+You can queue up messages and send them in a batch. This is most useful when multiple messages 
+need to sent from within a transaction block.
   
 For example:
 

data/lib/pwwka.rb

@@ -28,5 +28,7 @@ require 'pwwka/handling'
 require 'pwwka/receiver'
 require 'pwwka/transmitter'
 require 'pwwka/message_queuer'
-
 require 'pwwka/configuration'
+require 'pwwka/send_message_async_job'
+
+

data/lib/pwwka/configuration.rb

@@ -9,6 +9,7 @@ module Pwwka
     attr_accessor :delayed_exchange_name
     attr_accessor :logger
     attr_accessor :options
+    attr_accessor :send_message_resque_backoff_strategy
 
     def initialize
       @rabbit_mq_host        = nil
@@ -16,6 +17,9 @@ module Pwwka
       @delayed_exchange_name = "pwwka.delayed.#{Pwwka.environment}"
       @logger                = MonoLogger.new(STDOUT)
       @options               = {}
+      @send_message_resque_backoff_strategy = [5,                  #intermittent glitch?
+                                               60,                 # quick interruption
+                                               600, 600, 600] # longer-term outage?
     end
 
 

data/lib/pwwka/message_queuer.rb

@@ -28,7 +28,9 @@ module Pwwka
       @message_queue  = []
     end
 
-    def queue_message(payload:, routing_key:, delayed: false, delay_by: nil)
+    def queue_message(payload: nil, routing_key: nil, delayed: false, delay_by: nil)
+      raise 'Missing payload' if payload.nil?
+      raise 'Missing routing_key' if routing_key.nil?
       message_queue.push({
             payload: payload,
         routing_key: routing_key,

data/lib/pwwka/send_message_async_job.rb

@@ -0,0 +1,16 @@
+module Pwwka
+  class SendMessageAsyncJob
+
+    extend Pwwka::Logging
+
+    @queue = 'pwwka_send_message_async'
+
+    extend Resque::Plugins::ExponentialBackoff rescue nil # Optional
+    @backoff_strategy = Pwwka.configuration.send_message_resque_backoff_strategy
+
+    def self.perform(payload, routing_key)
+      info("Sending message async #{routing_key}, #{payload}")
+      Pwwka::Transmitter.send_message!(payload, routing_key, on_error: :raise)
+    end
+  end
+end

data/lib/pwwka/transmitter.rb

@@ -1,3 +1,5 @@
+require 'resque' rescue nil # optional dependency
+
 module Pwwka
   # Primary interface for sending messages.
   #
@@ -13,9 +15,12 @@ module Pwwka
     extend Pwwka::Logging
     include Pwwka::Logging
 
+    DEFAULT_DELAY_BY_MS = 5000
+
     attr_reader :channel_connector
+
     def initialize
-      @channel_connector = ChannelConnector.new 
+      @channel_connector = ChannelConnector.new
     end
 
     # Send an important message that must go through.  This method allows any raised exception 
@@ -25,17 +30,48 @@ module Pwwka
     # routing_key:: String routing key for the message
     # delayed:: Boolean send this message later
     # delay_by:: Integer milliseconds to delay the message
+    # on_error:: What is the behavior of
+    # - :ignore (aka as send_message_safely)
+    # - :raise
+    # - :resque -- use Resque to try to send the message later
     #
     # Returns true
     #
     # Raises any exception generated by the innerworkings of this library.
-    def self.send_message!(payload, routing_key, delayed: false, delay_by: nil)
+    def self.send_message!(payload, routing_key, on_error: :raise,
+        delayed: false, delay_by: nil)
       if delayed
         new.send_delayed_message!(*[payload, routing_key, delay_by].compact)
       else
         new.send_message!(payload, routing_key)
       end
       info "AFTER Transmitting Message on #{routing_key} -> #{payload}"
+
+    rescue => e
+
+      error "ERROR Transmitting Message on #{routing_key} -> #{payload}: #{e}"
+
+      case on_error
+
+        when :raise
+          raise e
+
+        when :resque
+          begin
+            send_message_async(payload, routing_key, delay_by_ms: delayed ? delay_by || DEFAULT_DELAY_BY_MS : 0)
+          rescue => resque_exception
+            warn(resque_exception.message)
+            raise e
+          end
+        else # ignore
+      end
+      false
+    end
+
+    # Use Resque to enqueue the message.
+    # - :delay_by_ms:: Integer milliseconds to delay the message. Default is 0.
+    def self.send_message_async(payload, routing_key, delay_by_ms: 0)
+      Resque.enqueue_in(delay_by_ms/1000, SendMessageAsyncJob, payload, routing_key)
     end
 
     # Send a less important message that doesn't have to go through. This eats
@@ -47,34 +83,33 @@ module Pwwka
     # delay_by:: Integer milliseconds to delay the message
     #
     # Returns true if the message was sent, false otherwise
+    # @deprecated This is ignoring a message. ::send_message supports this explicitly.
     def self.send_message_safely(payload, routing_key, delayed: false, delay_by: nil)
-      send_message!(payload, routing_key, delayed: delayed, delay_by: delay_by)
-    rescue => e
-      error "ERROR Transmitting Message on #{routing_key} -> #{payload}: #{e}"
-      false
+      send_message!(payload, routing_key, delayed: delayed, delay_by: delay_by, on_error: :ignore)
     end
 
     def send_message!(payload, routing_key)
       info "START Transmitting Message on #{routing_key} -> #{payload}"
       channel_connector.topic_exchange.publish(
-        payload.to_json,
-        routing_key: routing_key,
-        persistent: true)
+          payload.to_json,
+          routing_key: routing_key,
+          persistent:  true)
       channel_connector.connection_close
       # if it gets this far it has succeeded
       info "END Transmitting Message on #{routing_key} -> #{payload}"
       true
     end
 
-    def send_delayed_message!(payload, routing_key, delay_by = 5000)
+
+    def send_delayed_message!(payload, routing_key, delay_by = DEFAULT_DELAY_BY_MS)
       channel_connector.raise_if_delayed_not_allowed
       info "START Transmitting Delayed Message on #{routing_key} -> #{payload}"
       channel_connector.create_delayed_queue
       channel_connector.delayed_exchange.publish(
-        payload.to_json,
-        routing_key: routing_key,
-        expiration: delay_by,
-        persistent: true)
+          payload.to_json,
+          routing_key: routing_key,
+          expiration:  delay_by,
+          persistent:  true)
       channel_connector.connection_close
       # if it gets this far it has succeeded
       info "END Transmitting Delayed Message on #{routing_key} -> #{payload}"

data/lib/pwwka/version.rb

@@ -1,3 +1,3 @@
 module Pwwka
-  VERSION = '0.4.2'
+  VERSION = '0.5.0'
 end

data/pwwka.gemspec

@@ -6,9 +6,10 @@ Gem::Specification.new do |s|
   s.name        = "pwwka"
   s.version     = Pwwka::VERSION
   s.platform    = Gem::Platform::RUBY
-  s.authors     = ['Stitch Fix Engineering']
-  s.email       = ['opensource@stitchfix.com']
+  s.authors     = ["Stitch Fix Engineering","Andrew Peterson","Bill Eisenhauer","Dave Copeland","David A McClain","Jonathan Dean","Nick Reavill","Simeon Willbanks"]
+  s.email       = ["opensource@stitchfix.com","andy@ndpsoftware.com","bill@stitchfix.com","davetron5000@gmail.com","david@stitchfix.com","jon@jonathandean.com","nick@fluxequalsrad.com","simeon@simeons.net" ]
   s.homepage    = "https://github.com/stitchfix/pwwka"
+  s.license     = "MIT"
   s.summary     = "Send and receive messages via RabbitMQ"
   s.description = "The purpose of this gem is to normalise the sending and
   receiving of messages between Rails apps using the shared RabbitMQ
@@ -18,10 +19,10 @@ Gem::Specification.new do |s|
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
-  s.add_dependency("bunny")
-  s.add_dependency("activesupport")
-  s.add_dependency("activemodel")
-  s.add_dependency("mono_logger")
+  s.add_runtime_dependency("bunny")
+  s.add_runtime_dependency("activesupport")
+  s.add_runtime_dependency("activemodel")
+  s.add_runtime_dependency("mono_logger")
   s.add_development_dependency("rake")
   s.add_development_dependency("rspec")
   s.add_development_dependency("resque")

data/spec/send_message_async_job_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper.rb'
+
+describe Pwwka::SendMessageAsyncJob do
+
+  let(:payload) { Hash[:this, "that"] }
+  let(:routing_key) { "this.that.and.theother" }
+
+  describe '::perform' do
+    it 'calls Pwwwka::Transmitter to send the message' do
+      expect(Pwwka::Transmitter).to receive(:send_message!).with(payload, routing_key, on_error: :raise)
+      described_class.perform(payload, routing_key)
+    end
+  end
+
+end

data/spec/transmitter_spec.rb

@@ -10,8 +10,10 @@ describe Pwwka::Transmitter do
   after(:each) { @test_handler.purge_test_queue }
   after(:all) { @test_handler.test_teardown }
 
-  let(:payload)     { Hash[:this, "that"] }
+  let(:payload) { Hash[:this, "that"] }
   let(:routing_key) { "this.that.and.theother" }
+  let(:exception) { RuntimeError.new('blow up')}
+
 
   describe "#send_message!" do
 
@@ -32,10 +34,10 @@ describe Pwwka::Transmitter do
     end
 
     it "should blow up if exception raised" do
-      expect(Pwwka::ChannelConnector).to receive(:new).and_raise("blow up")
+      expect(Pwwka::ChannelConnector).to receive(:new).and_raise(exception)
       expect {
         Pwwka::Transmitter.new.send_message!(payload, routing_key)
-      }.to raise_error
+      }.to raise_error(exception)
     end
 
   end
@@ -63,10 +65,10 @@ describe Pwwka::Transmitter do
     end
 
     it "should blow up if exception raised" do
-      expect(Pwwka::ChannelConnector).to receive(:new).and_raise("blow up")
+      expect(Pwwka::ChannelConnector).to receive(:new).and_raise(exception)
       expect {
         Pwwka::Transmitter.new.send_delayed_message!(payload, routing_key, 1)
-      }.to raise_error
+      }.to raise_error(exception)
     end
 
     context "delayed not configured" do
@@ -82,30 +84,106 @@ describe Pwwka::Transmitter do
 
   describe "::send_message!" do
 
+
     it "should send the correct payload" do
       Pwwka::Transmitter.send_message!(payload, routing_key)
       received_payload = @test_handler.pop_message.payload
       expect(received_payload["this"]).to eq("that")
     end
 
-    it "should blow up if exception raised" do
-      expect(Pwwka::ChannelConnector).to receive(:new).and_raise("blow up")
-      expect{
-        Pwwka::Transmitter.send_message!(payload, routing_key)
-      }.to raise_error
+    it "should return true" do
+      expect(Pwwka::Transmitter.send_message!(payload, routing_key)).to eq true
+    end
+
+    it "should ignore delay_by parameter (should it?)" do
+      Pwwka::Transmitter.send_message!(payload, routing_key, delay_by: 5000)
+      received_payload = @test_handler.pop_message.payload
+      expect(received_payload["this"]).to eq("that")
+    end
+
+    context 'default exception policy' do
+      it "should blow up if exception raised" do
+        expect(Pwwka::ChannelConnector).to receive(:new).and_raise(exception)
+        expect {
+          Pwwka::Transmitter.send_message!(payload, routing_key)
+        }.to raise_error(exception)
+      end
+    end
+
+    context 'when on_error: :raise and exception raised' do
+      before(:each) { expect(Pwwka::ChannelConnector).to receive(:new).and_raise(exception) }
+
+      it "should blow up" do
+        expect {
+          Pwwka::Transmitter.send_message!(payload, routing_key, on_error: :raise)
+        }.to raise_error(exception)
+      end
+      it "should not enqueue a resque job" do
+        expect(Resque).not_to receive(:enqueue_in)
+        expect {
+          Pwwka::Transmitter.send_message!(payload, routing_key, on_error: :raise)
+        }.to raise_error(exception)
+      end
+    end
+
+    context 'when on_error: :ignore and exception raised' do
+      before :each do
+        expect(Pwwka::ChannelConnector).to receive(:new).and_raise("blow up")
+      end
+      it "should not blow up" do
+        Pwwka::Transmitter.send_message!(payload, routing_key, on_error: :ignore)
+        # check nothing has been queued
+        expect(@test_handler.test_queue.pop.compact.count).to eq(0)
+      end
+      it "should return false" do
+        expect(Pwwka::Transmitter.send_message!(payload, routing_key, on_error: :ignore)).to eql false
+      end
+      it "should not enqueue a resque job" do
+        expect(Resque).not_to receive(:enqueue_in)
+        Pwwka::Transmitter.send_message!(payload, routing_key, on_error: :ignore)
+      end
     end
 
+    context 'when on_error: :resque and exception raised' do
+      before :each do
+        allow(Resque).to receive(:enqueue_in)
+        expect(Pwwka::ChannelConnector).to receive(:new).and_raise("blow up")
+      end
+      it "should return false" do
+        expect(Pwwka::Transmitter.send_message!(payload, routing_key, on_error: :resque)).to eq false
+      end
+
+      it "should enqueue a Resque job if exception raised" do
+        expect(Resque).to receive(:enqueue_in).
+                              with(0, Pwwka::SendMessageAsyncJob, payload, routing_key)
+
+        Pwwka::Transmitter.send_message!(payload, routing_key, on_error: :resque)
+        # check nothing has been queued
+        expect(@test_handler.test_queue.pop.compact.count).to eq(0)
+      end
+
+      context 'and then resque fails' do
+        it 'returns the original exception' do
+          expect(Resque).to receive(:enqueue_in).and_raise('blow up in resque')
+          expect {
+            Pwwka::Transmitter.send_message!(payload, routing_key, on_error: :resque)
+          }.to raise_exception('blow up')
+        end
+      end
+    end
+
+
     context "delayed message" do
 
       it "should call send_delayed_message! if requested with delay_by" do
         expect_any_instance_of(Pwwka::Transmitter).to receive(:send_delayed_message!)
-          .with(payload, routing_key, 2000)
+                                                          .with(payload, routing_key, 2000)
         Pwwka::Transmitter.send_message!(payload, routing_key, delayed: true, delay_by: 2000)
       end
 
       it "should call send_delayed_message if requested without delay_by" do
         expect_any_instance_of(Pwwka::Transmitter).to receive(:send_delayed_message!)
-          .with(payload, routing_key)
+                                                          .with(payload, routing_key)
         Pwwka::Transmitter.send_message!(payload, routing_key, delayed: true)
       end
 
@@ -115,8 +193,49 @@ describe Pwwka::Transmitter do
         Pwwka::Transmitter.send_message_safely(payload, routing_key)
       end
 
+      it "should enqueue a Resque job if exception raised and on_error: :resque" do
+        expect(Pwwka::ChannelConnector).to receive(:new).and_raise("blow up")
+
+        expect(Resque).to receive(:enqueue_in).
+                              with(2, Pwwka::SendMessageAsyncJob, payload, routing_key)
+
+        Pwwka::Transmitter.send_message!(payload, routing_key, delayed: true, delay_by: 2000, on_error: :resque)
+        # check nothing has been queued
+        expect(@test_handler.test_queue.pop.compact.count).to eq(0)
+      end
+
+
+      it "should enqueue a Resque job if exception raised and on_error: :resque without delay_by" do
+        expect(Pwwka::ChannelConnector).to receive(:new).and_raise("blow up")
+
+        expect(Resque).to receive(:enqueue_in).
+                              with(Pwwka::Transmitter::DEFAULT_DELAY_BY_MS/1000, Pwwka::SendMessageAsyncJob, payload, routing_key)
+
+        Pwwka::Transmitter.send_message!(payload, routing_key, delayed: true, on_error: :resque)
+        # check nothing has been queued
+        expect(@test_handler.test_queue.pop.compact.count).to eq(0)
+      end
+
     end
+  end
 
+
+  describe '::send_message_async' do
+    context 'with no delay' do
+      it 'queues the message' do
+        expect(Resque).to receive(:enqueue_in).
+                              with(0, Pwwka::SendMessageAsyncJob, payload, routing_key)
+        Pwwka::Transmitter.send_message_async(payload, routing_key)
+      end
+    end
+
+    context 'with delay' do
+      it 'queues the message' do
+        expect(Resque).to receive(:enqueue_in).
+                              with(3, Pwwka::SendMessageAsyncJob, payload, routing_key)
+        Pwwka::Transmitter.send_message_async(payload, routing_key, delay_by_ms: 3000)
+      end
+    end
   end
 
   describe "::send_message_safely" do
@@ -138,13 +257,13 @@ describe Pwwka::Transmitter do
 
       it "should call send_delayed_message! if requested with delay_by" do
         expect_any_instance_of(Pwwka::Transmitter).to receive(:send_delayed_message!)
-          .with(payload, routing_key, 2000)
+                                                          .with(payload, routing_key, 2000)
         Pwwka::Transmitter.send_message_safely(payload, routing_key, delayed: true, delay_by: 2000)
       end
 
       it "should call send_delayed_message if requested without delay_by" do
         expect_any_instance_of(Pwwka::Transmitter).to receive(:send_delayed_message!)
-          .with(payload, routing_key)
+                                                          .with(payload, routing_key)
         Pwwka::Transmitter.send_message_safely(payload, routing_key, delayed: true)
       end
 

metadata

@@ -1,14 +1,21 @@
 --- !ruby/object:Gem::Specification
 name: pwwka
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.5.0
 platform: ruby
 authors:
 - Stitch Fix Engineering
+- Andrew Peterson
+- Bill Eisenhauer
+- Dave Copeland
+- David A McClain
+- Jonathan Dean
+- Nick Reavill
+- Simeon Willbanks
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-03 00:00:00.000000000 Z
+date: 2015-12-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny
@@ -114,6 +121,13 @@ description: |-
     message bus
 email:
 - opensource@stitchfix.com
+- andy@ndpsoftware.com
+- bill@stitchfix.com
+- davetron5000@gmail.com
+- david@stitchfix.com
+- jon@jonathandean.com
+- nick@fluxequalsrad.com
+- simeon@simeons.net
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -122,9 +136,11 @@ files:
 - ".ruby-gemset"
 - ".ruby-version"
 - ".travis.yml"
+- CODE_OF_CONDUCT.md
 - CONTRIBUTING.md
 - Gemfile
 - Gemfile.lock
+- LICENSE
 - README.md
 - Rakefile
 - docs/images/RabbitMQ_Management-2.png
@@ -138,6 +154,7 @@ files:
 - lib/pwwka/message_queuer.rb
 - lib/pwwka/queue_resque_job_handler.rb
 - lib/pwwka/receiver.rb
+- lib/pwwka/send_message_async_job.rb
 - lib/pwwka/tasks.rb
 - lib/pwwka/test_handler.rb
 - lib/pwwka/transmitter.rb
@@ -148,10 +165,12 @@ files:
 - spec/message_queuer_spec.rb
 - spec/queue_resque_job_handler_spec.rb
 - spec/receiver_spec.rb
+- spec/send_message_async_job_spec.rb
 - spec/spec_helper.rb
 - spec/transmitter_spec.rb
 homepage: https://github.com/stitchfix/pwwka
-licenses: []
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -169,7 +188,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.1
+rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
 summary: Send and receive messages via RabbitMQ
@@ -179,5 +198,6 @@ test_files:
 - spec/message_queuer_spec.rb
 - spec/queue_resque_job_handler_spec.rb
 - spec/receiver_spec.rb
+- spec/send_message_async_job_spec.rb
 - spec/spec_helper.rb
 - spec/transmitter_spec.rb