@arms/rum-reactnative 0.1.1 → 0.1.3-beta.0

package/android/src/main/java/com/rumsdkreactnative/crash/CrashHandler.kt

@@ -0,0 +1,444 @@
+package com.rumsdkreactnative.crash
+
+import android.content.Context
+import android.os.Build
+import android.os.Looper
+import org.json.JSONArray
+import org.json.JSONObject
+import java.io.File
+import java.io.FileOutputStream
+import java.util.UUID
+import java.util.concurrent.locks.ReentrantLock
+
+/**
+ * Java 层未捕获异常处理器。
+ *
+ * 关键设计：
+ * 1. 单例模式（@Volatile + double-check）
+ * 2. 自引用检测：避免重复 install 后形成无限递归链
+ * 3. ThreadLocal<Boolean> 重入保护：避免崩溃处理器自身抛异常时无限递归
+ * 4. ReentrantLock：多线程同时崩溃时只有一个进入采集流程
+ * 5. 同步落盘：FileOutputStream + fd.sync()，保证进程被杀死前文件已 flush 到磁盘
+ * 6. 链式调用：处理完成后调用前任 handler，保证系统/其他 SDK 行为不被破坏
+ */
+class CrashHandler private constructor(
+  private val context: Context
+) : Thread.UncaughtExceptionHandler {
+
+  private val crashDir: File = File(context.filesDir, CRASH_DIR_NAME).apply {
+    // 迁移旧版目录 arms_crashes → rum_crashes
+    val legacyDir = File(context.filesDir, LEGACY_CRASH_DIR_NAME)
+    if (legacyDir.exists() && legacyDir.isDirectory) {
+      try {
+        if (!exists()) {
+          legacyDir.renameTo(this)
+        } else {
+          // 新目录已存在，逐个迁移文件
+          legacyDir.listFiles()?.forEach { file ->
+            val target = File(this, file.name)
+            if (!target.exists()) file.renameTo(target)
+          }
+          legacyDir.delete()
+        }
+      } catch (_: Throwable) {
+        // ignore migration errors
+      }
+    }
+    if (!exists()) {
+      try {
+        mkdirs()
+      } catch (_: Throwable) {
+        // ignore
+      }
+    }
+  }
+
+  private val contextManager: CrashContextManager = CrashContextManager(context)
+
+  /** 安装时保存的前任默认 handler（可能为系统/其他 SDK 安装的 handler） */
+  @Volatile
+  private var previousDefaultHandler: Thread.UncaughtExceptionHandler? = null
+
+  /** 安装时保存的主线程 handler（部分系统会单独设置） */
+  @Volatile
+  private var previousMainThreadHandler: Thread.UncaughtExceptionHandler? = null
+
+  @Volatile
+  private var installed: Boolean = false
+
+  /** 重入保护：处理崩溃过程中如果再次抛异常，直接转交前任 handler，避免死循环 */
+  private val reentrantGuard: ThreadLocal<Boolean> = object : ThreadLocal<Boolean>() {
+    override fun initialValue(): Boolean = false
+  }
+
+  /** 并发锁：多线程同时崩溃时只允许一个进入采集 */
+  private val lock = ReentrantLock()
+
+  /**
+   * 安装为默认 UncaughtExceptionHandler。
+   * 若已安装则直接返回，避免重复挂链导致死循环。
+   */
+  fun install() {
+    if (installed) return
+    synchronized(this) {
+      if (installed) return
+
+      val current = Thread.getDefaultUncaughtExceptionHandler()
+      // 自引用检测：若当前 default handler 已经是自己，跳过
+      if (current is CrashHandler) {
+        installed = true
+        return
+      }
+      previousDefaultHandler = current
+
+      val mainThread = Looper.getMainLooper().thread
+      val mainHandler = mainThread.uncaughtExceptionHandler
+      if (mainHandler !== current && mainHandler !is CrashHandler) {
+        previousMainThreadHandler = mainHandler
+      }
+
+      Thread.setDefaultUncaughtExceptionHandler(this)
+      installed = true
+
+      // 安装 NDK 信号处理器，捕获原生崩溃（SIGSEGV / SIGABRT 等）
+      try {
+        NdkCrashHandler.install(crashDir.absolutePath)
+      } catch (_: Throwable) {
+        // 忽略 NDK 安装失败，不影响 Java 层 handler
+      }
+    }
+  }
+
+  override fun uncaughtException(thread: Thread, throwable: Throwable) {
+    // 重入保护
+    if (reentrantGuard.get() == true) {
+      chainToPrevious(thread, throwable)
+      return
+    }
+    reentrantGuard.set(true)
+
+    val acquired = try {
+      lock.tryLock()
+    } catch (_: Throwable) {
+      false
+    }
+
+    try {
+      if (acquired) {
+        try {
+          captureAndPersist(thread, throwable)
+        } catch (_: Throwable) {
+          // 崩溃处理器本身不能抛异常
+        }
+      }
+      // 未获取到锁说明已有线程在处理，直接走链式调用即可
+    } finally {
+      if (acquired) {
+        try {
+          lock.unlock()
+        } catch (_: Throwable) {
+          // ignore
+        }
+      }
+      try {
+        reentrantGuard.set(false)
+      } catch (_: Throwable) {
+        // ignore
+      }
+      chainToPrevious(thread, throwable)
+    }
+  }
+
+  private fun chainToPrevious(thread: Thread, throwable: Throwable) {
+    try {
+      // 主线程优先使用 previousMainThreadHandler
+      if (thread == Looper.getMainLooper().thread &&
+        previousMainThreadHandler != null
+      ) {
+        previousMainThreadHandler?.uncaughtException(thread, throwable)
+      } else {
+        previousDefaultHandler?.uncaughtException(thread, throwable)
+      }
+    } catch (_: Throwable) {
+      // ignore
+    }
+  }
+
+  private fun captureAndPersist(thread: Thread, throwable: Throwable) {
+    val crashId = UUID.randomUUID().toString()
+    val timestamp = System.currentTimeMillis()
+
+    val root = JSONObject()
+    root.put("crash_id", crashId)
+    root.put("timestamp", timestamp)
+    root.put("platform", "android")
+    root.put("exception", buildException(throwable))
+    root.put("crashed_thread", buildThread(thread, throwable.stackTrace))
+    root.put("context", safeReadContext())
+    root.put("device", buildDevice())
+    root.put("app", buildApp(context))
+
+    writeCrashFile(crashId, timestamp, root.toString())
+  }
+
+  private fun buildException(throwable: Throwable): JSONObject {
+    val obj = JSONObject()
+    obj.put("type", "java_exception")
+    obj.put("class_name", throwable.javaClass.name)
+    obj.put("message", throwable.message ?: "")
+    // 遍历 cause 链（最多 5 层），提取完整异常因果链
+    val causes = JSONArray()
+    var current = throwable.cause
+    var depth = 0
+    while (current != null && current !== throwable && depth < 5) {
+      try {
+        val causeObj = JSONObject()
+        causeObj.put("class_name", current.javaClass.name)
+        causeObj.put("message", current.message ?: "")
+        causes.put(causeObj)
+      } catch (_: Throwable) {
+        // ignore single cause errors
+      }
+      current = current.cause
+      depth++
+    }
+    if (causes.length() > 0) {
+      obj.put("causes", causes)
+    }
+    return obj
+  }
+
+  private fun buildThread(thread: Thread, stackTrace: Array<StackTraceElement>?): JSONObject {
+    val obj = JSONObject()
+    obj.put("id", thread.id.toString())
+    obj.put("name", thread.name ?: "")
+    obj.put("frames", buildFrames(stackTrace))
+    return obj
+  }
+
+  private fun buildFrames(stackTrace: Array<StackTraceElement>?): JSONArray {
+    val arr = JSONArray()
+    if (stackTrace == null) return arr
+    // 双侧截断（参照 Sentry 推荐方案）：帧数超过 512 时保留首尾各 256 帧，
+    // 中间插入标记帧，防止递归崩溃（如 StackOverflowError 产生数千帧）丢失程序入口点。
+    val truncationThreshold = 512
+    val keepPerSide = 256
+    val total = stackTrace.size
+    if (total > truncationThreshold) {
+      // 前 keepPerSide 帧
+      appendFrameRange(arr, stackTrace, 0, keepPerSide)
+      // 截断标记帧
+      try {
+        val marker = JSONObject()
+        marker.put("truncated", true)
+        marker.put("omitted_count", total - truncationThreshold)
+        arr.put(marker)
+      } catch (_: Throwable) {
+        // ignore
+      }
+      // 后 keepPerSide 帧
+      appendFrameRange(arr, stackTrace, total - keepPerSide, total)
+    } else {
+      // 帧数未超阈值，全部保留
+      appendFrameRange(arr, stackTrace, 0, total)
+    }
+    return arr
+  }
+
+  private fun appendFrameRange(
+    arr: JSONArray,
+    stackTrace: Array<StackTraceElement>,
+    from: Int,
+    to: Int
+  ) {
+    for (i in from until to) {
+      try {
+        val element = stackTrace[i]
+        val frame = JSONObject()
+        frame.put("class_name", element.className ?: "")
+        frame.put("method_name", element.methodName ?: "")
+        frame.put("file", element.fileName ?: "")
+        frame.put("line", element.lineNumber)
+        arr.put(frame)
+      } catch (_: Throwable) {
+        // ignore single frame errors
+      }
+    }
+  }
+
+  private fun safeReadContext(): JSONObject {
+    return try {
+      contextManager.readContext() ?: JSONObject()
+    } catch (_: Throwable) {
+      JSONObject()
+    }
+  }
+
+  /**
+   * 同步落盘：FileOutputStream + fd.sync()。
+   * 文件命名：crash_{timestamp}_{uuid}.json
+   */
+  private fun writeCrashFile(crashId: String, timestamp: Long, json: String) {
+    if (!crashDir.exists()) {
+      try {
+        crashDir.mkdirs()
+      } catch (_: Throwable) {
+        // ignore
+      }
+    }
+    val target = File(crashDir, "crash_${timestamp}_${crashId}.json")
+    var fos: FileOutputStream? = null
+    try {
+      fos = FileOutputStream(target)
+      fos.write(json.toByteArray(Charsets.UTF_8))
+      fos.flush()
+      try {
+        fos.fd.sync()
+      } catch (_: Throwable) {
+        // ignore sync errors，已尽力
+      }
+    } catch (_: Throwable) {
+      // ignore
+    } finally {
+      try {
+        fos?.close()
+      } catch (_: Throwable) {
+        // ignore
+      }
+    }
+  }
+
+  companion object {
+    private const val CRASH_DIR_NAME = "rum_crashes"
+    private const val LEGACY_CRASH_DIR_NAME = "arms_crashes"
+
+    /**
+     * 构建设备信息 JSON（供 CrashHandler 和 RumSdkReactnativeModule 共享）。
+     * NDK 崩溃的信号处理器只写 crash-specific 数据，不包含 device 字段，
+     * getPendingCrashes 读取时需要补入。
+     */
+    fun buildDevice(): JSONObject {
+      val obj = JSONObject()
+      try {
+        obj.put("model", Build.MODEL ?: "")
+        obj.put("brand", Build.MANUFACTURER?.takeIf { it.isNotBlank() } ?: (Build.BRAND ?: ""))
+        obj.put("os_version", Build.VERSION.RELEASE ?: "")
+      } catch (_: Throwable) {
+        // ignore
+      }
+      return obj
+    }
+
+    /**
+     * 构建应用信息 JSON（供 CrashHandler 和 RumSdkReactnativeModule 共享）。
+     * NDK 崩溃的信号处理器只写 crash-specific 数据，不包含 app 字段，
+     * getPendingCrashes 读取时需要补入。
+     */
+    fun buildApp(context: Context): JSONObject {
+      val obj = JSONObject()
+      try {
+        obj.put("package", context.packageName ?: "")
+        val pm = context.packageManager
+        val info = pm.getPackageInfo(context.packageName, 0)
+        obj.put("version", info.versionName ?: "")
+        val build = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+          info.longVersionCode.toString()
+        } else {
+          @Suppress("DEPRECATION")
+          info.versionCode.toString()
+        }
+        obj.put("build", build)
+        // 补入 React Native 版本号，与 iOS 对齐
+        try {
+          val versionClass = Class.forName("com.facebook.react.modules.systeminfo.ReactNativeVersion")
+          val versionField = versionClass.getDeclaredField("VERSION")
+          @Suppress("UNCHECKED_CAST")
+          val version = versionField.get(null) as? Map<*, *>
+          val rnVersion = "${version?.get("major") ?: 0}.${version?.get("minor") ?: 0}.${version?.get("patch") ?: 0}"
+          obj.put("rn_version", rnVersion)
+        } catch (_: Throwable) {
+          // RN 版本不可用时跳过
+        }
+      } catch (_: Throwable) {
+        // ignore
+      }
+      return obj
+    }
+
+    /**
+     * 为 NDK 崩溃补全缺失的标准字段（platform / exception / crashed_thread / mechanism）。
+     *
+     * NDK 信号处理器（rum_crash_writer.c）在 async-signal-safe 上下文中只写入了
+     * crash-specific 数据（signal / frames / arch / binary_images 等），
+     * 缺少 platform、exception、crashed_thread、mechanism 等结构化字段。
+     * 此方法在 getPendingCrashes 读取后统一补入，使 NDK 崩溃与 Java 崩溃
+     * 具有一致的数据结构，便于服务端解析和前端展示。
+     *
+     * 所有补入均使用 `if (!json.has(...))` 条件判断，不会覆盖已有字段。
+     */
+    fun enrichNdkCrash(json: JSONObject) {
+      // 仅处理 NDK 崩溃（有 signal 字段），Java 崩溃已有完整结构
+      if (!json.has("signal")) return
+      try {
+        // 补入 platform 字段，与 Java 崩溃保持一致
+        if (!json.has("platform")) {
+          json.put("platform", "android")
+        }
+
+        // 补入 exception 结构
+        if (!json.has("exception")) {
+          val signal = json.optJSONObject("signal")
+          val signalName = signal?.optString("name", "unknown") ?: "unknown"
+          val faultAddr = signal?.optString("fault_address", "0x0") ?: "0x0"
+          val exception = JSONObject()
+          exception.put("type", "native_crash")
+          exception.put("class_name", signalName)
+          exception.put("message", "$signalName at $faultAddr")
+          json.put("exception", exception)
+        }
+
+        // NDK frames 在 JSON 顶层，重组为 crashed_thread 结构
+        if (json.has("frames") && !json.has("crashed_thread")) {
+          val crashedThread = JSONObject()
+          crashedThread.put("id", json.optInt("tid", 0))
+          crashedThread.put("frames", json.get("frames"))
+          json.put("crashed_thread", crashedThread)
+          json.remove("frames")
+          // tid 保留在顶层，JS 层也用它做 fallback
+        }
+
+        // 补入 mechanism 信息（JS 层会将其放入 snapshots）
+        if (!json.has("mechanism")) {
+          val signal = json.optJSONObject("signal")
+          val signalName = signal?.optString("name", "signal") ?: "signal"
+          val mechanism = JSONObject()
+          mechanism.put("type", "signal")
+          mechanism.put("handled", false)
+          mechanism.put("signal_name", signalName)
+          json.put("mechanism", mechanism)
+        }
+      } catch (_: Throwable) {
+        // 补入失败不影响已有数据
+      }
+    }
+
+    @Volatile
+    private var instance: CrashHandler? = null
+
+    @JvmStatic
+    fun getInstance(context: Context): CrashHandler {
+      val existing = instance
+      if (existing != null) return existing
+      synchronized(CrashHandler::class.java) {
+        val again = instance
+        if (again != null) return again
+        val created = CrashHandler(context.applicationContext)
+        instance = created
+        return created
+      }
+    }
+
+    @JvmStatic
+    fun peekInstance(): CrashHandler? = instance
+  }
+}

