bunny 2.7.4 → 2.22.0

data/lib/bunny/queue.rb

@@ -11,6 +11,23 @@ module Bunny
     # API
     #
 
+    module Types
+      QUORUM  = "quorum"
+      CLASSIC = "classic"
+      STREAM  = "stream"
+
+      KNOWN = [CLASSIC, QUORUM, STREAM]
+
+      def self.known?(q_type)
+        KNOWN.include?(q_type)
+      end
+    end
+
+    module XArgs
+      MAX_LENGTH = "x-max-length",
+      QUEUE_TYPE = "x-queue-type"
+    end
+
     # @return [Bunny::Channel] Channel this queue uses
     attr_reader :channel
     # @return [String] Queue name
@@ -25,7 +42,8 @@ module Bunny
     # @option opts [Boolean] :durable (false)      Should this queue be durable?
     # @option opts [Boolean] :auto_delete (false)  Should this queue be automatically deleted when the last consumer disconnects?
     # @option opts [Boolean] :exclusive (false)    Should this queue be exclusive (only can be used by this connection, removed when the connection is closed)?
-    # @option opts [Boolean] :arguments ({})       Additional optional arguments (typically used by RabbitMQ extensions and plugins)
+    # @option opts [String] :type (nil)            Type of the declared queue (classic, quorum or stream)
+    # @option opts [Hash] :arguments (nil)         Additional optional arguments (typically used by RabbitMQ extensions and plugins)
     #
     # @see Bunny::Channel#queue
     # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
@@ -42,7 +60,17 @@ module Bunny
       @exclusive        = @options[:exclusive]
       @server_named     = @name.empty?
       @auto_delete      = @options[:auto_delete]
-      @arguments        = @options[:arguments]
+      @type             = @options[:type]
+
+      @arguments        = if @type and !@type.empty? then
+        (@options[:arguments] || {}).merge({XArgs::QUEUE_TYPE => @type})
+      else
+        @options[:arguments]
+      end
+      verify_type!(@arguments)
+      # reassigns updated and verified arguments because Bunny::Channel#declare_queue
+      # accepts a map of options
+      @options[:arguments] = @arguments
 
       @bindings         = Array.new
 
@@ -158,7 +186,6 @@ module Bunny
     # @option opts [Boolean] :ack (false) [DEPRECATED] Use :manual_ack instead
     # @option opts [Boolean] :manual_ack (false) Will this consumer use manual acknowledgements?
     # @option opts [Boolean] :exclusive (false) Should this consumer be exclusive for this queue?
-    # @option opts [Boolean] :block (false) Should the call block calling thread?
     # @option opts [#call] :on_cancellation Block to execute when this consumer is cancelled remotely (e.g. via the RabbitMQ Management plugin)
     # @option opts [String] :consumer_tag Unique consumer identifier. It is usually recommended to let Bunny generate it for you.
     # @option opts [Hash] :arguments ({}) Additional (optional) arguments, typically used by RabbitMQ extensions
@@ -373,11 +400,6 @@ module Bunny
 
     protected
 
-    # @private
-    def self.add_default_options(name, opts, block)
-      { :queue => name, :nowait => (block.nil? && !name.empty?) }.merge(opts)
-    end
-
     # @private
     def self.add_default_options(name, opts)
       # :nowait is always false for Bunny
@@ -395,5 +417,11 @@ module Bunny
         h
       end
     end
+
+    def verify_type!(args)
+      q_type = (args || {})["x-queue-type"]
+      throw ArgumentError.new(
+        "unsupported queue type #{q_type.inspect}, supported ones: #{Types::KNOWN.join(', ')}") if (q_type and !Types.known?(q_type))
+    end
   end
 end

data/lib/bunny/reader_loop.rb

@@ -9,13 +9,17 @@ module Bunny
   # @private
   class ReaderLoop
 
-    def initialize(transport, session, session_thread)
-      @transport      = transport
-      @session        = session
-      @session_thread = session_thread
-      @logger         = @session.logger
+    def initialize(transport, session, session_error_handler)
+      @transport             = transport
+      @session               = session
+      @session_error_handler = session_error_handler
+      @logger                = @session.logger
 
-      @mutex          = Mutex.new
+      @mutex                 = Mutex.new
+
+      @stopping              = false
+      @stopped               = false
+      @network_is_down       = false
     end
 
 
