Add MixpanelNetworkErrorListener (#857)

jaredmixpanel · web-flow · commit f15b7dc9f968 · 2025-05-02T14:05:08.000-07:00
* add MixpanelNetworkErrorListener

* pass to AnalyticsMessages and add to mixpaneldemo

* rename props

* make helper

* remove dupe calls from AnalyticsMessages add catch Exception

* update SimpleLoggingErrorListener example

* newline

* add ip and duration

* revert MIXPANEL_API test change

* add body size and response

* reformat

* cleanup

* move endTimeNanos up
diff --git a/mixpaneldemo/src/main/java/com/mixpanel/mixpaneldemo/SimpleLoggingErrorListener.kt b/mixpaneldemo/src/main/java/com/mixpanel/mixpaneldemo/SimpleLoggingErrorListener.kt
@@ -0,0 +1,113 @@
+package com.mixpanel.mixpaneldemo
+
+import android.util.Log
+import com.mixpanel.android.util.MixpanelNetworkErrorListener
+import java.io.EOFException
+import java.io.IOException
+import java.net.ConnectException
+import java.net.SocketException
+import java.net.SocketTimeoutException
+import java.net.UnknownHostException
+import javax.net.ssl.SSLException
+import javax.net.ssl.SSLHandshakeException
+import javax.net.ssl.SSLPeerUnverifiedException
+
+/**
+ * A simple implementation of MixpanelNetworkErrorListener that logs
+ * the encountered network errors using Android's Logcat.
+ */
+class SimpleLoggingErrorListener : MixpanelNetworkErrorListener {
+
+    companion object {
+        private const val TAG = "MixpanelNetworkError"
+    }
+
+    override fun onNetworkError(
+        endpointUrl: String,
+        ipAddress: String,
+        durationMillis: Long,
+        uncompressedBodySize: Long,
+        compressedBodySize: Long,
+        responseCode: Int,
+        responseMessage: String,
+        exception: Exception
+    ) {
+        Log.w(
+            TAG,
+            "Mixpanel network error for endpoint: $endpointUrl (IP: $ipAddress, duration: $durationMillis ms, uncompressed body size: $uncompressedBodySize, compressed body size: $compressedBodySize, response: $responseCode $responseMessage)"
+        )
+        Log.w(TAG, "Exception: ${exception.toString()} - Message: ${exception.message}", exception)
+
+        when (exception) {
+            // --- Specific SSL/TLS Issues ---
+            is SSLPeerUnverifiedException -> {
+                Log.e(
+                    TAG,
+                    "--> SSLPeerUnverifiedException occurred (Certificate validation issue?).",
+                    exception
+                )
+            }
+
+            is SSLHandshakeException -> {
+                Log.e(
+                    TAG,
+                    "--> SSLHandshakeException occurred (Handshake phase failure).",
+                    exception
+                )
+            }
+
+            is SSLException -> {
+                Log.e(TAG, "--> General SSLException occurred.", exception)
+            }
+
+            // --- Specific Connection/Network Issues ---
+            is ConnectException -> {
+                // TCP connection attempt failure (e.g., connection refused)
+                Log.e(
+                    TAG,
+                    "--> ConnectException occurred (Connection refused/TCP layer issue?).",
+                    exception
+                )
+            }
+
+            is SocketException -> {
+                // Catch other socket-level errors (e.g., "Broken pipe", "Socket closed")
+                Log.e(
+                    TAG,
+                    "--> SocketException occurred (Post-connection socket issue?).",
+                    exception
+                )
+            }
+
+            is SocketTimeoutException -> {
+                // Timeout during connection or read/write
+                Log.e(TAG, "--> Socket Timeout occurred.", exception)
+            }
+
+            is UnknownHostException -> {
+                // DNS resolution failure
+                Log.e(TAG, "--> Unknown Host Exception (DNS issue?).", exception)
+            }
+
+            is EOFException -> {
+                // Often indicates connection closed unexpectedly
+                Log.w(
+                    TAG,
+                    "--> EOFException occurred (Connection closed unexpectedly?).",
+                    exception
+                )
+            }
+
+            // --- General I/O Catch-all ---
+            is IOException -> {
+                // Catches other IOExceptions (like stream errors, etc.) not handled above
+                Log.e(TAG, "--> General IOException occurred.", exception)
+            }
+
+            // --- Non-I/O Catch-all ---
+            else -> {
+                Log.e(TAG, "--> An unexpected non-IOException occurred.", exception)
+            }
+        }
+    }
+}
diff --git a/mixpaneldemo/src/main/java/com/mixpanel/mixpaneldemo/TrackingPage.kt b/mixpaneldemo/src/main/java/com/mixpanel/mixpaneldemo/TrackingPage.kt
@@ -31,6 +31,9 @@ fun TrackingPage(navController: NavHostController) {
     val dialogMessage = remember { mutableStateOf("") }
     val context = LocalContext.current
     val mixpanel = MixpanelAPI.getInstance(context, MIXPANEL_PROJECT_TOKEN, true)
+    mixpanel.setEnableLogging(true)
+    mixpanel.setShouldGzipRequestPayload(true)
+    mixpanel.setNetworkErrorListener(SimpleLoggingErrorListener())
 
     val trackingActions = listOf(
         Triple("Track w/o Properties" ,"Event: \"Track Event!\"", {  println("Tracking without properties")
diff --git a/src/main/java/com/mixpanel/android/mpmetrics/AnalyticsMessages.java b/src/main/java/com/mixpanel/android/mpmetrics/AnalyticsMessages.java
@@ -13,6 +13,7 @@
 import com.mixpanel.android.util.HttpService;
 import com.mixpanel.android.util.LegacyVersionUtils;
 import com.mixpanel.android.util.MPLog;
+import com.mixpanel.android.util.MixpanelNetworkErrorListener;
 import com.mixpanel.android.util.RemoteService;
 
 import org.json.JSONException;
@@ -22,7 +23,6 @@
 import java.io.IOException;
 import java.io.UnsupportedEncodingException;
 import java.net.MalformedURLException;
-import java.net.SocketTimeoutException;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map;
@@ -77,6 +77,10 @@ public static AnalyticsMessages getInstance(final Context messageContext, MPConf
         }
     }
 
+    public void setNetworkErrorListener(MixpanelNetworkErrorListener errorListener) {
+        mNetworkErrorListener = errorListener;
+    }
+
     public void eventsMessage(final EventDescription eventDescription) {
         final Message m = Message.obtain();
         m.what = ENQUEUE_EVENTS;
@@ -171,7 +175,7 @@ protected MPDbAdapter makeDbAdapter(Context context) {
     }
 
     protected RemoteService getPoster() {
-        return new HttpService(mConfig.shouldGzipRequestPayload());
+        return new HttpService(mConfig.shouldGzipRequestPayload(), mNetworkErrorListener);
     }
 
     ////////////////////////////////////////////////////
@@ -542,9 +546,6 @@ private void sendData(MPDbAdapter dbAdapter, String token, MPDbAdapter.Table tab
                         logAboutMessageToMixpanel("Cannot post message to " + url + ".", e);
                         deleteEvents = false;
                         mTrackEngageRetryAfter = e.getRetryAfter() * 1000;
-                    } catch (final SocketTimeoutException e) {
-                        logAboutMessageToMixpanel("Cannot post message to " + url + ".", e);
-                        deleteEvents = false;
                     } catch (final IOException e) {
                         logAboutMessageToMixpanel("Cannot post message to " + url + ".", e);
                         deleteEvents = false;
@@ -691,6 +692,7 @@ public long getTrackEngageRetryAfter() {
     private final String mInstanceName;
     protected final Context mContext;
     protected final MPConfig mConfig;
+    protected MixpanelNetworkErrorListener mNetworkErrorListener;
 
     // Messages for our thread
     private static final int ENQUEUE_PEOPLE = 0; // push given JSON message to people DB
diff --git a/src/main/java/com/mixpanel/android/mpmetrics/MixpanelAPI.java b/src/main/java/com/mixpanel/android/mpmetrics/MixpanelAPI.java
@@ -15,6 +15,7 @@
 import androidx.core.content.ContextCompat;
 
 import com.mixpanel.android.util.MPLog;
+import com.mixpanel.android.util.MixpanelNetworkErrorListener;
 import com.mixpanel.android.util.ProxyServerInteractor;
 
 import org.json.JSONArray;
@@ -572,6 +573,14 @@ public void setServerURL(String serverURL, ProxyServerInteractor callback) {
         mConfig.setServerURL(serverURL, callback);
     }
 
+    /**
+     * Set the listener for network errors.
+     * @param listener
+     */
+    public void setNetworkErrorListener(MixpanelNetworkErrorListener listener) {
+        AnalyticsMessages.getInstance(mContext, mConfig).setNetworkErrorListener(listener);
+    }
+
     public Boolean getTrackAutomaticEvents() { return mTrackAutomaticEvents; }
     /**
      * This function creates a distinct_id alias from alias to distinct_id. If distinct_id is null, then it will create an alias
diff --git a/src/main/java/com/mixpanel/android/util/HttpService.java b/src/main/java/com/mixpanel/android/util/HttpService.java
@@ -17,7 +17,10 @@
 import java.net.HttpURLConnection;
 import java.net.InetAddress;
 import java.net.URL;
+import java.nio.charset.StandardCharsets;
 import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.TimeUnit;
 import java.util.zip.GZIPOutputStream;
 
 import javax.net.ssl.HttpsURLConnection;
@@ -30,28 +33,33 @@ public class HttpService implements RemoteService {
 
 
     private final boolean shouldGzipRequestPayload;
+    private final MixpanelNetworkErrorListener networkErrorListener;
 
     private static boolean sIsMixpanelBlocked;
     private static final int MIN_UNAVAILABLE_HTTP_RESPONSE_CODE = HttpURLConnection.HTTP_INTERNAL_ERROR;
     private static final int MAX_UNAVAILABLE_HTTP_RESPONSE_CODE = 599;
 
-    public HttpService(boolean shouldGzipRequestPayload) {
+    public HttpService(boolean shouldGzipRequestPayload, MixpanelNetworkErrorListener networkErrorListener) {
         this.shouldGzipRequestPayload = shouldGzipRequestPayload;
+        this.networkErrorListener = networkErrorListener;
     }
 
     public HttpService() {
-        this(false);
+        this(false, null);
     }
     @Override
     public void checkIsMixpanelBlocked() {
         Thread t = new Thread(new Runnable() {
             public void run() {
                 try {
-                    InetAddress apiMixpanelInet = InetAddress.getByName("api.mixpanel.com");
+                    long startTimeNanos = System.nanoTime();
+                    String host = "api.mixpanel.com";
+                    InetAddress apiMixpanelInet = InetAddress.getByName(host);
                     sIsMixpanelBlocked = apiMixpanelInet.isLoopbackAddress() ||
                             apiMixpanelInet.isAnyLocalAddress();
                     if (sIsMixpanelBlocked) {
                         MPLog.v(LOGTAG, "AdBlocker is enabled. Won't be able to use Mixpanel services.");
+                        onNetworkError(null, host, apiMixpanelInet.getHostAddress(), startTimeNanos, -1, -1, new IOException(host + " is blocked"));
                     }
                 } catch (Exception e) {
                 }
@@ -115,11 +123,18 @@ public byte[] performRequest(String endpointUrl, ProxyServerInteractor interacto
         while (retries < 3 && !succeeded) {
             InputStream in = null;
             OutputStream out = null;
-            OutputStream bout = null;
             HttpURLConnection connection = null;
 
+            String targetIpAddress = null;
+            long startTimeNanos = System.nanoTime();
+            long uncompressedBodySize = -1;
+            long compressedBodySize = -1;
+
             try {
                 final URL url = new URL(endpointUrl);
+
+                InetAddress inetAddress = InetAddress.getByName(url.getHost());
+                targetIpAddress = inetAddress.getHostAddress();
                 connection = (HttpURLConnection) url.openConnection();
                 if (null != socketFactory && connection instanceof HttpsURLConnection) {
                     ((HttpsURLConnection) connection).setSSLSocketFactory(socketFactory);
@@ -136,25 +151,35 @@ public byte[] performRequest(String endpointUrl, ProxyServerInteractor interacto
 
                 connection.setConnectTimeout(2000);
                 connection.setReadTimeout(30000);
+
+                byte[] bodyBytesToSend = null;
                 if (null != params) {
                     Uri.Builder builder = new Uri.Builder();
                     for (Map.Entry<String, Object> param : params.entrySet()) {
                         builder.appendQueryParameter(param.getKey(), param.getValue().toString());
                     }
                     String query = builder.build().getEncodedQuery();
+                    byte[] originalBodyBytes = Objects.requireNonNull(query).getBytes(StandardCharsets.UTF_8);
+                    uncompressedBodySize = originalBodyBytes.length;
+
                     if (shouldGzipRequestPayload) {
+                        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+                        try (GZIPOutputStream gzipOut = new GZIPOutputStream(baos)) {
+                            gzipOut.write(originalBodyBytes);
+                        }
+                        bodyBytesToSend = baos.toByteArray();
+                        compressedBodySize = bodyBytesToSend.length;
                         connection.setRequestProperty(CONTENT_ENCODING_HEADER, GZIP_CONTENT_TYPE_HEADER);
+                        connection.setFixedLengthStreamingMode(compressedBodySize);
                     } else {
-                        connection.setFixedLengthStreamingMode(query.getBytes().length);
+                        bodyBytesToSend = originalBodyBytes;
+                        connection.setFixedLengthStreamingMode(uncompressedBodySize);
                     }
                     connection.setDoOutput(true);
                     connection.setRequestMethod("POST");
                     out = connection.getOutputStream();
-                    bout = getBufferedOutputStream(out);
-                    bout.write(query.getBytes("UTF-8"));
-                    bout.flush();
-                    bout.close();
-                    bout = null;
+                    out.write(bodyBytesToSend);
+                    out.flush();
                     out.close();
                     out = null;
                 }
@@ -167,18 +192,21 @@ public byte[] performRequest(String endpointUrl, ProxyServerInteractor interacto
                 in = null;
                 succeeded = true;
             } catch (final EOFException e) {
+                onNetworkError(connection, endpointUrl, targetIpAddress, startTimeNanos, uncompressedBodySize, compressedBodySize, e);
                 MPLog.d(LOGTAG, "Failure to connect, likely caused by a known issue with Android lib. Retrying.");
                 retries = retries + 1;
             } catch (final IOException e) {
+                onNetworkError(connection, endpointUrl, targetIpAddress, startTimeNanos, uncompressedBodySize, compressedBodySize, e);
                 if (connection != null && connection.getResponseCode() >= MIN_UNAVAILABLE_HTTP_RESPONSE_CODE && connection.getResponseCode() <= MAX_UNAVAILABLE_HTTP_RESPONSE_CODE) {
                     throw new ServiceUnavailableException("Service Unavailable", connection.getHeaderField("Retry-After"));
                 } else {
                     throw e;
                 }
+            } catch (final Exception e) {
+                onNetworkError(connection, endpointUrl, targetIpAddress, startTimeNanos, uncompressedBodySize, compressedBodySize, e);
+                throw e;
             }
             finally {
-                if (null != bout)
-                    try { bout.close(); } catch (final IOException e) {}
                 if (null != out)
                     try { out.close(); } catch (final IOException e) {}
                 if (null != in)
@@ -193,6 +221,25 @@ public byte[] performRequest(String endpointUrl, ProxyServerInteractor interacto
         return response;
     }
 
+    private void onNetworkError(HttpURLConnection connection, String endpointUrl, String targetIpAddress, long startTimeNanos, long uncompressedBodySize, long compressedBodySize, Exception e) {
+        if (this.networkErrorListener != null) {
+            long endTimeNanos = System.nanoTime();
+            long durationMillis = TimeUnit.NANOSECONDS.toMillis(endTimeNanos - startTimeNanos);
+            int responseCode = -1;
+            String responseMessage = "";
+            if (connection != null) {
+                try {
+                    responseCode = connection.getResponseCode();
+                    responseMessage = connection.getResponseMessage();
+                } catch (Exception respExc) {
+                    MPLog.w(LOGTAG, "Could not retrieve response code/message after error", respExc);
+                }
+            }
+            String ip = (targetIpAddress == null) ? "N/A" : targetIpAddress;
+            this.networkErrorListener.onNetworkError(endpointUrl, ip, durationMillis, uncompressedBodySize, compressedBodySize, responseCode, responseMessage, e);
+        }
+    }
+
     private OutputStream getBufferedOutputStream(OutputStream out) throws IOException {
         if(shouldGzipRequestPayload) {
           return new GZIPOutputStream(new BufferedOutputStream(out), HTTP_OUTPUT_STREAM_BUFFER_SIZE);
@@ -225,3 +272,4 @@ private static byte[] slurp(final InputStream inputStream)
     private static final String CONTENT_ENCODING_HEADER = "Content-Encoding";
     private static final String GZIP_CONTENT_TYPE_HEADER = "gzip";
 }
+
diff --git a/src/main/java/com/mixpanel/android/util/MixpanelNetworkErrorListener.java b/src/main/java/com/mixpanel/android/util/MixpanelNetworkErrorListener.java
@@ -0,0 +1,23 @@
+package com.mixpanel.android.util;
+
+public interface MixpanelNetworkErrorListener {
+    /**
+     * Called when a network request within the Mixpanel SDK fails.
+     * This method may be called on a background thread.
+     *
+     * @param endpointUrl The URL that failed.
+     * @param ipAddress The IP address resolved from the endpointUrl's hostname for this attempt (may be "N/A" if DNS lookup failed).
+     * @param durationMillis The approximate duration in milliseconds from the start of this specific connection attempt until the exception was thrown.
+     * @param uncompressedBodySize The size in bytes of the request body *before* any compression.
+     * Will be -1 if no body was sent.
+     * @param compressedBodySize The size in bytes of the request body *after* Gzip compression.
+     * Will be -1 if no body was sent or if compression was not enabled
+     * (in which case uncompressed size applies).
+     * @param responseCode The HTTP response code returned by the server, if available.
+     * Defaults to -1 if no response code could be retrieved (e.g., connection error).
+     * @param responseMessage The HTTP response message returned by the server, if available.
+     * Defaults to empty string if no response message could be retrieved.
+     * @param exception The exception that occurred (e.g., IOException, EOFException, etc.).
+     */
+    void onNetworkError(String endpointUrl, String ipAddress, long durationMillis, long uncompressedBodySize, long compressedBodySize, int responseCode, String responseMessage, Exception exception);
+}