package/android/src/main/java/com/rumsdkreactnative/crash/CrashInitProvider.kt

@@ -0,0 +1,50 @@
+package com.rumsdkreactnative.crash
+
+import android.content.ContentProvider
+import android.content.ContentValues
+import android.database.Cursor
+import android.net.Uri
+
+/**
+ * 通过 ContentProvider 实现无侵入自启动。
+ *
+ * Android 在 Application.onCreate() 之前会调用所有已声明 ContentProvider 的 onCreate()，
+ * 因此这里是接入崩溃处理器最早的、且无需用户在 Application 中显式调用的时机。
+ *
+ * 注意：onCreate() 必须保持轻量，且绝不允许抛异常。
+ */
+class CrashInitProvider : ContentProvider() {
+
+  override fun onCreate(): Boolean {
+    try {
+      val ctx = context
+      if (ctx != null) {
+        CrashHandler.getInstance(ctx.applicationContext).install()
+      }
+    } catch (_: Throwable) {
+      // 自启动过程任何异常都不能抛出，避免影响宿主 App 启动
+    }
+    return true
+  }
+
+  override fun query(
+    uri: Uri,
+    projection: Array<out String>?,
+    selection: String?,
+    selectionArgs: Array<out String>?,
+    sortOrder: String?
+  ): Cursor? = null
+
+  override fun getType(uri: Uri): String? = null
+
+  override fun insert(uri: Uri, values: ContentValues?): Uri? = null
+
+  override fun delete(uri: Uri, selection: String?, selectionArgs: Array<out String>?): Int = 0
+
+  override fun update(
+    uri: Uri,
+    values: ContentValues?,
+    selection: String?,
+    selectionArgs: Array<out String>?
+  ): Int = 0
+}

