@devskin/browser-sdk 1.0.14 → 1.0.16

package/dist/devskin.umd.js

@@ -5567,24 +5567,12 @@
                 return;
             }
             try {
-                console.log('[RRWeb] Starting session recording:', this.sessionId);
-                console.log('[RRWeb] SDK Version: 1.0.14');
                 this.stopFn = record({
                     emit: (event) => {
-                        // DEBUG: Log ALL event types to diagnose issue
-                        if (!this.hasFullSnapshot) {
-                            console.log('[RRWeb] Event captured:', {
-                                type: event.type,
-                                timestamp: event.timestamp,
-                                hasData: !!event.data
-                            });
-                        }
                         this.events.push(event);
                         // Check if this is a FullSnapshot (type 2)
                         if (event.type === 2) {
                             this.hasFullSnapshot = true;
-                            console.log('[RRWeb] ✅ FullSnapshot captured! Sending immediately...');
-                            console.log('[RRWeb] FullSnapshot data keys:', Object.keys(event.data || {}));
                             // Send immediately to ensure FullSnapshot reaches backend first
                             this.flush();
                         }
@@ -5638,29 +5626,19 @@
                 // Safety check: After 2 seconds, force a full snapshot if none captured
                 setTimeout(() => {
                     if (!this.hasFullSnapshot) {
-                        console.warn('[RRWeb] ⚠️ No FullSnapshot captured after 2 seconds!');
-                        console.warn('[RRWeb] Events captured so far:', this.events.length);
-                        console.warn('[RRWeb] Event types:', this.events.map(e => e.type));
-                        console.warn('[RRWeb] Forcing a full snapshot via record.takeFullSnapshot()...');
                         // Try to force a full snapshot using rrweb's API
                         try {
-                            // Call record.takeFullSnapshot() to force a full snapshot
                             record.takeFullSnapshot();
-                            console.log('[RRWeb] ✅ Manual FullSnapshot triggered!');
                         }
                         catch (error) {
-                            console.error('[RRWeb] Failed to force snapshot:', error);
                             // If we have events but no FullSnapshot, flush anyway to not lose data
-                            // But warn that replay may not work correctly
                             if (this.events.length > 0) {
-                                console.warn('[RRWeb] Flushing existing events WITHOUT FullSnapshot...');
                                 this.hasFullSnapshot = true; // Set to true to allow flushing
                                 this.flush();
                             }
                         }
                     }
                 }, 2000);
-                console.log('[RRWeb] Recording started successfully');
             }
             catch (error) {
                 console.error('[RRWeb] Failed to start recording:', error);
@@ -5670,17 +5648,13 @@
             if (this.stopFn) {
                 this.stopFn();
                 this.stopFn = null;
-                console.log('[RRWeb] Recording stopped');
             }
             if (this.flushInterval) {
                 clearInterval(this.flushInterval);
                 this.flushInterval = null;
             }
-            // Flush remaining events (even without FullSnapshot, to not lose data)
+            // Flush remaining events
             if (this.events.length > 0) {
-                if (!this.hasFullSnapshot) {
-                    console.warn('[RRWeb] Flushing events without FullSnapshot - recording may not replay correctly');
-                }
                 this.flush();
             }
         }
@@ -5689,12 +5663,6 @@
                 return;
             const eventsToSend = [...this.events];
             this.events = [];
-            // Log event types being sent
-            const typeCounts = {};
-            eventsToSend.forEach(e => {
-                typeCounts[e.type] = (typeCounts[e.type] || 0) + 1;
-            });
-            console.log('[RRWeb] Flushing events:', typeCounts);
             if (this.onEventsReady) {
                 this.onEventsReady(eventsToSend);
             }
@@ -5752,11 +5720,6 @@
         }
         sendRecordingEvents(sessionId, events) {
             return __awaiter$1(this, void 0, void 0, function* () {
-                // DEBUG: Log event types being sent
-                const eventTypes = events.reduce((acc, e) => {
-                    acc[e.type] = (acc[e.type] || 0) + 1;
-                    return acc;
-                }, {});
                 // Calculate payload size
                 const payload = {
                     session_id: sessionId,
@@ -5766,10 +5729,6 @@
                     appId: this.config.appId,
                 };
                 const payloadSize = new Blob([JSON.stringify(payload)]).size;
-                const payloadSizeMB = (payloadSize / 1024 / 1024).toFixed(2);
-                console.log(`[DevSkin SDK] Sending ${events.length} recording events:`, eventTypes);
-                console.log(`[DevSkin SDK] Payload size: ${payloadSizeMB} MB (${payloadSize} bytes)`);
-                console.log(`[DevSkin SDK] First 3 events:`, events.slice(0, 3).map(e => ({ type: e.type, timestamp: e.timestamp })));
                 // Check if this batch contains FullSnapshot (type 2)
                 const hasFullSnapshot = events.some(e => e.type === 2);
                 const maxRetries = hasFullSnapshot ? 3 : 1; // Retry FullSnapshot batches up to 3 times
@@ -5777,25 +5736,35 @@
                 let lastError = null;
                 for (let attempt = 1; attempt <= maxRetries; attempt++) {
                     try {
-                        yield this.sendToBackend('/v1/rum/recordings', {
-                            session_id: sessionId,
-                            events,
-                            timestamp: new Date().toISOString(),
-                        });
-                        console.log(`[DevSkin SDK] ✅ Recording events sent successfully${attempt > 1 ? ` (attempt ${attempt})` : ''}`);
+                        // Use XMLHttpRequest for large payloads (more reliable than fetch for large data)
+                        if (payloadSize > 100000) { // > 100KB
+                            yield this.sendToBackendXHR('/v1/rum/recordings', {
+                                session_id: sessionId,
+                                events,
+                                timestamp: new Date().toISOString(),
+                            });
+                        }
+                        else {
+                            yield this.sendToBackend('/v1/rum/recordings', {
+                                session_id: sessionId,
+                                events,
+                                timestamp: new Date().toISOString(),
+                            });
+                        }
                         return; // Success, exit
                     }
                     catch (error) {
                         lastError = error;
                         if (attempt < maxRetries) {
                             const delay = attempt * 1000; // 1s, 2s, 3s...
-                            console.warn(`[DevSkin SDK] ⚠️ Failed to send recording events (attempt ${attempt}/${maxRetries}), retrying in ${delay}ms...`);
                             yield new Promise(resolve => setTimeout(resolve, delay));
                         }
                     }
                 }
                 // All retries failed
-                console.error(`[DevSkin SDK] ❌ Failed to send recording events after ${maxRetries} attempts:`, lastError);
+                if (this.config.debug) {
+                    console.error(`[DevSkin SDK] Failed to send recording events after ${maxRetries} attempts:`, lastError);
+                }
             });
         }
         sendHeatmapData(heatmapData) {
@@ -5856,6 +5825,56 @@
                     return '/v1/analytics/events';
             }
         }
+        sendToBackendXHR(endpoint, data) {
+            return __awaiter$1(this, void 0, void 0, function* () {
+                const url = `${this.apiUrl}${endpoint}`;
+                const payload = Object.assign(Object.assign({}, data), { apiKey: this.config.apiKey, appId: this.config.appId, environment: this.config.environment, release: this.config.release });
+                // Apply beforeSend hook if provided
+                if (this.config.beforeSend) {
+                    const processed = this.config.beforeSend(payload);
+                    if (!processed) {
+                        // Hook returned null, don't send
+                        return;
+                    }
+                }
+                return new Promise((resolve, reject) => {
+                    const xhr = new XMLHttpRequest();
+                    xhr.open('POST', url, true);
+                    xhr.setRequestHeader('Content-Type', 'application/json');
+                    xhr.setRequestHeader('Authorization', `Bearer ${this.config.apiKey}`);
+                    xhr.onload = () => {
+                        if (xhr.status >= 200 && xhr.status < 300) {
+                            if (this.config.debug) {
+                                console.log('[DevSkin] Data sent successfully via XHR:', endpoint);
+                            }
+                            resolve();
+                        }
+                        else {
+                            console.error('[DevSkin] XHR HTTP Error:', xhr.status, xhr.responseText);
+                            reject(new Error(`HTTP ${xhr.status}: ${xhr.statusText}`));
+                        }
+                    };
+                    xhr.onerror = () => {
+                        console.error('[DevSkin] XHR network error:', endpoint);
+                        reject(new Error('Network error'));
+                    };
+                    xhr.ontimeout = () => {
+                        console.error('[DevSkin] XHR timeout:', endpoint);
+                        reject(new Error('Request timeout'));
+                    };
+                    // Set a generous timeout for large payloads (30 seconds)
+                    xhr.timeout = 30000;
+                    try {
+                        const body = JSON.stringify(payload);
+                        xhr.send(body);
+                    }
+                    catch (error) {
+                        console.error('[DevSkin] Failed to send XHR request:', error);
+                        reject(error);
+                    }
+                });
+            });
+        }
         sendToBackend(endpoint_1, data_1) {
             return __awaiter$1(this, arguments, void 0, function* (endpoint, data, useBeacon = false) {
                 const url = `${this.apiUrl}${endpoint}`;