ably-rest 0.9.3 → 1.0.0

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

@@ -20,11 +20,12 @@ module Ably::Realtime
         state state_enum.to_sym, initial: index == 0
       end
 
-      transition :from => :initialized,  :to => [:attaching]
-      transition :from => :attaching,    :to => [:attached, :detaching, :failed]
-      transition :from => :attached,     :to => [:detaching, :detached, :failed]
-      transition :from => :detaching,    :to => [:detached, :attaching, :failed]
+      transition :from => :initialized,  :to => [:attaching, :failed]
+      transition :from => :attaching,    :to => [:attached, :detaching, :failed, :suspended]
+      transition :from => :attached,     :to => [:attaching, :detaching, :detached, :failed, :suspended]
+      transition :from => :detaching,    :to => [:detached, :attaching, :attached, :failed, :suspended]
       transition :from => :detached,     :to => [:attaching, :attached, :failed]
+      transition :from => :suspended,    :to => [:attaching, :detached, :failed]
       transition :from => :failed,       :to => [:attaching]
 
       after_transition do |channel, transition|
@@ -41,31 +42,29 @@ module Ably::Realtime
 
       after_transition(to: [:detaching]) do |channel, current_transition|
         err = error_from_state_change(current_transition)
-        channel.manager.detach err
+        channel.manager.detach err, current_transition.metadata.previous
       end
 
-      after_transition(to: [:detached]) do |channel, current_transition|
+      after_transition(to: [:detached, :failed, :suspended]) do |channel, current_transition|
         err = error_from_state_change(current_transition)
-        channel.manager.fail_messages_awaiting_ack err
-        channel.manager.emit_error err if err
+        channel.manager.fail_queued_messages err
+        channel.manager.log_channel_error err if err
       end
 
-      after_transition(to: [:failed]) do |channel, current_transition|
-        err = error_from_state_change(current_transition)
-        channel.manager.fail_messages_awaiting_ack err
-        channel.manager.emit_error err if err
+      after_transition(to: [:suspended]) do |channel, current_transition|
+        channel.manager.start_attach_from_suspended_timer
       end
 
       # Transitions responsible for updating channel#error_reason
-      before_transition(to: [:failed]) do |channel, current_transition|
+      before_transition(to: [:failed, :suspended]) do |channel, current_transition|
         err = error_from_state_change(current_transition)
-        channel.set_failed_channel_error_reason err if err
+        channel.set_channel_error_reason err if err
       end
 
       before_transition(to: [:attached, :detached]) do |channel, current_transition|
         err = error_from_state_change(current_transition)
         if err
-          channel.set_failed_channel_error_reason err
+          channel.set_channel_error_reason err
         else
           # Attached & Detached are "healthy" final states so reset the error reason
           channel.clear_error_reason

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

@@ -78,8 +78,10 @@ module Ably
       # @option options [String]  :recover        When a recover option is specified a connection inherits the state of a previous connection that may have existed under a different instance of the Realtime library, please refer to the API documentation for further information on connection state recovery
       # @option options [Boolean] :auto_connect   By default as soon as the client library is instantiated it will connect to Ably. You can optionally set this to false and explicitly connect.
       #
-      # @option options [Integer] :disconnected_retry_timeout  (15 seconds). When the connection enters the DISCONNECTED state, after this delay in milliseconds, if the state is still DISCONNECTED, the client library will attempt to reconnect automatically
-      # @option options [Integer] :suspended_retry_timeout     (30 seconds). When the connection enters the SUSPENDED state, after this delay in milliseconds, if the state is still SUSPENDED, the client library will attempt to reconnect automatically
+      # @option options [Integer] :channel_retry_timeout       (15 seconds). When a channel becomes SUSPENDED, after this delay in seconds, the channel will automatically attempt to reattach if the connection is CONNECTED
+      # @option options [Integer] :disconnected_retry_timeout  (15 seconds). When the connection enters the DISCONNECTED state, after this delay in seconds, if the state is still DISCONNECTED, the client library will attempt to reconnect automatically
+      # @option options [Integer] :suspended_retry_timeout     (30 seconds). When the connection enters the SUSPENDED state, after this delay in seconds, if the state is still SUSPENDED, the client library will attempt to reconnect automatically
+      # @option options [Boolean] :disable_websocket_heartbeats   WebSocket heartbeats are more efficient than protocol level heartbeats, however they can be disabled for development purposes
       #
       # @return [Ably::Realtime::Client]
       #
