Merge pull request #10 from Salesforce-Async-Messaging/u/bdrasin/W-20451274/retru_on_sse_error

w-20451274 retry_on_sse_error

Author: bdrasin

src/services/eventSourceService.js

@@ -5,6 +5,16 @@ import { getOrganizationId, getSalesforceMessagingUrl, getJwt, getLastEventId }
  */
 let eventSource;
 
+/**
+ * Configuration for reconnection behavior
+ */
+const RECONNECT_CONFIG = {
+    maxAttempts: 10,
+    initialDelay: 1000, // 1 second
+    maxDelay: 30000, // 30 seconds
+    backoffMultiplier: 1.5
+};
+
 /**
  * Get the request headers for connecting to SSE.
  */
@@ -51,6 +61,17 @@ const handleEventSourceListeners = (listenerOperationName, eventListenerMap) =>
     });
 };
 
+/**
+ * Calculate the delay for the next reconnection attempt using exponential backoff.
+ *
+ * @param {Number} attemptNumber - The current attempt number (0-indexed)
+ * @returns {Number} Delay in milliseconds
+ */
+const calculateReconnectDelay = (attemptNumber) => {
+    const delay = RECONNECT_CONFIG.initialDelay * Math.pow(RECONNECT_CONFIG.backoffMultiplier, attemptNumber);
+    return Math.min(delay, RECONNECT_CONFIG.maxDelay);
+};
+
 /**
  * Establish the EventSource object with handlers for onopen and onerror.
  *
@@ -70,26 +91,92 @@ export const createEventSource = (fullApiPath, eventListenerMap) => {
     }
 
     /**
-     * Create a closure here to isolate `reconnectAttempts` and `reconnectIntervalSeconds` values to a single invocation of `createEventSource`.
-     * All calls to `resolveEventSource` within a call to `createEventSource` share the same `reconnectAttempts` and `reconnectIntervalSeconds` values.
+     * Create a closure here to isolate `reconnectAttempts` and reconnect logic to a single invocation of `createEventSource`.
+     * All calls to `resolveEventSource` within a call to `createEventSource` share the same `reconnectAttempts` value.
      *
      * @param {Promise.resolve} resolve - Event source opened.
      * @param {Promise.reject} reject - Attempted to reconnect to event source too many times.
      */
     const resolveEventSource = (resolve, reject) => {
-        try {
-            eventSource = new window.EventSourcePolyfill(fullApiPath, getEventSourceParams());
-
-            eventSource.onopen = () => {
-                handleEventSourceListeners("addEventListener", eventListenerMap);
-                resolve();
-            };
-            eventSource.onerror = (error) => {
-                reject();
-            };
-        } catch (error) {
-            reject(error);
-        }
+        let reconnectAttempts = 0;
+        let reconnectTimeoutId = null;
+
+        /**
+         * Attempts to create a new EventSource connection.
+         * This function is called initially and on each reconnection attempt.
+         */
+        const attemptConnection = () => {
+            try {
+                // Close existing eventSource if it exists
+                if (eventSource) {
+                    try {
+                        eventSource.close();
+                    } catch (closeError) {
+                        // Ignore errors when closing, as the connection may already be closed
+                        console.warn("Error closing existing EventSource:", closeError);
+                    }
+                }
+
+                // Create new EventSource with timestamp to avoid caching
+                const apiPathWithTimestamp = `${fullApiPath}${fullApiPath.includes('?') ? '&' : '?'}_ts=${Date.now()}`;
+                eventSource = new window.EventSourcePolyfill(apiPathWithTimestamp, getEventSourceParams());
+
+                eventSource.onopen = () => {
+                    // Reset reconnect attempts on successful connection
+                    reconnectAttempts = 0;
+                    if (reconnectTimeoutId) {
+                        clearTimeout(reconnectTimeoutId);
+                        reconnectTimeoutId = null;
+                    }
+                    handleEventSourceListeners("addEventListener", eventListenerMap);
+                    resolve();
+                };
+
+                eventSource.onerror = (error) => {
+                    // Remove event listeners to prevent duplicates, then attenpt to reconnect
+                    handleEventSourceListeners("removeEventListener", eventListenerMap);
+                    reconnectAttempts++;
+                    
+                    if (reconnectAttempts <= RECONNECT_CONFIG.maxAttempts) {
+                        const delay = calculateReconnectDelay(reconnectAttempts - 1);
+                        console.log(`EventSource connection error. Attempting to reconnect (${reconnectAttempts}/${RECONNECT_CONFIG.maxAttempts}) in ${delay}ms...`);
+                        
+                        reconnectTimeoutId = setTimeout(() => {
+                            attemptConnection();
+                        }, delay);
+                    } else {
+                        console.error(`EventSource connection failed after ${RECONNECT_CONFIG.maxAttempts} reconnection attempts.`);
+                        if (reconnectTimeoutId) {
+                            clearTimeout(reconnectTimeoutId);
+                            reconnectTimeoutId = null;
+                        }
+                        reject(new Error(`Failed to establish EventSource connection after ${RECONNECT_CONFIG.maxAttempts} attempts`));
+                    }
+
+                };
+            } catch (error) {
+                reconnectAttempts++;
+                
+                if (reconnectAttempts <= RECONNECT_CONFIG.maxAttempts) {
+                    const delay = calculateReconnectDelay(reconnectAttempts - 1);
+                    console.log(`Error creating EventSource. Attempting to reconnect (${reconnectAttempts}/${RECONNECT_CONFIG.maxAttempts}) in ${delay}ms...`);
+                    
+                    reconnectTimeoutId = setTimeout(() => {
+                        attemptConnection();
+                    }, delay);
+                } else {
+                    console.error(`Failed to create EventSource after ${RECONNECT_CONFIG.maxAttempts} attempts.`);
+                    if (reconnectTimeoutId) {
+                        clearTimeout(reconnectTimeoutId);
+                        reconnectTimeoutId = null;
+                    }
+                    reject(error);
+                }
+            }
+        };
+
+        // Start the initial connection attempt
+        attemptConnection();
     };
 
     return new Promise(resolveEventSource);
@@ -114,7 +201,7 @@ export const subscribeToEventSource = (eventListenerMap) => {
              * Directly connect to event router endpoint on Salesforce Messaging domain instead of going through ia-message.
              */
             createEventSource(
-                getSalesforceMessagingUrl().concat(`/eventrouter/v1/sse?_ts=${Date.now()}`),
+                getSalesforceMessagingUrl().concat(`/eventrouter/v1/sse`),
                 eventListenerMap
             ).then(
                 resolve,