pwwka 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d40cdf7ab32f4a3731ecba95fd75c16cca7c4c70
-  data.tar.gz: cfa26d01c9484c309b45d27f09c40a7390d1e10c
+  metadata.gz: c195d91e8fc1f10c07a903840900b6e4fc1907ec
+  data.tar.gz: 7d429e0e5d3431f214ac8985299afc3884e3e82e
 SHA512:
-  metadata.gz: addff24275e10692962c599fdb04bc5d9536e22abea010ba18d95f5b9dcb168215e376aae0c49408a8273e361066b8979db0b10100e317271292ba399387d090
-  data.tar.gz: f387dad318f3cf12262313ebfc7432cc8fe606d758c207f05453a32bcc4f9c7cd3f10c665bf72ae7e7951b3c6f61d8cbffc40f8e1b2d83f85b5d6b506e1e610a
+  metadata.gz: 6ac4140dff8b136fc8b432625c787ce4132c4ce85057678e59acd57ef0475dcf3f676808c62d7c446770b52b732e524dcccbcaa4b6423f1d7f215272da547f47
+  data.tar.gz: fcdfbe94f023dd4a471301636acca4d61b182324b8ea521cc6f2175467c78cd7795785abecdb1036e496b2d2b37f02c99dab91f5ba47b18e3a62bc8a4dd78b93

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    pwwka (0.2.0)
+    pwwka (0.3.0)
       activemodel
       activesupport
       bunny
@@ -10,10 +10,10 @@ PATH
 GEM
   remote: https://www.rubygems.org/
   specs:
-    activemodel (4.1.4)
-      activesupport (= 4.1.4)
+    activemodel (4.1.5)
+      activesupport (= 4.1.5)
       builder (~> 3.1)
-    activesupport (4.1.4)
+    activesupport (4.1.5)
       i18n (~> 0.6, >= 0.6.9)
       json (~> 1.7, >= 1.7.7)
       minitest (~> 5.1)
@@ -26,7 +26,7 @@ GEM
     diff-lcs (1.2.5)
     i18n (0.6.11)
     json (1.8.1)
-    minitest (5.4.0)
+    minitest (5.4.1)
     mono_logger (1.1.0)
     rake (10.3.2)
     rspec (3.0.0)

data/README.md

@@ -55,6 +55,7 @@ require 'pwwka'
 Pwwka.configure do |config|
   config.rabbit_mq_host      = ENV['RABBITMQ_URL']
   config.topic_exchange_name = "mycompany-topics-#{Rails.env}"
