pwwka 0.21.2 → 0.21.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 913ec15d6763b56d762da0c368fa6caba28cc208a18f8aaba9349363e29097ef
-  data.tar.gz: 469f8b149b50c84ced5373ef6fe8cf8533593ecb9f9a0f78eee278b49bccbbd1
+  metadata.gz: 5a449a47ab0a38c86349112177ed30351d69b151fa47289545eab2f976969342
+  data.tar.gz: 7f1a1b34abaad80936b8ec1018233310c6e6746b5262731e291002937c0b47b7
 SHA512:
-  metadata.gz: 3d5ac493402d2afd1857ee86faa80b4043d91a4d7dc2837beb3fb9a8ff5cb729af4b9d00f2e7d763f9513856d2f3f518cde6c08710c2f9221240136d0ac31255
-  data.tar.gz: 41a48b20fa6a9fbc47383cd3d993372f8b0ad3a2fa4ddd0e85c6948dd07c469bfe2090b83aa62f7bc58a3067db443d90caa9b2f6f4ed7d98314bb7520d1ca99b
+  metadata.gz: 38d0afcaf9e40c7a97a466f8188854b25f3426ba63ae64d622ba18b4035427ad02a875abf53b64ef4df0ee10f35b7c1b73ccd44263a2bdb8ce0b8f2291acf766
+  data.tar.gz: eead705f93110e06656a747f6c894aac8236fcff670286e5685bbc6853ae49896d1f39db9548d46ee4f8f4c70c1f47f315734f6e4f3057dde896b1f2d8ebdd41

data/README.md

