@coralogix/react-native-plugin 0.12.0 → 0.13.0

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 0.13.0 (2026-10-07)
+
+### 🚀 Features
+
+- New `cold_hybrid` mobile vital: the time from process start until your React content is first on screen, reported once per launch next to the native `cold` start. Turning off `mobileVitals.cold` turns off both. On Android it isn't reported in bridgeless mode.
+
 ## 0.12.0 (2026-10-06)
 
 ### 🚀 Features

package/README.md

@@ -246,6 +246,23 @@ await CoralogixRum.init({
 });
 ```
 
+#### Cold start
+
+Two cold-start values are reported per user-visible launch:
+
+- `cold` — measured by the native SDK: process start to the first native frame.
+- `cold_hybrid` — measured by the plugin: process start to the first frame with React content
+  on screen. This is the launch time your users actually see, so it is always at least `cold`.
+
+Setting `mobileVitals.cold` (or `instrumentations.mobile_vitals`) to `false` disables both.
+Launches that start in the background (headless JS, background fetch, push) and prewarmed iOS
+launches do not report `cold_hybrid`.
+
+> [!NOTE]
+> On Android, `cold_hybrid` is not reported in bridgeless mode (the New Architecture default
+> since React Native 0.74): React Native only emits the content-appeared marker it relies on
+> when the app runs with the bridge.
+
 ### Exclude From Sampling
 
 By default, when a session is sampled out (via `sessionSampleRate`), nothing is

package/android/src/main/AndroidManifest.xml

@@ -1,2 +1,8 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
+  <application>
+    <provider
+      android:name="com.cxsdk.HybridColdStartProvider"
+      android:authorities="${applicationId}.cxsdk-hybrid-cold-start"
+      android:exported="false" />
+  </application>
 </manifest>

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

@@ -71,12 +71,18 @@ class CxSdkModule(reactContext: ReactApplicationContext) :
         config.getString("frameworkVersion") ?: ""
       else ""
 
+    val reportHybridColdStart =
+      config.hasKey("reportHybridColdStart") && config.getBoolean("reportHybridColdStart")
+
     Handler(Looper.getMainLooper()).post {
       CoralogixRum.initialize(
         application = application,
         options = options,
         framework = Framework.HybridFramework.ReactNative(rnPluginVersion)
       )
+      if (reportHybridColdStart) {
+        HybridColdStart.onSdkInitialized()
+      }
 
       promise.resolve(true)
     }

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

@@ -0,0 +1,70 @@
+package com.cxsdk
+
+import android.app.ActivityManager
+import android.content.ContentProvider
+import android.content.ContentValues
+import android.net.Uri
+import android.os.Process
+import android.os.SystemClock
+import com.coralogix.android.sdk.CoralogixRum
+import com.facebook.react.bridge.ReactMarker
+import com.facebook.react.bridge.ReactMarkerConstants
+
+/**
+ * Hybrid cold start: process start until React Native first puts content on screen.
+ * The marker fires before (or racing with) the JS `init` call, so the listener is
+ * registered from a ContentProvider at process start. Everything runs on the main
+ * thread: the marker comes from ReactRootView.onViewAdded and the module posts
+ * initialize to the main looper.
+ *
+ * React Native arms CONTENT_APPEARED only when it runs the app through the bridge,
+ * so bridgeless apps report nothing here.
+ */
+internal object HybridColdStart {
+  const val TYPE = "cold_hybrid"
+
+  private var measuredMs: Long? = null
+  private var sdkReady = false
+
+  private val listener = object : ReactMarker.MarkerListener {
+    override fun logMarker(name: ReactMarkerConstants, tag: String?, instanceKey: Int) {
+      if (name != ReactMarkerConstants.CONTENT_APPEARED) return
+      ReactMarker.removeListener(this)
+      measuredMs = SystemClock.uptimeMillis() - Process.getStartUptimeMillis()
+      reportIfReady()
+    }
+  }
+
+  fun start() = ReactMarker.addListener(listener)
+
+  fun onSdkInitialized() {
+    sdkReady = true
+    reportIfReady()
+  }
+
+  private fun reportIfReady() {
+    val ms = measuredMs ?: return
+    if (!sdkReady) return
+    measuredMs = null
+    CoralogixRum.reportMobileVitalsMeasurement(TYPE, ms.toDouble(), "ms")
+  }
+}
+
+class HybridColdStartProvider : ContentProvider() {
+  override fun onCreate(): Boolean {
+    // A process started for headless JS, a broadcast or a service is not a user-visible
+    // launch; content appearing later in it would measure idle time, not a cold start.
+    val info = ActivityManager.RunningAppProcessInfo()
+    ActivityManager.getMyMemoryState(info)
+    if (info.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND) {
+      HybridColdStart.start()
+    }
+    return true
+  }
+
+  override fun query(uri: Uri, p: Array<String>?, s: String?, a: Array<String>?, o: String?) = null
+  override fun getType(uri: Uri) = null
+  override fun insert(uri: Uri, values: ContentValues?) = null
+  override fun delete(uri: Uri, s: String?, a: Array<String>?) = 0
+  override fun update(uri: Uri, v: ContentValues?, s: String?, a: Array<String>?) = 0
+}

package/index.cjs.js

@@ -1140,7 +1140,7 @@ function stopJsRefreshRateSampler() {
   appStateSub = null;
 }
 
-var version = "0.12.0";
+var version = "0.13.0";
 var pkg = {
 	version: version};
 
@@ -1865,7 +1865,7 @@ async function runInit(options,
 // which can call `init()` again, and a shared flag would let that nested call answer for
 // this one.
 progress) {
-  var _options$debug, _resolvedOptions$excl, _resolvedOptions$excl2;
+  var _options$debug, _resolvedOptions$excl, _resolvedOptions$excl2, _finalOptions$instrum, _finalOptions$mobileV;
   // Configure the logger before anything that can warn: the `public_key` check below, and
   // resolving the options, which normalizes `sessionSampleRate` and warns about an invalid
   // rate. Setting it any later swallowed those warnings on the first init — exactly when
@@ -1932,7 +1932,8 @@ progress) {
     frameworkVersion: pkg.version,
     networkExtraConfig: finalOptions.networkExtraConfig ? serializeNetworkCaptureRules(finalOptions.networkExtraConfig) : undefined,
     hasBeforeSend: !!finalOptions.beforeSend,
-    hasTracesExporter: !!finalOptions.tracesExporter
+    hasTracesExporter: !!finalOptions.tracesExporter,
+    reportHybridColdStart: ((_finalOptions$instrum = finalOptions.instrumentations) == null ? void 0 : _finalOptions$instrum.mobile_vitals) !== false && ((_finalOptions$mobileV = finalOptions.mobileVitals) == null ? void 0 : _finalOptions$mobileV.cold) !== false
   }));
   isInited = true;
 }

package/index.esm.js

@@ -1138,7 +1138,7 @@ function stopJsRefreshRateSampler() {
   appStateSub = null;
 }
 
-var version = "0.12.0";
+var version = "0.13.0";
 var pkg = {
 	version: version};
 
@@ -1863,7 +1863,7 @@ async function runInit(options,
 // which can call `init()` again, and a shared flag would let that nested call answer for
 // this one.
 progress) {
-  var _options$debug, _resolvedOptions$excl, _resolvedOptions$excl2;
+  var _options$debug, _resolvedOptions$excl, _resolvedOptions$excl2, _finalOptions$instrum, _finalOptions$mobileV;
   // Configure the logger before anything that can warn: the `public_key` check below, and
   // resolving the options, which normalizes `sessionSampleRate` and warns about an invalid
   // rate. Setting it any later swallowed those warnings on the first init — exactly when
@@ -1930,7 +1930,8 @@ progress) {
     frameworkVersion: pkg.version,
     networkExtraConfig: finalOptions.networkExtraConfig ? serializeNetworkCaptureRules(finalOptions.networkExtraConfig) : undefined,
     hasBeforeSend: !!finalOptions.beforeSend,
-    hasTracesExporter: !!finalOptions.tracesExporter
+    hasTracesExporter: !!finalOptions.tracesExporter,
+    reportHybridColdStart: ((_finalOptions$instrum = finalOptions.instrumentations) == null ? void 0 : _finalOptions$instrum.mobile_vitals) !== false && ((_finalOptions$mobileV = finalOptions.mobileVitals) == null ? void 0 : _finalOptions$mobileV.cold) !== false
   }));
   isInited = true;
 }

package/ios/CxSdk.mm

@@ -1,5 +1,8 @@
 #import <React/RCTBridgeModule.h>
 #import <React/RCTEventEmitter.h>
+#import <React/RCTRootView.h>
+#import <UIKit/UIKit.h>
+#import <sys/sysctl.h>
 
 @interface RCT_EXTERN_MODULE(CxSdk, RCTEventEmitter)
 
@@ -139,3 +142,49 @@ RCT_EXTERN_METHOD(endSpan:(NSString *)spanId
 }
 
 @end
+
+@interface CxSdk (HybridColdStart)
++ (void)recordHybridColdStart:(double)ms;
+@end
+
+// Records process start -> first React content on screen. RCTContentDidAppearNotification
+// is posted by both RCTRootView and Fabric's RCTSurfaceHostingProxyRootView, before or
+// racing with the JS init call, so the observer is added in +load. Must stay trivial:
+// it runs in every process of every consuming app.
+@interface CxHybridColdStartRecorder : NSObject
+@end
+
+@implementation CxHybridColdStartRecorder
+
++ (void)load
+{
+  // Prewarmed processes start long before the user launches the app.
+  if ([NSProcessInfo.processInfo.environment[@"ActivePrewarm"] isEqualToString:@"1"]) {
+    return;
+  }
+
+  __block id observer = [NSNotificationCenter.defaultCenter
+      addObserverForName:RCTContentDidAppearNotification
+                  object:nil
+                   queue:NSOperationQueue.mainQueue
+              usingBlock:^(NSNotification *note) {
+                [NSNotificationCenter.defaultCenter removeObserver:observer];
+                observer = nil;
+                // Background launches (fetch, push, location) are not a user-visible cold start.
+                if (UIApplication.sharedApplication.applicationState == UIApplicationStateBackground) {
+                  return;
+                }
+                struct kinfo_proc info;
+                size_t size = sizeof(info);
+                int mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_PID, getpid()};
+                if (sysctl(mib, 4, &info, &size, NULL, 0) != 0) {
+                  return;
+                }
+                struct timeval start = info.kp_proc.p_starttime;
+                double ms = [NSDate date].timeIntervalSince1970 * 1000.0 -
+                    (start.tv_sec * 1000.0 + start.tv_usec / 1000.0);
+                [CxSdk recordHybridColdStart:ms];
+              }];
+}
+
+@end

package/ios/CxSdk.swift

@@ -24,6 +24,22 @@ class CxSdk: RCTEventEmitter {
     return false
   }
 
+  // Hybrid cold start, measured by CxHybridColdStartRecorder in CxSdk.mm. Main thread only:
+  // the content-appeared notification is posted on main and initialize hops there.
+  private static var hybridColdStartMs: Double?
+  private static weak var hybridColdStartRum: CoralogixRum?
+
+  @objc static func recordHybridColdStart(_ ms: Double) {
+    hybridColdStartMs = ms
+    reportHybridColdStartIfReady()
+  }
+
+  private static func reportHybridColdStartIfReady() {
+    guard let ms = hybridColdStartMs, let rum = hybridColdStartRum else { return }
+    hybridColdStartMs = nil
+    rum.reportMobileVitalsMeasurement(type: "cold_hybrid", value: ms, units: "ms")
+  }
+
   override func supportedEvents() -> [String]! {
     return ["onBeforeSend", "onTracesExport"]
   }
@@ -54,7 +70,14 @@ class CxSdk: RCTEventEmitter {
 
       let rnPluginVersion =  parameter["frameworkVersion"] as? String ?? ""
 
-      self.coralogixRum = CoralogixRum(options: options, sdkFramework: .reactNative(version: rnPluginVersion))
+      let rum = CoralogixRum(options: options, sdkFramework: .reactNative(version: rnPluginVersion))
+      self.coralogixRum = rum
+      if parameter["reportHybridColdStart"] as? Bool ?? false {
+        DispatchQueue.main.async {
+          CxSdk.hybridColdStartRum = rum
+          CxSdk.reportHybridColdStartIfReady()
+        }
+      }
       resolve("initialize success")
     } catch let error as CxSdkError {
       reject("CX_SDK_ERROR", error.localizedDescription, error)

package/package.json

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

package/src/index.d.ts

@@ -17,6 +17,7 @@ export interface CxSdkClient {
         frameworkVersion?: string;
         hasBeforeSend?: boolean;
         hasTracesExporter?: boolean;
+        reportHybridColdStart?: boolean;
     }): Promise<boolean>;
     setUserContext(userContext: UserContextConfig): void;
     getUserContext(): Promise<UserContextConfig>;