How to know when the SSE client has reconnected?

[hspaay]

I'm creating a client like this:

	sseClient := &sse.Client{
		HTTPClient: httpClient,
		OnRetry: func(err error, _ time.Duration) {
			slog.Info("SSE Connection retry", "err", err)
		},
	}
	conn := sseClient.NewConnection(req)

The callback is used to update the end-user that the connection was lost and reconnecting is in progress. This all works fine.

However, how to know that the connection has been restored?

[tmaxmax]

Hi there!

I think for this scenario you could try sending a certain event from the backend immediately as the connection is established. The most reliable way to test the connection is to see whether events are received.

In discussion #31 it is outlined how you can create a ReplayProvider which sends a message to each new subscription.

Let me know if this helps and suits your use case!

[hspaay]

Hmm, sort-of a ping message sent by the server that the client uses to confirm the connection is re-established. Its feels a bit like a hack as I'd expect that go-sse client would know the connection is re-established but maybe its not that simple (is it ever?). I will give your suggestion a try.
Thank you kindly for the feedback.

[tmaxmax]

The thing is that I don't think there is any other reliable way – think about it, what better guarantee is there that you're connected other than successfully receiving a message? It's similar to doing a health check to a service.

Also, should go-sse provided such callback, the question is at which point in time? When the request receives a successful response? What if before starting to read the request body the connection breaks? Or when the first event is read? Then we're basically using the first message of the server as the ping message – there may be situations where the first message is received a long while after actually connecting, so that's also not reliable.

I should maybe do some looking up to see whether there's some other way, but as of my knowledge the best way to test a connection is to see that communication can be successfully carried over it.

[hspaay]

Well Yes and No. Ultimately you are right that receiving a message is the best guarantee that the connection is established and functional. Hard to argue with that.
From a design point of view however, this burdens the application layer with a transport layer problem. I'm fairly certain that the underlying TLS transport does know the connection is established as it does the TLS handshake. Does SSE require a further upgrade handshake like websockets do? The completion of that handshake marks the completion of the connection.
btw, the suggested workaround is easy enough so no issue there. Just pointing out the separation of responsibility between transport and application layers.

[tmaxmax]

You're making a good point here. Something else that supports this standpoint is that the browser EventSource has a readyState field which indicates whether the client is connected or not and it is well-described in the spec how it should be implemented.

I'll look into how to support this from a technical standpoint which also integrates well with Go. Thank you for your input!