@@ -33,7 +37,8 @@ module Bunny
         begin
           break if @mutex.synchronize { @stopping || @stopped || @network_is_down }
           run_once
-        rescue AMQ::Protocol::EmptyResponseError, IOError, SystemCallError, Timeout::Error => e
+        rescue AMQ::Protocol::EmptyResponseError, IOError, SystemCallError, Timeout::Error,
+               OpenSSL::OpenSSLError => e
           break if terminate? || @session.closing? || @session.closed?
 
           @network_is_down = true
@@ -42,7 +47,7 @@ module Bunny
             @session.handle_network_failure(e)
           else
             log_exception(e)
-            @session_thread.raise(Bunny::NetworkFailure.new("detected a network failure: #{e.message}", e))
+            @session_error_handler.raise(Bunny::NetworkFailure.new("detected a network failure: #{e.message}", e))
           end
         rescue ShutdownSignal => _
           @mutex.synchronize { @stopping = true }
@@ -53,7 +58,7 @@ module Bunny
             log_exception(e)
 
             @network_is_down = true
-            @session_thread.raise(Bunny::NetworkFailure.new("caught an unexpected exception in the network loop: #{e.message}", e))
+            @session_error_handler.raise(Bunny::NetworkFailure.new("caught an unexpected exception in the network loop: #{e.message}", e))
           end
         rescue Errno::EBADF => _ebadf
           break if terminate?
@@ -111,7 +116,14 @@ module Bunny
     end
 
     def join
-      @thread.join if @thread
+      # Thread#join can/would trigger a re-raise of an unhandled exception in this thread.
+      # In addition, Thread.handle_interrupt can be used by other libraries or application code
+      # that would make this join operation fail with an obscure exception.
+      # So we try to save everyone some really unpleasant debugging time by introducing
+      # this condition which typically would not evaluate to true anyway.
+      #
+      # See ruby-amqp/bunny#589 and ruby-amqp/bunny#590 for background.
+      @thread.join if @thread && @thread != Thread.current
     end
 
     def kill

data/lib/bunny/session.rb

@@ -36,10 +36,10 @@ module Bunny
     DEFAULT_HEARTBEAT = :server
     # @private
     DEFAULT_FRAME_MAX = 131072
-    # 2^16 - 1, maximum representable signed 16 bit integer.
+    # Hard limit the user cannot go over regardless of server configuration.
     # @private
     CHANNEL_MAX_LIMIT   = 65535
-    DEFAULT_CHANNEL_MAX = CHANNEL_MAX_LIMIT
+    DEFAULT_CHANNEL_MAX = 2047
 
     # backwards compatibility
     # @private
@@ -71,6 +71,7 @@ module Bunny
     # Default reconnection interval for TCP connection failures
     DEFAULT_NETWORK_RECOVERY_INTERVAL = 5.0
 
+    DEFAULT_RECOVERABLE_EXCEPTIONS = [StandardError, TCPConnectionFailedForAllHosts, TCPConnectionFailed, AMQ::Protocol::EmptyResponseError, SystemCallError, Timeout::Error, Bunny::ConnectionLevelException, Bunny::ConnectionClosedError]
 
     #
     # API
@@ -78,7 +79,7 @@ module Bunny
 
     # @return [Bunny::Transport]
     attr_reader :transport
-    attr_reader :status, :port, :heartbeat, :user, :pass, :vhost, :frame_max, :channel_max, :threaded
+    attr_reader :status, :heartbeat, :user, :pass, :vhost, :frame_max, :channel_max, :threaded
     attr_reader :server_capabilities, :server_properties, :server_authentication_mechanisms, :server_locales
     attr_reader :channel_id_allocator
     # Authentication mechanism, e.g. "PLAIN" or "EXTERNAL"
@@ -89,7 +90,9 @@ module Bunny
     # @return [Integer] Timeout for blocking protocol operations (queue.declare, queue.bind, etc), in milliseconds. Default is 15000.
     attr_reader :continuation_timeout
     attr_reader :network_recovery_interval
+    attr_reader :connection_name
     attr_accessor :socket_configurator
+    attr_accessor :recoverable_exceptions
 
     # @param [String, Hash] connection_string_or_opts Connection string or a hash of connection options
     # @param [Hash] optz Extra options not related to connection
