@coralogix/react-native-plugin 0.1.0

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

@@ -0,0 +1,457 @@
+package com.cxsdk
+
+import android.app.Application
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import com.coralogix.android.sdk.CoralogixRum
+import com.coralogix.android.sdk.internal.features.instrumentations.error.CoralogixErrorDecorator
+import com.coralogix.android.sdk.internal.features.instrumentations.network.NetworkRequestDetails
+import com.coralogix.android.sdk.internal.infrastructure.threaddump.CoralogixJsStackFrame
+import com.coralogix.android.sdk.internal.infrastructure.threaddump.CoralogixStackTrace
+import com.coralogix.android.sdk.model.CoralogixDomain
+import com.coralogix.android.sdk.model.CoralogixLogSeverity
+import com.coralogix.android.sdk.model.CoralogixOptions
+import com.coralogix.android.sdk.model.Framework
+import com.coralogix.android.sdk.model.HybridMetric
+import com.coralogix.android.sdk.model.Instrumentation
+import com.coralogix.android.sdk.model.UserContext
+import com.coralogix.android.sdk.model.ViewContext
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import java.lang.Long.getLong
+
+class CxSdkModule(reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(reactContext), ICxSdkModule {
+
+  override fun getName(): String {
+    return NAME
+  }
+
+  @ReactMethod
+  override fun initialize(config: ReadableMap) {
+    val application = reactApplicationContext.applicationContext as Application
+    val options = config.toCoralogixOptions()
+
+    val rnPluginVersion = if (config.hasKey("frameworkVersion") && !config.isNull("frameworkVersion"))
+        config.getString("frameworkVersion") ?: ""
+      else ""
+
+    Handler(Looper.getMainLooper()).post {
+      CoralogixRum.initialize(
+        application = application,
+        options = options,
+        framework = Framework.HybridFramework.ReactNative(rnPluginVersion))
+    }
+  }
+
+  @ReactMethod
+  override fun setUserContext(userContextMap: ReadableMap) {
+    val userContext = userContextMap.toUserContext()
+    CoralogixRum.setUserContext(userContext)
+  }
+
+  @ReactMethod
+  override fun getUserContext(promise: Promise) {
+    promise.resolve(CoralogixRum.getUserContext().toWritableMap())
+  }
+
+  @ReactMethod
+  override fun setApplicationContext(appContextMap: ReadableMap) {
+    val appName = appContextMap.getString("application")
+      ?: throw IllegalArgumentException("Missing required parameter: application")
+    val appVersion = appContextMap.getString("version")
+      ?: throw IllegalArgumentException("Missing required parameter: version")
+
+    CoralogixRum.setApplicationContext(appName, appVersion)
+  }
+
+  @ReactMethod
+  override fun getSessionId(promise: Promise) {
+    promise.resolve(CoralogixRum.getSessionId())
+  }
+
+  @ReactMethod
+  override fun setLabels(labelsMap: ReadableMap) {
+    val labels = labelsMap.toStringMap()
+    CoralogixRum.setLabels(labels)
+  }
+
+  @ReactMethod
+  override fun getLabels(promise: Promise) {
+    promise.resolve(CoralogixRum.getLabels().toWritableMap())
+  }
+
+  @ReactMethod
+  override fun setViewContext(viewContext: String) {
+    CoralogixRum.setViewContext(viewContext)
+  }
+
+  @ReactMethod
+  override fun log(severity: Int, message: String, data: ReadableMap) {
+    CoralogixRum.log(severity.toCoralogixLogSeverity(), message, data.toStringMap())
+  }
+
+  @ReactMethod
+  override fun reportNetworkRequest(requestDetails: ReadableMap) {
+    val details = requestDetails.toNetworkRequestDetails()
+    CoralogixRum.reportNetworkRequest(details)
+  }
+
+  @ReactMethod
+  override fun sendCustomMeasurement(measurement: ReadableMap) {
+    val name = measurement.getString("name")
+      ?: throw IllegalArgumentException("Missing required parameter: name")
+
+    val value = if (measurement.hasKey("value"))
+      measurement.getDouble("value").toLong()
+    else throw IllegalArgumentException("Missing required parameter: value")
+
+    CoralogixRum.sendCustomMeasurement(name, value)
+  }
+
+  @ReactMethod
+  override fun reportError(details: ReadableMap) {
+    val errorType = details.getString("error_type").orEmpty()
+    val message = details.getString("error_message").orEmpty()
+    val isCrash = details.getBoolean("is_crash").takeIf {
+      details.hasKey("is_crash")
+    } ?: false
+
+    val parsedStackFrames = details.getArray("stack_trace")
+      ?.let { stackArray ->
+        (0 until stackArray.size())
+          .mapNotNull { index -> stackArray.getMap(index) }
+          .map { frame ->
+            CoralogixJsStackFrame(
+              functionName = frame.getString("functionName").orEmpty(),
+              fileName = frame.getString("fileName").orEmpty(),
+              lineNumber = if (frame.hasKey("lineNumber")) frame.getInt("lineNumber") else -1,
+              columnNumber = if (frame.hasKey("columnNumber")) frame.getInt("columnNumber") else -1,
+            )
+          }
+      }.orEmpty()
+
+    CoralogixRum.reportError(
+      CoralogixErrorDecorator(
+        errorType = errorType,
+        errorMessage = message,
+        errorStack = CoralogixStackTrace(parsedStackFrames),
+        isCrash = isCrash
+      )
+    )
+  }
+
+  @ReactMethod
+  override fun sendCxSpanData(results: ReadableArray) {
+    val data = convertStrictReadableArrayToListOfMaps(results)
+    CoralogixRum.sendCxSpanData(data)
+  }
+
+  @ReactMethod
+  override fun reportMobileVitalsMeasurement(type: String, value: Double, units: String) {
+    CoralogixRum.reportMobileVitalsMeasurement(type, value, units)
+  }
+
+  @ReactMethod
+  override fun reportMobileVitalsMeasurementSet(type: String, metrics: ReadableArray) {
+    val list = metrics.toHybridMetricList()
+    CoralogixRum.reportMobileVitalsMeasurement(type, list)
+  }
+
+  @ReactMethod
+  override fun shutdown() {
+    Handler(Looper.getMainLooper()).post {
+      CoralogixRum.shutdown()
+    }
+  }
+
+  @ReactMethod
+  fun addListener(eventName: String) {
+    Log.d("CxSdkModule", "addListener called with eventName: $eventName")
+  }
+
+  @ReactMethod
+  fun removeListeners(count: Int) {
+    Log.d("CxSdkModule", "removeListeners: $count")
+  }
+
+  private fun ReadableMap.toCoralogixOptions(): CoralogixOptions {
+    val applicationName = getString("application")
+      ?: throw IllegalArgumentException("Missing required parameter: application")
+    val publicKey = getString("public_key")
+      ?: throw IllegalArgumentException("Missing required parameter: publicKey")
+    val coralogixDomain = getString("coralogixDomain")?.toCoralogixDomain()
+      ?: throw IllegalArgumentException("Missing required parameter: coralogixDomain")
+
+    val traceParentInHeaderMap = getMap("traceParentInHeader")
+    val isTraceParentInHeaderEnabled = traceParentInHeaderMap?.let {
+      it.hasKey("enable") && it.getBoolean("enable")
+    } ?: false
+    val collectIpData = if (hasKey("collectIPData")) getBoolean("collectIPData") else true
+
+    return CoralogixOptions(
+      applicationName = applicationName,
+      coralogixDomain = coralogixDomain,
+      publicKey = publicKey,
+      labels = getMap("labels")?.toStringMap() ?: mapOf(),
+      environment = getString("environment") ?: "",
+      version = getString("version") ?: "",
+      userContext = getMap("user_context")?.toUserContext() ?: UserContext(),
+      viewContext = ViewContext(getMap("view_context")?.getString("view") ?: ""),
+      instrumentations = getMap("instrumentations")?.toInstrumentationMap() ?: mapOf(),
+      ignoreUrls = getArray("ignoreUrls")?.handleStringOrRegexList() ?: listOf(),
+      ignoreErrors = getArray("ignoreErrors")?.handleStringOrRegexList() ?: listOf(),
+      sessionSampleRate = 100,
+      traceParentInHeader = isTraceParentInHeaderEnabled,
+      fpsSamplingSeconds = if (hasKey("fpsSamplingSeconds")) getLong("fpsSamplingSeconds") else 300,
+      debug = if (hasKey("debug")) getBoolean("debug") else false,
+      proxyUrl = getString("proxyUrl"),
+      beforeSendCallback = ::beforeSendCallback,
+      collectIPData = collectIpData
+    )
+  }
+
+  private fun beforeSendCallback(data: List<Map<String, Any?>>) {
+    val args = convertAnyListToWritableArray(data)
+    reactApplicationContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit("onBeforeSend", args)
+  }
+
+  private fun convertAnyListToWritableArray(list: List<Any?>): WritableArray {
+    val array = Arguments.createArray()
+    list.forEach { value ->
+      when (value) {
+        null -> array.pushNull()
+        is Boolean -> array.pushBoolean(value)
+        is Int -> array.pushInt(value)
+        is Double -> array.pushDouble(value)
+        is Float -> array.pushDouble(value.toDouble())
+        is String -> array.pushString(value)
+        is Map<*, *> -> {
+          @Suppress("UNCHECKED_CAST")
+          array.pushMap(convertMapToWritableMap(value as Map<String, Any?>))
+        }
+        is List<*> -> {
+          array.pushArray(convertAnyListToWritableArray(value as List<Any?>))
+        }
+        else -> array.pushString(value.toString()) // fallback
+      }
+    }
+    return array
+  }
+
+  private fun convertMapToWritableMap(map: Map<String, Any?>): WritableMap {
+    val writableMap = Arguments.createMap()
+    map.forEach { (key, value) ->
+      when (value) {
+        null -> writableMap.putNull(key)
+        is Boolean -> writableMap.putBoolean(key, value)
+        is Int -> writableMap.putInt(key, value)
+        is Double -> writableMap.putDouble(key, value)
+        is Float -> writableMap.putDouble(key, value.toDouble())
+        is String -> writableMap.putString(key, value)
+        is Map<*, *> -> {
+          @Suppress("UNCHECKED_CAST")
+          writableMap.putMap(key, convertMapToWritableMap(value as Map<String, Any?>))
+        }
+        is List<*> -> {
+          writableMap.putArray(key, convertAnyListToWritableArray(value))
+        }
+        else -> writableMap.putString(key, value.toString()) // fallback
+      }
+    }
+    return writableMap
+  }
+
+  private fun convertStrictReadableArrayToListOfMaps(readableArray: ReadableArray): List<Map<String, Any?>> {
+    val list = mutableListOf<Map<String, Any?>>()
+    for (i in 0 until readableArray.size()) {
+      if (readableArray.getType(i) != ReadableType.Map) {
+        throw IllegalArgumentException("Expected array of maps, but found ${readableArray.getType(i)} at index $i")
+      }
+      val map = readableArray.getMap(i)
+      list.add(convertReadableMapToMap(map))
+    }
+    return list
+  }
+
+  private fun convertReadableArrayToAnyList(readableArray: ReadableArray): List<Any?> {
+    val list = mutableListOf<Any?>()
+    for (i in 0 until readableArray.size()) {
+      when (readableArray.getType(i)) {
+        ReadableType.Null -> list.add(null)
+        ReadableType.Boolean -> list.add(readableArray.getBoolean(i))
+        ReadableType.Number -> {
+          val value = readableArray.getDouble(i)
+          list.add(if (value % 1 == 0.0) value.toInt() else value)
+        }
+        ReadableType.String -> list.add(readableArray.getString(i))
+        ReadableType.Map -> list.add(convertReadableMapToMap(readableArray.getMap(i)))
+        ReadableType.Array -> list.add(convertReadableArrayToAnyList(readableArray.getArray(i)))
+      }
+    }
+    return list
+  }
+
+  private fun convertReadableMapToMap(readableMap: ReadableMap): Map<String, Any?> {
+    val map = mutableMapOf<String, Any?>()
+    val iterator = readableMap.keySetIterator()
+    while (iterator.hasNextKey()) {
+      val key = iterator.nextKey()
+      when (readableMap.getType(key)) {
+        ReadableType.Null -> map[key] = null
+        ReadableType.Boolean -> map[key] = readableMap.getBoolean(key)
+        ReadableType.Number -> {
+          val value = readableMap.getDouble(key)
+          // Try to preserve integer-ness when possible
+          map[key] = if (value % 1 == 0.0) value.toInt() else value
+        }
+        ReadableType.String -> map[key] = readableMap.getString(key)
+        ReadableType.Map -> map[key] = convertReadableMapToMap(readableMap.getMap(key)!!)
+        ReadableType.Array -> map[key] = convertReadableArrayToAnyList(readableMap.getArray(key)!!)
+      }
+    }
+    return map
+  }
+
+  private fun String.toCoralogixDomain(): CoralogixDomain {
+    return when (this.uppercase()) {
+      "EU1" -> CoralogixDomain.EU1
+      "EU2" -> CoralogixDomain.EU2
+      "US1" -> CoralogixDomain.US1
+      "US2" -> CoralogixDomain.US2
+      "AP1" -> CoralogixDomain.AP1
+      "AP2" -> CoralogixDomain.AP2
+      "AP3" -> CoralogixDomain.AP3
+      "STAGING" -> CoralogixDomain.STAGING
+      else -> throw IllegalArgumentException("Invalid coralogixDomain: $this. Must be one of [EU1, EU2, US1, US2, AP1, AP2, AP3, STAGING]")
+    }
+  }
+
+  private fun ReadableArray.handleStringOrRegexList(): List<String> {
+    val result = mutableListOf<String>()
+
+    for (i in 0 until size()) {
+      when (getType(i)) {
+        ReadableType.String -> {
+          result.add(getString(i))
+        }
+        ReadableType.Map -> {
+          val map = getMap(i)
+          val pattern = map.getString("source") // Extract regex pattern
+          pattern?.let { result.add(it) }
+        }
+        else -> {
+          // Skip other types (Numbers, Booleans, etc.)
+        }
+      }
+    }
+    return result
+  }
+
+  private fun ReadableMap.toUserContext() = UserContext(
+    userId = getString("user_id") ?: "",
+    username = getString("user_name") ?: "",
+    email = getString("user_email") ?: "",
+    metadata = getMap("user_metadata")?.toStringMap() ?: mapOf()
+  )
+
+  private fun ReadableMap.toInstrumentationMap(): Map<Instrumentation, Boolean> {
+    return mapOf(
+      Instrumentation.Error to if (hasKey("error")) getBoolean("error") else true,
+      Instrumentation.Network to if (hasKey("fetch")) getBoolean("fetch") else true,
+      Instrumentation.Custom to if (hasKey("custom")) getBoolean("custom") else true,
+      Instrumentation.MobileVitals to if (hasKey("mobile_vitals")) getBoolean("mobile_vitals") else true,
+      Instrumentation.Anr to if (hasKey("anr")) getBoolean("anr") else true,
+      Instrumentation.Lifecycle to if (hasKey("lifecycle")) getBoolean("lifecycle") else true,
+      Instrumentation.UserInteraction to if (hasKey("user_interaction")) getBoolean("user_interaction") else true,
+    )
+  }
+
+  private fun ReadableMap.toStringMap(): Map<String, String> {
+    val map = mutableMapOf<String, String>()
+    val iterator = keySetIterator()
+    while (iterator.hasNextKey()) {
+      val key = iterator.nextKey()
+      getString(key)?.let { map[key] = it }
+    }
+    return map
+  }
+
+  private fun Map<String, String>.toWritableMap(): WritableMap {
+    val map = Arguments.createMap()
+    for ((key, value) in this) {
+      map.putString(key, value)
+    }
+    return map
+  }
+
+  private fun UserContext.toWritableMap(): WritableMap {
+    val map = Arguments.createMap()
+    map.putString("user_id", userId)
+    map.putString("user_name", username)
+    map.putString("user_email", email)
+    map.putMap("user_metadata", metadata.toWritableMap())
+
+    return map
+  }
+
+  private fun Int.toCoralogixLogSeverity(): CoralogixLogSeverity {
+    return when (this) {
+      1 -> CoralogixLogSeverity.Debug
+      2 -> CoralogixLogSeverity.Verbose
+      3 -> CoralogixLogSeverity.Info
+      4 -> CoralogixLogSeverity.Warn
+      5 -> CoralogixLogSeverity.Error
+      6 -> CoralogixLogSeverity.Critical
+      else -> throw IllegalArgumentException("Invalid severity: $this. Must be one of [1, 2, 3, 4, 5, 6]")
+    }
+  }
+
+  private fun ReadableMap.toNetworkRequestDetails() = NetworkRequestDetails(
+    method = getString("method") ?: "",
+    statusCode = if (hasKey("statusCode")) getInt("statusCode") else 0,
+    url = getString("url") ?: "",
+    fragments = getString("fragments") ?: "",
+    host = getString("host") ?: "",
+    schema = getString("schema") ?: "",
+    statusText = getString("statusText") ?: "",
+    duration = if (hasKey("duration")) getDouble("duration").toLong() else 0,
+    responseContentLength = if (hasKey("responseContentLength"))
+      getDouble("responseContentLength").toLong() else 0,
+    errorMessage = getString("errorMessage"),
+    traceId = getString("customTraceId"),
+    spanId = getString("customSpanId")
+  ).also { Log.d("CxSdkModule", "toNetworkRequestDetails: $it") }
+
+  private fun ReadableArray.toHybridMetricList(): List<HybridMetric> {
+    val out = ArrayList<HybridMetric>(size())
+    for (i in 0 until size()) {
+      val m = getMap(i)
+      val name = m.getString("name") ?: throw IllegalArgumentException("metrics[$i].name is required")
+      // RN numbers are Double; accept both Int and Double transparently:
+      val value = when {
+        m.hasKey("value") && !m.isNull("value") -> m.getDouble("value")
+        else -> throw IllegalArgumentException("metrics[$i].value is required")
+      }
+      val units = m.getString("units") ?: throw IllegalArgumentException("metrics[$i].units is required")
+      out += HybridMetric(name = name, value = value, units = units)
+    }
+    return out
+  }
+
+  companion object {
+    const val NAME = "CxSdk"
+  }
+}

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

@@ -0,0 +1,16 @@
+package com.cxsdk
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class CxSdkPackage : ReactPackage {
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+    return listOf(CxSdkModule(reactContext))
+  }
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    return emptyList()
+  }
+}

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

@@ -0,0 +1,24 @@
+package com.cxsdk
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+
+interface ICxSdkModule {
+  fun initialize(config: ReadableMap)
+  fun setUserContext(userContextMap: ReadableMap)
+  fun getUserContext(promise: Promise)
+  fun setApplicationContext(appContextMap: ReadableMap)
+  fun getSessionId(promise: Promise)
+  fun setLabels(labelsMap: ReadableMap)
+  fun getLabels(promise: Promise)
+  fun setViewContext(viewContext: String)
+  fun log(severity: Int, message: String, data: ReadableMap)
+  fun reportNetworkRequest(requestDetails: ReadableMap)
+  fun sendCustomMeasurement(measurement: ReadableMap)
+  fun reportError(details: ReadableMap)
+  fun sendCxSpanData(results: ReadableArray)
+  fun reportMobileVitalsMeasurement(type: String, value: Double, units: String)
+  fun reportMobileVitalsMeasurementSet(type: String, metrics: ReadableArray)
+  fun shutdown()
+}