@@ -129,7 +129,13 @@ Pwwka::Transmitter.send_message!(
 
   * `: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. **Note, this doesn't guarantee the message will actually be sent—it just guarantees an attempt is made to queue a Resque job [which could fail]**
+  * `:retry_async` - Log the error and return false. Also, enqueue a job with the configured background job processor (`:resque` or `:sidekiq`). **Note, this doesn't guarantee the message will actually be sent— it just guarantees an attempt is made to queue a background job [which could fail]**. The background job processor will default to Resque, but can be configured to Sidekiq:
+
+  ```
+  Pwwka.configure do |config|
+    config.background_job_processor = :sidekiq
+  end
+  ```
 
 Example usage:
 
@@ -157,28 +163,32 @@ 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` 
+#### Sending message asynchronously
+To enqueue a message in a background job, use `Pwwka::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. (Important: Your load/require order is important if you want exponential backoff with the built-in job due to [its error handling](https://github.com/stitchfix/pwwka/blob/713c6003fa6cf52cb4713c02b39fe7ee07ebe2e9/lib/pwwka/send_message_async_job.rb#L8).)
-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`.
+The job will be enqueued using the configured background job processor. This will default to Resque, but can be configured to use Sidekiq:
+```
+Pwwka.configure do |config|
+  config.background_job_processor = :sidekiq
+end
+```
 
-You can configure Pwwka to use your own custom job using the `async_job_klass` configuration option. Example might be:
+Regardless of which processor you use, the name of the queue created is `pwwka_send_message_async`.
 
+You can also configure Pwwka to use your own custom job using the `async_job_klass` configuration option. An example might be:
 ```
 Pwwka.configure do |config|
   config.async_job_klass = YourApp::PwwkaAsyncJob
 end
 ```
 
+If you are using Resque and `Resque::Plugins::ExponentialBackoff` is available, the job will use it. (Important: Your load/require order is important if you want exponential backoff with the built-in job due to [its error handling](https://github.com/stitchfix/pwwka/blob/713c6003fa6cf52cb4713c02b39fe7ee07ebe2e9/lib/pwwka/send_message_async_job.rb#L8)). 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
+
+
+
 #### Message Queuer
 
 You can queue up messages and send them in a batch. This is most useful when multiple messages 

data/lib/pwwka.rb

@@ -31,4 +31,7 @@ require 'pwwka/message_queuer'
 require 'pwwka/error_handlers'
 require 'pwwka/configuration'
 require 'pwwka/send_message_async_job'
-
+begin  # optional dependency
+  require 'pwwka/send_message_async_sidekiq_job'
+rescue LoadError
+end

data/lib/pwwka/channel_connector.rb

@@ -14,16 +14,27 @@ module Pwwka
       @configuration     = Pwwka.configuration
       connection_options = {automatically_recover: false}.merge(configuration.options)
       connection_options = {client_properties: {connection_name: connection_name}}.merge(connection_options) if connection_name
-      @connection        = Bunny.new(configuration.rabbit_mq_host, connection_options)
-      @connection.start
-      @channel           = @connection.create_channel
+
+      begin
+        @connection = Bunny.new(configuration.rabbit_mq_host, connection_options)
+        @connection.start
+      rescue => e
+        logf "ERROR Connecting to RabbitMQ", error: e
+        @connection.close if @connection
+        raise e
+      end
+
+      begin
+        @channel = @connection.create_channel
+      rescue => e
+        logf "ERROR Opening RabbitMQ channel", error: e
+        @connection.close if @connection
+        raise e
+      end
+
       if prefetch
         @channel.prefetch(prefetch.to_i)
       end
-    rescue => e
-      logf "ERROR Connecting to RabbitMQ", error: e
-      @connection.close if @connection
-      raise e
     end
 
     def topic_exchange
@@ -67,9 +78,18 @@ module Pwwka
     end
 
     def connection_close
-      channel.close
-      connection.close
-    end
+      begin
+        channel.close
+      rescue => e
+        logf "ERROR Closing RabbitMQ channel", error: e
+      end
 
+      begin
+        connection.close
+      rescue => e
+        logf "ERROR Closing connection to RabbitMQ", error: e
+        raise e
+      end
+    end
   end
 end

data/lib/pwwka/configuration.rb

@@ -1,5 +1,6 @@
 require 'bunny'
 require 'mono_logger'
+
 module Pwwka
   class ConfigurationError < StandardError; end
   class Configuration
@@ -10,12 +11,13 @@ module Pwwka
     attr_accessor :logger
     attr_accessor :log_level
     attr_accessor :options
-    attr_accessor :async_job_klass
+    attr_accessor :background_job_processor
     attr_accessor :send_message_resque_backoff_strategy
     attr_accessor :default_prefetch
     attr_accessor :process_name
     attr_reader   :requeue_on_error
     attr_writer   :app_id
+    attr_writer   :async_job_klass
     attr_writer   :error_handling_chain
 
     def initialize
@@ -30,7 +32,7 @@ module Pwwka
                                                600, 600, 600] # longer-term outage?
       @requeue_on_error = false
       @keep_alive_on_handler_klass_exceptions = false
-      @async_job_klass = Pwwka::SendMessageAsyncJob
+      @background_job_processor = :resque
       @default_prefetch = nil
       @receive_raw_payload = false
       @process_name = ""
@@ -56,6 +58,10 @@ module Pwwka
       end
     end
 
+    def async_job_klass
+      @async_job_klass || background_jobs[background_job_processor]
+    end
+
     def payload_logging
       @payload_logging || :info
     end
@@ -139,5 +145,14 @@ module Pwwka
       return true if @receive_raw_payload
       Pwwka::Logging::LEVELS[Pwwka.configuration.payload_logging.to_sym] > Pwwka::Logging::LEVELS[level_of_message_with_payload.to_sym]
     end
+
+    private
+
+    def background_jobs
+      {
+        resque: Pwwka::SendMessageAsyncJob,
+        sidekiq: Pwwka::SendMessageAsyncSidekiqJob,
+      }
+    end
   end
 end

data/lib/pwwka/send_message_async_sidekiq_job.rb

@@ -0,0 +1,29 @@
+require 'sidekiq'
+
+module Pwwka
+  class SendMessageAsyncSidekiqJob
+    include Sidekiq::Worker
+    extend Pwwka::Logging
+
+    sidekiq_options queue: 'pwwka_send_message_async', retry: 3
+
+    def perform(payload, routing_key, options = {})
+      type = options["type"]
+      message_id = options["message_id"] || "auto_generate"
+      headers = options["headers"]
+
+      logger.info("Sending message async #{routing_key}, #{payload}")
+
+      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

@@ -3,6 +3,7 @@ require_relative "publish_options"
 begin  # optional dependency
   require 'resque'
   require 'resque-retry'
+  require 'sidekiq'
 rescue LoadError
 end
 
@@ -43,6 +44,7 @@ module Pwwka
     # - :ignore (aka as send_message_safely)
     # - :raise
     # - :resque -- use Resque to try to send the message later
+    # - :retry_async -- use the configured background job processor to retry sending the message later
     #
     # Returns true
     #
@@ -70,31 +72,39 @@ module Pwwka
         when :raise
           raise e
 
-        when :resque
+        when :resque, :retry_async
           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)
+          rescue => exception
+            warn(exception.message)
             raise e
           end
+
         else # ignore
       end
       false
     end
 
-    # Use Resque to enqueue the message.
+    # Enqueue the message with the configured background processor.
     # - :delay_by_ms:: Integer milliseconds to delay the message. Default is 0.
     def self.send_message_async(payload, routing_key,
                                 delay_by_ms: 0,
                                 type: nil,
                                 message_id: :auto_generate,
                                 headers: nil)
+      background_job_processor = Pwwka.configuration.background_job_processor
       job = Pwwka.configuration.async_job_klass
-      # 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)
+
+      if background_job_processor == :resque
+        # 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
+      elsif background_job_processor == :sidekiq
+        options = { delay_by_ms: delay_by_ms, type: type, message_id: message_id, headers: headers }
+        job.perform_async(payload, routing_key, options)
       end
     end
 

data/lib/pwwka/version.rb

@@ -1,4 +1,4 @@
 module Pwwka
-  VERSION = '0.21.2'
+  VERSION = '0.21.3'
 end
 

data/pwwka.gemspec

@@ -27,8 +27,10 @@ Gem::Specification.new do |s|
   s.add_development_dependency("rspec")
   s.add_development_dependency("resque")
   s.add_development_dependency("resque-retry")
+  s.add_development_dependency("sidekiq")
   s.add_development_dependency("simplecov")
   s.add_development_dependency("resqutils")
   s.add_development_dependency("rainbow")
-  s.add_development_dependency('rspec_junit_formatter')
+  s.add_development_dependency("rspec_junit_formatter")
+  s.add_development_dependency("pry-byebug")
 end

data/spec/spec_helper.rb

@@ -3,6 +3,7 @@ GEM_ROOT = File.expand_path(File.join(File.dirname(__FILE__),'..'))
 ENV['RAILS_ENV']  ||= 'test'
 
 require 'simplecov'
+require 'pry-byebug'
 
 SimpleCov.start do
   add_filter "/spec/"
@@ -16,6 +17,7 @@ require 'active_support/core_ext/hash'
 # an error if missing.  Requiring here so their absence will fail the tests
 require 'resque'
 require 'resque-retry'
+require 'sidekiq'
 
 require 'support/test_configuration'
 

data/spec/unit/configuration_spec.rb

@@ -155,4 +155,32 @@ describe Pwwka::Configuration do
     end
   end
 
+  describe "#background_job_processor" do
+    it "is :resque by default" do
+      expect(configuration.background_job_processor).to eq(:resque)
+    end
+
+    it "can be overridden" do
+      configuration.background_job_processor = :sidekiq
+      expect(configuration.background_job_processor).to eq(:sidekiq)
+    end
+  end
+
+  describe "#async_job_klass" do
+    it "is SendMessageAsyncJob by default" do
+      expect(configuration.async_job_klass).to eq(Pwwka::SendMessageAsyncJob)
+    end
+
+    it "is SendMessageAsyncSidekiqJob when background_job_processor=:sidekiq" do
+      configuration.background_job_processor = :sidekiq
+      expect(configuration.async_job_klass).to eq(Pwwka::SendMessageAsyncSidekiqJob)
+    end
+
+    it "can be configured to a custom class" do
+      class CustomBackgroundJob
+      end
+      configuration.async_job_klass = CustomBackgroundJob
+      expect(configuration.async_job_klass).to eq(CustomBackgroundJob)
+    end
+  end
 end

data/spec/unit/send_message_async_sidekiq_job_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper.rb'
+
+describe Pwwka::SendMessageAsyncSidekiqJob 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.new.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.new.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

@@ -33,41 +33,91 @@ describe Pwwka::Transmitter do
   subject(:transmitter) { described_class.new }
 
   describe ".send_message_async" do
-    before do
-      allow(Resque).to receive(:enqueue_in)
-    end
-    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)
+    context "when configured background_job_processor is Resque" do
+      before do
+        allow(Resque).to receive(:enqueue_in)
+      end
+      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
-    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",
-          }
-        )
+
+    context "when the configured background_job_processor is Sidekiq" do
+      before do
+        allow(Pwwka::SendMessageAsyncSidekiqJob).to receive(:perform_async)
+        Pwwka.configuration.background_job_processor = :sidekiq
+      end
+
+      after do
+        Pwwka::configuration.background_job_processor = :resque
+      end
+
+      context "with only basic required arguments" do
+        it "queues a Sidekiq job with no extra arguments" do
+          options = { delay_by_ms: 3_000, type: nil, message_id: :auto_generate, headers: nil}
+          described_class.send_message_async(payload, routing_key, delay_by_ms: 3_000)
+          expect(Pwwka::SendMessageAsyncSidekiqJob).to have_received(:perform_async)
+            .with(payload, routing_key, options)
+        end
+      end
+
+      context "with everything overridden" do
+        it "queues a Sidekiq job with the various arguments" do
+          described_class.send_message_async(
+            payload,routing_key,
+            delay_by_ms: 3_000,
+            message_id: "snowflake id that is likely a bad idea, but if you must",
+            type: "Customer",
+            headers: {
+              "custom" => "value",
+              "other_custom" => "other_value",
+            }
+          )
+          expect(Pwwka::SendMessageAsyncSidekiqJob).to have_received(:perform_async).with(
+            payload,
+            routing_key,
+            {
+              delay_by_ms: 3_000,
+              type: "Customer",
+              message_id: "snowflake id that is likely a bad idea, but if you must",
+               headers: {
+                "custom" => "value",
+                "other_custom" => "other_value",
+              }
+            }
+          )
+        end
       end
     end
   end