@@ -91,7 +93,18 @@ module Ably
       #    client = Ably::Realtime::Client.new(key: 'key.id:secret', client_id: 'john')
       #
       def initialize(options)
-        @rest_client           = Ably::Rest::Client.new(options)
+        raise ArgumentError, 'Options Hash is expected' if options.nil?
+
+        options = options.clone
+        if options.kind_of?(String)
+          options = if options.match(Ably::Auth::API_KEY_REGEX)
+            { key: options }
+          else
+            { token: options }
+          end
+        end
+
+        @rest_client           = Ably::Rest::Client.new(options.merge(realtime_client: self))
         @auth                  = Ably::Realtime::Auth.new(self)
         @channels              = Ably::Realtime::Channels.new(self)
         @connection            = Ably::Realtime::Connection.new(self, options)

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

@@ -27,7 +27,7 @@ module Ably::Realtime
 
       def get_channel(channel_name)
         channels.fetch(channel_name) do
-          logger.warn "Received channel message for non-existent channel"
+          logger.warn { "Received channel message for non-existent channel" }
           Ably::Realtime::Models::NilChannel.new
         end
       end
@@ -43,19 +43,13 @@ module Ably::Realtime
           raise ArgumentError, "Expected a ProtocolMessage. Received #{protocol_message}"
         end
 
-        unless [:nack, :error].include?(protocol_message.action)
-          logger.debug "#{protocol_message.action} received: #{protocol_message}"
+        unless protocol_message.action.match_any?(:nack, :error)
+          logger.debug { "#{protocol_message.action} received: #{protocol_message}" }
         end
 
-        if [:sync, :presence, :message].any? { |prevent_duplicate| protocol_message.action == prevent_duplicate }
+        if protocol_message.action.match_any?(:sync, :presence, :message)
           if connection.serial && protocol_message.has_connection_serial? && protocol_message.connection_serial <= connection.serial
-            error_target = if protocol_message.channel
-              get_channel(protocol_message.channel)
-            else
-              connection
-            end
             error_message = "Protocol error, duplicate message received for serial #{protocol_message.connection_serial}"
-            error_target.emit :error, Ably::Exceptions::ProtocolError.new(error_message, 400, 80013)
             logger.error error_message
             return
           end
@@ -69,15 +63,18 @@ module Ably::Realtime
             ack_pending_queue_for_message_serial(protocol_message) if protocol_message.has_message_serial?
 
           when ACTION.Nack
-            logger.warn "NACK received: #{protocol_message}"
+            logger.warn { "NACK received: #{protocol_message}" }
             nack_pending_queue_for_message_serial(protocol_message) if protocol_message.has_message_serial?
 
           when ACTION.Connect
           when ACTION.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}"
