pwwka 0.10.0 → 0.11.0.RC1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9a435465fa3e8dcad13bfed44eddbdf49470ad20
-  data.tar.gz: 6c9f76ff17f52267f047115c30b7e0859bb5c3e4
+  metadata.gz: 3694a0647439ed09e9d80f90aa35d3b16724ad9f
+  data.tar.gz: 0d6630ecdf0aa36954b24606378a618fa36f8e38
 SHA512:
-  metadata.gz: 7701a24942e9fadb630a02cd6f38fb9ae9309c5a5668085b1c7ae9d32fbce81bee06f74410d5d9b90d2458e3468ccd4e04819ebe36e31134ed3925f7c5a579f1
-  data.tar.gz: 3c01b9656cdbeaff56c1c56ae1a80e3a567ecb850ad661db646e792851da9a55ebc27f35d52a256909d9d8e11278f3afd8d4acbd687a702f9ae8f3dcb49ebea9
+  metadata.gz: 2dcb9350aef4c3f9eaf4b5691d3d39216c0e08e4bd606060565c68cb9bc41ba14f21d8ac5c451950bec1656f0d664fc67cd417263fe88543e4cdef185018a8a7
+  data.tar.gz: b4b94ed53542512a8e74bb456c3a845013d94869143cef7fcfa8d883a2153cd057256115e938720c9f2a39694ba52638976db2324800b071abebc23d696a62e3

data/.ruby-version

@@ -1 +1 @@
-2.3.1
+2.4.1

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    pwwka (0.10.0)
+    pwwka (0.11.0.RC1)
       activemodel
       activesupport
       bunny
@@ -10,32 +10,37 @@ PATH
 GEM
   remote: https://www.rubygems.org/
   specs:
-    activemodel (5.0.1)
-      activesupport (= 5.0.1)
-    activesupport (5.0.1)
+    activemodel (5.1.1)
+      activesupport (= 5.1.1)
+    activesupport (5.1.1)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (~> 0.7)
       minitest (~> 5.1)
       tzinfo (~> 1.1)
-    amq-protocol (2.1.0)
-    bunny (2.6.3)
-      amq-protocol (>= 2.0.1)
-    concurrent-ruby (1.0.4)
-    diff-lcs (1.2.5)
+    amq-protocol (2.2.0)
+    bunny (2.7.0)
+      amq-protocol (>= 2.2.0)
+    concurrent-ruby (1.0.5)
+    diff-lcs (1.3)
     docile (1.1.5)
-    i18n (0.8.0)
-    json (1.8.3)
-    minitest (5.10.1)
+    et-orbi (1.0.4)
+      tzinfo
+    i18n (0.8.1)
+    json (2.1.0)
+    minitest (5.10.2)
     mono_logger (1.1.0)
-    multi_json (1.11.2)
-    rack (1.6.4)
-    rack-protection (1.5.3)
+    multi_json (1.12.1)
+    mustermann (1.0.0)
+    rack (2.0.3)
+    rack-protection (2.0.0)
       rack
-    rake (10.5.0)
-    redis (3.2.2)
-    redis-namespace (1.5.2)
+    rainbow (2.2.2)
+      rake
+    rake (12.0.0)
+    redis (3.3.3)
+    redis-namespace (1.5.3)
       redis (~> 3.0, >= 3.0.4)
-    resque (1.25.2)
+    resque (1.27.4)
       mono_logger (~> 1.0)
       multi_json (~> 1.0)
       redis-namespace (~> 1.3)
@@ -44,40 +49,41 @@ GEM
     resque-retry (1.5.0)
       resque (~> 1.25)
       resque-scheduler (~> 4.0)
-    resque-scheduler (4.2.0)
+    resque-scheduler (4.3.0)
       mono_logger (~> 1.0)
-      redis (~> 3.0)
-      resque (~> 1.25)
+      redis (~> 3.3)
+      resque (~> 1.26)
       rufus-scheduler (~> 3.2)
-    resqutils (1.2.0)
+    resqutils (1.2.1)
       resque
-    rspec (3.4.0)
-      rspec-core (~> 3.4.0)
-      rspec-expectations (~> 3.4.0)
-      rspec-mocks (~> 3.4.0)
-    rspec-core (3.4.3)
-      rspec-support (~> 3.4.0)
-    rspec-expectations (3.4.0)
+    rspec (3.6.0)
+      rspec-core (~> 3.6.0)
+      rspec-expectations (~> 3.6.0)
+      rspec-mocks (~> 3.6.0)
+    rspec-core (3.6.0)
+      rspec-support (~> 3.6.0)
+    rspec-expectations (3.6.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.4.0)
-    rspec-mocks (3.4.1)
+      rspec-support (~> 3.6.0)
+    rspec-mocks (3.6.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.4.0)
-    rspec-support (3.4.1)
-    rufus-scheduler (3.3.1)
-      tzinfo
-    simplecov (0.12.0)
+      rspec-support (~> 3.6.0)
+    rspec-support (3.6.0)
+    rufus-scheduler (3.4.2)
+      et-orbi (~> 1.0)
+    simplecov (0.14.1)
       docile (~> 1.1.0)
       json (>= 1.8, < 3)
       simplecov-html (~> 0.10.0)
-    simplecov-html (0.10.0)
-    sinatra (1.4.7)
-      rack (~> 1.5)
-      rack-protection (~> 1.4)
-      tilt (>= 1.3, < 3)
-    thread_safe (0.3.5)
-    tilt (2.0.2)
-    tzinfo (1.2.2)
+    simplecov-html (0.10.1)
+    sinatra (2.0.0)
+      mustermann (~> 1.0)
+      rack (~> 2.0)
+      rack-protection (= 2.0.0)
+      tilt (~> 2.0)
+    thread_safe (0.3.6)
+    tilt (2.0.7)
+    tzinfo (1.2.3)
       thread_safe (~> 0.1)
     vegas (0.1.11)
       rack (>= 1.0.0)
