Check against posthog server (or other, ie. google.com) using simple ping before calling NetworkClient's SendBatch

[GDorneAtLaerdal]

Problem Statement

In EventQueue.cs's FlushCoroutine, the Application.internetReachability == NetworkReachability.NotReachable check does not actually always determine whether internet connection (especially to a specific server) is available and working.
On top of this first cheap check, I suggest to have another cheap check following it which just pings against any relevant servers, before running NetworkClient's SendBatch logic. If check fails, apply same logic as the internetReachability check.

Solution Brainstorm

You could use Task or Coroutine (see link below for simple example using coroutine). UniTask is great for this kind of stuff too but I don't think you guys are using it.
https://stackoverflow.com/a/57553685

See the code below for UniTask implementation based on the link above

public static async UniTask<bool> CheckInternetConnection(CancellationToken cancellationToken = default)
        {
            const string echoServer = "http://google.com";

            using (var request = UnityWebRequest.Head(echoServer))
            {
                request.timeout = 5;

                try
                {
                    await request.SendWebRequest().WithCancellation(cancellationToken);
                }
                catch (UnityWebRequestException)
                {
                    return false;
                }

                return (request.result != UnityWebRequest.Result.ConnectionError) && (request.result != UnityWebRequest.Result.ProtocolError) && request.responseCode == 200;
            }
        }

[dustinbyrne]

hey @GDorneAtLaerdal! thanks for the issue. we use NetworkReachability broadly for definitive cases like airplane mode or offline devices. otherwise, instead of a connectivity check to an external service, we attempt to send the event batch and can continue retrying if it's unsuccessful.

do you have a case where this is not working as intended?

[GDorneAtLaerdal]

Hi Dustin!

I was just thinking in terms of unecessary performance overhead, where imagine a scenario where I am connected to wifi router, so the NetworkReachability check passes, but the wifi router is having trouble/not connecting to the internet. Or if the PostHog server is down. In that case, if I am not mistaken, the following logic in this code will always run:

public IEnumerator SendBatch(BatchPayload payload, Action<bool, int> onComplete)
        {

// From here
            var url = GetBatchUrl();
            var json = JsonSerializer.SerializeBatch(payload);

            PostHogLogger.Debug($"Sending batch to {url}");

            using var request = new UnityWebRequest(url, "POST");
            var bodyRaw = Encoding.UTF8.GetBytes(json);
            request.uploadHandler = new UploadHandlerRaw(bodyRaw);
            request.downloadHandler = new DownloadHandlerBuffer();
            ApplyDefaultHeaders(request);
            request.timeout = TimeoutSeconds;

// To here
            yield return request.SendWebRequest();

            int statusCode = (int)request.responseCode;

            if (request.result == UnityWebRequest.Result.Success)
            {
                PostHogLogger.Debug($"Batch sent successfully (status: {statusCode})");
                onComplete?.Invoke(true, statusCode);
            }
            else
            {
                PostHogLogger.Warning($"Batch send failed: {request.error} (status: {statusCode})");
                onComplete?.Invoke(false, statusCode);
            }
        }

Whereas an additional more specific connectivity check beforehand (right after the NetworkReachability check) to either the PostHog server or the google server (or anything of your choice you think is applicable, albeit choosing the PostHog server would be most useful as it would also check against the server's status) would not run this logic. This secondary check could also have status code error debugging.