+            if connection.closing?
+              logger.debug { "Out-of-order incoming CONNECTED ProtocolMessage discarded as connection has moved on and is in state: #{connection.state}" }
+            elsif connection.disconnected? || connection.closing? || connection.closed? || connection.failed?
+              logger.warn { "Out-of-order 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"
+              logger.debug { "Updated CONNECTED ProtocolMessage received (whilst connected)" }
+              process_connected_update_message protocol_message
             else
               process_connected_message protocol_message
             end
@@ -90,7 +87,7 @@ module Ably::Realtime
             connection.transition_state_machine :closed unless connection.closed?
 
           when ACTION.Error
-            if protocol_message.channel && !protocol_message.has_message_serial?
+            if protocol_message.channel
               dispatch_channel_error protocol_message
             else
               process_connection_error protocol_message
@@ -99,21 +96,22 @@ module Ably::Realtime
           when ACTION.Attach
           when ACTION.Attached
             get_channel(protocol_message.channel).tap do |channel|
-              channel.transition_state_machine :attached, reason: protocol_message.error, protocol_message: protocol_message unless channel.attached?
+              if channel.attached?
+                channel.manager.duplicate_attached_received protocol_message
+              else
+                channel.transition_state_machine :attached, reason: protocol_message.error, resumed: protocol_message.has_channel_resumed_flag?, protocol_message: protocol_message
+              end
             end
 
           when ACTION.Detach
           when ACTION.Detached
             get_channel(protocol_message.channel).tap do |channel|
-              channel.transition_state_machine :detached unless channel.detached?
+              channel.manager.detached_received protocol_message.error
             end
 
           when ACTION.Sync
             presence = get_channel(protocol_message.channel).presence
-            protocol_message.presence.each do |presence_message|
-              presence.__incoming_msgbus__.publish :sync, presence_message
-            end
-            presence.members.update_sync_serial protocol_message.channel_serial
+            presence.manager.sync_process_messages protocol_message.channel_serial, protocol_message.presence
 
           when ACTION.Presence
             presence = get_channel(protocol_message.channel).presence
@@ -127,19 +125,23 @@ module Ably::Realtime
               channel.__incoming_msgbus__.publish :message, message
             end
 
+          when ACTION.Auth
+            client.auth.authorize
+
           else
             error = Ably::Exceptions::ProtocolError.new("Protocol Message Action #{protocol_message.action} is unsupported by this MessageDispatcher", 400, 80013)
-            client.connection.emit :error, error
             logger.fatal error.message
         end
+
+        connection.set_connection_confirmed_alive
       end
 
       def dispatch_channel_error(protocol_message)
-        logger.warn "Channel Error message received: #{protocol_message.error}"
+        logger.warn { "Channel Error message received: #{protocol_message.error}" }
         if !protocol_message.has_message_serial?
           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}"
+          logger.fatal { "Cannot process ProtocolMessage ERROR with message serial as not yet implemented: #{protocol_message}" }
         end
       end
 
@@ -149,11 +151,18 @@ module Ably::Realtime
 
       def process_connected_message(protocol_message)
         if client.auth.token_client_id_allowed?(protocol_message.connection_details.client_id)
-          client.auth.configure_client_id protocol_message.connection_details.client_id
-          client.connection.set_connection_details protocol_message.connection_details
           connection.transition_state_machine :connected, reason: protocol_message.error, protocol_message: protocol_message
         else
-          reason = Ably::Exceptions::IncompatibleClientId.new("Client ID '#{protocol_message.connection_details.client_id}' specified by the server is incompatible with the library's configured client ID '#{client.client_id}'", 400, 40012)
+          reason = Ably::Exceptions::IncompatibleClientId.new("Client ID '#{protocol_message.connection_details.client_id}' specified by the server is incompatible with the library's configured client ID '#{client.client_id}'")
+          connection.transition_state_machine :failed, reason: reason, protocol_message: protocol_message
+        end
+      end
+
+      def process_connected_update_message(protocol_message)
+        if client.auth.token_client_id_allowed?(protocol_message.connection_details.client_id)
+          connection.manager.connected_update protocol_message
+        else
+          reason = Ably::Exceptions::IncompatibleClientId.new("Client ID '#{protocol_message.connection_details.client_id}' in CONNECTED update specified by the server is incompatible with the library's configured client ID '#{client.client_id}'")
           connection.transition_state_machine :failed, reason: reason, protocol_message: protocol_message
         end
       end
@@ -178,14 +187,14 @@ module Ably::Realtime
 
       def ack_messages(messages)
         messages.each do |message|
-          logger.debug "Calling ACK success callbacks for #{message.class.name} - #{message.to_json}"
+          logger.debug { "Calling ACK success callbacks for #{message.class.name} - #{message.to_json}" }
           message.succeed message
         end
       end
 
       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}"
+          logger.debug { "Calling NACK failure callbacks for #{message.class.name} - #{message.to_json}, protocol message: #{protocol_message}" }
           message.fail protocol_message.error
         end
       end

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

@@ -74,7 +74,12 @@ module Ably::Realtime
 
       def setup_event_handlers
         connection.unsafe_on(:connected) do
-          deliver_queued_protocol_messages
+          # Give connection manager enough time to prevent message delivery if necessary
+          # For example, if reconnecting and connection and channel state is lost,
+          # then the queued messages must be NACK'd
+          EventMachine.next_tick do
+            deliver_queued_protocol_messages
+          end
         end
       end
     end

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