@@ -283,6 +333,81 @@ describe Pwwka::Transmitter do
           end
         end
       end
+
+      context "on_error: :retry_async" do
+        context "when configured background_job_processor is Resque" do
+          context "when the job is queued successfully" do
+            before do
+              allow(Resque).to receive(:enqueue_in)
+            end
+
+            it "queues a Resque job" do
+              described_class.send_message!(payload, routing_key, on_error: :retry_async)
+              expect(Resque).to have_received(:enqueue_in).with(0, Pwwka::SendMessageAsyncJob, payload, routing_key)
+            end
+          end
+
+          context "when there is a problem queueing the Resque job" do
+            before do
+              allow(Resque).to receive(:enqueue_in).and_raise("NOPE")
+            end
+
+            it "raises the original exception job" do
+              expect {
+                described_class.send_message!(payload,routing_key, on_error: :retry_async)
+              }.to raise_error(/OH NOES/)
+            end
+
+            it "logs the Resque error as a warning" do
+              begin
+                described_class.send_message!(payload,routing_key, on_error: :resque)
+              rescue => ex
+              end
+              expect(logger).to have_received(:warn).with(/NOPE/)
+            end
+          end
+        end
+
+        context "when configured background_job_processor is Sidekiq" do
+          before do
+            Pwwka.configuration.background_job_processor = :sidekiq
+          end
+
+          after do
+            Pwwka::configuration.background_job_processor = :resque
+          end
+
+          context "when the job is queued sucessfully" do
+            it "queues a Sidekiq job" do
+              allow(Pwwka::SendMessageAsyncSidekiqJob).to receive(:perform_async)
+              described_class.send_message!(payload, routing_key, on_error: :retry_async)
+              expect(Pwwka::SendMessageAsyncSidekiqJob).to have_received(:perform_async).with(
+                payload,
+                routing_key,
+                {delay_by_ms: 0, headers: nil, message_id: :auto_generate, type: nil}
+              )
+            end
+          end
+
+          context "when there is a problem queueing the Sidekiq job" do
+            it "raises the original exception job" do
+              allow(Pwwka::SendMessageAsyncSidekiqJob).to receive(:perform_async).and_raise("NOPE")
+              expect {
+                described_class.send_message!(payload, routing_key, on_error: :retry_async)
+              }.to raise_error(/OH NOES/)
+            end
+
+            it "logs the Sidekiq error as a warning" do
+              allow(Pwwka::SendMessageAsyncSidekiqJob).to receive(:perform_async).and_raise("NOPE")
+              begin
+                described_class.send_message!(payload,routing_key, on_error: :retry_async)
+              rescue => ex
+              end
+              expect(logger).to have_received(:warn).with(/NOPE/)
+            end
+          end
+        end
+      end
     end
   end
   describe ".send_message_safely" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pwwka
 version: !ruby/object:Gem::Version
