eventObject timeout has a timeout set when it's not expecting a response

[gak10100]

Inside the _processOutboundEvent event Objects are created and a timeout is set. The problem is that a timeout is set for event objects that aren't expecting a response.

socketcluster-client/lib/clientsocket.js

Lines 773 to 781 in f551443

	eventNode.data = eventObject;
	let ackTimeout = options.ackTimeout == null ? this.ackTimeout : options.ackTimeout;
	eventObject.timeout = setTimeout(() => {
	this._handleEventAckTimeout(eventObject, eventNode);
	}, ackTimeout);
	this._outboundBuffer.append(eventNode);

Inside the _flushOutboundBuffer function Event Objects are passed off to the transport object

socketcluster-client/lib/clientsocket.js

Lines 709 to 720 in f551443

	AGClientSocket.prototype._flushOutboundBuffer = function () {
	let currentNode = this._outboundBuffer.head;
	let nextNode;
	while (currentNode) {
	nextNode = currentNode.next;
	let eventObject = currentNode.data;
	currentNode.detach();
	this.transport.transmitObject(eventObject);
	currentNode = nextNode;
	}
	};

but because the event object doesn't have a callback it doesn't add it to the callbackMap

https://github.com/SocketCluster/socketcluster-client/blob/f5514434f51369166de9e5dafba2f7da147fb93e/lib/transport.js#L373C10-L387

This can lead to the timeout to hang even after the client has disconnected.

[jondubois]

@gak10100 Thanks for this detailed description. This has now been fixed in 19.2.6

Notes about this issue:

• Timeout of transmitted events (those without callbacks) is required to guarantee in-order processing of events. Any outbound event can potentially timeout and be removed from the outboundBuffer queue if not processed in time. This can happen in failure scenarios if a connection is lost for a long time and cannot be re-established.
• The issue was that the timeout for transmitted events would persist even after the eventObject was removed from the outboundBuffer queue (and after being sent to the underlying transport instance).
• A timeout function would therefore always get triggered once for each transmitted event, but since those did not have any callback associated, it did not produce any errors or visible effect.
• This had minor client-side performance implications for socket.transmit() and socket.transmitPublish() methods. More pronounced if socket has a large ackTimeout value or transmits messages at a high rate.