+  config.options             = {allow_delayed: true}
 end
 ```
 
@@ -93,6 +94,37 @@ 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.
 
+### 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:
+
+```ruby
+payload = {client_id: '13452564'}
+routing_key	= 'sf.clients.client.created'
+Pwwka::Transmitter.send_message!(payload, routing_key, delayed: true, delay_by: 3000)
+```
+
+`delay_by` is an integer of milliseconds to delay the message. The default (if no value is set) is 5000 (5 seconds).
+
+These extra arguments work for all message sending methods - the safe ones, the handling, and the message_queuer methods (see below).
+
+### 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.
+  
+For example:
+
+```ruby
+# instantiate a message_queuer object
+message_queuer  = MessageQueuerService.new
+ActiveRecord::Base.transaction do
+  # do a thing, then queue message
+  message_queuer.queue_message(payload: {this: 'that'}, routing_key: 'go.to.there')
+
+  # do another thing, then queue a delayed message
+  message_queuer.queue_message(payload: {the: 'other'}, routing_key: 'go.somewhere.else', delayed: true, delay_by: 3000)
+end
+# send the queued messages if we make it out of the transaction alive
+message_queuer.send_messages_safely
+```
 
 ## Receiving messages
 

data/lib/pwwka/channel_connector.rb

@@ -2,24 +2,47 @@ module Pwwka
   class ChannelConnector
 
     attr_reader :connection
-    attr_reader :topic_exchange_name
+    attr_reader :configuration
     attr_reader :channel
 
     # The channel_connector starts the connection to the message_bus
     # so it should only be instantiated by a method that has a strategy
     # for closing the connection
     def initialize
-      configuration        = Pwwka.configuration
-      connection_options   = {automatically_recover: false}.merge(configuration.options)
-      @connection          = Bunny.new(configuration.rabbit_mq_host,
+      @configuration     = Pwwka.configuration
+      connection_options = {automatically_recover: false}.merge(configuration.options)
+      @connection        = Bunny.new(configuration.rabbit_mq_host,
                                   connection_options)
-      @topic_exchange_name = configuration.topic_exchange_name
       @connection.start
-      @channel             = @connection.create_channel
+      @channel           = @connection.create_channel
     end
 
     def topic_exchange
-      @topic_exchange ||= channel.topic(topic_exchange_name, durable: true)
+      @topic_exchange ||= channel.topic(configuration.topic_exchange_name, durable: true)
+    end
+
+    def delayed_exchange
+      raise_if_delayed_not_allowed
+      @delayed_exchange ||= channel.fanout(configuration.delayed_exchange_name, durable: true)
+    end
+
+    def delayed_queue
+      raise_if_delayed_not_allowed
+      @delayed_queue ||= begin
+        queue = channel.queue("pwwka_delayed_#{Pwwka.environment}", durable: true,
+          arguments: {
+            'x-dead-letter-exchange' => configuration.topic_exchange_name,
+        })
+        queue.bind(delayed_exchange)
+        queue
+      end 
+    end
+    alias :create_delayed_queue :delayed_queue
+
+    def raise_if_delayed_not_allowed
+      unless configuration.allow_delayed?
+        raise ConfigurationError, "Delayed messages are not allowed. Update your configuration to allow them." 
+      end
     end
 
     def connection_close
@@ -28,4 +51,4 @@ module Pwwka
     end
 
   end
-end
+end

data/lib/pwwka/configuration.rb

@@ -1,18 +1,26 @@
 require 'bunny'
 require 'mono_logger'
 module Pwwka
+  class ConfigurationError < StandardError; end
   class Configuration
 
     attr_accessor :rabbit_mq_host 
     attr_accessor :topic_exchange_name
+    attr_accessor :delayed_exchange_name
     attr_accessor :logger
     attr_accessor :options
 
     def initialize
-      @rabbit_mq_host       = nil
-      @topic_exchange_name  = "pwwka-topics-#{Pwwka.environment}"
-      @logger               = MonoLogger.new(STDOUT)
-      @options              = {}
+      @rabbit_mq_host        = nil
+      @topic_exchange_name   = "pwwka.topics.#{Pwwka.environment}"
+      @delayed_exchange_name = "pwwka.delayed.#{Pwwka.environment}"
+      @logger                = MonoLogger.new(STDOUT)
+      @options               = {}
+    end
+
+
+    def allow_delayed?
+      options[:allow_delayed]
     end
 
   end

data/lib/pwwka/handling.rb

@@ -1,14 +1,10 @@
+require 'forwardable'
 module Pwwka
 
   module Handling
+    extend Forwardable
 
-    def send_message!(payload, routing_key)
-      Pwwka::Transmitter.send_message!(payload, routing_key)
-    end
-
-    def send_message_safely(payload, routing_key)
-      Pwwka::Transmitter.send_message_safely(payload, routing_key)
-    end
+    def_delegators :'Pwwka::Transmitter', :send_message!, :send_message_safely
 
   end
 

data/lib/pwwka/message_queuer.rb

@@ -0,0 +1,66 @@
+module Pwwka
+  # Queue messages for sending in a batch
+  # Primarily used when multiple messages need to sent from within a 
+  # transaction block
+  #
+  # Example:
+  #
+  #     # instantiate a message_queuer object
+  #     message_queuer  = MessageQueuerService.new
+  #     ActiveRecord::Base.transaction do
+  #       # do a thing, then queue message
+  #       message_queuer.queue_message(payload: {this: 'that'}, routing_key: 'go.to.there')
+  #
+  #       # do another thing, then queue a delayed message
+  #       message_queuer.queue_message(payload: {the: 'other'}, routing_key: 'go.somewhere.else', delayed: true, delay_by: 3000)
+  #     end
+  #     # send the queued messages if we make it out of the transaction alive
+  #     message_queuer.send_messages_safely
+
+
+  class MessageQueuer
+
+    include Handling
+
+    attr_reader :message_queue
+
+    def initialize()
+      @message_queue  = []
+    end
+
+    def queue_message(payload:, routing_key:, delayed: false, delay_by: nil)
+      message_queue.push({
+            payload: payload,
+        routing_key: routing_key,
+            delayed: delayed,
+           delay_by: delay_by
+      })
+    end
+
+    def send_messages_safely
+      message_queue.each do |message|
+        delay_hash  = {delayed: message[:delayed], delay_by: message[:delay_by]}.delete_if{|_,v|!v}
+        send_message_safely(*message_arguments(message))
+      end
+      clear_messages
+    end
+
+    def send_messages!
+      message_queue.each do |message|
+        send_message!(*message_arguments(message))
+      end
+      clear_messages
+    end
+
+    def clear_messages
+      @message_queue.clear
+    end
+
+    private
+    def message_arguments(message)
+      delay_hash  = {delayed: message[:delayed], delay_by: message[:delay_by]}.delete_if{|_,v|!v}
+      [message[:payload], message[:routing_key], (delay_hash.any? ? delay_hash : nil)].compact
+    end
+
+  end
+end

data/lib/pwwka/test_handler.rb

@@ -10,13 +10,9 @@ module Pwwka
   class TestHandler
 
     attr_reader :channel_connector
-    attr_reader :channel
-    attr_reader :topic_exchange
 
     def initialize
       @channel_connector = ChannelConnector.new
-      @channel           = channel_connector.channel
-      @topic_exchange    = channel_connector.topic_exchange
     end
 
     # call this method to create the queue used for testing
@@ -28,8 +24,8 @@ module Pwwka
 
     def test_queue
       @test_queue  ||= begin
-                         test_queue  = channel.queue("test-queue", durable: true)
-                         test_queue.bind(topic_exchange, routing_key: "#.#")
+                         test_queue  = channel_connector.channel.queue("test-queue", durable: true)
+                         test_queue.bind(channel_connector.topic_exchange, routing_key: "#.#")
                          test_queue
                        end
     end
@@ -62,11 +58,16 @@ module Pwwka
 
     def purge_test_queue
       test_queue.purge  
+      channel_connector.delayed_queue.purge if channel_connector.configuration.allow_delayed?
     end
 
     def test_teardown
       test_queue.delete
-      topic_exchange.delete
+      channel_connector.topic_exchange.delete
+      # delayed messages
+      channel_connector.delayed_queue.delete
+      channel_connector.delayed_exchange.delete
+
       channel_connector.connection_close 
     end
 

data/lib/pwwka/transmitter.rb

@@ -13,17 +13,28 @@ module Pwwka
     extend Pwwka::Logging
     include Pwwka::Logging
 
+    attr_reader :channel_connector
+    def initialize
+      @channel_connector = ChannelConnector.new 
+    end
+
     # Send an important message that must go through.  This method allows any raised exception 
     # to pass through.
     #
     # payload:: Hash of what you'd like to include in your message
     # routing_key:: String routing key for the message
+    # delayed:: Boolean send this message later
+    # delay_by:: Integer milliseconds to delay the message
     #
     # Returns true
     #
     # Raises any exception generated by the innerworkings of this library.
-    def self.send_message!(payload, routing_key)
-      new.send_message!(payload, routing_key)
+    def self.send_message!(payload, routing_key, 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}"
     end
 
@@ -32,10 +43,12 @@ module Pwwka
     #
     # payload:: Hash of what you'd like to include in your message
     # routing_key:: String routing key for the message
+    # delayed:: Boolean send this message later
+    # delay_by:: Integer milliseconds to delay the message
     #
     # Returns true if the message was sent, false otherwise
-    def self.send_message_safely(payload, routing_key)
-      send_message!(payload, routing_key)
+    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
@@ -43,7 +56,6 @@ module Pwwka
 
     def send_message!(payload, routing_key)
       info "START Transmitting Message on #{routing_key} -> #{payload}"
-      channel_connector = ChannelConnector.new 
       channel_connector.topic_exchange.publish(
         payload.to_json,
         routing_key: routing_key,
@@ -53,5 +65,21 @@ module Pwwka
       info "END Transmitting Message on #{routing_key} -> #{payload}"
       true
     end
+
+    def send_delayed_message!(payload, routing_key, delay_by = 5000)
+      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)
+      channel_connector.connection_close
+      # if it gets this far it has succeeded
+      info "END Transmitting Delayed Message on #{routing_key} -> #{payload}"
+      true
+    end
+
   end
 end

data/lib/pwwka/version.rb

@@ -1,3 +1,3 @@
 module Pwwka
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

data/lib/pwwka.rb

@@ -27,5 +27,6 @@ require 'pwwka/channel_connector'
 require 'pwwka/handling'
 require 'pwwka/receiver'
 require 'pwwka/transmitter'
+require 'pwwka/message_queuer'
 
 require 'pwwka/configuration'

data/spec/handling_spec.rb

@@ -9,17 +9,17 @@ describe Pwwka::Handling do
   describe "adding handler methods" do
 
     let(:handling_class) { HKlass.new }
-    let(:payload)     { { this: 'that'} }
-    let(:routing_key) { 'sf.merch.style.updated' }
+    let(:payload)        { { this: 'that'} }
+    let(:routing_key)    { 'sf.merch.style.updated' }
 
     it "should respond to 'send_message!'" do
-      expect(Pwwka::Transmitter).to receive(:send_message!).with(payload, routing_key)
-      handling_class.send_message!(payload, routing_key)
+      expect(Pwwka::Transmitter).to receive(:send_message!).with(payload, routing_key, delayed: false, delay_by: nil)
+      handling_class.send_message!(payload, routing_key, delayed: false, delay_by: nil)
     end
 
     it "should respond to 'send_message_safely'" do
-      expect(Pwwka::Transmitter).to receive(:send_message_safely).with(payload, routing_key)
-      handling_class.send_message_safely(payload, routing_key)
+      expect(Pwwka::Transmitter).to receive(:send_message_safely).with(payload, routing_key, delayed: true, delay_by: 4000)
+      handling_class.send_message_safely(payload, routing_key, delayed: true, delay_by: 4000)
     end
 
   end

data/spec/message_queuer_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe Pwwka::MessageQueuer do
+
+  let(:message_queuer)  { Pwwka::MessageQueuer.new }
+  let(:message_queuer_with_messages) {
+    message_queuer  = Pwwka::MessageQueuer.new
+    message_queuer.queue_message(payload: payload1, routing_key: routing_key1)
+    message_queuer.queue_message(
+      payload: payload2, routing_key: routing_key2, delayed: true, delay_by: 3500
+    )
+    message_queuer
+  }
+  let(:payload1)        { {this: 'that'} }
+  let(:routing_key1)    { "thing.7.happened" }
+  let(:payload2)        { {shim: 'sham'} }
+  let(:routing_key2)    { "thing.8.happened" }
+
+  describe "#queue_message" do
+
+    it "should add a message to the queue" do
+      expect(message_queuer.message_queue).to eq([])
+      message_queuer.queue_message(payload: payload1, routing_key: routing_key1)
+      message_queuer.queue_message(
+        payload: payload2, routing_key: routing_key2, delayed: true, delay_by: 3500
+      )
+      expect(message_queuer.message_queue).to eq([{payload: payload1, routing_key: routing_key1, delayed: false, delay_by: nil}, {payload: payload2, routing_key: routing_key2, delayed: true, delay_by: 3500}])
+    end
+
+  end
+
+
+  describe "#send_messages_safely" do
+
+    it "should send the queued messages" do
+      expect(message_queuer_with_messages).to receive(:send_message_safely).with(payload1, routing_key1).and_call_original
+      expect(message_queuer_with_messages).to receive(:send_message_safely).with(payload2, routing_key2, delayed: true, delay_by: 3500).and_call_original
+      message_queuer_with_messages.send_messages_safely
+      expect(message_queuer_with_messages.message_queue).to eq([])
+    end
+
+  end
+
+  describe "#send_messages!" do
+
+    it "should send the queued messages" do
+      expect(message_queuer_with_messages).to receive(:send_message!).with(payload1, routing_key1).and_call_original
+      expect(message_queuer_with_messages).to receive(:send_message!).with(payload2, routing_key2, delayed: true, delay_by: 3500).and_call_original
+      message_queuer_with_messages.send_messages!
+      expect(message_queuer_with_messages.message_queue).to eq([])
+    end
+
+  end
+
+  describe "#clear_messages" do
+
+    it "should clear the queued messages" do
+      expect(message_queuer_with_messages.message_queue.size).to eq(2)
+      message_queuer_with_messages.clear_messages
+      expect(message_queuer_with_messages.message_queue).to eq([])
+    end
+
+  end
+
+
+end

data/spec/spec_helper.rb

@@ -1,4 +1,5 @@
 GEM_ROOT = File.expand_path(File.join(File.dirname(__FILE__),'..'))
+ENV['RAILS_ENV']  ||= 'test'
 require 'pwwka'
 require 'pwwka/test_handler'
 Dir["#{GEM_ROOT}/spec/support/**/*.rb"].sort.each {|f| require f}
@@ -12,6 +13,7 @@ RSpec.configure do |config|
 end
 
 Pwwka.configure do |config|
-  config.topic_exchange_name  = "topics-test"
-  config.logger               = MonoLogger.new("/dev/null")
+  config.topic_exchange_name     = "topics-test"
+  config.logger                  = MonoLogger.new("/dev/null")
+  config.options[:allow_delayed] = true
 end

data/spec/transmitter_spec.rb

@@ -7,6 +7,7 @@ describe Pwwka::Transmitter do
     @test_handler.test_setup
   end
 
+  after(:each) { @test_handler.purge_test_queue }
   after(:all) { @test_handler.test_teardown }
 
   let(:payload)     { Hash[:this, "that"] }
@@ -22,7 +23,7 @@ describe Pwwka::Transmitter do
         expect(received_payload["this"]).to eq("that")
       end
 
-      it "should delivery on the expected routing key" do
+      it "should deliver on the expected routing key" do
         success = Pwwka::Transmitter.new.send_message!(payload, routing_key)
         expect(success).to be_truthy
         delivery_info = @test_handler.pop_message.delivery_info
@@ -39,6 +40,46 @@ describe Pwwka::Transmitter do
 
   end
 
+  describe "#send_delayed_message!" do
+
+    context "happy path" do
+      it "should send the correct payload" do
+        success = Pwwka::Transmitter.new.send_delayed_message!(payload, routing_key, 1000)
+        expect(success).to be_truthy
+        expect(@test_handler.test_queue.message_count).to eq(0)
+        sleep 5
+        expect(@test_handler.test_queue.message_count).to eq(1)
+        received_payload = @test_handler.pop_message.payload
+        expect(received_payload["this"]).to eq("that")
+      end
+
+      it "should deliver on the expected routing key" do
+        success = Pwwka::Transmitter.new.send_delayed_message!(payload, routing_key, 1)
+        expect(success).to be_truthy
+        sleep 1
+        delivery_info = @test_handler.pop_message.delivery_info
+        expect(delivery_info.routing_key).to eq(routing_key)
+      end
+    end
+
+    it "should blow up if exception raised" do
+      expect(Pwwka::ChannelConnector).to receive(:new).and_raise("blow up")
+      expect {
+        Pwwka::Transmitter.new.send_delayed_message!(payload, routing_key, 1)
+      }.to raise_error
+    end
+
+    context "delayed not configured" do
+      it "should blow up if allow_delayed? is false" do
+        expect(@test_handler.channel_connector.configuration).to receive(:allow_delayed?).at_least(:once).and_return(false)
+        expect {
+          Pwwka::Transmitter.new.send_delayed_message!(payload, routing_key, 1)
+        }.to raise_error(Pwwka::ConfigurationError)
+      end
+    end
+
+  end
+
   describe "::send_message!" do
 
     it "should send the correct payload" do
@@ -54,6 +95,28 @@ describe Pwwka::Transmitter do
       }.to raise_error
     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)
+        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)
+        Pwwka::Transmitter.send_message!(payload, routing_key, delayed: true)
+      end
+
+      it "should not call send_delayed_message if not requested" do
+        expect_any_instance_of(Pwwka::Transmitter).not_to receive(:send_delayed_message!)
+        expect_any_instance_of(Pwwka::Transmitter).to receive(:send_message!)
+        Pwwka::Transmitter.send_message_safely(payload, routing_key)
+      end
+
+    end
+
   end
 
   describe "::send_message_safely" do
@@ -71,6 +134,28 @@ describe Pwwka::Transmitter do
       expect(@test_handler.test_queue.pop.compact.count).to eq(0)
     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)
+        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)
+        Pwwka::Transmitter.send_message_safely(payload, routing_key, delayed: true)
+      end
+
+      it "should not call send_delayed_message if not requested" do
+        expect_any_instance_of(Pwwka::Transmitter).not_to receive(:send_delayed_message!)
+        expect_any_instance_of(Pwwka::Transmitter).to receive(:send_message!)
+        Pwwka::Transmitter.send_message_safely(payload, routing_key)
+      end
+
+    end
+
   end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pwwka
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Stitch Fix Engineering
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-23 00:00:00.000000000 Z
+date: 2014-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny
@@ -119,6 +119,7 @@ files:
 - lib/pwwka/configuration.rb
 - lib/pwwka/handling.rb
 - lib/pwwka/logging.rb
+- lib/pwwka/message_queuer.rb
 - lib/pwwka/receiver.rb
 - lib/pwwka/tasks.rb
 - lib/pwwka/test_handler.rb
@@ -127,6 +128,7 @@ files:
 - pwwka.gemspec
 - spec/handling_spec.rb
 - spec/logging_spec.rb
+- spec/message_queuer_spec.rb
 - spec/receiver_spec.rb
 - spec/spec_helper.rb
 - spec/transmitter_spec.rb
@@ -149,13 +151,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0.rc.1
+rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
 summary: Send and receive messages via RabbitMQ
 test_files:
 - spec/handling_spec.rb
 - spec/logging_spec.rb
+- spec/message_queuer_spec.rb
 - spec/receiver_spec.rb
 - spec/spec_helper.rb
 - spec/transmitter_spec.rb