@echoteam/signoz-react 1.2.11 → 1.2.14

package/TROUBLESHOOTING.md

@@ -4,6 +4,15 @@
 
 ### Masalah
 Jika Anda mendapatkan error seperti ini di console:
+```
+Error: Timeout
+at https://admin.caready.co.id/static/js/8748.967a232d.js:2:51673
+at i.<computed> (https://admin.caready.co.id/static/js/8748.967a232d.js:2:106994)
+at c.invokeTask (https://admin.caready.co.id/static/js/8748.967a232d.js:2:84776)
+```
+
+atau
+
 ```
 Unhandled Promise rejection: Timeout ; Zone: <root> ; Task: Promise.then ; Value: Error: Timeout
 at BatchSpanProcessorBase.js:132:1
@@ -15,10 +24,32 @@ Error ini terjadi ketika BatchSpanProcessor mencoba mengirim spans ke backend Si
 2. Network lambat atau tidak stabil
 3. CORS tidak dikonfigurasi dengan benar di backend
 4. Timeout terlalu pendek untuk koneksi Anda
+5. Firewall atau proxy memblokir koneksi
 
 ### Solusi
 
-#### 1. Verifikasi Backend SignOz Dapat Dijangkau
+#### 1. Update ke Versi Terbaru (v1.2.13+) - RECOMMENDED ✅
+Sejak versi 1.2.13, masalah ini sudah **sepenuhnya diatasi**:
+
+```bash
+yarn add @echoteam/signoz-react@latest
+# atau
+npm install @echoteam/signoz-react@latest
+```
+
+**Perbaikan di v1.2.13:**
+- ✅ Error timeout **tidak muncul di console**
+- ✅ Error timeout **tidak dikirim ke server SignOz**
+- ✅ Mencegah recursive timeout
+- ✅ Dashboard SignOz bersih dari error timeout
+- ✅ Tidak mengganggu aplikasi Anda
+
+**Cara kerja:**
+- Error timeout di-filter di semua error handler (window.error, unhandledrejection, console.error, Zone.js)
+- Hanya error aplikasi yang sebenarnya yang dikirim ke SignOz
+- Timeout dikurangi menjadi 30 detik untuk fail faster
+
+#### 2. Verifikasi Backend SignOz Dapat Dijangkau
 Pastikan URL SignOz Anda benar dan dapat diakses dari browser:
 ```javascript
 // Test di browser console
@@ -28,11 +59,11 @@ fetch('http://your-signoz-url:4318/v1/traces', {
 })
 ```
 
-#### 2. Periksa CORS Configuration
+#### 3. Periksa CORS Configuration
 Pastikan backend SignOz Anda mengizinkan request dari domain frontend Anda. Lihat [BACKEND_CORS_SETUP.md](./BACKEND_CORS_SETUP.md) untuk panduan lengkap.
 
-#### 3. Tingkatkan Timeout (Recommended)
-Sejak versi 1.2.10, timeout default sudah ditingkatkan menjadi 60 detik. Jika masih timeout, Anda bisa meningkatkannya lebih lanjut:
+#### 4. Tingkatkan Timeout (Jika Diperlukan)
+Jika koneksi Anda lambat, Anda bisa meningkatkan timeout:
 
 ```javascript
 import { initializeSignOzTracing } from '@echoteam/signoz-react';
@@ -46,33 +77,81 @@ initializeSignOzTracing({
   batchSpanProcessorConfig: {
     maxQueueSize: 100,
     scheduledDelayMillis: 5000,
-    exportTimeoutMillis: 120000, // 120 seconds
+    exportTimeoutMillis: 60000, // 60 seconds
     maxExportBatchSize: 50
   }
 });
 ```
 
-#### 4. Suppress Timeout Errors (Jika Tidak Mengganggu)
-Sejak versi 1.2.10, timeout errors dari BatchSpanProcessor secara otomatis di-suppress untuk menghindari noise di console. Error ini biasanya aman untuk diabaikan karena spans akan di-retry atau di-queue ulang.
+#### 5. Disable SignOz Sementara (Untuk Testing)
+Jika Anda ingin menonaktifkan SignOz sementara untuk testing:
 
-Jika Anda ingin melihat warning untuk timeout ini, aktifkan console logging:
 ```javascript