package/android/src/main/java/com/rumsdkreactnative/crash/NdkCrashHandler.kt

@@ -0,0 +1,66 @@
+package com.rumsdkreactnative.crash
+
+import android.util.Log
+
+/**
+ * JNI bridge for the native (NDK) crash signal handler.
+ *
+ * Loads librum_crash.so and installs sigaction-based handlers for
+ * SIGSEGV/SIGABRT/SIGBUS/SIGFPE/SIGILL/SIGTRAP. Crash dumps are written
+ * to the provided directory as `crash_native_{timestamp}.json`.
+ *
+ * Designed to fail soft: if the native library cannot be loaded
+ * (e.g. unsupported ABI), the install is a no-op and the SDK falls
+ * back to Java-only crash capture.
+ */
+object NdkCrashHandler {
+
+    private const val TAG = "RumCrash"
+    private const val LIB_NAME = "rum_crash"
+
+    @Volatile
+    private var installed = false
+
+    @Volatile
+    private var libraryLoaded = false
+
+    init {
+        try {
+            System.loadLibrary(LIB_NAME)
+            libraryLoaded = true
+        } catch (e: UnsatisfiedLinkError) {
+            Log.w(TAG, "Failed to load lib$LIB_NAME.so: ${e.message}")
+        } catch (e: SecurityException) {
+            Log.w(TAG, "SecurityException loading lib$LIB_NAME.so: ${e.message}")
+        }
+    }
+
+    /**
+     * Install the native signal handlers. Idempotent and thread-safe.
+     *
+     * @param crashDir absolute directory where crash JSON files will be written.
+     *                 Must already exist and be writable by the app process.
+     */
+    @Synchronized
+    fun install(crashDir: String) {
+        if (installed) return
+        if (!libraryLoaded) {
+            Log.w(TAG, "Native lib not loaded; NDK crash capture disabled")
+            return
+        }
+        try {
+            nativeInstall(crashDir)
+            installed = true
+            Log.i(TAG, "NDK crash handler installed -> $crashDir")
+        } catch (e: UnsatisfiedLinkError) {
+            Log.w(TAG, "nativeInstall not found: ${e.message}")
+        } catch (e: Throwable) {
+            Log.w(TAG, "nativeInstall failed: ${e.message}")
+        }
+    }
+
+    fun isInstalled(): Boolean = installed
+
+    @JvmStatic
+    private external fun nativeInstall(crashDir: String)
+}

package/android/src/main/jni/CMakeLists.txt

@@ -0,0 +1,21 @@
+cmake_minimum_required(VERSION 3.22.1)
+project(rum_crash)
+
+add_library(rum_crash SHARED
+    rum_crash_handler.c
+    rum_backtrace.c
+    rum_crash_writer.c
+    rum_module_info.c
+    rum_test_crash.cpp
+)
+
+target_link_libraries(rum_crash
+    log
+    android
+)
+
+target_compile_options(rum_crash PRIVATE
+    -fno-omit-frame-pointer
+    -Wno-format
+    -Wno-unused-parameter
+)