-  version: 0.21.2
+  version: 0.21.3
 platform: ruby
 authors:
 - Stitch Fix Engineering
@@ -15,7 +15,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-08 00:00:00.000000000 Z
+date: 2019-01-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny
@@ -129,6 +129,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  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'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -185,6 +199,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  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
@@ -239,6 +267,7 @@ files:
 - lib/pwwka/queue_resque_job_handler.rb
 - lib/pwwka/receiver.rb
 - lib/pwwka/send_message_async_job.rb
+- lib/pwwka/send_message_async_sidekiq_job.rb
 - lib/pwwka/tasks.rb
 - lib/pwwka/test_handler.rb
 - lib/pwwka/transmitter.rb
@@ -266,6 +295,7 @@ files:
 - spec/unit/queue_resque_job_handler_spec.rb
 - spec/unit/receiver_spec.rb
 - spec/unit/send_message_async_job_spec.rb
+- spec/unit/send_message_async_sidekiq_job_spec.rb
 - spec/unit/test_handler_message_spec.rb
 - spec/unit/transmitter_spec.rb
 homepage: https://github.com/stitchfix/pwwka
@@ -314,5 +344,6 @@ test_files:
 - spec/unit/queue_resque_job_handler_spec.rb
 - spec/unit/receiver_spec.rb
 - spec/unit/send_message_async_job_spec.rb
+- spec/unit/send_message_async_sidekiq_job_spec.rb
 - spec/unit/test_handler_message_spec.rb
 - spec/unit/transmitter_spec.rb