@posthog/react-native-plugin 2.12.0 → 2.12.2

package/android/build.gradle

@@ -91,7 +91,7 @@ dependencies {
   //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-native:+"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-  implementation "com.posthog:posthog-android:3.71.1"
+  implementation "com.posthog:posthog-android:3.71.2"
 
   testImplementation "junit:junit:4.13.2"
   testImplementation "org.json:json:20250517"

package/android/src/main/java/com/posthogreactnativeplugin/PosthogReactNativePluginModule.kt

@@ -17,6 +17,7 @@ import com.facebook.react.common.JavascriptException
 import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.posthog.PostHog
 import com.posthog.PostHogConfig
+import com.posthog.PostHogEvent
 import com.posthog.android.PostHogAndroid
 import com.posthog.android.PostHogAndroidConfig
 import com.posthog.android.replay.PostHogReplayIntegration
@@ -171,6 +172,7 @@ class PosthogReactNativePluginModule(
               // React Native rethrows fatal JS errors natively as JavascriptException.
               // The JS layer already captured them, so drop the native duplicate.
               errorTrackingConfig.ignoredExceptionTypes.add(JavascriptException::class.java)
+              addBeforeSend { restoreJsFatalCaptureProperties(it) }
 
               // Always apply the session replay configuration so that recording started later
               // (e.g. startRecording or a linked feature flag) uses the right mode and masking;
@@ -456,12 +458,14 @@ class PosthogReactNativePluginModule(
       // ReadableMap.toHashMap() is HashMap<String, Any?>; the native API takes Map<String, Any>?.
       @Suppress("UNCHECKED_CAST")
       val nativeProperties = properties.toHashMap() as Map<String, Any>
-      PostHog.capture(
-        event = "\$exception",
-        distinctId = distinctId.takeIf { it.isNotEmpty() },
-        properties = nativeProperties,
-        timestamp = parsedTimestamp,
-      )
+      withJsFatalCaptureProperties(nativeProperties) {
+        PostHog.capture(
+          event = "\$exception",
+          distinctId = distinctId.takeIf { it.isNotEmpty() },
+          properties = nativeProperties,
+          timestamp = parsedTimestamp,
+        )
+      }
       promise.resolve(null)
     } catch (e: Throwable) {
       logError("captureFatalException", e)
@@ -722,6 +726,49 @@ class PosthogReactNativePluginModule(
   }
 }
 
+// posthog-android computes these from its own state, which JS never syncs (the app's
+// `personProfiles` mode, identify, person processing started by `group()` and friends), and
+// newer versions no longer let caller properties override them. JS decided them for its fatal
+// crash, so its values stand.
+private val JS_OWNED_FATAL_CAPTURE_KEYS = listOf("\$process_person_profile", "\$is_identified")
+
+// Set only while the JS layer's own fatal capture runs; posthog-android runs `beforeSend`
+// on the calling thread, so nothing else it emits sees these properties.
+private val jsFatalCaptureProperties = ThreadLocal<Map<String, Any>?>()
+
+internal fun <T> withJsFatalCaptureProperties(
+  properties: Map<String, Any>,
+  block: () -> T,
+): T {
+  jsFatalCaptureProperties.set(properties)
+  try {
+    return block()
+  } finally {
+    jsFatalCaptureProperties.remove()
+  }
+}
+
+internal fun restoreJsFatalCaptureProperties(event: PostHogEvent): PostHogEvent {
+  val jsProperties = jsFatalCaptureProperties.get()
+  if (event.event != "\$exception" || jsProperties == null) {
+    return event
+  }
+  for (key in JS_OWNED_FATAL_CAPTURE_KEYS) {
+    if (!jsProperties.containsKey(key)) {
+      continue
+    }
+    // The JS map can hold nulls despite its type (`toHashMap()`); a null is omitted on the
+    // wire, so drop native's value rather than send it.
+    val value: Any? = jsProperties[key]
+    if (value == null) {
+      event.properties?.remove(key)
+    } else {
+      event.properties?.put(key, value)
+    }
+  }
+  return event
+}
+
 // The JS layer sends an ISO-8601 UTC timestamp (`Date#toISOString`). Parse it explicitly
 // rather than trusting a locale-dependent default, and treat anything unparseable as a
 // caller error: silently substituting "now" would attribute the crash to the wrong instant.

package/ios/PosthogReactNativePlugin.swift

@@ -274,9 +274,9 @@ public class PosthogReactNativePlugin: RCTEventEmitter {
                 // `buildProperties` keeps its own value on a key clash (`{ current, _ in
                 // current }`), so native's enrichment silently wins over what JS decided —
                 // `$process_person_profile` from `personProfiles: 'never'`, or any value the
-                // app's `before_send` rewrote. Put the JS-approved values back. Android has
-                // the opposite precedence (`putAll` after its own context), so this keeps the
-                // two platforms agreeing.
+                // app's `before_send` rewrote. Put the JS-approved values back. On Android,
+                // caller properties already win apart from SDK debug properties, so the
+                // module there only restores `$process_person_profile` and `$is_identified`.
                 for (key, value) in jsProperties {
                     event.properties[key] = value
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@posthog/react-native-plugin",
-  "version": "2.12.0",
+  "version": "2.12.2",
   "description": "PostHog React Native plugin for iOS and Android integrations",
   "source": "./src/index.tsx",
   "main": "./lib/commonjs/index.js",