@@ -101,19 +104,21 @@ module Bunny
     # @option connection_string_or_opts [String] :username ("guest") Username
     # @option connection_string_or_opts [String] :password ("guest") Password
     # @option connection_string_or_opts [String] :vhost ("/") Virtual host to use
-    # @option connection_string_or_opts [Integer, Symbol] :heartbeat (:server) Heartbeat interval. :server means use the default suggested by RabbitMQ. 0 means no heartbeat (not recommended).
+    # @option connection_string_or_opts [Integer, Symbol] :heartbeat (:server) Heartbeat timeout to offer to the server. :server means use the value suggested by RabbitMQ. 0 means heartbeats and socket read timeouts will be disabled (not recommended).
     # @option connection_string_or_opts [Integer] :network_recovery_interval (4) Recovery interval periodic network recovery will use. This includes initial pause after network failure.
     # @option connection_string_or_opts [Boolean] :tls (false) Should TLS/SSL be used?
     # @option connection_string_or_opts [String] :tls_cert (nil) Path to client TLS/SSL certificate file (.pem)
     # @option connection_string_or_opts [String] :tls_key (nil) Path to client TLS/SSL private key file (.pem)
     # @option connection_string_or_opts [Array<String>] :tls_ca_certificates Array of paths to TLS/SSL CA files (.pem), by default detected from OpenSSL configuration
     # @option connection_string_or_opts [String] :verify_peer (true) Whether TLS peer verification should be performed
-    # @option connection_string_or_opts [Symbol] :tls_version (negotiated) What TLS version should be used (:TLSv1, :TLSv1_1, or :TLSv1_2)
+    # @option connection_string_or_opts [Symbol] :tls_protocol (negotiated) What TLS version should be used (:TLSv1, :TLSv1_1, or :TLSv1_2)
+    # @option connection_string_or_opts [Integer] :channel_max (2047) Maximum number of channels allowed on this connection, minus 1 to account for the special channel 0.
     # @option connection_string_or_opts [Integer] :continuation_timeout (15000) Timeout for client operations that expect a response (e.g. {Bunny::Queue#get}), in milliseconds.
     # @option connection_string_or_opts [Integer] :connection_timeout (30) Timeout in seconds for connecting to the server.
-    # @option connection_string_or_opts [Integer] :read_timeout (30) TCP socket read timeout in seconds.
+    # @option connection_string_or_opts [Integer] :read_timeout (30) TCP socket read timeout in seconds. If heartbeats are disabled this will be ignored.
     # @option connection_string_or_opts [Integer] :write_timeout (30) TCP socket write timeout in seconds.
-    # @option connection_string_or_opts [Proc] :hosts_shuffle_strategy A Proc that reorders a list of host strings, defaults to Array#shuffle
+    # @option connection_string_or_opts [Proc] :hosts_shuffle_strategy a callable that reorders a list of host strings, defaults to Array#shuffle
+    # @option connection_string_or_opts [Proc] :recovery_completed a callable that will be called when a network recovery is performed
     # @option connection_string_or_opts [Logger] :logger The logger.  If missing, one is created using :log_file and :log_level.
     # @option connection_string_or_opts [IO, String] :log_file The file or path to use when creating a logger.  Defaults to STDOUT.
     # @option connection_string_or_opts [IO, String] :logfile DEPRECATED: use :log_file instead.  The file or path to use when creating a logger.  Defaults to STDOUT.
@@ -121,10 +126,15 @@ module Bunny
     # @option connection_string_or_opts [Boolean] :automatically_recover (true) Should automatically recover from network failures?
     # @option connection_string_or_opts [Integer] :recovery_attempts (nil) Max number of recovery attempts, nil means forever
     # @option connection_string_or_opts [Integer] :reset_recovery_attempts_after_reconnection (true) Should recovery attempt counter be reset after successful reconnection? When set to false, the attempt counter will last through the entire lifetime of the connection object.
+    # @option connection_string_or_opts [Proc] :recovery_attempt_started (nil) Will be called before every connection recovery attempt
+    # @option connection_string_or_opts [Proc] :recovery_completed (nil) Will be called after successful connection recovery
+    # @option connection_string_or_opts [Proc] :recovery_attempts_exhausted (nil) Will be called when the connection recovery failed after the specified amount of recovery attempts
     # @option connection_string_or_opts [Boolean] :recover_from_connection_close (true) Should this connection recover after receiving a server-sent connection.close (e.g. connection was force closed)?
