queue-bus 0.5.0 → 0.5.1

data/Gemfile

@@ -2,5 +2,4 @@ source "http://rubygems.org"
 
 gemspec
 
-gem "debugger"
-gem "rake"
+gem "rake"

data/lib/queue_bus/adapters/base.rb

@@ -10,6 +10,7 @@ module QueueBus
       def enabled!
         # called the first time we know we are using this adapter
         # it would be a good spot to require the libraries you're using
+        # and modify QueueBus::Worker as needed
         raise NotImplementedError
       end
 
@@ -18,12 +19,12 @@ module QueueBus
         raise NotImplementedError
       end
 
-      def enqueue(queue_name, klass, hash)
+      def enqueue(queue_name, klass, json)
         # enqueue the given class (Driver/Rider) in your queue
         raise NotImplementedError
       end
 
-      def enqueue_at(epoch_seconds, queue_name, klass, hash)
+      def enqueue_at(epoch_seconds, queue_name, klass, json)
         # enqueue the given class (Publisher) in your queue to run at given time
         raise NotImplementedError
       end
@@ -32,10 +33,6 @@ module QueueBus
         # if possible, tell a recurring job system to publish every minute
         raise NotImplementedError
       end
-
-      def worker_included(base)
-        # optional method for including more modules in classes that work in the queue
-      end
     end
   end
 end

data/lib/queue_bus/adapters/data.rb

@@ -15,12 +15,12 @@ module QueueBus
         block.call(@redis)
       end
 
-      def enqueue(queue_name, klass, hash)
-        push(queue_name, :class => klass.to_s, :args => [hash])
+      def enqueue(queue_name, klass, json)
+        push(queue_name, :class => klass.to_s, :args => [json])
       end
 
-      def enqueue_at(epoch_seconds, queue_name, klass, hash)
-        item = delayed_job_to_hash_with_queue(queue_name, klass, [hash])
+      def enqueue_at(epoch_seconds, queue_name, klass, json)
+        item = delayed_job_to_hash_with_queue(queue_name, klass, [json])
         delayed_push(epoch_seconds, item)
       end
 

data/lib/queue_bus/driver.rb

@@ -1,7 +1,6 @@
 module QueueBus
   # fans out an event to multiple queues
   class Driver
-    include ::QueueBus::Worker
 
     class << self
       def subscription_matches(attributes)
@@ -21,8 +20,14 @@ module QueueBus
         subscription_matches(attributes).each do |sub|
           ::QueueBus.log_worker("  ...sending to #{sub.queue_name} queue with class #{sub.class_name} for app #{sub.app_key} because of subscription: #{sub.key}")
 
-          bus_attr = {"bus_driven_at" => Time.now.to_i, "bus_rider_queue" => sub.queue_name, "bus_rider_app_key" => sub.app_key, "bus_rider_sub_key" => sub.key, "bus_rider_class_name" => sub.class_name}
-          ::QueueBus.enqueue_to(sub.queue_name, sub.class_name, bus_attr.merge(attributes || {}))
+          bus_attr = {  "bus_driven_at" => Time.now.to_i,
+                        "bus_rider_queue" => sub.queue_name,
+                        "bus_rider_app_key" => sub.app_key,
+                        "bus_rider_sub_key" => sub.key,
+                        "bus_rider_class_name" => sub.class_name}
+          bus_attr = bus_attr.merge(attributes || {})
+          bus_attr["bus_class_proxy"] = sub.class_name
+          ::QueueBus.enqueue_to(sub.queue_name, ::QueueBus::Worker, bus_attr)
         end
       end
     end

data/lib/queue_bus/heartbeat.rb

@@ -1,7 +1,6 @@
 module QueueBus
   # publishes event about the current time
   class Heartbeat
-    include ::QueueBus::Worker
 
     class << self
 

data/lib/queue_bus/local.rb

@@ -13,10 +13,15 @@ module QueueBus
 
         # looking for subscriptions, not queues
         subscription_matches(attributes).each do |sub|
