action_subscriber 2.5.0.pre2 → 3.0.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 85dc20de7aa4e917f499156bb94d4b2e40b9ed12
-  data.tar.gz: 7f34bea3b45e1e230cbc55e4e432540094c6241a
+  metadata.gz: b0a848297f91f557f43e6240545866aaad495d17
+  data.tar.gz: 0fd512e453740a0ad0e34f1f42ddef7ab5ac240f
 SHA512:
-  metadata.gz: c2b3f863edc1609bc43f403b519cb05c62a7b4dc7e7b8f2048d076fdb7d4523271bd742e3006f67e50b34360c2ac357dc773771e1e0b6d321450e941effed54f
-  data.tar.gz: a4261aa2255ad0eb865a1d3e64b0249ea0fac3b91a103301f337ca715777913ff7e1e2a1fe13b6f69a2b2cfcf1bc2d8fb87018c0653fc2ec0e73738cda6e594c
+  metadata.gz: 6d30b59daffa7e89a4c48eb3044a65af90804d91b3c0991e3dd0899b9a20944532878bc6327684577d05c11b9017edfb233bbd251daa42dff9a50d614f4701da
+  data.tar.gz: df4cf38fe9cbfed26adcc53e43823348726176cc387ccaa46d22274099182198aa1c2d1fcd1c7e341d87dd6e4f1a88e24702788a41c9955e8a2161a880459d56

data/action_subscriber.gemspec

@@ -30,6 +30,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'middleware'
   spec.add_dependency 'thor'
 
+  spec.add_development_dependency "active_publisher", "~> 0.1.5"
   spec.add_development_dependency "activerecord", ">= 3.2"
   spec.add_development_dependency "bundler", ">= 1.6"
   spec.add_development_dependency "pry-nav"

data/lib/action_subscriber/babou.rb

@@ -7,7 +7,7 @@ module ActionSubscriber
     def self.auto_pop!
       @pop_mode = true
       reload_active_record
-      load_subscribers unless subscribers_loaded?
+      ::ActionSubscriber.setup_default_connection!
       sleep_time = ::ActionSubscriber.configuration.pop_interval.to_i / 1000.0
 
       ::ActionSubscriber.start_queues
@@ -30,7 +30,7 @@ module ActionSubscriber
     def self.start_subscribers
       @prowl_mode = true
       reload_active_record
-      load_subscribers unless subscribers_loaded?
+      ::ActionSubscriber.setup_default_connection!
 
       ::ActionSubscriber.start_subscribers
       logger.info "Action Subscriber connected"
@@ -45,29 +45,6 @@ module ActionSubscriber
       !!@prowl_mode
     end
 
-    def self.load_subscribers
-      subscription_paths = ["subscriptions", "subscribers"]
-      path_prefixes = ["lib", "app"]
-      cloned_paths = subscription_paths.dup
-
-      path_prefixes.each do |prefix|
-        cloned_paths.each { |path| subscription_paths << "#{prefix}/#{path}" }
-      end
-
-      absolute_subscription_paths = subscription_paths.map{ |path| ::File.expand_path(path) }
-      absolute_subscription_paths.each do |path|
-        if ::File.exists?("#{path}.rb")
-          load("#{path}.rb")
-        end
-
-        if ::File.directory?(path)
-          ::Dir[::File.join(path, "**", "*.rb")].sort.each do |file|
-            load file
-          end
-        end
-      end
-    end
-
     def self.logger
       ::ActionSubscriber::Logging.logger
     end
@@ -108,9 +85,5 @@ module ActionSubscriber
 
       puts "threadpool empty. Shutting down"
     end
-
-    def self.subscribers_loaded?
-      !::ActionSubscriber::Base.inherited_classes.empty?
-    end
   end
 end

data/lib/action_subscriber/base.rb

@@ -26,10 +26,6 @@ module ActionSubscriber
     # Class Methods
     #
 