+    # @option connection_string_or_opts [Object] :session_error_handler (Thread.current) Object which responds to #raise that will act as a session error handler. Defaults to Thread.current, which will raise asynchronous exceptions in the thread that created the session.
     #
     # @option optz [String] :auth_mechanism ("PLAIN") Authentication mechanism, PLAIN or EXTERNAL
     # @option optz [String] :locale ("PLAIN") Locale RabbitMQ should use
+    # @option optz [String] :connection_name (nil) Client-provided connection name, if any. Note that the value returned does not uniquely identify a connection and cannot be used as a connection identifier in HTTP API requests.
     #
     # @see http://rubybunny.info/articles/connecting.html Connecting to RabbitMQ guide
     # @see http://rubybunny.info/articles/tls.html TLS/SSL guide
@@ -151,22 +161,25 @@ module Bunny
       @addresses       = self.addresses_from(opts)
       @address_index   = 0
 
-      # re-init, see above
-      @logger          = opts.fetch(:logger, init_default_logger(log_file, log_level))
-
+      @transport       = nil
       @user            = self.username_from(opts)
       @pass            = self.password_from(opts)
       @vhost           = self.vhost_from(opts)
       @threaded        = opts.fetch(:threaded, true)
 
+      # re-init, see above
+      @logger          = opts.fetch(:logger, init_default_logger(log_file, log_level))
+
       validate_connection_options(opts)
+      @last_connection_error = nil
 
       # should automatic recovery from network failures be used?
       @automatically_recover = if opts[:automatically_recover].nil? && opts[:automatic_recovery].nil?
                                  true
                                else
-                                 opts[:automatically_recover] || opts[:automatic_recovery]
+                                 opts[:automatically_recover] | opts[:automatic_recovery]
                                end
+      @recovering_from_network_failure = false
       @max_recovery_attempts = opts[:recovery_attempts]
       @recovery_attempts     = @max_recovery_attempts
       # When this is set, connection attempts won't be reset after
@@ -180,6 +193,7 @@ module Bunny
       @continuation_timeout   = opts.fetch(:continuation_timeout, DEFAULT_CONTINUATION_TIMEOUT)
 
       @status             = :not_connected
+      @manually_closed    = false
       @blocked            = false
 
       # these are negotiated with the broker during the connection tuning phase
@@ -187,10 +201,13 @@ module Bunny
       @client_channel_max = normalize_client_channel_max(opts.fetch(:channel_max, DEFAULT_CHANNEL_MAX))
       # will be-renegotiated during connection tuning steps. MK.
       @channel_max        = @client_channel_max
+      @heartbeat_sender   = nil
       @client_heartbeat   = self.heartbeat_from(opts)
 
       client_props         = opts[:properties] || opts[:client_properties] || {}
+      @connection_name     = client_props[:connection_name] || opts[:connection_name]
       @client_properties   = DEFAULT_CLIENT_PROPERTIES.merge(client_props)
+                                                      .merge(connection_name: connection_name)
       @mechanism           = normalize_auth_mechanism(opts.fetch(:auth_mechanism, "PLAIN"))
       @credentials_encoder = credentials_encoder_for(@mechanism)
       @locale              = @opts.fetch(:locale, DEFAULT_LOCALE)
@@ -207,10 +224,17 @@ module Bunny
 
       @channels            = Hash.new
 
-      @origin_thread       = Thread.current
+      @recovery_attempt_started = opts[:recovery_attempt_started]
+      @recovery_completed       = opts[:recovery_completed]
+      @recovery_attempts_exhausted          = opts[:recovery_attempts_exhausted]
+
+      @session_error_handler = opts.fetch(:session_error_handler, Thread.current)
+
+      @recoverable_exceptions = DEFAULT_RECOVERABLE_EXCEPTIONS.dup
 
       self.reset_continuations
       self.initialize_transport
+
     end
 
     def validate_connection_options(options)
@@ -232,9 +256,13 @@ module Bunny
     # @return [String] Virtual host used
     def virtual_host; self.vhost; end
 
-    # @return [Integer] Heartbeat interval used
+    # @deprecated
+    # @return [Integer] Heartbeat timeout (not interval) used
     def heartbeat_interval; self.heartbeat; end
 