@@ -1,3 +1,5 @@
+require 'securerandom'
+
 module Ably
   module Realtime
     # The Connection class represents the connection associated with an Ably Realtime instance.
@@ -25,8 +27,6 @@ module Ably
     #   Connection::STATE.Closed
     #   Connection::STATE.Failed
     #
-    # Connection emit errors - use `on(:error)` to subscribe to errors
-    #
     # @example
     #    client = Ably::Realtime::Client.new('key.id:secret')
     #    client.connection.on(:connected) do
@@ -42,7 +42,8 @@ module Ably
       include Ably::Modules::SafeYield
       extend Ably::Modules::Enum
 
-      # Valid Connection states
+      # ConnectionState
+      # The permited states for this connection
       STATE = ruby_enum('STATE',
         :initialized,
         :connecting,
@@ -53,6 +54,13 @@ module Ably
         :closed,
         :failed
       )
+
+      # ConnectionEvent
+      # The permitted connection events that are emitted for this connection
+      EVENT = ruby_enum('EVENT',
+        STATE.to_sym_arr + [:update]
+      )
+
       include Ably::Modules::StateEmitter
       include Ably::Modules::UsesStateMachine
       ensure_state_machine_emits 'Ably::Models::ConnectionStateChange'
@@ -62,11 +70,13 @@ module Ably
 
       # Defaults for automatic connection recovery and timeouts
       DEFAULTS = {
+        channel_retry_timeout:      15, # when a channel becomes SUSPENDED, after this delay in seconds, the channel will automatically attempt to reattach if the connection is CONNECTED
         disconnected_retry_timeout: 15, # when the connection enters the DISCONNECTED state, after this delay in milliseconds, if the state is still DISCONNECTED, the client library will attempt to reconnect automatically
         suspended_retry_timeout:    30, # when the connection enters the SUSPENDED state, after this delay in milliseconds, if the state is still SUSPENDED, the client library will attempt to reconnect automatically
         connection_state_ttl:       120, # the duration that Ably will persist the connection state when a Realtime client is abruptly disconnected
-        max_connection_state_ttl:   nil, # allow a max TTL to be passed in for CI test purposes thus overiding any connection_state_ttl sent from Ably
+        max_connection_state_ttl:   nil, # allow a max TTL to be passed in, usually for CI test purposes thus overiding any connection_state_ttl sent from Ably
         realtime_request_timeout:   10,  # default timeout when establishing a connection, or sending a HEARTBEAT, CONNECT, ATTACH, DETACH or CLOSE ProtocolMessage
+        websocket_heartbeats_disabled: false,
       }.freeze
 
       # A unique public identifier for this connection, used to identify this member in presence events and messages
@@ -122,9 +132,9 @@ module Ably
       # @api public
       def initialize(client, options)
         @client                        = client
-        @client_serial                 = -1
         @__outgoing_message_queue__    = []
         @__pending_message_ack_queue__ = []
+        reset_client_serial
 
         @defaults = DEFAULTS.dup
         options.each do |key, val|
@@ -150,7 +160,9 @@ module Ably
       #
       def close(&success_block)
         unless closing? || closed?
-          raise exception_for_state_change_to(:closing) unless can_transition_to?(:closing)
+          unless can_transition_to?(:closing)
+            return Ably::Util::SafeDeferrable.new_and_fail_immediately(logger, exception_for_state_change_to(:closing))
+          end
           transition_state_machine :closing
         end
         deferrable_for_state_change_to(STATE.Closed, &success_block)
@@ -170,8 +182,11 @@ module Ably
       #
       def connect(&success_block)
         unless connecting? || connected?
-          raise exception_for_state_change_to(:connecting) unless can_transition_to?(:connecting)
-          transition_state_machine :connecting
+          unless can_transition_to?(:connecting)
+            return Ably::Util::SafeDeferrable.new_and_fail_immediately(logger, exception_for_state_change_to(:connecting))
+          end
+          # If connect called in a suspended block, we want to ensure the other callbacks have finished their work first
+          EventMachine.next_tick { transition_state_machine :connecting if can_transition_to?(:connecting) }
         end
 
         Ably::Util::SafeDeferrable.new(logger).tap do |deferrable|
