@debugbundle/sdk-react-native 1.1.0 → 1.2.0

package/CHANGELOG.md

@@ -0,0 +1,35 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## Unreleased
+
+## 1.2.0 - 2026-07-29
+
+- Preserve React Native SDK identity, original JavaScript error fields, service, correlation, context, probes, and mobile metadata through additive Android and Swift external-event APIs.
+- Compose JavaScript request observations with native capture policy, remote probes, trigger tokens, queue/transport/redaction settings, headers, sampling, and probe configuration.
+- Normalize integer-valued JavaScript numbers recursively at the Android bridge so native request capture policy and integer envelope fields retain their canonical types.
+- Added the universal `beforeSend` hook, a committed npm lockfile, frozen installs, npm/pnpm/Yarn clean-package smokes, Android/iOS runtime delivery lanes, and Expo development-build verification.
+- Coordinate native Android artifacts explicitly during clean Android and Expo builds so source validation never resolves an unrelated published native version.
+- Resolve native modules through Metro-visible React Native imports, provide the generated iOS TurboModule implementation for New Architecture apps, preserve scalar context through an object-safe additive bridge, and retain merged app context on canonical request envelopes.
+- Added a real RN 0.85 New Architecture iOS simulator smoke that verifies exception and failed-request delivery through the packed npm package, native Swift queue, and HTTP ingestion acknowledgement.
+- Prepare the coordinated `1.2.0` source line with Android/Swift `1.2` requirements, enforce per-file TypeScript coverage, and block npm publication until clean Android and iOS apps compile against the published native artifacts.
+- Add bare React Native 0.85 Android and Expo SDK 57 / React Native 0.86 Android end-to-end build verification, including consumer-safe Kotlin metadata validation.
+- Add repository-local Android Java, Swift, and Objective-C++ wrapper tests and
+  enforce at least 80% line coverage for every handwritten native bridge
+  source in Make and CI.
+- Preserve React Native 0.76 New Architecture codegen discovery by exporting
+  package metadata, accept both generated iOS header layouts, and give
+  unaccelerated Android runtime smokes enough time and diagnostics to
+  distinguish slow startup from bridge or ingestion failures.
+- Preserve the legacy arbitrary-value Android `setContext` bridge through
+  React Native's New Architecture-compatible `Dynamic` type so module parsing
+  cannot crash the host process before initialization.
+
+## 1.1.0
+
+- Added path-scoped immediate client-error promotion while retaining context-only handling for unpromoted client errors.
+
+## 1.0.0
+
+- Declared the React Native Android/iOS package line stable.

package/DebugBundleReactNative.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
   s.name         = "DebugBundleReactNative"
-  s.version      = "1.1.0"
+  s.version      = "1.2.0"
   s.summary      = "React Native wrapper for the DebugBundle mobile SDKs."
   s.license      = { :type => "AGPL-3.0-only" }
   s.author       = { "DebugBundle" => "support@debugbundle.com" }
@@ -11,5 +11,6 @@ Pod::Spec.new do |s|
   s.swift_version = "5.10"
 
   s.dependency "React-Core"
-  s.dependency "DebugBundle", "~> 1.1"
+  install_modules_dependencies(s) if defined?(install_modules_dependencies)
+  s.dependency "DebugBundle", "~> 1.2"
 end

package/README.md

@@ -16,6 +16,8 @@ Published implementation:
 - `fetch` and `XMLHttpRequest` instrumentation with target-scoped `X-DebugBundle-Trace-Id`.
 - JS-side bounded serialization and redaction before native queue persistence.
 - Android and iOS native wrappers that delegate queueing, config/status, request capture, crash/error capture, flushing, and probe trigger activation to the native SDK foundations.
+- Repository-local Android Java, Swift, and Objective-C++ wrapper tests with an
+  enforced 80% line-coverage floor for every handwritten native bridge source.
 - Clean-install React Native app smoke coverage for Android and iOS, including New Architecture codegen/autolinking.
 
 ## Runtime Support
@@ -23,9 +25,9 @@ Published implementation:
 | Lane | Support |
 | --- | --- |
 | Minimum compatibility | React Native 0.76+, React 18.2+, iOS 15+, Android minSdk 23 |
-| Recommended production | Current stable React Native 0.85.x with Hermes and the New Architecture enabled where your app supports it |
+| Recommended production | Current stable React Native 0.86.x with Hermes and the New Architecture enabled where your app supports it |
 | Installed-base compatibility | React Native 0.76 through current stable, including legacy bridge apps |
-| Rolling CI | TypeScript/package smoke, Android bridge compile on RN 0.76.9, 0.82.1, and 0.85.3, plus current-stable Android and iOS clean-app smokes |
+| Rolling CI | TypeScript/package smoke, Android bridge compile on RN 0.76.9, 0.82.1, and 0.85.3, bare iOS compatibility/current-installed-base lanes, plus Expo SDK 57 / RN 0.86 Android and iOS development builds |
 | Expo | Expo development builds and prebuild; Expo Go is degraded because it cannot load custom native modules |
 
 JSC compatibility is best-effort where the selected React Native lane still supports it. Hermes is the primary tested JavaScript engine.