+    # @return [Integer] Heartbeat timeout used
+    def heartbeat_timeout; self.heartbeat; end
+
     # @return [Boolean] true if this connection uses TLS (SSL)
     def uses_tls?
       @transport.uses_tls?
@@ -303,10 +331,6 @@ module Bunny
           @transport.post_initialize_socket
           @transport.connect
 
-          if @socket_configurator
-            @transport.configure_socket(&@socket_configurator)
-          end
-
           self.init_connection
           self.open_connection
 
@@ -333,6 +357,14 @@ module Bunny
       self
     end
 
+    def update_secret(value, reason)
+      @transport.send_frame(AMQ::Protocol::Connection::UpdateSecret.encode(value, reason))
+      @last_update_secret_ok = wait_on_continuations
+      raise_if_continuation_resulted_in_a_connection_error!
+
+      @last_update_secret_ok
+    end
+
     # Socket operation write timeout used by this connection
     # @return [Integer]
     # @private
@@ -363,14 +395,16 @@ module Bunny
     alias channel create_channel
 
     # Closes the connection. This involves closing all of its channels.
-    def close
+    def close(await_response = true)
       @status_mutex.synchronize { @status = :closing }
 
       ignoring_io_errors do
         if @transport.open?
+          @logger.debug "Transport is still open..."
           close_all_channels
 
-          self.close_connection(true)
+          @logger.debug "Will close all channels...."
+          self.close_connection(await_response)
         end
 
         clean_up_on_shutdown
@@ -379,6 +413,8 @@ module Bunny
         @status = :closed
         @manually_closed = true
       end
+      @logger.debug "Connection is closed"
+      true
     end
     alias stop close
 
@@ -413,7 +449,7 @@ module Bunny
       @status_mutex.synchronize { @status == :closed }
     end
 
-    # @return [Boolean] true if this AMQP 0.9.1 connection has been programmatically closed
+    # @return [Boolean] true if this AMQP 0.9.1 connection has been closed by the user (as opposed to the server)
     def manually_closed?
       @status_mutex.synchronize { @manually_closed == true }
     end
@@ -464,7 +500,7 @@ module Bunny
     # @param [String] uri amqp or amqps URI to parse
     # @return [Hash] Parsed URI as a hash
     def self.parse_uri(uri)
-      AMQ::Settings.parse_amqp_url(uri)
+      AMQ::Settings.configure(uri)
     end
 
     # Checks if a queue with given name exists.
@@ -507,6 +543,24 @@ module Bunny
       end
     end
 
+    # Defines a callable (e.g. a block) that will be called
+    # before every connection recovery attempt.
+    def before_recovery_attempt_starts(&block)
+      @recovery_attempt_started = block
+    end
+
+    # Defines a callable (e.g. a block) that will be called
+    # after successful connection recovery.
+    def after_recovery_completed(&block)
+      @recovery_completed = block
+    end
+
+    # Defines a callable (e.g. a block) that will be called
+    # when the connection recovery failed after the specified
+    # numbers of recovery attempts.
+    def after_recovery_attempts_exhausted(&block)
+      @recovery_attempts_exhausted = block
+    end
 
     #
     # Implementation
@@ -563,11 +617,13 @@ module Bunny
     end
 
     # @private
-    def close_connection(sync = true)
+    def close_connection(await_response = true)
       if @transport.open?
+        @logger.debug "Transport is still open"
         @transport.send_frame(AMQ::Protocol::Connection::Close.encode(200, "Goodbye", 0, 0))
 
-        if sync
+        if await_response
+          @logger.debug "Waiting for a connection.close-ok..."
           @last_connection_close_ok = wait_on_continuations
         end
       end
@@ -617,6 +673,8 @@ module Bunny
       when AMQ::Protocol::Connection::Unblocked then
         @blocked = false
         @unblock_callback.call(method) if @unblock_callback
+      when AMQ::Protocol::Connection::UpdateSecretOk then
+        @continuations.push(method)
       when AMQ::Protocol::Channel::Close then
         begin
           ch = synchronised_find_channel(ch_number)
@@ -625,8 +683,12 @@ module Bunny
           # avoid doing that while holding a mutex lock. MK.
           ch.handle_method(method)
         ensure
