@coralogix/react-native-plugin 0.7.1 → 0.7.2

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## 0.7.2 (2026-07-20)
+
+### 🩹 Fixes
+
+- drain every beforeSend delivery during the fatal flush
+- flush crash events before fatal-error handover
+
 ## 0.7.1 (2026-07-09)
 
 ### 🩹 Fixes

package/CxSdk.podspec

@@ -16,9 +16,9 @@ Pod::Spec.new do |s|
 
   s.source_files = "ios/**/*.{h,m,mm,swift}"
 
-  s.dependency 'Coralogix','2.10.0'
-  s.dependency 'CoralogixInternal','2.10.0'
-  s.dependency 'SessionReplay','2.10.0'
+  s.dependency 'Coralogix','2.11.1'
+  s.dependency 'CoralogixInternal','2.11.1'
+  s.dependency 'SessionReplay','2.11.1'
 
   # Use install_modules_dependencies helper to install the dependencies if React Native version >=0.71.0.
   # See https://github.com/facebook/react-native/blob/febf6b7f33fdb4904669f99d795eba4c0f95d7bf/scripts/cocoapods/new_architecture.rb#L79.

package/android/build.gradle

@@ -84,7 +84,7 @@ dependencies {
   implementation "com.facebook.react:react-android"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
 
-  implementation "com.coralogix:android-sdk:2.17.1"
+  implementation "com.coralogix:android-sdk:2.18.0"
 
   testImplementation "org.jetbrains.kotlin:kotlin-test:$kotlin_version"
   testImplementation "org.mockito:mockito-core:5.12.0"

package/android/src/main/java/com/cxsdk/CxSdkModule.kt

@@ -193,6 +193,15 @@ class CxSdkModule(reactContext: ReactApplicationContext) :
     )
   }
 