@@ -181,12 +196,12 @@ module Ably
           succeed_callback = deferrable.method(:succeed)
           fail_callback    = deferrable.method(:fail)
 
-          once(:connected) do
+          unsafe_once(:connected) do
             deferrable.succeed
             off(&fail_callback)
           end
 
-          once(:failed, :closed, :closing) do
+          unsafe_once(:failed, :closed, :closing) do
             deferrable.fail
             off(&succeed_callback)
           end
@@ -206,38 +221,53 @@ module Ably
       #      puts "Ping took #{elapsed_s}s"
       #    end
       #
-      # @return [void]
+      # @return [Ably::Util::SafeDeferrable]
       #
       def ping(&block)
-        raise RuntimeError, 'Cannot send a ping when connection is not open' if initialized?
-        raise RuntimeError, 'Cannot send a ping when connection is in a closed or failed state' if closed? || failed?
+        if initialized? || suspended? || closing? || closed? || failed?
+          error = Ably::Models::ErrorInfo.new(message: "Cannot send a ping when the connection is #{state}", code: 80003)
+          return Ably::Util::SafeDeferrable.new_and_fail_immediately(logger, error)
+        end
 
-        started = nil
-        finished = false
+        Ably::Util::SafeDeferrable.new(logger).tap do |deferrable|
+          started = nil
+          finished = false
+          ping_id = SecureRandom.hex(16)
+          heartbeat_action = Ably::Models::ProtocolMessage::ACTION.Heartbeat
+
+          wait_for_ping = Proc.new do |protocol_message|
+            next if finished
+            if protocol_message.action == heartbeat_action && protocol_message.id == ping_id
+              finished = true
+              __incoming_protocol_msgbus__.unsubscribe(:protocol_message, &wait_for_ping)
+              time_passed = Time.now.to_f - started.to_f
+              deferrable.succeed time_passed
+              safe_yield block, time_passed if block_given?
+            end
+          end
 
-        wait_for_ping = Proc.new do |protocol_message|
-          next if finished
-          if protocol_message.action == Ably::Models::ProtocolMessage::ACTION.Heartbeat
-            finished = true
-            __incoming_protocol_msgbus__.unsubscribe(:protocol_message, &wait_for_ping)
-            time_passed = Time.now.to_f - started.to_f
-            safe_yield block, time_passed if block_given?
+          once_or_if(STATE.Connected) do
+            next if finished
+            started = Time.now
+            send_protocol_message action: heartbeat_action.to_i, id: ping_id
+            __incoming_protocol_msgbus__.subscribe :protocol_message, &wait_for_ping
           end
-        end
 
-        once_or_if(STATE.Connected) do
-          next if finished
-          started = Time.now
-          send_protocol_message action: Ably::Models::ProtocolMessage::ACTION.Heartbeat.to_i
-          __incoming_protocol_msgbus__.subscribe :protocol_message, &wait_for_ping
-        end
+          once_or_if([:suspended, :closing, :closed, :failed]) do
+            next if finished
+            finished = true
+            deferrable.fail Ably::Models::ErrorInfo.new(message: "Ping failed as connection has changed state to #{state}", code: 80003)
+          end
 
-        EventMachine.add_timer(defaults.fetch(:realtime_request_timeout)) do
-          next if finished
-          finished = true
-          __incoming_protocol_msgbus__.unsubscribe(:protocol_message, &wait_for_ping)
-          logger.warn "Ping timed out after #{defaults.fetch(:realtime_request_timeout)}s"
-          safe_yield block, nil if block_given?
+          EventMachine.add_timer(defaults.fetch(:realtime_request_timeout)) do
+            next if finished
+            finished = true
+            __incoming_protocol_msgbus__.unsubscribe(:protocol_message, &wait_for_ping)
+            error_msg = "Ping timed out after #{defaults.fetch(:realtime_request_timeout)}s"
+            logger.warn { error_msg }
+            deferrable.fail Ably::Models::ErrorInfo.new(message: error_msg, code: 50003)
+            safe_yield block, nil if block_given?
+          end
         end
       end
 