-           bus_attr = {"bus_driven_at" => Time.now.to_i, "bus_rider_queue" => sub.queue_name, "bus_rider_app_key" => sub.app_key, "bus_rider_sub_key" => sub.key, "bus_rider_class_name" => sub.class_name}
+          bus_attr = {  "bus_driven_at" => Time.now.to_i,
+                        "bus_rider_queue" => sub.queue_name,
+                        "bus_rider_app_key" => sub.app_key,
+                        "bus_rider_sub_key" => sub.key,
+                        "bus_rider_class_name" => sub.class_name,
+                        "bus_class_proxy" => sub.class_name}
           to_publish = bus_attr.merge(attributes || {})
           if ::QueueBus.local_mode == :standalone
-            ::QueueBus.enqueue_to(sub.queue_name, sub.class_name, bus_attr.merge(attributes || {}))
+            ::QueueBus.enqueue_to(sub.queue_name, ::QueueBus::Worker, bus_attr.merge(attributes || {}))
           else  # defaults to inline mode
             sub.execute!(to_publish)
           end

data/lib/queue_bus/publisher.rb

@@ -1,7 +1,6 @@
 module QueueBus
   # publishes on a delay
   class Publisher
-    include ::QueueBus::Worker
 
     class << self
       def perform(*args)

data/lib/queue_bus/publishing.rb

@@ -48,11 +48,13 @@ module QueueBus
 
     def publish(event_type, attributes = {})
       to_publish = publish_metadata(event_type, attributes)
+      to_publish["bus_class_proxy"] = ::QueueBus::Driver.name.to_s
+
       ::QueueBus.log_application("Event published: #{event_type} #{to_publish.inspect}")
       if local_mode
         ::QueueBus::Local.perform(to_publish)
       else
-        enqueue_to(::QueueBus.incoming_queue, Driver, to_publish)
+        enqueue_to(::QueueBus.incoming_queue, ::QueueBus::Worker, to_publish)
       end
     end
 
@@ -60,17 +62,18 @@ module QueueBus
       to_publish = publish_metadata(event_type, attributes)
       to_publish["bus_delayed_until"] ||= timestamp_or_epoch.to_i
       to_publish.delete("bus_published_at") unless attributes["bus_published_at"] # will be put on when it actually does it
+      to_publish["bus_class_proxy"] = ::QueueBus::Publisher.name.to_s
 
       ::QueueBus.log_application("Event published:#{event_type} #{to_publish.inspect} publish_at: #{timestamp_or_epoch.to_i}")
-      delayed_enqueue_to(timestamp_or_epoch.to_i, incoming_queue, Publisher, to_publish)
+      delayed_enqueue_to(timestamp_or_epoch.to_i, incoming_queue, ::QueueBus::Worker, to_publish)
     end
 
     def enqueue_to(queue_name, klass, hash)
-      ::QueueBus.adapter.enqueue(queue_name, klass, hash)
+      ::QueueBus.adapter.enqueue(queue_name, klass, ::QueueBus::Util.encode(hash || {}))
     end
 
     def delayed_enqueue_to(epoch_seconds, queue_name, klass, hash)
-      ::QueueBus.adapter.enqueue_at(epoch_seconds, queue_name, klass, hash)
+      ::QueueBus.adapter.enqueue_at(epoch_seconds, queue_name, klass, ::QueueBus::Util.encode(hash || {}))
     end
 
     def heartbeat!

data/lib/queue_bus/rider.rb

@@ -1,8 +1,7 @@
 module QueueBus
   # queue'd in each
   class Rider
-    include ::QueueBus::Worker
-    
+
     class << self
       def perform(attributes = {})
         sub_key = attributes["bus_rider_sub_key"]

data/lib/queue_bus/subscriber.rb

@@ -2,7 +2,6 @@ module QueueBus
   module Subscriber
 
     def self.included(base)