+  @ReactMethod
+  override fun flushSpans(promise: Promise) {
+    // Force-flushes the batch processor and resolves once the export/upload
+    // attempt finishes — the same contract as iOS. Called by the JS fatal-error
+    // handler before it hands over to the framework's default handler, which
+    // terminates the process.
+    CoralogixRum.flush { promise.resolve("flushSpans success") }
+  }
+
   @ReactMethod
   override fun sendCxSpanData(results: ReadableArray) {
     val data = convertStrictReadableArrayToListOfMaps(results)

package/android/src/main/java/com/cxsdk/RUMClient.kt

@@ -19,6 +19,7 @@ interface RUMClient {
   fun startTimeMeasure(name: String, labels: ReadableMap?)
   fun endTimeMeasure(name: String)
   fun reportError(details: ReadableMap)
+  fun flushSpans(promise: Promise)
   fun sendCxSpanData(results: ReadableArray)
   fun reportMobileVitalsMeasurement(type: String, value: Double, units: String)
   fun reportMobileVitalsMeasurementSet(type: String, metrics: ReadableArray)

package/index.cjs.js

@@ -130,10 +130,17 @@ class CoralogixErrorInstrumentation extends instrumentation.InstrumentationBase
     const defaultHandler = ErrorUtils.getGlobalHandler();
     ErrorUtils.setGlobalHandler((error, isFatal) => {
       this.report(error, isFatal);
-      if (defaultHandler) {
-        setTimeout(() => {
-          defaultHandler(error, isFatal);
-        }, 2500);
+      if (!defaultHandler) {
+        return;
+      }
+      if (isFatal) {
+        // In release builds the default handler terminates the app (RCTFatal),
+        // killing any crash event still queued in the native batch processor —
+        // flush it out first. waitForFatalErrorFlush never rejects and is
+        // time-capped, so the handover is guaranteed.
+        waitForFatalErrorFlush().catch(() => undefined).finally(() => defaultHandler(error, isFatal));
+      } else {
+        defaultHandler(error, isFatal);
       }
     });
     this.listenToConsoleError();
@@ -537,7 +544,7 @@ function stopJsRefreshRateSampler() {
   appStateSub = null;
 }
 
-var version = "0.7.1";
+var version = "0.7.2";
 var pkg = {
 	version: version};
 
@@ -1389,6 +1396,23 @@ const parseErrorStack = error => {
     return null;
   }).filter(frame => frame !== null);
 };
+const FATAL_FLUSH_MAX_WAIT_MS = 2500;
+const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+/**
+ * Best-effort delivery of a crash before a fatal error is handed back to RN's
+ * default handler, which terminates the app in release builds. `flushSpans`
+ * force-flushes the native batch processor; the native SDK uploads crash events
+ * directly (bypassing the beforeSend round trip) and resolves once the upload
+ * attempt finishes, so awaiting it is the full crash-delivery guarantee.
+ * Never rejects; resolves within FATAL_FLUSH_MAX_WAIT_MS.
+ *
+ * @internal Used by the error instrumentation — not part of the public API.
+ */
+const waitForFatalErrorFlush = async () => {
+  const flush = Promise.resolve(CxSdk.flushSpans()).catch(e => logger.debug('flushSpans failed:', e));
+  await Promise.race([flush, delay(FATAL_FLUSH_MAX_WAIT_MS)]);
+};
 
 // Create event emitter
 const eventEmitter = new reactNative.NativeEventEmitter(CxSdk);
@@ -1445,3 +1469,4 @@ exports.CxSdk = CxSdk;
 exports.SessionReplay = SessionReplay;
 exports.attachReactNavigationObserver = attachReactNavigationObserver;
 exports.parseErrorStack = parseErrorStack;
+exports.waitForFatalErrorFlush = waitForFatalErrorFlush;

package/index.esm.js

@@ -128,10 +128,17 @@ class CoralogixErrorInstrumentation extends InstrumentationBase {
     const defaultHandler = ErrorUtils.getGlobalHandler();
     ErrorUtils.setGlobalHandler((error, isFatal) => {
       this.report(error, isFatal);
-      if (defaultHandler) {
-        setTimeout(() => {
-          defaultHandler(error, isFatal);
-        }, 2500);
+      if (!defaultHandler) {
+        return;
+      }
+      if (isFatal) {
+        // In release builds the default handler terminates the app (RCTFatal),
+        // killing any crash event still queued in the native batch processor —
+        // flush it out first. waitForFatalErrorFlush never rejects and is
+        // time-capped, so the handover is guaranteed.
+        waitForFatalErrorFlush().catch(() => undefined).finally(() => defaultHandler(error, isFatal));
+      } else {
+        defaultHandler(error, isFatal);
       }
     });
     this.listenToConsoleError();
@@ -535,7 +542,7 @@ function stopJsRefreshRateSampler() {
   appStateSub = null;
 }
 
-var version = "0.7.1";
+var version = "0.7.2";
 var pkg = {
 	version: version};
 
@@ -1387,6 +1394,23 @@ const parseErrorStack = error => {
     return null;
   }).filter(frame => frame !== null);
 };
+const FATAL_FLUSH_MAX_WAIT_MS = 2500;
+const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+/**
+ * Best-effort delivery of a crash before a fatal error is handed back to RN's
+ * default handler, which terminates the app in release builds. `flushSpans`
+ * force-flushes the native batch processor; the native SDK uploads crash events
+ * directly (bypassing the beforeSend round trip) and resolves once the upload
+ * attempt finishes, so awaiting it is the full crash-delivery guarantee.
+ * Never rejects; resolves within FATAL_FLUSH_MAX_WAIT_MS.
+ *
+ * @internal Used by the error instrumentation — not part of the public API.
+ */
+const waitForFatalErrorFlush = async () => {
+  const flush = Promise.resolve(CxSdk.flushSpans()).catch(e => logger.debug('flushSpans failed:', e));
+  await Promise.race([flush, delay(FATAL_FLUSH_MAX_WAIT_MS)]);
+};
 
 // Create event emitter
 const eventEmitter = new NativeEventEmitter(CxSdk);
@@ -1433,4 +1457,4 @@ const subscription = eventEmitter.addListener('onBeforeSend', events => {
   }
 });
 