@@ -364,7 +394,7 @@ module Ably
           Ably::Models::ProtocolMessage.new(protocol_message, logger: logger).tap do |message|
             add_message_to_outgoing_queue message
             notify_message_dispatcher_of_new_message message
-            logger.debug("Connection: Prot msg queued =>: #{message.action} #{message}")
+            logger.debug { "Connection: Prot msg queued =>: #{message.action} #{message}" }
           end
         end
       end
@@ -387,21 +417,24 @@ module Ably
           client.auth.auth_params.tap do |auth_deferrable|
             auth_deferrable.callback do |auth_params|
               url_params = auth_params.merge(
-                format:    client.protocol,
-                echo:      client.echo_messages,
-                v:         Ably::PROTOCOL_VERSION,
-                lib:       client.rest_client.lib_version_id,
+                format:     client.protocol,
+                echo:       client.echo_messages,
+                v:          Ably::PROTOCOL_VERSION,
+                lib:        client.rest_client.lib_version_id,
               )
 
+              # Use native websocket heartbeats if possible
+              url_params['heartbeats'] = 'false' unless defaults.fetch(:websocket_heartbeats_disabled)
+
               url_params['clientId'] = client.auth.client_id if client.auth.has_client_id?
 
               if connection_resumable?
                 url_params.merge! resume: key, connection_serial: serial
-                logger.debug "Resuming connection key #{key} with serial #{serial}"
+                logger.debug { "Resuming connection key #{key} with serial #{serial}" }
               elsif connection_recoverable?
-                url_params.merge! recover: connection_recover_parts[:recover], connection_serial: connection_recover_parts[:connection_serial]
-                logger.debug "Recovering connection with key #{client.recover}"
-                once(:connected, :closed, :failed) do
+                url_params.merge! recover: connection_recover_parts[:recover], connectionSerial: connection_recover_parts[:connection_serial]
+                logger.debug { "Recovering connection with key #{client.recover}" }
+                unsafe_once(:connected, :closed, :failed) do
                   client.disable_automatic_connection_recovery
                 end
               end
@@ -412,7 +445,7 @@ module Ably
 
               determine_host do |host|
                 begin
-                  logger.debug "Connection: Opening socket connection to #{host}:#{port}/#{url.path}?#{url.query}"
+                  logger.debug { "Connection: Opening socket connection to #{host}:#{port}/#{url.path}?#{url.query}" }
                   @transport = create_transport(host, port, url) do |websocket_transport|
                     websocket_deferrable.succeed websocket_transport
                   end
@@ -451,7 +484,7 @@ module Ably
 
       # Executes registered callbacks for a successful connection resume event
       # @api private
-      def resumed
+      def trigger_resumed
         resume_callbacks.each(&:call)
       end
 
@@ -490,6 +523,33 @@ module Ably
         @connection_state_ttl = val
       end
 
+      # @api private
+      def heartbeat_interval
+        # See RTN23a
+        (details && details.max_idle_interval).to_i +
+          defaults.fetch(:realtime_request_timeout)
+      end
+
+      # Resets the client serial (msgSerial) sent to Ably for each new {Ably::Models::ProtocolMessage}
+      # (see #client_serial)
+      # @api private
+      def reset_client_serial
+        @client_serial = -1
+      end
+
+      # When a hearbeat or any other message from Ably is received
+      # we know it's alive, see #RTN23
+      # @api private
+      def set_connection_confirmed_alive
+        @last_liveness_event = Time.now
+        manager.reset_liveness_timer
+      end
+
+      # @api private
+      def time_since_connection_confirmed_alive?
+        Time.now.to_i - @last_liveness_event.to_i
+      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
@@ -500,9 +560,8 @@ module Ably
       # Note that this is different to the connection serial that contains the last known serial number
       # received from the server.
       #
-      # A client serial number therefore does not guarantee a message has been received, only sent.
-      # A connection serial guarantees the server has received the message and is thus used for connection
-      # recovery and resumes.
+      # A message serial number does not guarantee a message has been received, only sent.
+      # A connection serial guarantees the server has received the message and is thus used for connection recovery and resumes.
       # @return [Integer] starting at -1 indicating no messages sent, 0 when the first message is sent
       def client_serial
         @client_serial