-initializeSignOzTracing({
-  // ... config lainnya
-  enableConsoleLog: true
-});
+// Jangan panggil initializeSignOzTracing() sama sekali
+// atau gunakan environment variable untuk mengontrol
+if (process.env.REACT_APP_ENABLE_SIGNOZ === 'true') {
+  initializeSignOzTracing({
+    // ... config
+  });
+}
 ```
 
-#### 5. Gunakan Network yang Lebih Stabil
+#### 6. Gunakan Network yang Lebih Stabil
 Jika Anda mengalami timeout secara konsisten, pertimbangkan:
 - Menggunakan koneksi internet yang lebih stabil
 - Mengurangi ukuran batch dengan `maxExportBatchSize`
 - Meningkatkan `scheduledDelayMillis` untuk mengirim spans lebih jarang
 
 ### Catatan Penting
+- **Sejak v1.2.13**: Timeout errors otomatis di-filter dan tidak dikirim ke SignOz
+- **Sejak v1.2.12**: Timeout errors otomatis di-suppress dan tidak muncul di console
 - Timeout errors biasanya tidak mempengaruhi fungsionalitas aplikasi Anda
 - Spans yang gagal dikirim akan di-queue ulang dan dicoba lagi
 - Jika backend SignOz tidak dapat dijangkau sama sekali, spans akan di-drop setelah queue penuh
+- Error ini aman untuk diabaikan jika aplikasi Anda berjalan normal
+
+### Debugging
+Jika Anda ingin melihat detail timeout untuk debugging, aktifkan console logging:
+```javascript
+initializeSignOzTracing({
+  // ... config lainnya
+  enableConsoleLog: true
+});
+```
+
+Anda akan melihat warning: `[SignOz] Span export timeout detected (safe to ignore - not tracking this error)`
+
+### Verifikasi Perbaikan
+Setelah update ke v1.2.13, verifikasi bahwa error sudah hilang:
+
+1. **Clear cache browser:**
+   ```
+   Ctrl+Shift+R (Windows/Linux)
+   Cmd+Shift+R (Mac)
+   ```
+
+2. **Cek versi package:**
+   ```bash
+   yarn list @echoteam/signoz-react
+   # atau
+   npm list @echoteam/signoz-react
+   ```
+   Pastikan versi adalah `1.2.13` atau lebih baru
+
+3. **Rebuild aplikasi:**
+   ```bash
+   yarn build
+   # atau
+   npm run build
+   ```
+
+4. **Cek console browser:**
+   - Error timeout seharusnya tidak muncul lagi
+   - Aplikasi berjalan normal tanpa gangguan
+
+5. **Cek SignOz dashboard:**
+   - Error timeout seharusnya tidak muncul di dashboard
+   - Hanya error aplikasi yang sebenarnya yang tercatat
 
 ---
 

package/dist/index.d.ts

@@ -24,6 +24,8 @@ interface SignOzConfig {
     enableConsoleLog?: boolean;
     enableWebSocketLogging?: boolean;
     logWebSocketMessages?: boolean;
+    trackNetworkErrors?: boolean;
+    ignoreNetworkErrorUrls?: (string | RegExp)[];
 }
 declare global {
     interface Window {

package/dist/index.esm.js

@@ -15548,10 +15548,77 @@ function addXHRLogging(config) {
     };
 }
 // Fungsi untuk menambahkan error tracking
-function addErrorTracking(enableConsoleLog = false) {
+function addErrorTracking(config) {
+    // Helper function to check if URL should be ignored
+    const shouldIgnoreUrl = (url) => {
+        if (!url)
+            return false;
+        return config.ignoreNetworkErrorUrls.some(pattern => {
+            if (pattern instanceof RegExp) {
+                return pattern.test(url);
+            }
+            return url.includes(pattern);
+        });
+    };
     // Track unhandled errors
     window.addEventListener('error', (event) => {
-        var _a;
+        var _a, _b;
+        // Skip SignOz internal timeout errors and network errors
+        const errorMessage = event.message || '';
+        const errorStack = ((_a = event.error) === null || _a === void 0 ? void 0 : _a.stack) || '';
+        const errorFilename = event.filename || '';
+        const isSignOzTimeout = ((errorMessage.includes('Timeout') || errorMessage.includes('timeout') || errorMessage.includes('ETIMEDOUT')) &&
+            (errorMessage.includes('BatchSpanProcessor') ||
+                errorMessage.includes('OTLP') ||
+                errorMessage.includes('exporter') ||
+                errorStack.includes('BatchSpanProcessor') ||
+                errorStack.includes('OTLPTraceExporter') ||
+                errorStack.includes('zone.js') ||
+                errorStack.includes('SignOz') ||
+                errorFilename.includes('zone.js')));
+        // Also skip generic timeout errors that might be from SignOz
+        const isGenericTimeout = (errorMessage === 'Timeout' ||
+            errorMessage === 'timeout' ||
+            (errorMessage.includes('Timeout') && errorStack.includes('zone.js')));
+        if (isSignOzTimeout || isGenericTimeout) {
+            if (config.enableConsoleLog) {
+                console.warn('[SignOz] Span export timeout detected (safe to ignore - not tracking this error)');
+            }
+            event.preventDefault(); // Prevent the error from propagating
+            event.stopPropagation(); // Stop event bubbling
+            event.stopImmediatePropagation(); // Stop other listeners
+            return;
+        }
+        // Skip network errors if trackNetworkErrors is disabled
+        if (!config.trackNetworkErrors) {
+            const isNetworkError = (errorMessage.includes('XHR request failed') ||
+                errorMessage.includes('Failed to fetch') ||
+                errorMessage.includes('Network request failed') ||
+                errorMessage.includes('NetworkError') ||
+                errorMessage.includes('net::ERR_') ||
+                errorStack.includes('XMLHttpRequest') ||
+                errorStack.includes('fetch'));
+            if (isNetworkError) {
+                if (config.enableConsoleLog) {
+                    console.warn('[SignOz] Network error detected (not tracking - trackNetworkErrors is disabled)');
+                }
+                event.preventDefault();
+                event.stopPropagation();
+                event.stopImmediatePropagation();
+                return;
+            }
+        }
+        // Check if URL should be ignored
+        const errorUrl = event.filename || '';
+        if (shouldIgnoreUrl(errorUrl)) {
+            if (config.enableConsoleLog) {
+                console.warn('[SignOz] Error from ignored URL (not tracking):', errorUrl);
+            }
+            event.preventDefault();
+            event.stopPropagation();
+            event.stopImmediatePropagation();
+            return;
+        }
         const tracer = trace.getTracer('error-tracker');
         const span = tracer.startSpan('Unhandled Error');
         span.setAttribute('error.type', 'unhandled');
@@ -15570,13 +15637,13 @@ function addErrorTracking(enableConsoleLog = false) {
             span.setAttribute('error.name', event.error.name || 'Error');
         }
         span.setStatus({ code: SpanStatusCode.ERROR, message: event.message });
-        if (enableConsoleLog) {
+        if (config.enableConsoleLog) {
             console.error('[SignOz] Unhandled Error:', {
                 message: event.message,
                 filename: event.filename,
                 lineno: event.lineno,
                 colno: event.colno,
-                stack: (_a = event.error) === null || _a === void 0 ? void 0 : _a.stack,
+                stack: (_b = event.error) === null || _b === void 0 ? void 0 : _b.stack,
                 page: window.location.pathname
             });
         }
@@ -15588,17 +15655,45 @@ function addErrorTracking(enableConsoleLog = false) {
         const reason = String(event.reason);
         const stack = event.reason instanceof Error ? (event.reason.stack || '') : '';
         // Check if this is a SignOz internal timeout error
-        const isSignOzTimeout = (reason.includes('Timeout') &&
+        const isSignOzTimeout = ((reason.includes('Timeout') || reason.includes('timeout') || reason.includes('ETIMEDOUT')) &&
             (reason.includes('BatchSpanProcessor') ||
+                reason.includes('OTLP') ||
+                reason.includes('exporter') ||
                 stack.includes('BatchSpanProcessor') ||
+                stack.includes('OTLPTraceExporter') ||
                 stack.includes('zone.js')));
-        if (isSignOzTimeout) {
-            if (enableConsoleLog) {
+        // Also skip generic timeout errors that might be from SignOz
+        const isGenericTimeout = (reason === 'Timeout' ||
+            reason === 'timeout' ||
+            (reason.includes('Timeout') && stack.includes('zone.js')));
+        if (isSignOzTimeout || isGenericTimeout) {
+            if (config.enableConsoleLog) {
                 console.warn('[SignOz] Span export timeout (this is usually safe to ignore - check if SignOz endpoint is reachable)');
             }
             event.preventDefault(); // Prevent the error from being logged
+            event.stopPropagation(); // Stop event bubbling
+            event.stopImmediatePropagation(); // Stop other listeners
             return;
         }
+        // Skip network errors if trackNetworkErrors is disabled
+        if (!config.trackNetworkErrors) {
+            const isNetworkError = (reason.includes('XHR request failed') ||
+                reason.includes('Failed to fetch') ||
+                reason.includes('Network request failed') ||
+                reason.includes('NetworkError') ||
+                reason.includes('net::ERR_') ||
+                stack.includes('XMLHttpRequest') ||
+                stack.includes('fetch'));
+            if (isNetworkError) {
+                if (config.enableConsoleLog) {
+                    console.warn('[SignOz] Network error in promise (not tracking - trackNetworkErrors is disabled)');
+                }
+                event.preventDefault();
+                event.stopPropagation();
+                event.stopImmediatePropagation();
+                return;
+            }
+        }
         const tracer = trace.getTracer('error-tracker');
         const span = tracer.startSpan('Unhandled Promise Rejection');
         span.setAttribute('error.type', 'unhandled_rejection');
@@ -15615,7 +15710,7 @@ function addErrorTracking(enableConsoleLog = false) {
             span.setAttribute('error.name', event.reason.name || 'Error');
         }
         span.setStatus({ code: SpanStatusCode.ERROR, message: String(event.reason) });
-        if (enableConsoleLog) {
+        if (config.enableConsoleLog) {
             console.error('[SignOz] Unhandled Promise Rejection:', event.reason, 'on page', window.location.pathname);
         }
         span.end();
@@ -15629,14 +15724,39 @@ function addErrorTracking(enableConsoleLog = false) {
                 // Skip SignOz internal timeout errors
                 const errorMessage = error.message || String(error);
                 const errorStack = error.stack || '';
-                const isSignOzTimeout = (errorMessage.includes('Timeout') &&
-                    (errorStack.includes('BatchSpanProcessor') || errorStack.includes('zone.js')));
-                if (isSignOzTimeout) {
-                    if (enableConsoleLog) {
+                const isSignOzTimeout = ((errorMessage.includes('Timeout') || errorMessage.includes('timeout') || errorMessage.includes('ETIMEDOUT')) &&
+                    (errorMessage.includes('BatchSpanProcessor') ||
+                        errorMessage.includes('OTLP') ||
+                        errorMessage.includes('exporter') ||
+                        errorStack.includes('BatchSpanProcessor') ||
+                        errorStack.includes('OTLPTraceExporter') ||
+                        errorStack.includes('zone.js')));
+                // Also skip generic timeout errors
+                const isGenericTimeout = (errorMessage === 'Timeout' ||
+                    errorMessage === 'timeout' ||
+                    (errorMessage.includes('Timeout') && errorStack.includes('zone.js')));
+                if (isSignOzTimeout || isGenericTimeout) {
+                    if (config.enableConsoleLog) {
                         console.warn('[SignOz] Zone.js caught span export timeout (safe to ignore)');
                     }
                     return; // Don't track this error
                 }
+                // Skip network errors if trackNetworkErrors is disabled
+                if (!config.trackNetworkErrors) {
+                    const isNetworkError = (errorMessage.includes('XHR request failed') ||
+                        errorMessage.includes('Failed to fetch') ||
+                        errorMessage.includes('Network request failed') ||
+                        errorMessage.includes('NetworkError') ||
+                        errorMessage.includes('net::ERR_') ||
+                        errorStack.includes('XMLHttpRequest') ||
+                        errorStack.includes('fetch'));
+                    if (isNetworkError) {
+                        if (config.enableConsoleLog) {
+                            console.warn('[SignOz] Zone.js caught network error (not tracking - trackNetworkErrors is disabled)');
+                        }
+                        return;
+                    }
+                }
                 const tracer = trace.getTracer('error-tracker');
                 const span = tracer.startSpan('Zone.js Error');
                 span.setAttribute('error.type', 'zone_error');
@@ -15652,7 +15772,7 @@ function addErrorTracking(enableConsoleLog = false) {
                 }
                 span.recordException(error);
                 span.setStatus({ code: SpanStatusCode.ERROR, message: error.message || String(error) });
-                if (enableConsoleLog) {
+                if (config.enableConsoleLog) {
                     console.error('[SignOz] Zone.js Error:', error, 'on page', window.location.pathname);
                 }
                 span.end();
@@ -15666,6 +15786,25 @@ function addErrorTracking(enableConsoleLog = false) {
     console.error = function (...args) {
         // Check if this is a React error
         const errorMessage = args.map(arg => String(arg)).join(' ');
+        // Skip SignOz internal errors
+        const isSignOzError = (errorMessage.includes('Timeout') &&
+            (errorMessage.includes('BatchSpanProcessor') ||
+                errorMessage.includes('zone.js') ||
+                errorMessage.includes('SignOz')));
+        if (isSignOzError) {
+            // Just call original console.error without tracking
+            return originalConsoleError.apply(console, args);
+        }
+        // Skip network errors if trackNetworkErrors is disabled
+        const isNetworkError = (errorMessage.includes('XHR request failed') ||
+            errorMessage.includes('Failed to fetch') ||
+            errorMessage.includes('Network request failed') ||
+            errorMessage.includes('NetworkError') ||
+            errorMessage.includes('net::ERR_'));
+        if (isNetworkError && !config.trackNetworkErrors) {
+            // Just call original console.error without tracking
+            return originalConsoleError.apply(console, args);
+        }
         if (errorMessage.includes('React') || errorMessage.includes('TypeError') || errorMessage.includes('Uncaught')) {
             const tracer = trace.getTracer('error-tracker');
             const span = tracer.startSpan('Console Error');
@@ -15995,6 +16134,34 @@ function addWebSocketLogging(config) {
  */
 function initializeSignOzTracing(config) {
     try {
+        // Install global error suppression for SignOz timeout errors FIRST
+        // This must be done before any other initialization
+        const originalWindowError = window.onerror;
+        window.onerror = function (message, source, lineno, colno, error) {
+            const errorMessage = String(message);
+            const errorStack = (error === null || error === void 0 ? void 0 : error.stack) || '';
+            // Suppress SignOz timeout errors globally
+            const isSignOzTimeout = ((errorMessage.includes('Timeout') || errorMessage.includes('timeout') || errorMessage.includes('ETIMEDOUT')) &&
+                (errorMessage.includes('BatchSpanProcessor') ||
+                    errorMessage.includes('OTLP') ||
+                    errorMessage.includes('exporter') ||
+                    errorStack.includes('BatchSpanProcessor') ||
+                    errorStack.includes('OTLPTraceExporter') ||
+                    errorStack.includes('zone.js') ||
+                    (source === null || source === void 0 ? void 0 : source.includes('zone.js'))));
+            const isGenericTimeout = (errorMessage === 'Timeout' ||
+                errorMessage === 'timeout' ||
+                (errorMessage.includes('Timeout') && errorStack.includes('zone.js')));
+            if (isSignOzTimeout || isGenericTimeout) {
+                // Suppress completely - don't log, don't propagate
+                return true; // Returning true prevents default error handling
+            }
+            // Call original handler for other errors
+            if (originalWindowError) {
+                return originalWindowError.call(window, message, source, lineno, colno, error);
+            }
+            return false;
+        };
         // Gabungkan konfigurasi dari parameter, process.env, dan window
         const effectiveConfig = {
             serviceName: (config === null || config === void 0 ? void 0 : config.serviceName) || getConfigValue('REACT_APP_SIGNOZ_SERVICE_NAME'),
@@ -16009,9 +16176,9 @@ function initializeSignOzTracing(config) {
             })(),
             batchSpanProcessorConfig: (config === null || config === void 0 ? void 0 : config.batchSpanProcessorConfig) || {
                 maxQueueSize: 100,
-                scheduledDelayMillis: 5000,
-                exportTimeoutMillis: 60000, // Increased to 60 seconds
-                maxExportBatchSize: 50 // Smaller batches to avoid timeouts
+                scheduledDelayMillis: 3000, // Kirim lebih cepat (3 detik)
+                exportTimeoutMillis: 10000, // Timeout lebih pendek (10 detik)
+                maxExportBatchSize: 30 // Batch lebih kecil untuk menghindari timeout
             },
             allowedOrigins: (config === null || config === void 0 ? void 0 : config.allowedOrigins) || parseAllowedOrigins(getConfigValue('REACT_APP_SIGNOZ_ALLOWED_ORIGINS')),
             enableRequestLogging: (config === null || config === void 0 ? void 0 : config.enableRequestLogging) !== undefined ? config.enableRequestLogging : (getConfigValue('REACT_APP_SIGNOZ_ENABLE_REQUEST_LOGGING') === 'true' || true),
@@ -16023,7 +16190,9 @@ function initializeSignOzTracing(config) {
             enableNavigationTracking: (config === null || config === void 0 ? void 0 : config.enableNavigationTracking) !== undefined ? config.enableNavigationTracking : (getConfigValue('REACT_APP_SIGNOZ_ENABLE_NAVIGATION_TRACKING') === 'true'),
             enableConsoleLog: (config === null || config === void 0 ? void 0 : config.enableConsoleLog) !== undefined ? config.enableConsoleLog : (getConfigValue('REACT_APP_SIGNOZ_ENABLE_CONSOLE_LOG') === 'true'),
             enableWebSocketLogging: (config === null || config === void 0 ? void 0 : config.enableWebSocketLogging) !== undefined ? config.enableWebSocketLogging : (getConfigValue('REACT_APP_SIGNOZ_ENABLE_WEBSOCKET_LOGGING') === 'true'),
-            logWebSocketMessages: (config === null || config === void 0 ? void 0 : config.logWebSocketMessages) !== undefined ? config.logWebSocketMessages : (getConfigValue('REACT_APP_SIGNOZ_LOG_WEBSOCKET_MESSAGES') === 'true')
+            logWebSocketMessages: (config === null || config === void 0 ? void 0 : config.logWebSocketMessages) !== undefined ? config.logWebSocketMessages : (getConfigValue('REACT_APP_SIGNOZ_LOG_WEBSOCKET_MESSAGES') === 'true'),
+            trackNetworkErrors: (config === null || config === void 0 ? void 0 : config.trackNetworkErrors) !== undefined ? config.trackNetworkErrors : (getConfigValue('REACT_APP_SIGNOZ_TRACK_NETWORK_ERRORS') === 'true'),
+            ignoreNetworkErrorUrls: (config === null || config === void 0 ? void 0 : config.ignoreNetworkErrorUrls) || []
         };
         // Validasi konfigurasi
         const { isValid, missingFields } = validateConfig(effectiveConfig);
@@ -16039,17 +16208,53 @@ function initializeSignOzTracing(config) {
             'deployment.environment': effectiveConfig.environment,
             'service.namespace': effectiveConfig.serviceNamespace,
         });
-        // Set up the OTLP trace exporter
+        // Set up the OTLP trace exporter with error handling
         const exporter = new OTLPTraceExporter({
             url: effectiveConfig.url,
             headers: effectiveConfig.headers,
-            timeoutMillis: 60000 // Set exporter timeout to 60 seconds
+            timeoutMillis: 10000 // Timeout lebih pendek (10 detik)
         });
+        // Wrap exporter to suppress timeout errors completely
+        const originalExport = exporter.export.bind(exporter);
+        exporter.export = function (spans, resultCallback) {
+            // Wrap in try-catch to prevent any errors from propagating
+            try {
+                originalExport(spans, (result) => {
+                    // Suppress ALL errors to prevent console noise and Zone.js catching them
+                    if (result.error) {
+                        const errorMessage = String(result.error);
+                        if (errorMessage.includes('Timeout') || errorMessage.includes('timeout') || errorMessage.includes('ETIMEDOUT')) {
+                            if (effectiveConfig.enableConsoleLog) {
+                                console.warn('[SignOz] Span export timeout - check if SignOz endpoint is reachable:', effectiveConfig.url);
+                            }
+                            // Call callback with success to prevent error propagation
+                            resultCallback({ code: 0 });
+                            return;
+                        }
+                        // For other errors, also suppress but log if console logging is enabled
+                        if (effectiveConfig.enableConsoleLog) {
+                            console.warn('[SignOz] Span export error (suppressed):', errorMessage);
+                        }
+                        resultCallback({ code: 0 });
+                        return;
+                    }
+                    resultCallback(result);
+                });
+            }
+            catch (error) {
+                // Catch any synchronous errors and suppress them
+                if (effectiveConfig.enableConsoleLog) {
+                    console.warn('[SignOz] Span export exception (suppressed):', error);
+                }
+                resultCallback({ code: 0 });
+            }
+        };
         // Set up the span processor with configuration
         const processor = new BatchSpanProcessor(exporter, {
             maxQueueSize: effectiveConfig.batchSpanProcessorConfig.maxQueueSize,
             scheduledDelayMillis: effectiveConfig.batchSpanProcessorConfig.scheduledDelayMillis,
-            exportTimeoutMillis: effectiveConfig.batchSpanProcessorConfig.exportTimeoutMillis
+            exportTimeoutMillis: effectiveConfig.batchSpanProcessorConfig.exportTimeoutMillis,
+            maxExportBatchSize: effectiveConfig.batchSpanProcessorConfig.maxExportBatchSize
         });
         // Create and configure the WebTracerProvider
         const provider = new WebTracerProvider({
@@ -16106,7 +16311,11 @@ function initializeSignOzTracing(config) {
         }
         // Tambahkan error tracking
         if (effectiveConfig.enableErrorTracking) {
-            addErrorTracking(effectiveConfig.enableConsoleLog);
+            addErrorTracking({
+                enableConsoleLog: effectiveConfig.enableConsoleLog,
+                trackNetworkErrors: effectiveConfig.trackNetworkErrors,
+                ignoreNetworkErrorUrls: effectiveConfig.ignoreNetworkErrorUrls
+            });
         }
         // Tambahkan navigation tracking
         if (effectiveConfig.enableNavigationTracking) {
@@ -16134,7 +16343,8 @@ function initializeSignOzTracing(config) {
             enableErrorTracking: effectiveConfig.enableErrorTracking,
             enableNavigationTracking: effectiveConfig.enableNavigationTracking,
             enableWebSocketLogging: effectiveConfig.enableWebSocketLogging,
-            logWebSocketMessages: effectiveConfig.logWebSocketMessages
+            logWebSocketMessages: effectiveConfig.logWebSocketMessages,
+            trackNetworkErrors: effectiveConfig.trackNetworkErrors
         });
         console.log('SignOz: Tracing berhasil diinisialisasi');
     }