@@ -129,6 +131,14 @@ export function AppNavigation() {
 
 Expo development builds and prebuild are supported through the config plugin. Expo Go cannot load the native module, so the SDK reports degraded status and does not claim durable native queueing, native crash evidence, native device context, or remote-probe parity.
 
+## Verification
+
+Run `make verify` for the TypeScript, package, and JavaScript coverage gates.
+Run `make android-test` for the Android bridge unit/coverage gate and
+`make ios-test` on macOS for the Swift and Objective-C++ bridge gates.
+`make verify-native` combines the JavaScript and available platform-native
+checks.
+
 ## Release
 
-The package publishes to npm from `v*` tags through GitHub Actions. Configure the repository secret `NPM_TOKEN`, make sure the tag matches `package.json` exactly, for example `v1.1.0`, and push the tag after the native Swift `DebugBundle` pod version referenced by `DebugBundleReactNative.podspec` is available to CocoaPods consumers.
+The package publishes to npm from `v*` tags through GitHub Actions. Configure the repository secret `NPM_TOKEN`, make sure the tag matches `package.json` exactly, for example `v1.2.0`, and push the tag only after the exact Android and Swift native dependency line referenced by this package is available to Maven Central and CocoaPods consumers. The release workflow compiles clean apps against those published artifacts before npm publication.

package/android/build.gradle

@@ -1,5 +1,6 @@
 plugins {
   id "com.android.library"
+  id "jacoco"
 }
 
 def isReactNativeHostBuild = rootProject.name != "debugbundle-react-native"
@@ -10,6 +11,7 @@ if (isReactNativeHostBuild) {
 def hostKotlinVersion = rootProject.ext.has("kotlinVersion")
   ? rootProject.ext.get("kotlinVersion")
   : "2.1.20"
+def debugBundleAndroidVersion = rootProject.findProperty("debugBundleAndroidVersion") ?: "1.2.0"
 
 android {
   namespace "com.debugbundle.reactnative"
@@ -23,15 +25,82 @@ android {
     sourceCompatibility JavaVersion.VERSION_17
     targetCompatibility JavaVersion.VERSION_17
   }
+
+  testOptions {
+    unitTests.returnDefaultValues = true
+  }
 }
 
 dependencies {
   compileOnly "com.facebook.react:react-android:${rootProject.findProperty("reactNativeVersion") ?: "0.85.3"}"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:${hostKotlinVersion}"
-  implementation platform("com.debugbundle:debugbundle-android-bom:1.1.0")
+  implementation platform("com.debugbundle:debugbundle-android-bom:${debugBundleAndroidVersion}")
   implementation("com.debugbundle:debugbundle-android") {
     exclude group: "org.jetbrains.kotlin", module: "kotlin-stdlib"
     exclude group: "org.jetbrains.kotlin", module: "kotlin-stdlib-jdk7"
     exclude group: "org.jetbrains.kotlin", module: "kotlin-stdlib-jdk8"
   }
+  testImplementation "com.facebook.react:react-android:${rootProject.findProperty("reactNativeVersion") ?: "0.85.3"}"
+  testImplementation "junit:junit:4.13.2"
+  testImplementation "org.mockito:mockito-core:5.14.2"
+}
+
+jacoco {
+  toolVersion = "0.8.13"
+}
+
+tasks.register("androidWrapperCoverage", JacocoReport) {
+  dependsOn "testDebugUnitTest"
+  executionData.from(fileTree(layout.buildDirectory) {
+    include "jacoco/testDebugUnitTest.exec"
+    include "outputs/unit_test_code_coverage/**/*.exec"
+  })
+  sourceDirectories.from(files("src/main/java"))
+  classDirectories.from(fileTree(layout.buildDirectory.dir("intermediates/javac/debug/compileDebugJavaWithJavac/classes")) {
+    exclude "**/BuildConfig.*"
+    exclude "**/R.class"
+    exclude '**/R$*.class'
+  })
+  reports {
+    xml.required = true
+    html.required = true
+    csv.required = false
+  }
+}
+
+tasks.register("verifyAndroidWrapperCoverage") {
+  dependsOn "androidWrapperCoverage"
+  doLast {
+    def report = file("${layout.buildDirectory.get()}/reports/jacoco/androidWrapperCoverage/androidWrapperCoverage.xml")
+    if (!report.isFile()) {
+      throw new GradleException("Android wrapper coverage report is missing: ${report}")
+    }
+    def sourceCoverage = [:]
+    def sourcePattern = ~/(?s)<sourcefile name="([^"]+)">.*?<counter type="LINE" missed="(\d+)" covered="(\d+)"\/><counter type="COMPLEXITY"/
+    (report.text =~ sourcePattern).each { match ->
+      sourceCoverage[match[1]] = [
+        missed: match[2].toInteger(),
+        covered: match[3].toInteger()
+      ]
+    }
+    fileTree("src/main/java") {
+      include "**/*.java"
+    }.files.sort().each { sourceFile ->
+      def coverage = sourceCoverage[sourceFile.name]
+      if (coverage == null) {
+        throw new GradleException("Android wrapper coverage did not include ${sourceFile.name}")
+      }
+      def ratio = coverage.covered / (coverage.covered + coverage.missed)
+      if (ratio < 0.80) {
+        throw new GradleException(
+          String.format(
+            "%s line coverage %.2f%% is below the required 80.00%%",
+            sourceFile.name,
+            ratio * 100
+          )
+        )
+      }
+      println String.format("%s line coverage: %.2f%%", sourceFile.name, ratio * 100)
+    }
+  }
 }