-          # synchronises on @channel_mutex under the hood
-          self.unregister_channel(ch)
+          if ch.nil?
+            @logger.warn "Received a server-sent channel.close but the channel was not found locally. Ignoring the frame."
+          else
+            # synchronises on @channel_mutex under the hood
+            self.unregister_channel(ch)
+          end
         end
       when AMQ::Protocol::Basic::GetEmpty then
         ch = find_channel(ch_number)
@@ -697,9 +759,7 @@ module Bunny
 
     # @private
     def recoverable_network_failure?(exception)
-      # No reasonably smart strategy was suggested in a few years.
-      # So just recover unconditionally. MK.
-      true
+      @recoverable_exceptions.any? {|x| exception.kind_of? x}
     end
 
     # @private
@@ -720,6 +780,7 @@ module Bunny
     def recover_from_network_failure
       sleep @network_recovery_interval
       @logger.debug "Will attempt connection recovery..."
+      notify_of_recovery_attempt_start
 
       self.initialize_transport
 
@@ -738,20 +799,28 @@ module Bunny
         end
 
         recover_channels
+        notify_of_recovery_completion
       end
     rescue HostListDepleted
       reset_address_index
       retry
-    rescue TCPConnectionFailedForAllHosts, TCPConnectionFailed, AMQ::Protocol::EmptyResponseError, SystemCallError => e
-      @logger.warn "TCP connection failed, reconnecting in #{@network_recovery_interval} seconds"
-      if should_retry_recovery?
-        decrement_recovery_attemp_counter!
-        if recoverable_network_failure?(e)
+    rescue => e
+      if recoverable_network_failure?(e)
+        @logger.warn "TCP connection failed"
+        if should_retry_recovery?
+          @logger.warn "Reconnecting in #{@network_recovery_interval} seconds"
+          decrement_recovery_attemp_counter!
           announce_network_failure_recovery
           retry
+        else
+          @logger.error "Ran out of recovery attempts (limit set to #{@max_recovery_attempts}), giving up"
+          @transport.close
+          self.close(false)
+          @manually_closed = false
+          notify_of_recovery_attempts_exhausted
         end
       else
-        @logger.error "Ran out of recovery attempts (limit set to #{@max_recovery_attempts})"
+        raise e
       end
     end
 
@@ -767,8 +836,10 @@ module Bunny
 
     # @private
     def decrement_recovery_attemp_counter!
-      @recovery_attempts -= 1 if @recovery_attempts
-      @logger.debug "#{@recovery_attempts} recovery attempts left"
+      if @recovery_attempts
+        @recovery_attempts -= 1
+        @logger.debug "#{@recovery_attempts} recovery attempts left"
+      end
       @recovery_attempts
     end
 
@@ -782,12 +853,26 @@ module Bunny
       @channel_mutex.synchronize do
         @channels.each do |n, ch|
           ch.open
-
           ch.recover_from_network_failure
         end
       end
     end
 
+    # @private
+    def notify_of_recovery_attempt_start
+      @recovery_attempt_started.call if @recovery_attempt_started
+    end
+
+    # @private
+    def notify_of_recovery_completion
+      @recovery_completed.call if @recovery_completed
+    end
+
+    # @private
+    def notify_of_recovery_attempts_exhausted
+      @recovery_attempts_exhausted.call if @recovery_attempts_exhausted
+    end
+
     # @private
     def instantiate_connection_level_exception(frame)
       case frame
@@ -823,7 +908,7 @@ module Bunny
 
       clean_up_on_shutdown
       if threaded?
-        @origin_thread.raise(@last_connection_error)
+        @session_error_handler.raise(@last_connection_error)
       else
         raise @last_connection_error
       end
@@ -943,7 +1028,7 @@ module Bunny
 
     # @private
     def heartbeat_from(options)
-      options[:heartbeat] || options[:heartbeat_interval] || options[:requested_heartbeat] || DEFAULT_HEARTBEAT
+      options[:heartbeat] || options[:heartbeat_timeout] || options[:requested_heartbeat] || options[:heartbeat_interval] || DEFAULT_HEARTBEAT
     end
 
     # @private
@@ -980,7 +1065,7 @@ module Bunny
 
     # @private
     def reader_loop
-      @reader_loop ||= ReaderLoop.new(@transport, self, Thread.current)
+      @reader_loop ||= ReaderLoop.new(@transport, self, @session_error_handler)
     end
 
     # @private