@@ -87,6 +93,7 @@ PLATFORMS
 
 DEPENDENCIES
   pwwka!
+  rainbow
   rake
   resque
   resque-retry
@@ -95,4 +102,4 @@ DEPENDENCIES
   simplecov
 
 BUNDLED WITH
-   1.13.6
+   1.14.6

data/README.md

@@ -91,6 +91,35 @@ Pwwka::Transmitter.send_message!(payload, routing_key)
 
 The payload should be a simple hash containing primitives. Don't send objects because the payload will be converted to JSON for sending.
 
+#### AMQP Attributes
+
+By default, pwwka will set the following [AMQP Attributes](http://stackoverflow.com/questions/18403623/rabbitmq-amqp-basicproperties-builder-values/18447385#18447385):
+
+* `message_id` - a GUID
+* `timestamp` - The time the message is sent
+* `app_id` - the name of your Rails app or, if you aren't using rails, the value of `app_id` given to the configuration
+* `content_type` - `application/json; version=1`
+
+You may optionally set the following when sending a message to set these additional attributes:
+
+* `message_id` - to override the GUID.  Generally don't do this.
+* `type` - a String to define the data type you are sending.  Useful for languages with static types to know how to
+deserialize.  You should ensure that the combo of `app_id` and `type` are unique to your entire ecosystem or consumers won't
+know what they are receiving.
+* `headers` - a hash of arbitrary headers.
+
+A fuller example:
+
+```ruby
+Pwwka::Transmitter.send_message!(
+  { "customer_id" => 12345, "active" => true },
+  "customers.customer.created",
+  type: "Customer",
+  headers: {
+    "RAILS_VERSION" => "5.1.1"
+  }
+)
+```
 
 #### Error Handling
 

data/lib/pwwka/configuration.rb

@@ -12,6 +12,7 @@ module Pwwka
     attr_accessor :async_job_klass
     attr_accessor :send_message_resque_backoff_strategy
     attr_accessor :requeue_on_error
+    attr_writer   :app_id
     attr_writer   :keep_alive_on_handler_klass_exceptions
 
     def initialize
@@ -32,6 +33,22 @@ module Pwwka
       @keep_alive_on_handler_klass_exceptions
     end
 
+    def app_id
+      if @app_id.to_s.strip == ""
+        if defined?(Rails)
+          if Rails.respond_to?(:application)
+            Rails.application.class.parent.name
+          else
+            raise "'Rails' is defined, but it doesn't respond to #application, so could not derive the app_id; you must explicitly set it"
+          end
+        else
+          raise "Could not derive the app_id; you must explicitly set it"
+        end
+      else
+        @app_id
+      end
+    end
+
     def payload_logging
       @payload_logging || :info
     end

data/lib/pwwka/publish_options.rb

@@ -0,0 +1,30 @@
+require "securerandom"
+module Pwwka
+  # Encaspulates the options we pass to `topic_exchange.publish` as well
+  # as the various defaults and auto-generated values.
+  class PublishOptions
+    def initialize(routing_key: ,
+                   message_id: :auto_generate,
+                   type: ,
+                   headers:,
+                   expiration: nil)
+      @options_hash = {
+        routing_key: routing_key,
+        message_id: message_id.to_s == "auto_generate" ? SecureRandom.uuid : message_id,
+        content_type: "application/json; version=1",
+        persistent:  true,
+        app_id: Pwwka.configuration.app_id
+      }
+      @options_hash[:type]       = type unless type.nil?
+      @options_hash[:headers]    = headers unless headers.nil?
+      @options_hash[:expiration] = expiration unless expiration.nil?
+    end
+
+    def message_id
+      @options_hash[:message_id]
+    end
+    def to_h
+      @options_hash.merge(timestamp: Time.now.to_i)
+    end
+  end
+end

data/lib/pwwka/send_message_async_job.rb

@@ -8,9 +8,21 @@ module Pwwka
     extend Resque::Plugins::ExponentialBackoff rescue nil # Optional
     @backoff_strategy = Pwwka.configuration.send_message_resque_backoff_strategy
 
-    def self.perform(payload, routing_key)
+    def self.perform(payload, routing_key, options = {})
+
+      type       = options["type"]
+      message_id = options["message_id"] || "auto_generate"
+      headers    = options["headers"]
+
       info("Sending message async #{routing_key}, #{payload}")
-      Pwwka::Transmitter.send_message!(payload, routing_key, on_error: :raise)
+      message_id = message_id.to_sym if message_id == "auto_generate"
+      Pwwka::Transmitter.send_message!(
+        payload,
+        routing_key,
+        type: type,
+        message_id: message_id,
+        headers: headers,
+        on_error: :raise)
     end
   end
 end

data/lib/pwwka/transmitter.rb

@@ -1,3 +1,5 @@
+require_relative "publish_options"
+
 begin  # optional dependency
   require 'resque'
   require 'resque-retry'
@@ -34,6 +36,9 @@ module Pwwka
     # routing_key:: String routing key for the message
     # delayed:: Boolean send this message later
     # delay_by:: Integer milliseconds to delay the message
+    # type:: A string describing the type.  This + your configured app_id should be unique to your entire ecosystem.
+    # message_id:: If specified (which generally you should not do), sets the id of the message.  If omitted, a GUID is used.
+    # headers:: A hash of arbitrary headers to include in the AMQP attributes
     # on_error:: What is the behavior of
     # - :ignore (aka as send_message_safely)
     # - :raise
@@ -42,12 +47,17 @@ module Pwwka
     # Returns true
     #
     # Raises any exception generated by the innerworkings of this library.
-    def self.send_message!(payload, routing_key, on_error: :raise,
-        delayed: false, delay_by: nil)
+    def self.send_message!(payload, routing_key,
+                           on_error: :raise,
+                           delayed: false,
+                           delay_by: nil,
+                           type: nil,
+                           message_id: :auto_generate,
+                           headers: nil)
       if delayed
-        new.send_delayed_message!(*[payload, routing_key, delay_by].compact)
+        new.send_delayed_message!(*[payload, routing_key, delay_by].compact, type: type, headers: headers, message_id: message_id)
       else
-        new.send_message!(payload, routing_key)
+        new.send_message!(payload, routing_key, type: type, headers: headers, message_id: message_id)
       end
       logf "AFTER Transmitting Message on %{routing_key} -> %{payload}",routing_key: routing_key, payload: payload
       true
@@ -74,9 +84,18 @@ module Pwwka
 
     # 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)
+    def self.send_message_async(payload, routing_key,
+                                delay_by_ms: 0,
+                                type: nil,
+                                message_id: :auto_generate,
+                                headers: nil)
       job = Pwwka.configuration.async_job_klass
-      Resque.enqueue_in(delay_by_ms/1000, job, payload, routing_key)
+      # Be perhaps too carefully making sure we queue jobs in the legacy way
+      if type == nil && message_id == :auto_generate && headers == nil
+        Resque.enqueue_in(delay_by_ms/1000, job, payload, routing_key)
+      else
+        Resque.enqueue_in(delay_by_ms/1000, job, payload, routing_key, type: type, message_id: message_id, headers: headers)
+      end
     end
 
     # Send a less important message that doesn't have to go through. This eats
@@ -89,35 +108,41 @@ module Pwwka
     #
     # 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)
+    def self.send_message_safely(payload, routing_key, delayed: false, delay_by: nil, message_id: message_id)
       send_message!(payload, routing_key, delayed: delayed, delay_by: delay_by, on_error: :ignore)
     end
 
-    def send_message!(payload, routing_key)
-      logf "START Transmitting Message on %{routing_key} -> %{payload}", routing_key: routing_key, payload: payload
-      channel_connector.topic_exchange.publish(
-          payload.to_json,
-          routing_key: routing_key,
-          persistent:  true)
+    def send_message!(payload, routing_key, type: nil, headers: nil, message_id: :auto_generate)
+      publish_options = Pwwka::PublishOptions.new(
+        routing_key: routing_key,
+        message_id: message_id,
+        type: type,
+        headers: headers
+      )
+      logf "START Transmitting Message on id[%{id}] %{routing_key} -> %{payload}", id: publish_options.message_id, routing_key: routing_key, payload: payload
+      channel_connector.topic_exchange.publish(payload.to_json, publish_options.to_h)
       channel_connector.connection_close
       # if it gets this far it has succeeded
-      logf "END Transmitting Message on %{routing_key} -> %{payload}", routing_key: routing_key, payload: payload
+      logf "END Transmitting Message on id[%{id}] %{routing_key} -> %{payload}", id: publish_options.message_id, routing_key: routing_key, payload: payload
       true
     end
 
 
-    def send_delayed_message!(payload, routing_key, delay_by = DEFAULT_DELAY_BY_MS)
+    def send_delayed_message!(payload, routing_key, delay_by = DEFAULT_DELAY_BY_MS, type: nil, headers: nil, message_id: :auto_generate)
       channel_connector.raise_if_delayed_not_allowed
-      logf "START Transmitting Delayed Message on %{routing_key} -> %{payload}", routing_key: routing_key, payload: payload
+      publish_options = Pwwka::PublishOptions.new(
+        routing_key: routing_key,
+        message_id: message_id,
+        type: type,
+        headers: headers,
+        expiration: delay_by
+      )
+      logf "START Transmitting Delayed Message on id[%{id}] %{routing_key} -> %{payload}", id: publish_options.message_id, routing_key: routing_key, payload: 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.delayed_exchange.publish(payload.to_json,publish_options.to_h)
       channel_connector.connection_close
       # if it gets this far it has succeeded
-      logf "END Transmitting Delayed Message on %{routing_key} -> %{payload}", routing_key: routing_key, payload: payload
+      logf "END Transmitting Delayed Message on id[%{id}] %{routing_key} -> %{payload}", id: publish_options.message_id, routing_key: routing_key, payload: payload
       true
     end
 

data/lib/pwwka/version.rb

@@ -1,3 +1,3 @@
 module Pwwka
-  VERSION = '0.10.0'
+  VERSION = '0.11.0.RC1'
 end

data/pwwka.gemspec

@@ -29,4 +29,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency("resque-retry")
   s.add_development_dependency("simplecov")
   s.add_development_dependency("resqutils")
+  s.add_development_dependency("rainbow")
 end

data/spec/integration/send_and_receive_spec.rb

@@ -31,79 +31,177 @@ describe "sending and receiving messages", :integration do
     @testing_setup.kill_threads_and_clear_queues
   end
 
-  it "can send a message that gets routed to all receivers" do
-    Pwwka::Transmitter.send_message!({ sample: "payload", has: { deeply: true, nested: 4 }},
-                                     "pwwka.testing.foo")
-    allow_receivers_to_process_queues
-
-    expect(AllReceiver.messages_received.size).to eq(1)
-    expect(FooReceiver.messages_received.size).to eq(1)
-    expect(OtherFooReceiver.messages_received.size).to eq(1)
-    @testing_setup.queues.each do |queue|
-      expect(queue.message_count).to eq(0)
+  context "routing" do
+    it "can send a message that gets routed to all receivers" do
+      Pwwka::Transmitter.send_message!({ sample: "payload", has: { deeply: true, nested: 4 }},
+                                       "pwwka.testing.foo")
+      allow_receivers_to_process_queues
+
+      expect(AllReceiver.messages_received.size).to eq(1)
+      expect(FooReceiver.messages_received.size).to eq(1)
+      expect(OtherFooReceiver.messages_received.size).to eq(1)
+      @testing_setup.queues.each do |queue|
+        expect(queue.message_count).to eq(0)
+      end
+    end
+    it "can send a message that is only delivered to some  handlers based on routing key" do
+      Pwwka::Transmitter.send_message!({ sample: "payload", has: { deeply: true, nested: 4 }},
+                                       "pwwka.testing.bar")
+      allow_receivers_to_process_queues
+
+      expect(AllReceiver.messages_received.size).to eq(1)
+      expect(FooReceiver.messages_received.size).to eq(0)
+      expect(OtherFooReceiver.messages_received.size).to eq(0)
+      @testing_setup.queues.each do |queue|
+        expect(queue.message_count).to eq(0)
+      end
     end
   end
 
-  it "can send a message delayed" do
-    Pwwka::Transmitter.send_message!({ sample: "payload", has: { deeply: true, nested: 4 }},
-                                     "pwwka.testing.foo",
-                                      delayed: true,
-                                      delay_by: 5_000)
-    allow_receivers_to_process_queues(1_000)
+  context "metadata" do
+    it "can access standard metadata" do
+      Pwwka::Transmitter.send_message!({ sample: "payload", has: { deeply: true, nested: 4 }},
+                                       "pwwka.testing.foo")
+      allow_receivers_to_process_queues
 
-    expect(AllReceiver.messages_received.size).to eq(0)
-    expect(FooReceiver.messages_received.size).to eq(0)
-    expect(OtherFooReceiver.messages_received.size).to eq(0)
+      expect(AllReceiver.metadata[0].message_id).not_to be_nil
+      expect(AllReceiver.metadata[0].timestamp).to be_within(2.minutes).of(Time.now)
+      expect(AllReceiver.metadata[0].content_type).to eq("application/json; version=1")
+      expect(AllReceiver.metadata[0].app_id).to eq("MyAwesomeApp")
+    end
 
-    allow_receivers_to_process_queues(5_000)
-    expect(AllReceiver.messages_received.size).to eq(1)
-    expect(FooReceiver.messages_received.size).to eq(1)
-    expect(OtherFooReceiver.messages_received.size).to eq(1)
-  end
+    it "can access standard metadata on delayed jobs" do
+      Pwwka::Transmitter.send_message!({ sample: "payload", has: { deeply: true, nested: 4 }},
+                                       "pwwka.testing.foo",
+                                       delayed: true,
+                                       delay_by: 100)
+      allow_receivers_to_process_queues(200)
+
+      expect(AllReceiver.metadata[0].message_id).not_to be_nil
+      expect(AllReceiver.metadata[0].timestamp).to be_within(2.minutes).of(Time.now)
+      expect(AllReceiver.metadata[0].content_type).to eq("application/json; version=1")
+      expect(AllReceiver.metadata[0].app_id).to eq("MyAwesomeApp")
+    end
 
-  it "can send a message that is only delivered to some  handlers based on routing key" do
-    Pwwka::Transmitter.send_message!({ sample: "payload", has: { deeply: true, nested: 4 }},
-                                     "pwwka.testing.bar")
-    allow_receivers_to_process_queues
+    it "can access explicitly-provided metadata" do
+      Pwwka::Transmitter.send_message!({ sample: "payload", has: { deeply: true, nested: 4 }},
+                                       "pwwka.testing.foo",
+                                       type: "Customer",
+                                       headers: {
+                                         foo: "bar",
+                                         blah: 42,
+                                       })
+      allow_receivers_to_process_queues
+
+      expect(AllReceiver.metadata[0].message_id).not_to be_nil
+      expect(AllReceiver.metadata[0].timestamp).to be_within(2.minutes).of(Time.now)
+      expect(AllReceiver.metadata[0].content_type).to eq("application/json; version=1")
+      expect(AllReceiver.metadata[0].app_id).to eq("MyAwesomeApp")
+      expect(AllReceiver.metadata[0].type).to eq("Customer")
+      expect(AllReceiver.metadata[0].headers["foo"]).to eq("bar")
+      expect(AllReceiver.metadata[0].headers["blah"]).to eq(42)
+    end
 
-    expect(AllReceiver.messages_received.size).to eq(1)
-    expect(FooReceiver.messages_received.size).to eq(0)
-    expect(OtherFooReceiver.messages_received.size).to eq(0)
-    @testing_setup.queues.each do |queue|
-      expect(queue.message_count).to eq(0)
+    it "can access explicitly-provided metadata on delayed jobs" do
+      Pwwka::Transmitter.send_message!({ sample: "payload", has: { deeply: true, nested: 4 }},
+                                       "pwwka.testing.foo",
+                                       type: "Customer",
+                                       headers: {
+                                         foo: "bar",
+                                         blah: 42,
+                                       },
+                                       delayed: true,
+                                       delay_by: 100)
+      allow_receivers_to_process_queues(200)
+
+      expect(AllReceiver.metadata[0].message_id).not_to be_nil
+      expect(AllReceiver.metadata[0].timestamp).to be_within(2.minutes).of(Time.now)
+      expect(AllReceiver.metadata[0].content_type).to eq("application/json; version=1")
+      expect(AllReceiver.metadata[0].type).to eq("Customer")
+      expect(AllReceiver.metadata[0].app_id).to eq("MyAwesomeApp")
+      expect(AllReceiver.metadata[0].headers["foo"]).to eq("bar")
+      expect(AllReceiver.metadata[0].headers["blah"]).to eq(42)
     end
   end
 
-  it "can queue a job to send a message from a Resque job" do
-    Pwwka::Transmitter.send_message_async({ sample: "payload", has: { deeply: true, nested: 4 }},
-                                          "pwwka.testing.bar")
+  context "sending messages from a background job" do
+    it "can queue a job to send a message from a Resque job" do
+      Pwwka::Transmitter.send_message_async({ sample: "payload", has: { deeply: true, nested: 4 }},
+                                            "pwwka.testing.bar")
 
-    allow_receivers_to_process_queues # not expecting anything to be processed
+      allow_receivers_to_process_queues # not expecting anything to be processed
 
-    expect(AllReceiver.messages_received.size).to eq(0)
+      expect(AllReceiver.messages_received.size).to eq(0)
 
-    process_resque_job(Pwwka::SendMessageAsyncJob,:delayed)
+      process_resque_job(Pwwka::SendMessageAsyncJob,:delayed)
 
-    allow_receivers_to_process_queues
+      allow_receivers_to_process_queues
 
-    expect(AllReceiver.messages_received.size).to eq(1)
-  end
+      expect(AllReceiver.messages_received.size).to eq(1)
+    end
+
+    it "can queue a job with optional arguments to send a message from a Resque job" do
+      Pwwka::Transmitter.send_message_async(
+        { sample: "payload", has: { deeply: true, nested: 4 }},
+        "pwwka.testing.bar",
+        message_id: "setting this is a bad idea, but you can do it",
+        headers: {
+          "FOO" => "bar"
+        },
+        type: "Customer"
+      )
+
+      allow_receivers_to_process_queues # not expecting anything to be processed
+
+      expect(AllReceiver.messages_received.size).to eq(0)
+
+      process_resque_job(Pwwka::SendMessageAsyncJob,:delayed)
+
+      allow_receivers_to_process_queues
 
-  it "can queue a job to send a message to a specified Resque job queue" do
-    async_job_klass = double(:async_job_klass)
-    configuration = Pwwka::Configuration.new
-    configuration.async_job_klass = async_job_klass
+      expect(AllReceiver.messages_received.size).to eq(1)
+      expect(AllReceiver.metadata[0].message_id).to eq("setting this is a bad idea, but you can do it")
+      expect(AllReceiver.metadata[0].timestamp).to be_within(2.minutes).of(Time.now)
+      expect(AllReceiver.metadata[0].content_type).to eq("application/json; version=1")
+      expect(AllReceiver.metadata[0].type).to eq("Customer")
+      expect(AllReceiver.metadata[0].app_id).to eq("MyAwesomeApp")
+      expect(AllReceiver.metadata[0].headers["FOO"]).to eq("bar")
+    end
+
+    it "can queue a job to send a message to a specified Resque job queue" do
+      async_job_klass = double(:async_job_klass)
+      configuration = Pwwka::Configuration.new
+      configuration.async_job_klass = async_job_klass
+
+      allow(Pwwka).to receive(:configuration).and_return(configuration)
+
+      allow(Resque).to receive(:enqueue_in)
 
-    allow(Pwwka).to receive(:configuration).and_return(configuration)
+      Pwwka::Transmitter.send_message_async({ sample: "payload", has: { deeply: true, nested: 4 }},
+                                            "pwwka.testing.bar")
+
+      expect(Resque).to have_received(:enqueue_in).with(anything, async_job_klass, anything, anything)
+    end
+  end
 
-    allow(Resque).to receive(:enqueue_in)
+  it "can send a message delayed" do
+    Pwwka::Transmitter.send_message!({ sample: "payload", has: { deeply: true, nested: 4 }},
+                                     "pwwka.testing.foo",
+                                      delayed: true,
+                                      delay_by: 5_000)
+    allow_receivers_to_process_queues(1_000)
 
-    Pwwka::Transmitter.send_message_async({ sample: "payload", has: { deeply: true, nested: 4 }},
-                                          "pwwka.testing.bar")
+    expect(AllReceiver.messages_received.size).to eq(0)
+    expect(FooReceiver.messages_received.size).to eq(0)
+    expect(OtherFooReceiver.messages_received.size).to eq(0)
 
-    expect(Resque).to have_received(:enqueue_in).with(anything, async_job_klass, anything, anything)
+    allow_receivers_to_process_queues(5_000)
+    expect(AllReceiver.messages_received.size).to eq(1)
+    expect(FooReceiver.messages_received.size).to eq(1)
+    expect(OtherFooReceiver.messages_received.size).to eq(1)
   end
 
+
   class AllReceiver < LoggingReceiver
   end
   class FooReceiver < AllReceiver

data/spec/integration/support/logging_receiver.rb

@@ -1,10 +1,17 @@
 class LoggingReceiver
-  def self.reset!; @messages_received = []; end
+
+  def self.reset!
+    @messages_received = []
+    @metadata = []
+  end
+
   def self.messages_received; @messages_received ||= []; end
+  def self.metadata; @metadata ||= []; end
 
   reset!
 
   def self.handle!(delivery_info,properties,payload)
     messages_received << [ delivery_info,properties,payload ]
+    metadata << properties
   end
 end

data/spec/spec_helper.rb

@@ -34,6 +34,7 @@ RSpec.configure do |config|
       c.options[:allow_delayed]    = true
       c.requeue_on_error           = false
       c.rabbit_mq_host             = "amqp://guest:guest@localhost:#{test_configuration.rabbit_port}"
+      c.app_id                     = "MyAwesomeApp"
 
       unless ENV["SHOW_PWWKA_LOG"] == "true"
         c.logger = MonoLogger.new("/dev/null")
@@ -41,7 +42,16 @@ RSpec.configure do |config|
     end
     Resque.redis = Redis.new(port: test_configuration.resque_redis_port)
   end
-
+  config.around(:each) do |example|
+    if example.metadata[:integration]
+      result = test_configuration.check_services
+      unless result.up?
+        puts "\n\n" + Rainbow(result.error).yellow.bright + "\n\n"
+        exit 1
+      end
+    end
+    example.run
+  end
   config.order = :random
   config.filter_run_excluding :legacy
 end

data/spec/support/test_configuration.rb

@@ -1,4 +1,8 @@
-require 'yaml'
+require "yaml"
+require "socket"
+require "timeout"
+require "rainbow"
+
 class TestConfiguration
   attr_reader :resque_redis_port, :rabbit_port
   def initialize(docker_compose_file)
@@ -7,4 +11,34 @@ class TestConfiguration
     @resque_redis_port = (ENV["PWWKA_RESQUE_REDIS_PORT"] || yaml["services"]["resque"]["ports"].first.split(/:/)[0]).to_i
     @rabbit_port       = (ENV["PWWKA_RABBIT_PORT"]       || yaml["services"]["rabbit"]["ports"].first.split(/:/)[0]).to_i
   end
+
+  def check_services
+    redis_running = is_port_open?("localhost",@resque_redis_port)
+    rabbit_running = is_port_open?("localhost",@rabbit_port)
+    if !(redis_running && rabbit_port)
+      OpenStruct.new(error: "Rabbit and/or Redis is not running - you need to run `docker-compose up` in the root dir",
+                     up?: false)
+    else
+      OpenStruct.new(up?: true)
+    end
+  end
+
+private
+
+  def is_port_open?(ip, port)
+    begin
+      Timeout::timeout(1) do
+        begin
+          s = TCPSocket.new(ip, port)
+          s.close
+          return true
+        rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+          return false
+        end
+      end
+    rescue Timeout::Error
+    end
+
+    return false
+  end
 end

data/spec/unit/configuration_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper.rb'
+
+module MyAmazingApp
+  class Application
+  end
+end
+describe Pwwka::Configuration do
+
+  subject(:configuration) { described_class.new }
+  before do
+    @env = ENV["RAILS_ENV"]
+    ENV["RAILS_ENV"] = "production"
+  end
+  after do
+    ENV["RAILS_ENV"] = @env
+  end
+
+  describe "#topic_exchange_name" do
+    it "is based on the Pwwka.environment" do
+      expect(configuration.topic_exchange_name).to eq("pwwka.topics.production")
+    end
+  end
+  describe "#delayed_exchange_name" do
+    it "is based on the Pwwka.environment" do
+      expect(configuration.delayed_exchange_name).to eq("pwwka.delayed.production")
+    end
+  end
+
+  describe "#payload_logging" do
+    it "is info by default" do
+      expect(configuration.payload_logging).to eq(:info)
+    end
+
+    it "can be overridden" do
+      configuration.payload_logging = :debug
+      expect(configuration.payload_logging).to eq(:debug)
+    end
+  end
+
+  describe "#app_id" do
+    it "returns the value set explicitly" do
+      configuration.app_id = "MyApp"
+      expect(configuration.app_id).to eq("MyApp")
+    end
+    it "blows up when not set" do
+      expect {
+        configuration.app_id
+      }.to raise_error(/Could not derive the app_id; you must explicitly set it/)
+    end
+    context "when inside a Rails app" do
+      before do
+        rails = Class.new do
+          def self.application
+            MyAmazingApp::Application.new
+          end
+        end
+        Object.const_set("Rails",rails)
+      end
+      after do
+        Object.send(:remove_const,"Rails")
+      end
+      it "uses the Rails app name" do
+        expect(configuration.app_id).to eq("MyAmazingApp")
+      end
+    end
+
+    context "when Rails is defined, but not how we expect" do
+      before do
+        rails = Class.new
+        Object.const_set("Rails",rails)
+      end
+      after do
+        Object.send(:remove_const,"Rails")
+      end
+      it "blows up when not set" do
+        expect {
+          configuration.app_id
+        }.to raise_error(/'Rails' is defined, but it doesn't respond to #application, so could not derive the app_id; you must explicitly set it/)
+      end
+    end
+  end
+end

data/spec/unit/send_message_async_job_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper.rb'
+
+describe Pwwka::SendMessageAsyncJob do
+  describe "::perform" do
+    before do
+      allow(Pwwka::Transmitter).to receive(:send_message!)
+    end
+    context "with just two arguments" do
+      it "calls through to Pwwka::Transmitter, setting error handling to 'raise'" do
+        described_class.perform({ "foo" => "bar"} , "some.routing.key")
+        expect(Pwwka::Transmitter).to have_received(:send_message!).with(
+          { "foo" => "bar" },
+          "some.routing.key",
+          type: nil,
+          message_id: :auto_generate,
+          headers: nil,
+          on_error: :raise
+        )
+      end
+    end
+    context "with optional values" do
+      it "passes them through to Pwwka::Transmitter" do
+        described_class.perform(
+          { "foo" => "bar"},
+          "some.routing.key",
+          "type" =>  "Customer",
+          "message_id" =>  "foobar",
+          "headers" =>  { "x" => "y" }
+        )
+        expect(Pwwka::Transmitter).to have_received(:send_message!).with(
+          { "foo" => "bar" },
+          "some.routing.key",
+          type: "Customer",
+          message_id: "foobar",
+          headers: { "x" => "y" },
+          on_error: :raise
+        )
+      end
+    end
+  end
+end

data/spec/unit/transmitter_spec.rb

@@ -36,18 +36,46 @@ describe Pwwka::Transmitter do
     before do
       allow(Resque).to receive(:enqueue_in)
     end
-
-    it "queues a Resque job" do
-      delay_by_ms = 3_000
-      described_class.send_message_async(payload,routing_key,delay_by_ms: delay_by_ms)
-      expect(Resque).to have_received(:enqueue_in).with(delay_by_ms/1_000,Pwwka::SendMessageAsyncJob,payload,routing_key)
+    context "with only basic required arguments" do
+      it "queues a Resque job with no extra args" do
+        delay_by_ms = 3_000
+        described_class.send_message_async(payload,routing_key,delay_by_ms: delay_by_ms)
+        expect(Resque).to have_received(:enqueue_in).with(delay_by_ms/1_000,Pwwka::SendMessageAsyncJob,payload,routing_key)
+      end
+    end
+    context "with everything overridden" do
+      it "queues a Resque job with the various arguments" do
+        delay_by_ms = 3_000
+        described_class.send_message_async(
+          payload,routing_key,
+          delay_by_ms: delay_by_ms,
+          message_id: "snowflake id that is likely a bad idea, but if you must",
+          type: "Customer",
+          headers: {
+            "custom" => "value",
+            "other_custom" => "other_value",
+          }
+        )
+        expect(Resque).to have_received(:enqueue_in).with(
+          delay_by_ms/1_000,
+          Pwwka::SendMessageAsyncJob,
+          payload,
+          routing_key,
+          message_id: "snowflake id that is likely a bad idea, but if you must",
+          type: "Customer",
+          headers: {
+            "custom" => "value",
+            "other_custom" => "other_value",
+          }
+        )
+      end
     end
   end
 
   shared_examples "it passes through to an instance" do
     context "not using delayed flag" do
       it "calls through to send_message!" do
-        expect_any_instance_of(described_class).to receive(:send_message!).with(payload,routing_key)
+        expect_any_instance_of(described_class).to receive(:send_message!).with(payload,routing_key, type: nil, headers: nil, message_id: :auto_generate)
         described_class.send(method,payload,routing_key)
       end
       it "logs after sending" do
@@ -66,19 +94,140 @@ describe Pwwka::Transmitter do
       context "explicitly setting delay time" do
         it "calls through to send_delayed_message! using the given delay time" do
           delay_by = 1_000
-          expect_any_instance_of(described_class).to receive(:send_delayed_message!).with(payload,routing_key,delay_by)
+          expect_any_instance_of(described_class).to receive(:send_delayed_message!).with(payload,routing_key,delay_by, type: nil, headers: nil, message_id: :auto_generate)
           described_class.send(method,payload,routing_key,delayed: true, delay_by: delay_by)
         end
       end
       context "using the default delay time" do
         it "calls through to send_delayed_message! using its default delay time" do
-          expect_any_instance_of(described_class).to receive(:send_delayed_message!).with(payload,routing_key)
+          expect_any_instance_of(described_class).to receive(:send_delayed_message!).with(payload,routing_key, type: nil, headers: nil, message_id: :auto_generate)
           described_class.send(method,payload,routing_key,delayed: true)
         end
       end
     end
   end
 
+  shared_examples "it sends standard and overridden data to the exchange" do
+    it "publishes to the topic exchange" do
+      expect(exchange).to have_received(:publish).with(payload.to_json, kind_of(Hash))
+    end
+
+    it "passes the routing key" do
+      expect(exchange).to have_received(:publish).with(
+        payload.to_json,
+        hash_including(routing_key: routing_key))
+    end
+
+    it "sets the type" do
+      expect(exchange).to have_received(:publish).with(
+        payload.to_json,
+        hash_including(type: "Customer"))
+    end
+
+    it "sets the headers" do
+      expect(exchange).to have_received(:publish).with(
+        payload.to_json,
+        hash_including(headers: { "custom" => "value", "other_custom" => "other_value" }))
+    end
+
+    it "uses the overridden message id" do
+      expect(exchange).to have_received(:publish).with(
+        payload.to_json,
+        hash_including(message_id: "snowflake id that is likely a bad idea, but if you must"))
+    end
+
+    it "sets the timestamp to now" do
+      expect(exchange).to have_received(:publish).with(
+        payload.to_json,
+        hash_including(timestamp: a_timestamp_about_now))
+    end
+
+    it "sets the app id to what's configured" do
+      expect(exchange).to have_received(:publish).with(
+        payload.to_json,
+        hash_including(app_id: "MyAwesomeApp"))
+    end
+
+    it "sets the content type to JSON with a version" do
+      expect(exchange).to have_received(:publish).with(
+        payload.to_json,
+        hash_including(content_type: "application/json; version=1"))
+    end
+
+    it "sets persistent true" do
+      expect(exchange).to have_received(:publish).with(
+        payload.to_json,
+        hash_including(persistent: true))
+    end
+  end
+
+  shared_examples "it sends standard attributes and the payload to the exchange" do
+    it "publishes to the topic exchange" do
+      expect(exchange).to have_received(:publish).with(payload.to_json, kind_of(Hash))
+    end
+
+    it "passes the routing key" do
+      expect(exchange).to have_received(:publish).with(
+        payload.to_json,
+        hash_including(routing_key: routing_key))
+    end
+
+    it "sets a default message id" do
+      expect(exchange).to have_received(:publish).with(
+        payload.to_json,
+        hash_including(message_id: a_uuid))
+    end
+
+    it "sets the timestamp to now" do
+      expect(exchange).to have_received(:publish).with(
+        payload.to_json,
+        hash_including(timestamp: a_timestamp_about_now))
+    end
+
+    it "sets the app id to what's configured" do
+      expect(exchange).to have_received(:publish).with(
+        payload.to_json,
+        hash_including(app_id: "MyAwesomeApp"))
+    end
+
+    it "sets the content type to JSON with a version" do
+      expect(exchange).to have_received(:publish).with(
+        payload.to_json,
+        hash_including(content_type: "application/json; version=1"))
+    end
+
+    it "sets persistent true" do
+      expect(exchange).to have_received(:publish).with(
+        payload.to_json,
+        hash_including(persistent: true))
+    end
+
+    it "does not set the type" do
+      expect(exchange).to have_received(:publish).with(
+        payload.to_json,
+        hash_excluding(:type))
+    end
+
+    it "does not set headers" do
+      expect(exchange).to have_received(:publish).with(
+        payload.to_json,
+        hash_excluding(:headers))
+    end
+  end
+
+  RSpec::Matchers.define :a_uuid do |x|
+    match { |actual|
+      actual =~ /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/
+    }
+  end
+
+  RSpec::Matchers.define :a_timestamp_about_now do |x|
+    match { |actual|
+      (actual - Time.now.to_i).abs < 1000
+    }
+  end
+
+
   describe ".send_message!" do
     context "no errors" do
       it_behaves_like "it passes through to an instance" do
@@ -165,21 +314,45 @@ describe Pwwka::Transmitter do
       expect(transmitter.send_message!(payload,routing_key)).to eq(true)
     end
 
-    it "publishes the message" do
-      transmitter.send_message!(payload,routing_key)
-      expect(topic_exchange).to have_received(:publish).with(payload.to_json,routing_key: routing_key, persistent: true)
-    end
-
     it "logs the start and end of the transmission" do
       transmitter.send_message!(payload,routing_key)
-      expect(logger).to have_received(:info).with(/START Transmitting Message on #{routing_key} ->/)
-      expect(logger).to have_received(:info).with(/END Transmitting Message on #{routing_key} ->/)
+      expect(logger).to have_received(:info).with(/START Transmitting Message on id\[[\w\-\d]+\] #{routing_key} ->/)
+      expect(logger).to have_received(:info).with(/END Transmitting Message on id\[[\w\-\d]+\] #{routing_key} ->/)
     end
 
     it "closes the channel connector" do
       transmitter.send_message!(payload,routing_key)
       expect(channel_connector).to have_received(:connection_close)
     end
+
+    context "with only basic required arguments" do
+
+      before do
+        transmitter.send_message!(payload,routing_key)
+      end
+
+      it_behaves_like "it sends standard attributes and the payload to the exchange" do
+        let(:exchange) { topic_exchange }
+      end
+    end
+    context "with everything overridden" do
+      before do
+        transmitter.send_message!(
+          payload,
+          routing_key,
+          message_id: "snowflake id that is likely a bad idea, but if you must",
+          type: "Customer",
+          headers: {
+            "custom" => "value",
+            "other_custom" => "other_value",
+          }
+        )
+      end
+
+      it_behaves_like "it sends standard and overridden data to the exchange" do
+        let(:exchange) { topic_exchange }
+      end
+    end
   end
 
   describe "#send_delayed_message!" do
@@ -189,29 +362,44 @@ describe Pwwka::Transmitter do
         allow(channel_connector).to receive(:create_delayed_queue)
       end
 
-      it "returns true" do
-        expect(transmitter.send_delayed_message!(payload,routing_key)).to eq(true)
-      end
-
       it "creates the delayed queue" do
         transmitter.send_delayed_message!(payload,routing_key)
         expect(channel_connector).to have_received(:create_delayed_queue)
       end
 
-      it "publishes the message to the delayed exchange" do
-        delay_by = 12345
-        transmitter.send_delayed_message!(payload,routing_key, delay_by)
-        expect(delayed_exchange).to have_received(:publish).with(payload.to_json,routing_key: routing_key, expiration: delay_by, persistent: true)
-      end
+      context "with only basic required arguments" do
+        before do
+          transmitter.send_delayed_message!(payload,routing_key,5_000)
+        end
 
-      it "logs the start and end of the transmission" do
-        transmitter.send_delayed_message!(payload,routing_key)
-        expect(logger).to have_received(:info).with(/START Transmitting Delayed Message on #{routing_key} ->/)
-        expect(logger).to have_received(:info).with(/END Transmitting Delayed Message on #{routing_key} ->/)
+        it_behaves_like "it sends standard attributes and the payload to the exchange" do
+          let(:exchange) { delayed_exchange }
+        end
+
+        it "passes an expiration value" do
+          expect(delayed_exchange).to have_received(:publish).with(
+            payload.to_json,
+            hash_including(expiration: 5_000))
+        end
       end
-      it "closes the channel connector" do
-        transmitter.send_delayed_message!(payload,routing_key)
-        expect(channel_connector).to have_received(:connection_close)
+
+      context "with everything overridden" do
+        before do
+          transmitter.send_delayed_message!(
+            payload,
+            routing_key,
+            message_id: "snowflake id that is likely a bad idea, but if you must",
+            type: "Customer",
+            headers: {
+              "custom" => "value",
+              "other_custom" => "other_value",
+            }
+          )
+        end
+
+        it_behaves_like "it sends standard and overridden data to the exchange" do
+          let(:exchange) { delayed_exchange }
+        end
       end
     end
     context "delayed queue not configured" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pwwka
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.0.RC1
 platform: ruby
 authors:
 - Stitch Fix Engineering
@@ -15,7 +15,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-21 00:00:00.000000000 Z
+date: 2017-06-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny
@@ -157,6 +157,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rainbow
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: |-
   The purpose of this gem is to normalise the sending and
     receiving of messages between Rails apps using the shared RabbitMQ
@@ -195,6 +209,7 @@ files:
 - lib/pwwka/handling.rb
 - lib/pwwka/logging.rb
 - lib/pwwka/message_queuer.rb
+- lib/pwwka/publish_options.rb
 - lib/pwwka/queue_resque_job_handler.rb
 - lib/pwwka/receiver.rb
 - lib/pwwka/send_message_async_job.rb
@@ -217,9 +232,11 @@ files:
 - spec/spec_helper.rb
 - spec/support/test_configuration.rb
 - spec/unit/channel_connector_spec.rb
+- spec/unit/configuration_spec.rb
 - spec/unit/logging_spec.rb
 - spec/unit/message_queuer_spec.rb
 - spec/unit/queue_resque_job_handler_spec.rb
+- spec/unit/send_message_async_job_spec.rb
 - spec/unit/test_handler_message_spec.rb
 - spec/unit/transmitter_spec.rb
 homepage: https://github.com/stitchfix/pwwka
@@ -237,12 +254,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.5.1
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Send and receive messages via RabbitMQ
@@ -261,8 +278,10 @@ test_files:
 - spec/spec_helper.rb
 - spec/support/test_configuration.rb
 - spec/unit/channel_connector_spec.rb
+- spec/unit/configuration_spec.rb
 - spec/unit/logging_spec.rb
 - spec/unit/message_queuer_spec.rb
 - spec/unit/queue_resque_job_handler_spec.rb
+- spec/unit/send_message_async_job_spec.rb
 - spec/unit/test_handler_message_spec.rb
 - spec/unit/transmitter_spec.rb