-export { CoralogixCustomSpan, CoralogixCustomTracer, CoralogixDomain, CoralogixGlobalSpan, CoralogixLogSeverity, CoralogixRum, CxSdk, SessionReplay, attachReactNavigationObserver, parseErrorStack };
+export { CoralogixCustomSpan, CoralogixCustomTracer, CoralogixDomain, CoralogixGlobalSpan, CoralogixLogSeverity, CoralogixRum, CxSdk, SessionReplay, attachReactNavigationObserver, parseErrorStack, waitForFatalErrorFlush };

package/ios/CxSdk.mm

@@ -64,6 +64,9 @@ RCT_EXTERN_METHOD(reportNetworkRequest:(NSDictionary *)networkRequestDictionary
                   withResolver:(RCTPromiseResolveBlock)resolve
                   withRejecter:(RCTPromiseRejectBlock)reject)
 
+RCT_EXTERN_METHOD(flushSpans:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
 RCT_EXTERN_METHOD(sendCxSpanData:(NSArray *)beforeSendResults
                   withResolver:(RCTPromiseResolveBlock)resolve
                   withRejecter:(RCTPromiseRejectBlock)reject)

package/ios/CxSdk.swift

@@ -249,6 +249,24 @@ class CxSdk: RCTEventEmitter {
     resolve("reportError success")
   }
 
+  @objc(flushSpans:withRejecter:)
+  func flushSpans(resolve: @escaping RCTPromiseResolveBlock,
+                  reject: @escaping RCTPromiseRejectBlock) -> Void {
+    // Force-flushes the batch processor and resolves once the export/upload
+    // attempt finishes — the same public SDK API the Android bridge calls.
+    // Invoked by the JS fatal-error handler before it hands over to RN's default
+    // handler, which terminates the process in release builds. `flush` handles
+    // its own threading and always invokes completion (immediately when the SDK
+    // is not initialized), so callers never hang.
+    guard let coralogixRum else {
+      resolve("flushSpans success")
+      return
+    }
+    coralogixRum.flush {
+      resolve("flushSpans success")
+    }
+  }
+
   @objc(sendCxSpanData:withResolver:withRejecter:)
   func sendCxSpanData(beforeSendResults: NSArray,
                       resolve:RCTPromiseResolveBlock,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coralogix/react-native-plugin",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "description": "Official Coralogix React Native plugin",
   "license": "Apache-2.0",
   "author": "Coralogix",

package/src/index.d.ts

@@ -25,6 +25,14 @@ interface CxSdkClient {
     endTimeMeasure(name: string): void;
     reportError(details: Record<string, unknown>): void;
     reportNetworkRequest(details: NetworkRequestDetails): void;
+    /**
+     * Forces immediate export of natively queued telemetry. iOS drains the batch
+     * processor and resolves after the upload attempt; Android resolves
+     * immediately WITHOUT flushing (the native SDK exposes no flush API yet), so
+     * a resolved promise must not be read as delivery there — see
+     * waitForFatalErrorFlush for the Android fallback.
+     */
+    flushSpans(): Promise<string>;
     shutdown(): Promise<boolean>;
     createNewSession(): Promise<boolean>;
     sendCxSpanData(results: CxSpan[]): void;
@@ -56,6 +64,17 @@ export declare const CxSdk: CxSdkClient;
 export declare const CoralogixRum: CoralogixOtelWebType;
 export declare const SessionReplay: SessionReplayType;
 export declare const parseErrorStack: (error: Error) => CoralogixStackFrame[];
+/**
+ * Best-effort delivery of a crash before a fatal error is handed back to RN's
+ * default handler, which terminates the app in release builds. `flushSpans`
+ * force-flushes the native batch processor; the native SDK uploads crash events
+ * directly (bypassing the beforeSend round trip) and resolves once the upload
+ * attempt finishes, so awaiting it is the full crash-delivery guarantee.
+ * Never rejects; resolves within FATAL_FLUSH_MAX_WAIT_MS.
+ *
+ * @internal Used by the error instrumentation — not part of the public API.
+ */
+export declare const waitForFatalErrorFlush: () => Promise<void>;
 export { type ApplicationContextConfig } from './model/ApplicationContextConfig';
 export { type ViewContextConfig } from './model/ViewContextConfig';
 export { CoralogixDomain } from './model/CoralogixDomain';