@@ -1068,12 +1153,18 @@ module Bunny
       # threads publish on the same channel aggressively, at some point frames will be
       # delivered out of order and broker will raise 505 UNEXPECTED_FRAME exception.
       # If we synchronize on the channel, however, this is both thread safe and pretty fine-grained
-      # locking. Note that "single frame" methods do not need this kind of synchronization. MK.
+      # locking. Note that "single frame" methods technically do not need this kind of synchronization
+      # (no incorrect frame interleaving of the same kind as with basic.publish isn't possible) but we
+      # still recommend not sharing channels between threads except for consumer-only cases in the docs. MK.
       channel.synchronize do
         # see rabbitmq/rabbitmq-server#156
-        data = frames.reduce("") { |acc, frame| acc << frame.encode }
-        @transport.write(data)
-        signal_activity!
+        if open?
+          data = frames.reduce("") { |acc, frame| acc << frame.encode }
+          @transport.write(data)
+          signal_activity!
+        else
+          raise ConnectionClosedError.new(frames)
+        end
       end
     end # send_frameset(frames)
 
@@ -1087,10 +1178,14 @@ module Bunny
       # threads publish on the same channel aggressively, at some point frames will be
       # delivered out of order and broker will raise 505 UNEXPECTED_FRAME exception.
       # If we synchronize on the channel, however, this is both thread safe and pretty fine-grained
-      # locking. Note that "single frame" methods do not need this kind of synchronization. MK.
+      # locking. See a note about "single frame" methods in a comment in `send_frameset`. MK.
       channel.synchronize do
-        frames.each { |frame| self.send_frame_without_timeout(frame, false) }
-        signal_activity!
+        if open?
+          frames.each { |frame| self.send_frame_without_timeout(frame, false) }
+          signal_activity!
+        else
+          raise ConnectionClosedError.new(frames)
+        end
       end
     end # send_frameset_without_timeout(frames)
 
@@ -1177,26 +1272,18 @@ module Bunny
       @logger.debug { "Heartbeat interval negotiation: client = #{@client_heartbeat}, server = #{connection_tune.heartbeat}, result = #{@heartbeat}" }
       @logger.info "Heartbeat interval used (in seconds): #{@heartbeat}"
 
-      # We set the read_write_timeout to twice the heartbeat value
+      # We set the read_write_timeout to twice the heartbeat value,
+      # and then some padding for edge cases.
       # This allows us to miss a single heartbeat before we time out the socket.
-      #
-      # Since RabbitMQ can be configured to disable heartbeats (bad idea but technically
-      # possible nonetheless), we need to take both client and server values into
-      # consideration when deciding about using the heartbeat value for read timeouts.
-      @transport.read_timeout = if heartbeat_disabled?(@client_heartbeat) || heartbeat_disabled?(@heartbeat)
-                                  @logger.debug { "Will use default socket read timeout of #{Transport::DEFAULT_READ_TIMEOUT}" }
-                                  Transport::DEFAULT_READ_TIMEOUT
-                                else
-                                  # pad to account for edge cases. MK.
-                                  n = @heartbeat * 2.2
-                                  @logger.debug { "Will use socket read timeout of #{n}" }
-                                  n
-                                end
-
+      # If heartbeats are disabled, assume that TCP keepalives or a similar mechanism will be used
+      # and disable socket read timeouts. See ruby-amqp/bunny#551.
+      @transport.read_timeout = @heartbeat * 2.2
+      @logger.debug { "Will use socket read timeout of #{@transport.read_timeout.to_i} seconds" }
 
       # if there are existing channels we've just recovered from
       # a network failure and need to fix the allocated set. See issue 205. MK.
       if @channels.empty?
+        @logger.debug { "Initializing channel ID allocator with channel_max = #{@channel_max}" }
         @channel_id_allocator = ChannelIdAllocator.new(@channel_max)
       end
 
@@ -1241,7 +1328,7 @@ module Bunny
           end
 
           if threaded?
-            @origin_thread.raise(e)
+            @session_error_handler.raise(e)
           else
             raise e
           end
@@ -1287,8 +1374,8 @@ module Bunny
         @transport = Transport.new(self,
                                    host_from_address(address),
                                    port_from_address(address),
-                                   @opts.merge(:session_thread => @origin_thread)
-                                  )
+                                   @opts.merge(:session_error_handler => @session_error_handler)
+        )
 
         # Reset the cached progname for the logger only when no logger was provided
         @default_logger.progname = self.to_s