-      base.send(:include, ::QueueBus::Worker)
       base.extend ClassMethods
     end
 

data/lib/queue_bus/version.rb

@@ -1,3 +1,3 @@
 module QueueBus
-  VERSION = "0.5.0"
+  VERSION = "0.5.1"
 end

data/lib/queue_bus/worker.rb

@@ -1,14 +1,23 @@
 module QueueBus
-  module Worker
+  class Worker
 
-    def self.included(base)
-      ::QueueBus.adapter.worker_included(base)
+    def self.perform(attributes)
+      klass = nil
+      begin
+        class_name = attributes["bus_class_proxy"]
+        klass = ::QueueBus::Util.constantize(class_name)
+      rescue NameError
+        # not there anymore
+        return
+      end
+
+      klass.perform(attributes)
     end
 
     # all our workers include this one
-    def perform(*args)
+    def perform(attributes)
       # instance method level support for sidekiq
-      self.class.perform(*args)
+      self.class.perform(attributes)
     end
   end
 end

data/spec/adapter/publish_at_spec.rb

@@ -9,7 +9,8 @@ describe "Publishing an event in the future" do
   after(:each) do
     Timecop.return
   end
-  let(:delayed_attrs) { {"bus_delayed_until" => future.to_i,
+  let(:delayed_attrs) { {
+                     "bus_delayed_until" => future.to_i,
                      "bus_id" => "#{now.to_i}-idfhlkj",
                      "bus_app_hostname" =>  `hostname 2>&1`.strip.sub(/.local/,'')} }
 
@@ -29,20 +30,22 @@ describe "Publishing an event in the future" do
     val = QueueBus.redis { |redis| redis.lpop("delayed:#{future.to_i}") }
     hash = JSON.parse(val)
 
-    hash["class"].should == "QueueBus::Publisher"
-    hash["args"].should == [ {"bus_event_type"=>"event_name", "two"=>"here", "one"=>1, "id" => 12}.merge(delayed_attrs) ]
+    hash["class"].should == "QueueBus::Worker"
+    hash["args"].size.should == 1
+    JSON.parse(hash["args"].first).should == {"bus_class_proxy"=>"QueueBus::Publisher", "bus_event_type"=>"event_name", "two"=>"here", "one"=>1, "id" => 12}.merge(delayed_attrs)
     hash["queue"].should == "bus_incoming"
 
     val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
     val.should == nil # nothing really added
 
     Timecop.freeze(worktime)
-    QueueBus::Publisher.perform(*hash["args"])
+    QueueBus::Publisher.perform(JSON.parse(hash["args"].first))
 
     val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
     hash = JSON.parse(val)
-    hash["class"].should == "QueueBus::Driver"
-    hash["args"].should == [ {"bus_event_type"=>"event_name", "two"=>"here", "one"=>1, "id" => 12}.merge(bus_attrs) ]
+    hash["class"].should == "QueueBus::Worker"
+    hash["args"].size.should == 1
+    JSON.parse(hash["args"].first).should == {"bus_class_proxy"=>"QueueBus::Driver", "bus_event_type"=>"event_name", "two"=>"here", "one"=>1, "id" => 12}.merge(bus_attrs)
   end
 
 end

data/spec/driver_spec.rb

@@ -12,7 +12,7 @@ module QueueBus
       Timecop.return
     end
 
-    let(:bus_attrs) { {"bus_driven_at" => Time.now.to_i, "bus_rider_class_name"=>"::QueueBus::Rider"} }
+    let(:bus_attrs) { {"bus_driven_at" => Time.now.to_i, "bus_rider_class_name"=>"::QueueBus::Rider", "bus_class_proxy" => "::QueueBus::Rider"} }
 
     describe ".subscription_matches" do
       it "return empty array when none" do
@@ -35,7 +35,7 @@ module QueueBus
     end
 
     describe ".perform" do
-      let(:attributes) { {"x" => "y"} }
+      let(:attributes) { {"x" => "y", "bus_class_proxy" => "ResqueBus::Driver"} }
 
       before(:each) do
         QueueBus.redis { |redis| redis.smembers("queues") }.should == []
@@ -55,8 +55,9 @@ module QueueBus
         QueueBus.redis { |redis| redis.smembers("queues") }.should =~ ["default"]
 
         hash = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:default") })
-        hash["class"].should == "::QueueBus::Rider"
-        hash["args"].should == [ {"bus_rider_app_key"=>"app1", "x" => "y", "bus_event_type" => "event1", "bus_rider_sub_key"=>"event1", "bus_rider_queue" => "default"}.merge(bus_attrs) ]
+        hash["class"].should == "QueueBus::Worker"
+        hash["args"].size.should == 1
+        JSON.parse(hash["args"].first).should == {"bus_rider_app_key"=>"app1", "x" => "y", "bus_event_type" => "event1", "bus_rider_sub_key"=>"event1", "bus_rider_queue" => "default"}.merge(bus_attrs)
       end
 
       it "should queue up to multiple" do
@@ -64,12 +65,14 @@ module QueueBus
         QueueBus.redis { |redis| redis.smembers("queues") }.should =~ ["default", "more"]
 
         hash = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:more") })
-        hash["class"].should == "::QueueBus::Rider"
-        hash["args"].should == [ {"bus_rider_app_key"=>"app2", "x" => "y", "bus_event_type" => "event4", "bus_rider_sub_key"=>"event4", "bus_rider_queue" => "more"}.merge(bus_attrs) ]
+        hash["class"].should == "QueueBus::Worker"
+        hash["args"].size.should == 1
+        JSON.parse(hash["args"].first).should == {"bus_rider_app_key"=>"app2", "x" => "y", "bus_event_type" => "event4", "bus_rider_sub_key"=>"event4", "bus_rider_queue" => "more"}.merge(bus_attrs)
 
         hash = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:default") })
-        hash["class"].should == "::QueueBus::Rider"
-        hash["args"].should == [ {"bus_rider_app_key"=>"app3", "x" => "y", "bus_event_type" => "event4", "bus_rider_sub_key"=>"event[45]", "bus_rider_queue" => "default"}.merge(bus_attrs) ]
+        hash["class"].should == "QueueBus::Worker"
+        hash["args"].size.should == 1
+        JSON.parse(hash["args"].first).should == {"bus_rider_app_key"=>"app3", "x" => "y", "bus_event_type" => "event4", "bus_rider_sub_key"=>"event[45]", "bus_rider_queue" => "default"}.merge(bus_attrs)
       end
 
       it "should queue up to the same" do
@@ -81,19 +84,25 @@ module QueueBus
         pop1 = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:default") })
         pop2 = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:default") })
 
-        if pop1["args"][0]["bus_rider_sub_key"] == "event5"
+        pargs1 = JSON.parse(pop1["args"].first)
+        pargs2 = JSON.parse(pop2["args"].first)
+        if pargs1["bus_rider_sub_key"] == "event5"
           hash1 = pop1
           hash2 = pop2
+          args1 = pargs1
+          args2 = pargs2
         else
           hash1 = pop2
           hash2 = pop1
+          args1 = pargs2
+          args2 = pargs2
         end
 
-        hash1["class"].should == "::QueueBus::Rider"
-        hash1["args"][0].should == {"bus_rider_app_key"=>"app3", "x" => "y", "bus_event_type" => "event5", "bus_rider_sub_key"=>"event5", "bus_rider_queue" => "default"}.merge(bus_attrs)
+        hash1["class"].should == "QueueBus::Worker"
+        args1.should == {"bus_rider_app_key"=>"app3", "x" => "y", "bus_event_type" => "event5", "bus_rider_sub_key"=>"event5", "bus_rider_queue" => "default"}.merge(bus_attrs)
 
-        hash2["class"].should == "::QueueBus::Rider"
-        hash2["args"][0].should == {"bus_rider_app_key"=>"app3", "x" => "y", "bus_event_type" => "event5", "bus_rider_sub_key"=>"event[45]", "bus_rider_queue" => "default"}.merge(bus_attrs)
+        hash2["class"].should == "QueueBus::Worker"
+        args2.should == {"bus_rider_app_key"=>"app3", "x" => "y", "bus_event_type" => "event5", "bus_rider_sub_key"=>"event[45]", "bus_rider_queue" => "default"}.merge(bus_attrs)
       end
     end
   end

data/spec/publish_spec.rb

@@ -9,7 +9,8 @@ describe "Publishing an event" do
   after(:each) do
     Timecop.return
   end
-  let(:bus_attrs) { {"bus_published_at" => Time.now.to_i,
+  let(:bus_attrs) { {"bus_class_proxy"=>"QueueBus::Driver",
+                     "bus_published_at" => Time.now.to_i,
                      "bus_id"=>"#{Time.now.to_i}-idfhlkj",
                      "bus_app_hostname" =>  `hostname 2>&1`.strip.sub(/.local/,'')} }
 
@@ -24,8 +25,9 @@ describe "Publishing an event" do
 
     val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
     hash = JSON.parse(val)
-    hash["class"].should == "QueueBus::Driver"
-    hash["args"].should == [ {"bus_event_type" => event_name, "two"=>"here", "one"=>1, "id" => 12}.merge(bus_attrs) ]
+    hash["class"].should == "QueueBus::Worker"
+    hash["args"].size.should == 1
+    JSON.parse(hash["args"].first).should == {"bus_event_type" => event_name, "two"=>"here", "one"=>1, "id" => 12}.merge(bus_attrs)
 
   end
 
@@ -40,8 +42,9 @@ describe "Publishing an event" do
 
     val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
     hash = JSON.parse(val)
-    hash["class"].should == "QueueBus::Driver"
-    hash["args"].should == [ {"bus_event_type" => event_name, "two"=>"here", "one"=>1}.merge(bus_attrs).merge("bus_id" => 'app-given') ]
+    hash["class"].should == "QueueBus::Worker"
+    hash["args"].size.should == 1
+    JSON.parse(hash["args"].first).should == {"bus_event_type" => event_name, "two"=>"here", "one"=>1}.merge(bus_attrs).merge("bus_id" => 'app-given')
   end
 
   it "should add metadata via callback" do
@@ -62,7 +65,7 @@ describe "Publishing an event" do
 
     val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
     hash = JSON.parse(val)
-    att = hash["args"].first
+    att = JSON.parse(hash["args"].first)
     att["mine"].should == 4
     myval.should == 1
   end
@@ -86,8 +89,8 @@ describe "Publishing an event" do
 
     val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
     hash = JSON.parse(val)
-    hash["class"].should == "QueueBus::Driver"
-    att = hash["args"].first
+    hash["class"].should == "QueueBus::Worker"
+    att = JSON.parse(hash["args"].first)
     att["bus_locale"].should == "jp"
     att["bus_timezone"].should == "EST"
   end

data/spec/subscriber_spec.rb

@@ -89,13 +89,14 @@ require 'spec_helper'
       QueueBus::Driver.perform(attributes.merge("bus_event_type" => "something2", "value"=>"nice"))
 
       hash = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:test2_default") })
-      hash["class"].should == "SubscriberTest2"
-      hash["args"].should eq [ {"bus_rider_app_key"=>"test2", "bus_rider_sub_key"=>"SubscriberTest2.test2", "bus_rider_queue" => "test2_default", "bus_rider_class_name"=>"SubscriberTest2",
-                               "bus_event_type" => "something2", "value"=>"nice", "x"=>"y"}.merge(bus_attrs) ]
+      hash["class"].should == "QueueBus::Worker"
+      hash["args"].size.should == 1
+      JSON.parse(hash["args"].first).should eq({"bus_class_proxy" => "SubscriberTest2", "bus_rider_app_key"=>"test2", "bus_rider_sub_key"=>"SubscriberTest2.test2", "bus_rider_queue" => "test2_default", "bus_rider_class_name"=>"SubscriberTest2",
+                               "bus_event_type" => "something2", "value"=>"nice", "x"=>"y"}.merge(bus_attrs))
 
       QueueBus::Runner1.value.should == 0
       QueueBus::Runner2.value.should == 0
-      QueueBus::Util.constantize(hash["class"]).perform(*hash["args"])
+      QueueBus::Util.constantize(hash["class"]).perform(JSON.parse(hash["args"].first))
       QueueBus::Runner1.value.should == 1
       QueueBus::Runner2.value.should == 0
 
@@ -105,13 +106,14 @@ require 'spec_helper'
       QueueBus::Driver.perform(attributes.merge("bus_event_type" => "something2", "value"=>"12"))
 
       hash = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:test2_default") })
-      hash["class"].should == "SubscriberTest2"
-      hash["args"].should == [ {"bus_rider_app_key"=>"test2", "bus_rider_sub_key"=>"SubscriberTest2.test2", "bus_rider_queue" => "test2_default", "bus_rider_class_name"=>"SubscriberTest2",
-                               "bus_event_type" => "something2", "value"=>"12", "x"=>"y"}.merge(bus_attrs) ]
+      hash["class"].should == "QueueBus::Worker"
+      hash["args"].size.should == 1
+      JSON.parse(hash["args"].first).should == {"bus_class_proxy" => "SubscriberTest2", "bus_rider_app_key"=>"test2", "bus_rider_sub_key"=>"SubscriberTest2.test2", "bus_rider_queue" => "test2_default", "bus_rider_class_name"=>"SubscriberTest2",
+                               "bus_event_type" => "something2", "value"=>"12", "x"=>"y"}.merge(bus_attrs)
 
       QueueBus::Runner1.value.should == 1
       QueueBus::Runner2.value.should == 0
-      QueueBus::Util.constantize(hash["class"]).perform(*hash["args"])
+      QueueBus::Util.constantize(hash["class"]).perform(JSON.parse(hash["args"].first))
       QueueBus::Runner1.value.should == 2
       QueueBus::Runner2.value.should == 0
 
@@ -151,24 +153,26 @@ require 'spec_helper'
       QueueBus::Driver.perform(attributes.merge("bus_event_type" => "the_event"))
 
       hash = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:sub_queue1") })
-      hash["class"].should == "SubModule::SubscriberTest3"
-      hash["args"].should == [ {"bus_rider_app_key"=>"sub_module", "bus_rider_sub_key"=>"SubModule::SubscriberTest3.test3", "bus_rider_queue" => "sub_queue1", "bus_rider_class_name"=>"SubModule::SubscriberTest3",
-                                "bus_event_type" => "the_event", "x" => "y"}.merge(bus_attrs) ]
+      hash["class"].should == "QueueBus::Worker"
+      hash["args"].size.should == 1
+      JSON.parse(hash["args"].first).should == {"bus_class_proxy" => "SubModule::SubscriberTest3", "bus_rider_app_key"=>"sub_module", "bus_rider_sub_key"=>"SubModule::SubscriberTest3.test3", "bus_rider_queue" => "sub_queue1", "bus_rider_class_name"=>"SubModule::SubscriberTest3",
+                                "bus_event_type" => "the_event", "x" => "y"}.merge(bus_attrs)
 
       QueueBus::Runner1.value.should == 0
       QueueBus::Runner2.value.should == 0
-      QueueBus::Util.constantize(hash["class"]).perform(*hash["args"])
+      QueueBus::Util.constantize(hash["class"]).perform(JSON.parse(hash["args"].first))
       QueueBus::Runner1.value.should == 1
       QueueBus::Runner2.value.should == 0
 
       hash = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:sub_queue2") })
-      hash["class"].should == "SubModule::SubscriberTest3"
-      hash["args"].should == [ {"bus_rider_app_key"=>"sub_module", "bus_rider_sub_key"=>"SubModule::SubscriberTest3.the_event", "bus_rider_queue" => "sub_queue2", "bus_rider_class_name"=>"SubModule::SubscriberTest3",
-                                "bus_event_type" => "the_event", "x" => "y"}.merge(bus_attrs) ]
+      hash["class"].should == "QueueBus::Worker"
+      hash["args"].size.should == 1
+      JSON.parse(hash["args"].first).should == {"bus_class_proxy" => "SubModule::SubscriberTest3", "bus_rider_app_key"=>"sub_module", "bus_rider_sub_key"=>"SubModule::SubscriberTest3.the_event", "bus_rider_queue" => "sub_queue2", "bus_rider_class_name"=>"SubModule::SubscriberTest3",
+                                "bus_event_type" => "the_event", "x" => "y"}.merge(bus_attrs)
 
       QueueBus::Runner1.value.should == 1
       QueueBus::Runner2.value.should == 0
-      QueueBus::Util.constantize(hash["class"]).perform(*hash["args"])
+      QueueBus::Util.constantize(hash["class"]).perform(JSON.parse(hash["args"].first))
       QueueBus::Runner1.value.should == 1
       QueueBus::Runner2.value.should == 1
     end
@@ -203,23 +207,24 @@ require 'spec_helper'
         hash2 = pop1
       end
 
-      hash1["class"].should == "SubscriberTest1"
-      hash1["args"].first.should eq({"bus_rider_app_key"=>"my_thing", "bus_rider_sub_key"=>"SubscriberTest1.thing_filter", "bus_rider_queue" => "myqueue", "bus_rider_class_name"=>"SubscriberTest1",
+      hash1["class"].should == "QueueBus::Worker"
+      JSON.parse(hash1["args"].first).should eq({"bus_class_proxy" => "SubscriberTest1", "bus_rider_app_key"=>"my_thing", "bus_rider_sub_key"=>"SubscriberTest1.thing_filter", "bus_rider_queue" => "myqueue", "bus_rider_class_name"=>"SubscriberTest1",
                                 "bus_event_type" => "event_sub", "x" => "y"}.merge(bus_attrs))
 
       QueueBus::Runner1.value.should == 0
       QueueBus::Runner2.value.should == 0
-      QueueBus::Util.constantize(hash1["class"]).perform(*hash1["args"])
+      QueueBus::Util.constantize(hash1["class"]).perform(JSON.parse(hash1["args"].first))
       QueueBus::Runner1.value.should == 0
       QueueBus::Runner2.value.should == 1
 
-      hash2["class"].should == "SubscriberTest1"
-      hash2["args"].should == [ {"bus_rider_app_key"=>"my_thing", "bus_rider_sub_key"=>"SubscriberTest1.event_sub", "bus_rider_queue" => "myqueue", "bus_rider_class_name"=>"SubscriberTest1",
-                                "bus_event_type" => "event_sub", "x" => "y"}.merge(bus_attrs) ]
+      hash2["class"].should == "QueueBus::Worker"
+      hash2["args"].size.should == 1
+      JSON.parse(hash2["args"].first).should == {"bus_class_proxy" => "SubscriberTest1", "bus_rider_app_key"=>"my_thing", "bus_rider_sub_key"=>"SubscriberTest1.event_sub", "bus_rider_queue" => "myqueue", "bus_rider_class_name"=>"SubscriberTest1",
+                                "bus_event_type" => "event_sub", "x" => "y"}.merge(bus_attrs)
 
       QueueBus::Runner1.value.should == 0
       QueueBus::Runner2.value.should == 1
-      QueueBus::Util.constantize(hash2["class"]).perform(*hash2["args"])
+      QueueBus::Util.constantize(hash2["class"]).perform(JSON.parse(hash2["args"].first))
       QueueBus::Runner1.value.should == 1
       QueueBus::Runner2.value.should == 1
 
@@ -227,13 +232,14 @@ require 'spec_helper'
       QueueBus.redis { |redis| redis.smembers("queues") }.should =~ ["myqueue"]
 
       hash = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:myqueue") })
-      hash["class"].should == "SubscriberTest1"
-      hash["args"].should == [ {"bus_rider_app_key"=>"my_thing", "bus_rider_sub_key"=>"SubscriberTest1.thing_filter", "bus_rider_queue" => "myqueue", "bus_rider_class_name"=>"SubscriberTest1",
-                                "bus_event_type" => "event_sub_other", "x" => "y"}.merge(bus_attrs) ]
+      hash["class"].should == "QueueBus::Worker"
+      hash["args"].size.should == 1
+      JSON.parse(hash["args"].first).should == {"bus_class_proxy" => "SubscriberTest1", "bus_rider_app_key"=>"my_thing", "bus_rider_sub_key"=>"SubscriberTest1.thing_filter", "bus_rider_queue" => "myqueue", "bus_rider_class_name"=>"SubscriberTest1",
+                                "bus_event_type" => "event_sub_other", "x" => "y"}.merge(bus_attrs)
 
       QueueBus::Runner1.value.should == 1
       QueueBus::Runner2.value.should == 1
-      QueueBus::Util.constantize(hash["class"]).perform(*hash["args"])
+      QueueBus::Util.constantize(hash["class"]).perform(JSON.parse(hash["args"].first))
       QueueBus::Runner1.value.should == 1
       QueueBus::Runner2.value.should == 2
 
@@ -243,10 +249,6 @@ require 'spec_helper'
       QueueBus.redis { |redis| redis.lpop("queue:myqueue") }.should be_nil
     end
 
-    it "should have gotten the perform method from the ::Worker" do
-      SubscriberTest1.instance_methods.should include(:perform)
-    end
-
     describe ".perform" do
       let(:attributes) { {"bus_rider_sub_key"=>"SubscriberTest1.event_sub", "bus_locale" => "en", "bus_timezone" => "PST"} }
       it "should call the method based on key" do

data/spec/worker_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+module QueueBus
+  describe Worker do
+    it "should proxy to given class" do
+      hash = {"bus_class_proxy" => "QueueBus::Driver", "ok" => true}
+      QueueBus::Driver.should_receive(:perform).with(hash)
+      QueueBus::Worker.perform(hash)
+    end
+
+    it "should use instance" do
+      hash = {"bus_class_proxy" => "QueueBus::Rider", "ok" => true}
+      QueueBus::Rider.should_receive(:perform).with(hash)
+      QueueBus::Worker.new.perform(hash)
+    end
+
+    it "should not freak out if class not there anymore" do
+      hash = {"bus_class_proxy" => "QueueBus::BadClass", "ok" => true}
+      lambda {
+        QueueBus::Worker.perform(hash)
+      }.should_not raise_error
+    end
+
+    it "should raise error if proxy raises error" do
+      hash = {"bus_class_proxy" => "QueueBus::Rider", "ok" => true}
+      QueueBus::Rider.should_receive(:perform).with(hash).and_raise("rider crash")
+      lambda {
+        QueueBus::Worker.perform(hash)
+      }.should raise_error
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: queue-bus
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-17 00:00:00.000000000 Z
+date: 2015-01-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
@@ -147,6 +147,7 @@ files:
 - spec/subscriber_spec.rb
 - spec/subscription_list_spec.rb
 - spec/subscription_spec.rb
+- spec/worker_spec.rb
 homepage: ''
 licenses: []
 post_install_message: 
@@ -189,4 +190,5 @@ test_files:
 - spec/subscriber_spec.rb
 - spec/subscription_list_spec.rb
 - spec/subscription_spec.rb
+- spec/worker_spec.rb
 has_rdoc: