ably-rest 0.8.3 → 0.8.5

data/lib/submodules/ably-ruby/lib/ably/realtime/auth.rb

@@ -65,9 +65,9 @@ module Ably
       #      token_details #=> Ably::Models::TokenDetails
       #    end
       #
-      def authorise(auth_options = {}, token_params = {}, &success_callback)
+      def authorise(token_params = {}, auth_options = {}, &success_callback)
         async_wrap(success_callback) do
-          auth_sync.authorise(auth_options, token_params)
+          auth_sync.authorise(token_params, auth_options)
         end
       end
 
@@ -76,8 +76,8 @@ module Ably
       # @option (see Ably::Auth#authorise)
       # @return [Ably::Models::TokenDetails]
       #
-      def authorise_sync(auth_options = {}, token_params = {})
-        auth_sync.authorise(auth_options, token_params)
+      def authorise_sync(token_params = {}, auth_options = {})
+        auth_sync.authorise(token_params, auth_options)
       end
 
       # def_delegator :auth_sync, :request_token, :request_token_sync
@@ -100,9 +100,9 @@ module Ably
       #      token_details #=> Ably::Models::TokenDetails
       #    end
       #
-      def request_token(auth_options = {}, token_params = {}, &success_callback)
+      def request_token(token_params = {}, auth_options = {}, &success_callback)
         async_wrap(success_callback) do
-          request_token_sync(auth_options, token_params)
+          request_token_sync(token_params, auth_options)
         end
       end
 
@@ -111,8 +111,8 @@ module Ably
       # @option (see Ably::Auth#authorise)
       # @return [Ably::Models::TokenDetails]
       #
-      def request_token_sync(auth_options = {}, token_params = {})
-        auth_sync.request_token(auth_options, token_params)
+      def request_token_sync(token_params = {}, auth_options = {})
+        auth_sync.request_token(token_params, auth_options)
       end
 
       # Creates and signs a token request that can then subsequently be used by any client to request a token
@@ -124,12 +124,12 @@ module Ably
       # @yield [Models::TokenRequest]
       #
       # @example
-      #   client.auth.create_token_request(id: 'asd.asd', ttl: 3600) do |token_request|
+      #   client.auth.create_token_request({ ttl: 3600 }, id: 'asd.asd') do |token_request|
       #     token_request #=> Ably::Models::TokenRequest
       #   end
-      def create_token_request(auth_options = {}, token_params = {}, &success_callback)
+      def create_token_request(token_params = {}, auth_options = {}, &success_callback)
         async_wrap(success_callback) do
-          create_token_request_sync(auth_options, token_params)
+          create_token_request_sync(token_params, auth_options)
         end
       end
 
@@ -138,8 +138,8 @@ module Ably
       # @option (see Ably::Auth#authorise)
       # @return [Ably::Models::TokenRequest]
       #
-      def create_token_request_sync(auth_options = {}, token_params = {})
-        auth_sync.create_token_request(auth_options, token_params)
+      def create_token_request_sync(token_params = {}, auth_options = {})
+        auth_sync.create_token_request(token_params, auth_options)
       end
 
       # Auth header string used in HTTP requests to Ably

data/lib/submodules/ably-ruby/lib/ably/realtime/channel.rb

@@ -46,6 +46,7 @@ module Ably
       )
       include Ably::Modules::StateEmitter
       include Ably::Modules::UsesStateMachine
+      ensure_state_machine_emits 'Ably::Models::ChannelStateChange'
 
       # Max number of messages to bundle in a single ProtocolMessage
       MAX_PROTOCOL_MESSAGE_BATCH_SIZE = 50
@@ -106,6 +107,7 @@ module Ably
       #
       # @param name [String, Array<Ably::Models::Message|Hash>, nil]   The event name of the message to publish, or an Array of [Ably::Model::Message] objects or [Hash] objects with +:name+ and +:data+ pairs
       # @param data [String, ByteArray, nil]   The message payload unless an Array of [Ably::Model::Message] objects passed in the first argument
+      # @param attributes [Hash, nil]   Optional additional message attributes such as :client_id or :connection_id, applied when name attribute is nil or a string
       #
       # @yield [Ably::Models::Message,Array<Ably::Models::Message>] On success, will call the block with the {Ably::Models::Message} if a single message is publishde, or an Array of {Ably::Models::Message} when multiple messages are published
       # @return [Ably::Util::SafeDeferrable] Deferrable that supports both success (callback) and failure (errback) callbacks
@@ -132,11 +134,11 @@ module Ably
       #     puts "#{message.name} event received with #{message.data}"
       #   end
       #
-      #   channel.publish('click', 'body').errback do |message, error|
+      #   channel.publish('click', 'body').errback do |error, message|
       #     puts "#{message.name} was not received, error #{error.message}"
       #   end
       #
-      def publish(name, data = nil, &success_block)
+      def publish(name, data = nil, attributes = {}, &success_block)
         raise Ably::Exceptions::ChannelInactive.new('Cannot publish messages on a detached channel') if detached? || detaching?
         raise Ably::Exceptions::ChannelInactive.new('Cannot publish messages on a failed channel') if failed?
 
@@ -149,11 +151,11 @@ module Ably
         else
           ensure_utf_8 :name, name, allow_nil: true
           ensure_supported_payload data
-          [{ name: name, data: data }]
+          [{ name: name, data: data }.merge(attributes)]
         end
 
         queue_messages(messages).tap do |deferrable|
-          deferrable.callback &success_block if block_given?
+          deferrable.callback(&success_block) if block_given?
         end
       end
 
@@ -190,7 +192,9 @@ module Ably
       # @return [Ably::Util::SafeDeferrable] Deferrable that supports both success (callback) and failure (errback) callback
       #
       def attach(&success_block)
-        raise Ably::Exceptions::InvalidStateChange.new("Cannot ATTACH channel when the connection is in a closed, suspended or failed state. Connection state: #{connection.state}") if connection.closing? || connection.closed? || connection.suspended? || connection.failed?
+        if connection.closing? || connection.closed? || connection.suspended? || connection.failed?
+          raise Ably::Exceptions::InvalidStateChange.new("Cannot ATTACH channel when the connection is in a closed, suspended or failed state. Connection state: #{connection.state}")
+        end
 
         transition_state_machine :attaching if can_transition_to?(:attaching)
         deferrable_for_state_change_to(STATE.Attached, &success_block)
@@ -285,6 +289,10 @@ module Ably
         client.logger
       end
 
+      # As we are using a state machine, do not allow change_state to be used
+      # #transition_state_machine must be used instead
+      private :change_state
+
       private
       attr_reader :queue
 

data/lib/submodules/ably-ruby/lib/ably/realtime/channel/channel_manager.rb

@@ -27,7 +27,7 @@ module Ably::Realtime
       # Commence attachment
       def detach(error = nil)
         if connection.closed? || connection.connecting? || connection.suspended?
-          channel.transition_state_machine :detached, error
+          channel.transition_state_machine :detached, reason: error
         elsif can_transition_to?(:detached)
           send_detach_protocol_message
         end
@@ -51,7 +51,7 @@ module Ably::Realtime
 
       # Detach a channel as a result of an error
       def suspend(error)
-        channel.transition_state_machine! :detaching, error
+        channel.transition_state_machine! :detaching, reason: error
       end
 
       # When a channel is no longer attached or has failed,
@@ -77,10 +77,10 @@ module Ably::Realtime
       def nack_messages(protocol_message, error)
         (protocol_message.messages + protocol_message.presence).each do |message|
           logger.debug "Calling NACK failure callbacks for #{message.class.name} - #{message.to_json}, protocol message: #{protocol_message}"
-          message.fail message, error
+          message.fail error
         end
         logger.debug "Calling NACK failure callbacks for #{protocol_message.class.name} - #{protocol_message.to_json}"
-        protocol_message.fail protocol_message, error
+        protocol_message.fail error
       end
 
       def drop_pending_queue_from_ack(ack_protocol_message)
@@ -118,6 +118,22 @@ module Ably::Realtime
         )
       end
 
+      # Any message sent before an ACK/NACK was received on the previous transport
+      # needs to be resent to the Ably service so that a subsequent ACK/NACK is received.
+      # It is up to Ably to ensure that duplicate messages are not retransmitted on the channel
+      # base on the serial numbers
+      #
+      # @api private
+      def resend_pending_message_ack_queue
+        connection.__pending_message_ack_queue__.delete_if do |protocol_message|
+          if protocol_message.channel == channel.name
+            connection.__outgoing_message_queue__ << protocol_message
+            connection.__outgoing_protocol_msgbus__.publish :protocol_message
+            true
+          end
+        end
+      end
+
       def setup_connection_event_handlers
         connection.unsafe_on(:closed) do
           channel.transition_state_machine :detaching if can_transition_to?(:detaching)
@@ -125,15 +141,19 @@ module Ably::Realtime
 
         connection.unsafe_on(:suspended) do |error|
           if can_transition_to?(:detaching)
-            channel.transition_state_machine :detaching, Ably::Exceptions::ConnectionSuspended.new('Connection suspended', nil, 80002, error)
+            channel.transition_state_machine :detaching, reason: Ably::Exceptions::ConnectionSuspended.new('Connection suspended', nil, 80002, error)
           end
         end
 
         connection.unsafe_on(:failed) do |error|
-          if can_transition_to?(:failed)
-            channel.transition_state_machine :failed, Ably::Exceptions::ConnectionFailed.new('Connection failed', nil, 80002, error)
+          if can_transition_to?(:failed) && !channel.detached?
+            channel.transition_state_machine :failed, reason: Ably::Exceptions::ConnectionFailed.new('Connection failed', nil, 80002, error)
           end
         end
+
+        connection.unsafe_on(:connected) do |error|
+          resend_pending_message_ack_queue
+        end
       end
 
       def logger

data/lib/submodules/ably-ruby/lib/ably/realtime/channel/channel_state_machine.rb

@@ -22,8 +22,9 @@ module Ably::Realtime
 
       transition :from => :initialized,  :to => [:attaching]
       transition :from => :attaching,    :to => [:attached, :detaching, :failed]
-      transition :from => :attached,     :to => [:detaching, :failed]
+      transition :from => :attached,     :to => [:detaching, :detached, :failed]
       transition :from => :detaching,    :to => [:detached, :attaching, :failed]
+      transition :from => :detached,     :to => [:attaching, :attached, :failed]
       transition :from => :failed,       :to => [:attaching]
 
       after_transition do |channel, transition|
@@ -35,39 +36,48 @@ module Ably::Realtime
       end
 
       before_transition(to: [:attached]) do |channel, current_transition|
-        channel.manager.attached current_transition.metadata
+        channel.manager.attached current_transition.metadata.protocol_message
       end
 
       after_transition(to: [:detaching]) do |channel, current_transition|
-        channel.manager.detach current_transition.metadata
+        err = error_from_state_change(current_transition)
+        channel.manager.detach err
       end
 
       after_transition(to: [:detached]) do |channel, current_transition|
-        channel.manager.fail_messages_awaiting_ack nil_unless_error(current_transition.metadata)
-        channel.manager.emit_error current_transition.metadata if is_error_type?(current_transition.metadata)
+        err = error_from_state_change(current_transition)
+        channel.manager.fail_messages_awaiting_ack err
+        channel.manager.emit_error err if err
       end
 
       after_transition(to: [:failed]) do |channel, current_transition|
-        channel.manager.fail_messages_awaiting_ack nil_unless_error(current_transition.metadata)
-        channel.manager.emit_error current_transition.metadata if is_error_type?(current_transition.metadata)
+        err = error_from_state_change(current_transition)
+        channel.manager.fail_messages_awaiting_ack err
+        channel.manager.emit_error err if err
       end
 
       # Transitions responsible for updating channel#error_reason
       before_transition(to: [:failed]) do |channel, current_transition|
-        channel.set_failed_channel_error_reason current_transition.metadata if is_error_type?(current_transition.metadata)
+        err = error_from_state_change(current_transition)
+        channel.set_failed_channel_error_reason err if err
       end
 
       before_transition(to: [:attached, :detached]) do |channel, current_transition|
-        if is_error_type?(current_transition.metadata)
-          channel.set_failed_channel_error_reason current_transition.metadata
+        err = error_from_state_change(current_transition)
+        if err
+          channel.set_failed_channel_error_reason err
         else
           # Attached & Detached are "healthy" final states so reset the error reason
           channel.clear_error_reason
         end
       end
 
-      def self.nil_unless_error(error_object)
-        error_object if is_error_type?(error_object)
+      def self.error_from_state_change(current_transition)
+        # ChannelStateChange object is always passed in current_transition metadata object
+        connection_state_change = current_transition.metadata
+        # Reason attribute contains errors
+        err = connection_state_change && connection_state_change.reason
+        err if is_error_type?(err)
       end
 
       private

data/lib/submodules/ably-ruby/lib/ably/realtime/client/incoming_message_dispatcher.rb

@@ -68,10 +68,16 @@ module Ably::Realtime
 
           when ACTION.Connect
           when ACTION.Connected
-            connection.transition_state_machine :connected, protocol_message unless connection.connected?
+            if connection.disconnected? || connection.closing? || connection.closed? || connection.failed?
+              logger.debug "Incoming CONNECTED ProtocolMessage discarded as connection has moved on and is in state: #{connection.state}"
+            elsif connection.connected?
+              logger.error "CONNECTED ProtocolMessage should not have been received when the connection is in the CONNECTED state"
+            else
+              connection.transition_state_machine :connected, reason: protocol_message.error, protocol_message: protocol_message
+            end
 
           when ACTION.Disconnect, ACTION.Disconnected
-            connection.transition_state_machine :disconnected, protocol_message.error unless connection.disconnected?
+            connection.transition_state_machine :disconnected, reason: protocol_message.error unless connection.disconnected?
 
           when ACTION.Close
           when ACTION.Closed
@@ -87,7 +93,7 @@ module Ably::Realtime
           when ACTION.Attach
           when ACTION.Attached
             get_channel(protocol_message.channel).tap do |channel|
-              channel.transition_state_machine :attached, protocol_message unless channel.attached?
+              channel.transition_state_machine :attached, reason: protocol_message.error, protocol_message: protocol_message unless channel.attached?
             end
 
           when ACTION.Detach
@@ -125,7 +131,7 @@ module Ably::Realtime
       def dispatch_channel_error(protocol_message)
         logger.warn "Channel Error message received: #{protocol_message.error}"
         if !protocol_message.has_message_serial?
-          get_channel(protocol_message.channel).transition_state_machine :failed, protocol_message.error
+          get_channel(protocol_message.channel).transition_state_machine :failed, reason: protocol_message.error
         else
           logger.fatal "Cannot process ProtocolMessage as not yet implemented: #{protocol_message}"
         end
@@ -163,17 +169,17 @@ module Ably::Realtime
       def nack_messages(messages, protocol_message)
         messages.each do |message|
           logger.debug "Calling NACK failure callbacks for #{message.class.name} - #{message.to_json}, protocol message: #{protocol_message}"
-          message.fail message, protocol_message.error
+          message.fail protocol_message.error
         end
       end
 
       def drop_pending_queue_from_ack(ack_protocol_message)
         message_serial_up_to = ack_protocol_message.message_serial + ack_protocol_message.count - 1
-        connection.__pending_message_ack_queue__.drop_while do |protocol_message|
-          if protocol_message.message_serial <= message_serial_up_to
-            yield protocol_message
-            true
-          end
+
+        while !connection.__pending_message_ack_queue__.empty?
+          next_message = connection.__pending_message_ack_queue__.first
+          return if next_message.message_serial > message_serial_up_to
+          yield connection.__pending_message_ack_queue__.shift
         end
       end
 

data/lib/submodules/ably-ruby/lib/ably/realtime/client/outgoing_message_dispatcher.rb

@@ -44,6 +44,12 @@ module Ably::Realtime
 
         non_blocking_loop_while(condition) do
           protocol_message = outgoing_queue.shift
+
+          if (!connection.transport)
+            protocol_message.fail Ably::Exceptions::TransportClosed.new('Transport disconnected unexpectedly', nil, 80003)
+            next
+          end
+
           current_transport_outgoing_message_bus.publish :protocol_message, protocol_message
 
           if protocol_message.ack_required?

data/lib/submodules/ably-ruby/lib/ably/realtime/connection.rb

@@ -55,6 +55,7 @@ module Ably
       )
       include Ably::Modules::StateEmitter
       include Ably::Modules::UsesStateMachine
+      ensure_state_machine_emits 'Ably::Models::ConnectionStateChange'
 
       # Expected format for a connection recover key
       RECOVER_REGEX = /^(?<recover>[\w-]+):(?<connection_serial>\-?\w+)$/
@@ -118,7 +119,7 @@ module Ably
       # the failed state. Once closed, the library will not attempt to re-establish the
       # connection without a call to {Connection#connect}.
       #
-      # @yield [Ably::Realtime::Connection] block is called as soon as this connection is in the Closed state
+      # @yield block is called as soon as this connection is in the Closed state
       #
       # @return [EventMachine::Deferrable]
       #
@@ -133,7 +134,7 @@ module Ably
       # Causes the library to attempt connection.  If it was previously explicitly
       # closed by the user, or was closed as a result of an unrecoverable error, a new connection will be opened.
       #
-      # @yield [Ably::Realtime::Connection] block is called as soon as this connection is in the Connected state
+      # @yield block is called as soon as this connection is in the Connected state
       #
       # @return [EventMachine::Deferrable]
       #
@@ -189,7 +190,7 @@ module Ably
           EventMachine::HttpRequest.new(url).get.tap do |http|
             http.errback do
               yield false if block_given?
-              deferrable.fail "Unable to connect to #{url}"
+              deferrable.fail Ably::Exceptions::ConnectionFailed.new("Unable to connect to #{url}", nil, 80000)
             end
             http.callback do
               EventMachine.next_tick do
@@ -198,7 +199,7 @@ module Ably
                 if result
                   deferrable.succeed
                 else
-                  deferrable.fail "Unexpected response from #{url} (#{http.response_header.status})"
+                  deferrable.fail Ably::Exceptions::ConnectionFailed.new("Unexpected response from #{url} (#{http.response_header.status})", 400, 40000)
                 end
               end
             end

data/lib/submodules/ably-ruby/lib/ably/realtime/connection/connection_manager.rb

@@ -39,7 +39,7 @@ module Ably::Realtime
 
         EventMachine.next_tick do
           # Connect once Connection object is initialised
-          connection.connect if client.auto_connect
+          connection.connect if client.auto_connect && connection.can_transition_to?(:connecting)
         end
       end
 
@@ -53,7 +53,7 @@ module Ably::Realtime
         end
 
         unless client.auth.authentication_security_requirements_met?
-          connection.transition_state_machine :failed, Ably::Exceptions::InsecureRequest.new('Cannot use Basic Auth over non-TLS connections', 401, 40103)
+          connection.transition_state_machine :failed, reason: Ably::Exceptions::InsecureRequest.new('Cannot use Basic Auth over non-TLS connections', 401, 40103)
           return
         end
 
@@ -80,7 +80,8 @@ module Ably::Realtime
       # @api private
       def connection_opening_failed(error)
         logger.warn "ConnectionManager: Connection to #{connection.current_host}:#{connection.port} failed; #{error.message}"
-        connection.transition_state_machine next_retry_state, Ably::Exceptions::ConnectionError.new("Connection failed: #{error.message}", nil, 80000)
+        next_state = get_next_retry_state_info
+        connection.transition_state_machine next_state.fetch(:state), retry_in: next_state.fetch(:pause), reason: Ably::Exceptions::ConnectionError.new("Connection failed: #{error.message}", nil, 80000)
       end
 
       # Called whenever a new connection is made
@@ -88,7 +89,7 @@ module Ably::Realtime
       # @api private
       def connected(protocol_message)
         if connection.key
-          if protocol_message.connection_key == connection.key
+          if connection_key_shared(protocol_message.connection_key) == connection_key_shared(connection.key)
             logger.debug "ConnectionManager: Connection resumed successfully - ID #{connection.id} and key #{connection.key}"
             EventMachine.next_tick { connection.resumed }
           else
@@ -155,11 +156,10 @@ module Ably::Realtime
       # When a connection is disconnected whilst connecting, attempt reconnect and/or set state to :suspended or :failed
       #
       # @api private
-      def respond_to_transport_disconnected_when_connecting(current_transition)
+      def respond_to_transport_disconnected_when_connecting(error)
         return unless connection.disconnected? || connection.suspended? # do nothing if state has changed through an explicit request
         return unless retry_connection? # do not always reattempt connection or change state as client may be re-authorising
 
-        error = current_transition.metadata
         if error.kind_of?(Ably::Models::ErrorInfo)
           renew_token_and_reconnect error if error.code == RESOLVABLE_ERROR_CODES.fetch(:token_expired)
           return
@@ -172,23 +172,22 @@ module Ably::Realtime
         return if connection_retry_for(:suspended)
 
         # Fallback if no other criteria met
-        connection.transition_state_machine :failed, current_transition.metadata
+        connection.transition_state_machine :failed, reason: error
       end
 
       # When a connection is disconnected after connecting, attempt reconnect and/or set state to :suspended or :failed
       #
       # @api private
-      def respond_to_transport_disconnected_whilst_connected(current_transition)
-        logger.warn "ConnectionManager: Connection to #{connection.transport.url} was disconnected unexpectedly"
+      def respond_to_transport_disconnected_whilst_connected(error)
+        logger.warn "ConnectionManager: Connection #{"to #{connection.transport.url}" if connection.transport} was disconnected unexpectedly"
 
-        error = current_transition.metadata
         if error.kind_of?(Ably::Models::ErrorInfo) && error.code != RESOLVABLE_ERROR_CODES.fetch(:token_expired)
           connection.emit :error, error
           logger.error "ConnectionManager: Error in Disconnected ProtocolMessage received from the server - #{error}"
         end
 
         destroy_transport