-    def self.connection
-      ::ActionSubscriber::RabbitConnection.subscriber_connection
-    end
-
     # Inherited callback, save a reference to our descendents
     #
     def self.inherited(klass)

data/lib/action_subscriber/bunny/subscriber.rb

@@ -20,7 +20,9 @@ module ActionSubscriber
         # of times we will pop each time we poll the broker
         times_to_pop = [::ActionSubscriber::Threadpool.ready_size, ::ActionSubscriber.config.times_to_pop].min
         times_to_pop.times do
-          queues.each do |route, queue|
+          subscriptions.each do |subscription|
+            route = subscription[:route]
+            queue = subscription[:queue]
             # Handle busy checks on a per threadpool basis
             next if route.threadpool.busy?
 
@@ -29,7 +31,6 @@ module ActionSubscriber
             ::ActiveSupport::Notifications.instrument "popped_event.action_subscriber", :payload_size => encoded_payload.bytesize, :queue => queue.name
             properties = {
               :action => route.action,
-              :channel => queue.channel,
               :content_type => properties[:content_type],
               :delivery_tag => delivery_info.delivery_tag,
               :exchange => delivery_info.exchange,
@@ -45,7 +46,9 @@ module ActionSubscriber
       end
 
       def auto_subscribe!
-        queues.each do |route, queue|
+        subscriptions.each do |subscription|
+          route = subscription[:route]
+          queue = subscription[:queue]
           channel = queue.channel
           channel.prefetch(route.prefetch) if route.acknowledgements?
           consumer = ::Bunny::Consumer.new(channel, queue, channel.generate_consumer_tag, !route.acknowledgements?)
@@ -63,7 +66,7 @@ module ActionSubscriber
               :queue => queue.name,
             }
             env = ::ActionSubscriber::Middleware::Env.new(route.subscriber, encoded_payload, properties)
-            enqueue_env(route.threadpool, env)
+            run_env(env)
           end
           bunny_consumers << consumer
           queue.subscribe_with(consumer)
@@ -80,6 +83,13 @@ module ActionSubscriber
           end
         end
       end
+
+      def run_env(env)
+        logger.info "RECEIVED #{env.message_id} from #{env.queue}"
+        ::ActiveSupport::Notifications.instrument "process_event.action_subscriber", :subscriber => env.subscriber.to_s, :routing_key => env.routing_key, :queue => env.queue do
+          ::ActionSubscriber.config.middleware.call(env)
+        end
+      end
     end
   end
 end

data/lib/action_subscriber/configuration.rb

@@ -4,10 +4,6 @@ require "action_subscriber/uri"
 module ActionSubscriber
   class Configuration
     attr_accessor :allow_low_priority_methods,
-                  :async_publisher,
-                  :async_publisher_drop_messages_when_queue_full,
-                  :async_publisher_max_queue_size,
-                  :async_publisher_supervisor_interval,
                   :decoder,
                   :default_exchange,
                   :error_handler,
@@ -19,7 +15,6 @@ module ActionSubscriber
                   :pop_interval,
                   :port,
                   :prefetch,
-                  :publisher_confirms,
                   :seconds_to_wait_for_graceful_shutdown,
                   :username,
                   :threadpool_size,
@@ -31,10 +26,6 @@ module ActionSubscriber
 
     DEFAULTS = {
       :allow_low_priority_methods => false,
-      :async_publisher => 'memory',
-      :async_publisher_drop_messages_when_queue_full => false,
-      :async_publisher_max_queue_size => 1_000_000,
-      :async_publisher_supervisor_interval => 200, # in milliseconds
       :default_exchange => 'events',
       :heartbeat => 5,
       :host => 'localhost',
@@ -42,8 +33,7 @@ module ActionSubscriber
       :mode => 'subscribe',
       :pop_interval => 100, # in milliseconds
       :port => 5672,
-      :prefetch => 5,
-      :publisher_confirms => false,
+      :prefetch => 2,
       :seconds_to_wait_for_graceful_shutdown => 30,
       :threadpool_size => 8,
       :timeout => 1,

data/lib/action_subscriber/default_routing.rb

@@ -1,19 +1,21 @@
 module ActionSubscriber
   module DefaultRouting
-    def routes
+    def routes(route_settings)
       @routes ||= begin
         routes = []
         exchange_names.each do |exchange_name|
           subscribable_methods.each do |method_name|
-            routes << ActionSubscriber::Route.new({
+            settings = {
               acknowledgements: acknowledge_messages?,
               action: method_name,
-              durable: false, 
+              durable: false,
               exchange: exchange_name,
               routing_key: routing_key_name_for_method(method_name),
               subscriber: self,
               queue: queue_name_for_method(method_name),
-            })
+            }
+            settings.merge!(route_settings)
+            routes << ActionSubscriber::Route.new(settings)
           end
         end
         routes

data/lib/action_subscriber/march_hare/subscriber.rb

@@ -18,7 +18,9 @@ module ActionSubscriber
         # of times we will pop each time we poll the broker
         times_to_pop = [::ActionSubscriber::Threadpool.ready_size, ::ActionSubscriber.config.times_to_pop].min
         times_to_pop.times do
-          queues.each do |route,queue|
+          subscriptions.each do |subscription|
+            route = subscription[:route]
+            queue = subscription[:queue]
             # Handle busy checks on a per threadpool basis
             next if route.threadpool.busy?
 
@@ -27,7 +29,6 @@ module ActionSubscriber
             ::ActiveSupport::Notifications.instrument "popped_event.action_subscriber", :payload_size => encoded_payload.bytesize, :queue => queue.name
             properties = {
               :action => route.action,
-              :channel => queue.channel,
               :content_type => metadata.content_type,
               :delivery_tag => metadata.delivery_tag,
               :exchange => metadata.exchange,
@@ -46,7 +47,9 @@ module ActionSubscriber
       end
 
       def auto_subscribe!
-        queues.each do |route,queue|
+        subscriptions.each do |subscription|
+          route = subscription[:route]
+          queue = subscription[:queue]
           queue.channel.prefetch = route.prefetch if route.acknowledgements?
           consumer = queue.subscribe(route.queue_subscription_options) do |metadata, encoded_payload|
             ::ActiveSupport::Notifications.instrument "received_event.action_subscriber", :payload_size => encoded_payload.bytesize, :queue => queue.name
@@ -62,7 +65,7 @@ module ActionSubscriber
               :queue => queue.name,
             }
             env = ::ActionSubscriber::Middleware::Env.new(route.subscriber, encoded_payload, properties)
-            enqueue_env(route.threadpool, env)
+            run_env(env)
           end
 
           march_hare_consumers << consumer
@@ -84,6 +87,13 @@ module ActionSubscriber
         end
       end
 
+      def run_env(env)
+        logger.info "RECEIVED #{env.message_id} from #{env.queue}"
+        ::ActiveSupport::Notifications.instrument "process_event.action_subscriber", :subscriber => env.subscriber.to_s, :routing_key => env.routing_key, :queue => env.queue do
+          ::ActionSubscriber.config.middleware.call(env)
+        end
+      end
+
       def _normalized_headers(metadata)
         return {} unless metadata.headers
         metadata.headers.each_with_object({}) do |(header,value), hash|

data/lib/action_subscriber/message_retry.rb

@@ -46,7 +46,7 @@ module ActionSubscriber
     end
 
     def self.with_exchange(env, ttl, retry_queue_name)
-      channel = RabbitConnection.subscriber_connection.create_channel
+      channel = RabbitConnection.with_connection(:default){|connection| connection.create_channel}
       begin
         channel.confirm_select
         # an empty string is the default exchange [see bunny docs](http://rubybunny.info/articles/exchanges.html#default_exchange)

data/lib/action_subscriber/middleware/env.rb

@@ -28,7 +28,7 @@ module ActionSubscriber
       #         :routing_key => String
       def initialize(subscriber, encoded_payload, properties)
         @action = properties.fetch(:action)
-        @channel = properties.fetch(:channel)
+        @channel = properties[:channel]
         @content_type = properties.fetch(:content_type)
         @delivery_tag = properties.fetch(:delivery_tag)
         @encoded_payload = encoded_payload
@@ -41,12 +41,14 @@ module ActionSubscriber
       end
 
       def acknowledge
+        fail ::RuntimeError, "you can't acknowledge messages under the polling API" unless @channel
         acknowledge_multiple_messages = false
         @channel.ack(@delivery_tag, acknowledge_multiple_messages)
         true
       end
 
       def reject
+        fail ::RuntimeError, "you can't acknowledge messages under the polling API" unless @channel
         requeue_message = true
         @channel.reject(@delivery_tag, requeue_message)
         true

data/lib/action_subscriber/middleware/error_handler.rb

@@ -8,10 +8,17 @@ module ActionSubscriber
       end
 
       def call(env)
-        @app.call(env)
-      rescue => error
-        logger.error "FAILED #{env.message_id}"
-        ::ActionSubscriber.configuration.error_handler.call(error, env.to_h)
+        # This insulates the connection thread from errors that are raised by the error_handle or
+        # exceptions that don't fall under StandardError (which are not caught by `rescue => error`)
+        new_thread = ::Thread.new do
+          begin
+            @app.call(env)
+          rescue => error
+            logger.error "FAILED #{env.message_id}"
+            ::ActionSubscriber.configuration.error_handler.call(error, env.to_h)
+          end
+        end
+        ::Thread.pass while new_thread.alive?
       end
     end
   end

data/lib/action_subscriber/rabbit_connection.rb

@@ -3,57 +3,40 @@ require 'thread'
 module ActionSubscriber
   module RabbitConnection
     SUBSCRIBER_CONNECTION_MUTEX = ::Mutex.new
-    PUBLISHER_CONNECTION_MUTEX = ::Mutex.new
     NETWORK_RECOVERY_INTERVAL = 1.freeze
 
-    def self.publisher_connected?
-      publisher_connection.try(:connected?)
-    end
-
-    def self.publisher_connection
+    def self.setup_connection(name, settings)
       SUBSCRIBER_CONNECTION_MUTEX.synchronize do
-        return @publisher_connection if @publisher_connection
-        @publisher_connection = create_connection
-      end
-    end
-
-    def self.publisher_disconnect!
-      SUBSCRIBER_CONNECTION_MUTEX.synchronize do
-        if @publisher_connection && @publisher_connection.connected?
-          @publisher_connection.close
-        end
-
-        @publisher_connection = nil
+        fail ArgumentError, "a #{name} connection already exists" if subscriber_connections[name]
+        subscriber_connections[name] = create_connection(settings)
       end
     end
 
     def self.subscriber_connected?
-      subscriber_connection.try(:connected?)
+      subscriber_connections.all?{|_name, connection| connection.connected?}
     end
 
-    def self.subscriber_connection
+    def self.subscriber_disconnect!
       SUBSCRIBER_CONNECTION_MUTEX.synchronize do
-        return @subscriber_connection if @subscriber_connection
-        @subscriber_connection = create_connection
+        subscriber_connections.each{|_name, connection| connection.close}
+        @subscriber_connections = []
       end
     end
 
-    def self.subscriber_disconnect!
+    def self.with_connection(name)
       SUBSCRIBER_CONNECTION_MUTEX.synchronize do
-        if @subscriber_connection && @subscriber_connection.connected?
-          @subscriber_connection.close
-        end
-
-        @subscriber_connection = nil
+        fail ArgumentError, "there is no connection named #{name}" unless subscriber_connections[name]
+        yield(subscriber_connections[name])
       end
     end
 
     # Private API
-    def self.create_connection
+    def self.create_connection(settings)
+      options = connection_options.merge(settings)
       if ::RUBY_PLATFORM == "java"
-        connection = ::MarchHare.connect(connection_options)
+        connection = ::MarchHare.connect(options)
       else
-        connection = ::Bunny.new(connection_options)
+        connection = ::Bunny.new(options)
         connection.start
         connection
       end
@@ -62,18 +45,24 @@ module ActionSubscriber
 
     def self.connection_options
       {
+        :automatically_recover         => true,
         :continuation_timeout          => ::ActionSubscriber.configuration.timeout * 1_000.0, #convert sec to ms
         :heartbeat                     => ::ActionSubscriber.configuration.heartbeat,
         :hosts                         => ::ActionSubscriber.configuration.hosts,
+        :network_recovery_interval     => NETWORK_RECOVERY_INTERVAL,
         :pass                          => ::ActionSubscriber.configuration.password,
         :port                          => ::ActionSubscriber.configuration.port,
+        :recover_from_connection_close => true,
+        :threadpool_size               => ::ActionSubscriber.configuration.threadpool_size,
         :user                          => ::ActionSubscriber.configuration.username,
         :vhost                         => ::ActionSubscriber.configuration.virtual_host,
-        :automatically_recover         => true,
-        :network_recovery_interval     => NETWORK_RECOVERY_INTERVAL,
-        :recover_from_connection_close => true,
       }
     end
     private_class_method :connection_options
+
+    def self.subscriber_connections
+      @subscriber_connections ||= {}
+    end
+    private_class_method :subscriber_connections
   end
 end

data/lib/action_subscriber/route.rb

@@ -2,7 +2,9 @@ module ActionSubscriber
   class Route
     attr_reader :acknowledgements,
                 :action,
-                :durable, 
+                :concurrency,
+                :connection_name,
+                :durable,
                 :exchange,
                 :prefetch,
                 :queue,
@@ -13,6 +15,8 @@ module ActionSubscriber
     def initialize(attributes)
       @acknowledgements = attributes.fetch(:acknowledgements)
       @action = attributes.fetch(:action)
+      @concurrency = attributes.fetch(:concurrency, 1)
+      @connection_name = attributes.fetch(:connection_name)
       @durable = attributes.fetch(:durable)
       @exchange = attributes.fetch(:exchange).to_s
       @prefetch = attributes.fetch(:prefetch) { ::ActionSubscriber.config.prefetch }

data/lib/action_subscriber/route_set.rb

@@ -12,27 +12,28 @@ module ActionSubscriber
       @routes = routes
     end
 
-    def setup_queues!
+    def setup_subscriptions!
+      fail ::RuntimeError, "you cannot setup queues multiple times, this should only happen once at startup" unless subscriptions.empty?
       routes.each do |route|
-        queues[route] = setup_queue(route)
+        route.concurrency.times do
+          subscriptions << {
+            :route => route,
+            :queue => setup_queue(route),
+          }
+        end
       end
     end
 
   private
 
-    def queues
-      @queues ||= {}
+    def subscriptions
+      @subscriptions ||= []
     end
 
     def setup_queue(route)
-      channel = ::ActionSubscriber::RabbitConnection.subscriber_connection.create_channel
-      # Make channels threadsafe again! Believe Me!
-      # Accessing channels from multiple threads for messsage acknowledgement will crash
-      # a channel and stop messages from being received on that channel
-      # this isn't very clear in the documentation for march_hare/bunny, but it is
-      # explicitly addresses here: https://github.com/rabbitmq/rabbitmq-java-client/issues/53
-      channel = ::ActionSubscriber::Synchronizer.new(channel)
+      channel = ::ActionSubscriber::RabbitConnection.with_connection(route.connection_name){ |connection| connection.create_channel }
       exchange = channel.topic(route.exchange)
+      # TODO go to back to the old way of creating a queue?
       queue = create_queue(channel, route.queue, :durable => route.durable)
       queue.bind(exchange, :routing_key => route.routing_key)
       queue

data/lib/action_subscriber/router.rb

@@ -12,6 +12,17 @@ module ActionSubscriber
       :exchange => "events",
     }.freeze
 
+    def initialize
+      @current_connection_name = :default
+    end
+
+    def connection(name, settings)
+      ::ActionSubscriber::RabbitConnection.setup_connection(name, settings)
+      @current_connection_name = name
+      yield
+      @current_connection_name = :default
+    end
+
     def default_routing_key_for(route_settings)
       [
         route_settings[:publisher],
@@ -30,7 +41,7 @@ module ActionSubscriber
     end
 
     def default_routes_for(subscriber)
-      subscriber.routes.each do |route|
+      subscriber.routes({:connection_name => @current_connection_name}).each do |route|
         routes << route
       end
     end
@@ -40,7 +51,7 @@ module ActionSubscriber
     end
 
     def route(subscriber, action, options = {})
-      route_settings = DEFAULT_SETTINGS.merge(options).merge(:subscriber => subscriber, :action => action)
+      route_settings = DEFAULT_SETTINGS.merge(:connection_name => @current_connection_name).merge(options).merge(:subscriber => subscriber, :action => action)
       route_settings[:routing_key] ||= default_routing_key_for(route_settings)
       route_settings[:queue] ||= default_queue_for(route_settings)
       routes << Route.new(route_settings)

data/lib/action_subscriber/version.rb

@@ -1,3 +1,3 @@
 module ActionSubscriber
-  VERSION = "2.5.0.pre2"
+  VERSION = "3.0.0.pre1"
 end

data/lib/action_subscriber.rb

@@ -25,9 +25,6 @@ require "action_subscriber/subscribable"
 require "action_subscriber/bunny/subscriber"
 require "action_subscriber/march_hare/subscriber"
 require "action_subscriber/babou"
-require "action_subscriber/publisher"
-require "action_subscriber/publisher/async"
-require "action_subscriber/synchronizer"
 require "action_subscriber/route"
 require "action_subscriber/route_set"
 require "action_subscriber/router"
@@ -81,19 +78,21 @@ module ActionSubscriber
     end
   end
 
-  def self.setup_queues!
-    route_set.setup_queues!
+  def self.setup_default_connection!
+    ::ActionSubscriber::RabbitConnection.setup_connection(:default, {})
+  end
+
+  def self.setup_subscriptions!
+    route_set.setup_subscriptions!
   end
 
   def self.start_queues
-    ::ActionSubscriber::RabbitConnection.subscriber_connection
-    setup_queues!
+    setup_subscriptions!
     print_subscriptions
   end
 
   def self.start_subscribers
-    ::ActionSubscriber::RabbitConnection.subscriber_connection
-    setup_queues!
+    setup_subscriptions!
     auto_subscribe!
     print_subscriptions
   end
@@ -106,21 +105,14 @@ module ActionSubscriber
   require "action_subscriber/railtie" if defined?(Rails)
   ::ActiveSupport.run_load_hooks(:action_subscriber, Base)
 
-  # Intialize async publisher adapter
-  ::ActionSubscriber::Publisher::Async.publisher_adapter
-
   ##
   # Private Implementation
   #
   def self.route_set
     @route_set ||= begin
-      if @draw_routes_block
-        routes = Router.draw_routes(&@draw_routes_block)
-        RouteSet.new(routes)
-      else
-        logger.warn "DEPRECATION WARNING: We are inferring your routes by looking at your subscribers. This behavior is deprecated and will be removed in version 2.0. Please see the routing guide at https://github.com/mxenabled/action_subscriber/blob/master/routing.md"
-        RouteSet.new(self.send(:default_routes))
-      end
+      fail "cannot start because no routes have been defined. Please make sure that you call ActionSubscriber.draw_routes when your application loads" unless @draw_routes_block
+      routes = Router.draw_routes(&@draw_routes_block)
+      RouteSet.new(routes)
     end
   end
   private_class_method :route_set
@@ -132,8 +124,3 @@ module ActionSubscriber
   end
   private_class_method :default_routes
 end
-
-at_exit do
-  ::ActionSubscriber::Publisher::Async.publisher_adapter.shutdown!
-  ::ActionSubscriber::RabbitConnection.publisher_disconnect!
-end

data/spec/integration/around_filters_spec.rb

@@ -32,7 +32,7 @@ describe "subscriber filters", :integration => true do
   it "runs multiple around filters" do
     $messages = []  #testing the order of things
     ::ActionSubscriber.auto_subscribe!
-    ::ActionSubscriber::Publisher.publish("insta.first", "hEY Guyz!", "events")
+    ::ActivePublisher.publish("insta.first", "hEY Guyz!", "events")
 
     verify_expectation_within(1.0) do
       expect($messages).to eq [:whisper_before, :yell_before, "hEY Guyz!", :yell_after, :whisper_after]

data/spec/integration/at_least_once_spec.rb

@@ -17,7 +17,7 @@ describe "at_least_once! mode", :integration => true do
 
   it "retries a failed job until it succeeds" do
     ::ActionSubscriber.auto_subscribe!
-    ::ActionSubscriber::Publisher.publish("gorby_puff.grumpy", "GrumpFace", "events")
+    ::ActivePublisher.publish("gorby_puff.grumpy", "GrumpFace", "events")
 
     verify_expectation_within(2.0) do
       expect($messages).to eq Set.new(["GrumpFace::0","GrumpFace::1","GrumpFace::2"])

data/spec/integration/at_most_once_spec.rb

@@ -17,7 +17,7 @@ describe "at_most_once! mode", :integration => true do
 
   it "does not retry a failed message" do
     ::ActionSubscriber.auto_subscribe!
-    ::ActionSubscriber::Publisher.publish("pokemon.caught_em_all", "All Pokemon have been caught", "events")
+    ::ActivePublisher.publish("pokemon.caught_em_all", "All Pokemon have been caught", "events")
 
     verify_expectation_within(1.0) do
       expect($messages.size).to eq 1

data/spec/integration/automatic_reconnect_spec.rb

@@ -7,7 +7,6 @@ class GusSubscriber < ActionSubscriber::Base
 end
 
 describe "Automatically reconnect on connection failure", :integration => true, :slow => true do
-  let(:connection) { subscriber.connection }
   let(:draw_routes) do
     ::ActionSubscriber.draw_routes do
       default_routes_for GusSubscriber
@@ -18,7 +17,7 @@ describe "Automatically reconnect on connection failure", :integration => true,
 
   it "reconnects when a connection drops" do
     ::ActionSubscriber::auto_subscribe!
-    ::ActionSubscriber::Publisher.publish("gus.spoke", "First", "events")
+    ::ActivePublisher.publish("gus.spoke", "First", "events")
     verify_expectation_within(5.0) do
       expect($messages).to eq(Set.new(["First"]))
     end
@@ -26,10 +25,10 @@ describe "Automatically reconnect on connection failure", :integration => true,
     close_all_connections!
     sleep 5.0
     verify_expectation_within(5.0) do
-      expect(connection).to be_open
+      expect(::ActionSubscriber::RabbitConnection.with_connection(:default){|connection| connection.open?}).to eq(true)
     end
 
-    ::ActionSubscriber::Publisher.publish("gus.spoke", "Second", "events")
+    ::ActivePublisher.publish("gus.spoke", "Second", "events")
     verify_expectation_within(5.0) do
       expect($messages).to eq(Set.new(["First", "Second"]))
     end