-        respond_to_transport_disconnected_when_connecting current_transition
+        respond_to_transport_disconnected_when_connecting error
       end
 
       # {Ably::Models::ProtocolMessage ProtocolMessage Error} received from server.
@@ -198,13 +197,13 @@ module Ably::Realtime
       def error_received_from_server(error)
         case error.code
         when RESOLVABLE_ERROR_CODES.fetch(:token_expired)
-          connection.transition_state_machine :disconnected
+          connection.transition_state_machine :disconnected, retry_in: 0
           connection.unsafe_once_or_if(:disconnected) do
             renew_token_and_reconnect error
           end
         else
           logger.error "ConnectionManager: Error #{error.class.name} code #{error.code} received from server '#{error.message}', transitioning to failed state"
-          connection.transition_state_machine :failed, error
+          connection.transition_state_machine :failed, reason: error
         end
       end
 
@@ -234,6 +233,12 @@ module Ably::Realtime
         client.channels
       end
 
+      # Connection key left part is consistent between connection resumes
+      # i.e. wVIsgTHAB1UvXh7z-1991d8586 becomes wVIsgTHAB1UvXh7z-1990d8586 after a resume
+      def connection_key_shared(connection_key)
+        (connection_key || '')[/^\w{5,}-/, 0]
+      end
+
       # Create a timer that will execute in timeout_in seconds.
       # If the connection state changes however, cancel the timer
       def create_timeout_timer_whilst_in_state(timer_id, timeout_in)
@@ -249,12 +254,26 @@ module Ably::Realtime
         timers.fetch(key, []).each(&:cancel)
       end
 
-      def next_retry_state
-        if connection_retry_from_suspended_state? || time_passed_since_disconnected > CONNECT_RETRY_CONFIG.fetch(:disconnected).fetch(:max_time_in_state)
+      def get_next_retry_state_info
+        retry_state = if connection_retry_from_suspended_state? || !can_reattempt_connect_for_state?(:disconnected)
           :suspended
         else
           :disconnected
         end
+        {
+          state: retry_state,
+          pause: next_retry_pause(retry_state)
+        }
+      end
+
+      def next_retry_pause(retry_state)
+        return nil unless CONNECT_RETRY_CONFIG.fetch(retry_state)
+
+        if retries_for_state(retry_state, ignore_states: [:connecting]).empty?
+          0
+        else
+          CONNECT_RETRY_CONFIG.fetch(retry_state).fetch(:retry_every)
+        end
       end
 
       def connection_retry_from_suspended_state?
@@ -348,13 +367,12 @@ module Ably::Realtime
             connection.transition_state_machine :closed
           elsif !connection.closed? && !connection.disconnected?
             exception = if reason
-              Ably::Exceptions::ConnectionClosed.new(reason)
-            end
-            if connection_retry_from_suspended_state? || !can_reattempt_connect_for_state?(:disconnected)
-              connection.transition_state_machine :suspended, exception
+              Ably::Exceptions::TransportClosed.new(reason, nil, 80003)
             else
-              connection.transition_state_machine :disconnected, exception
+              Ably::Exceptions::TransportClosed.new('Transport disconnected unexpectedly', nil, 80003)
             end
+            next_state = get_next_retry_state_info
+            connection.transition_state_machine next_state.fetch(:state), retry_in: next_state.fetch(:pause), reason: exception
           end
         end
       end
@@ -362,7 +380,7 @@ module Ably::Realtime
       def renew_token_and_reconnect(error)
         if client.auth.token_renewable?
           if @renewing_token
-            connection.transition_state_machine :failed, error
+            connection.transition_state_machine :failed, reason: error
             return
           end
 
@@ -383,18 +401,18 @@ module Ably::Realtime
               if token_details && !token_details.expired?
                 connection.connect
               else
-                connection.transition_state_machine :failed, error unless connection.failed?
+                connection.transition_state_machine :failed, reason: error unless connection.failed?
               end
             end
 
             authorise_deferrable.errback do |auth_error|
               logger.error "ConnectionManager: Error authorising following token expiry: #{auth_error}"
-              connection.transition_state_machine :failed, auth_error
+              connection.transition_state_machine :failed, reason: auth_error
             end
           end
         else
           logger.error "ConnectionManager: Token has expired and is not renewable - #{error}"
-          connection.transition_state_machine :failed, error
+          connection.transition_state_machine :failed, reason: error
         end
       end