@coralogix/react-native-plugin 0.11.2 → 0.11.3

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## 0.11.3 (2026-09-26)
+
+### 🩹 Fixes
+
+- Fixed a crash on iOS when calling `setLabels`. Labels with non-string values (such as numbers or booleans) are now preserved instead of being dropped.
+- `log` now handles missing or incorrectly typed arguments gracefully instead of crashing your app.
+
 ## 0.11.2 (2026-09-19)
 
 ### ⬆️ Dependency Updates

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

@@ -109,9 +109,14 @@ class CxSdkModule(reactContext: ReactApplicationContext) :
   }
 
   @ReactMethod
-  override fun setLabels(labelsMap: ReadableMap) {
-    val labels = labelsMap.toStringAnyMap()
-    CoralogixRum.setLabels(labels)
+  override fun setLabels(labelsMap: ReadableMap?) {
+    // Nullable: a JS null would fail Kotlin's null check and crash the app.
+    if (labelsMap == null) {
+      Log.w("CxSdkModule", "setLabels: labels is null, ignoring")
+      return
+    }
+
+    CoralogixRum.setLabels(labelsMap.toStringAnyMap())
   }
 
   @ReactMethod
@@ -126,8 +131,23 @@ class CxSdkModule(reactContext: ReactApplicationContext) :
   }
 
   @ReactMethod
-  override fun log(severity: Int, message: String, data: ReadableMap, labels: ReadableMap) {
-    CoralogixRum.log(severity.toCoralogixLogSeverity(), message, data.toStringAnyMap(), labels.toStringAnyMap())
+  override fun log(severity: Int, message: String?, data: ReadableMap?, labels: ReadableMap?) {
+    // Nullable: a JS null would fail Kotlin's null check and crash the app.
+    // Non-string messages fail earlier, in RN's parsing; `toSafeMessage` (JS) covers them.
+
+    // Drop unknown severities, like iOS, rather than invent one.
+    val cxSeverity = runCatching { severity.toCoralogixLogSeverity() }.getOrNull()
+    if (cxSeverity == null) {
+      Log.w("CxSdkModule", "log: invalid severity $severity, dropping log. Must be one of [1, 2, 3, 4, 5, 6]")
+      return
+    }
+
+    CoralogixRum.log(
+      cxSeverity,
+      message ?: "",
+      data?.toStringAnyMap() ?: emptyMap(),
+      labels?.toStringAnyMap() ?: emptyMap()
+    )
   }
 
   @ReactMethod

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

@@ -10,10 +10,10 @@ interface RUMClient {
   fun getUserContext(promise: Promise)
   fun setApplicationContext(appContextMap: ReadableMap)
   fun getSessionId(promise: Promise)
-  fun setLabels(labelsMap: ReadableMap)
+  fun setLabels(labelsMap: ReadableMap?)
   fun getLabels(promise: Promise)
   fun setViewContext(viewContext: String)
-  fun log(severity: Int, message: String, data: ReadableMap, labels: ReadableMap)
+  fun log(severity: Int, message: String?, data: ReadableMap?, labels: ReadableMap?)
   fun reportNetworkRequest(requestDetails: ReadableMap)
   fun sendCustomMeasurement(measurement: ReadableMap)
   fun startTimeMeasure(name: String, labels: ReadableMap?)

package/index.cjs.js

@@ -1140,7 +1140,7 @@ function stopJsRefreshRateSampler() {
   appStateSub = null;
 }
 
-var version = "0.11.2";
+var version = "0.11.3";
 var pkg = {
 	version: version};
 
@@ -1741,17 +1741,121 @@ let initPromise;
 // `CoralogixRum.isInited` be true while native has no RUM behind it.
 let nativeOwnsSamplingRoll = false;
 let fetchInstrumentation;
+
+/**
+ * Whether RN can send `value` as a dictionary; never throws. RN sends an object's
+ * enumerable properties, so plain objects and class instances with fields work,
+ * while `Map`, `Set` and `Date` (none enumerable) would arrive as `{}`.
+ */
+function isPlainObjectArgument(value) {
+  try {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+      return false;
+    }
+    const proto = Object.getPrototypeOf(value);
+    if (proto === Object.prototype || proto === null) {
+      return true;
+    }
+    for (const _key in value) {
+      return true;
+    }
+    return false;
+  } catch (_unused) {
+    return false;
+  }
+}
+
+/** Whether `severity` is one of the `CoralogixLogSeverity` values (1–6). */
+function isValidSeverity(severity) {
+  return Number.isInteger(severity) && severity >= 1 && severity <= 6;
+}
+
+/** Type name for warnings; never throws. */
+function describeArgument(value) {
+  if (value === null) {
+    return 'null';
+  }
+  try {
+    var _Object$getPrototypeO;
+    if (Array.isArray(value)) {
+      return 'array';
+    }
+    const name = typeof value === 'object' ? (_Object$getPrototypeO = Object.getPrototypeOf(value)) == null || (_Object$getPrototypeO = _Object$getPrototypeO.constructor) == null ? void 0 : _Object$getPrototypeO.name : undefined;
+    // Minified builds rename classes to one letter, which would only confuse.
+    return name && name !== 'Object' && name.length > 1 ? name : typeof value;
+  } catch (_unused2) {
+    return 'an uninspectable value';
+  }
+}
 function toSafeRecord(name, value) {
   if (value == null) {
     return {};
   }
-  if (typeof value !== 'object' || Array.isArray(value)) {
-    logger.warn(`CoralogixRum.log: \`${name}\` must be a plain object; received ${Array.isArray(value) ? 'array' : typeof value}. Ignoring.`);
+  if (!isPlainObjectArgument(value)) {
+    logger.warn(`CoralogixRum.log: \`${name}\` must be a plain object; received ${describeArgument(value)}. Ignoring.`);
     return {};
   }
   return value;
 }
 
+/** Stringifies any value without throwing (`JSON.stringify` and `String()` both can). */
+function stringifyUnknown(value) {
+  try {
+    const json = JSON.stringify(value);
+    if (typeof json === 'string') {
+      return json;
+    }
+  } catch (_unused3) {
+    // fall through to String()
+  }
+  try {
+    return String(value);
+  } catch (_unused4) {
+    return '[unserializable]';
+  }
+}
+
+/**
+ * Readable text for an `Error` or a function, which `JSON.stringify` renders as `"{}"`
+ * or source code. Returns undefined for anything else; never throws.
+ */
+function describeSpecialMessage(value) {
+  try {
+    if (value instanceof Error) {
+      return value.stack || String(value);
+    }
+    if (typeof value === 'function') {
+      return `[function ${value.name || 'anonymous'}]`;
+    }
+  } catch (_unused5) {
+    // fall through to stringifyUnknown
+  }
+  return undefined;
+}
+
+/**
+ * Coerces `message` to a string before the bridge. On Android a non-string throws
+ * inside RN's argument parsing, before native code runs, so only JS can guard it.
+ */
+function toSafeMessage(value) {
+  if (typeof value === 'string') {
+    return value;
+  }
+  if (value == null) {
+    logger.warn(`CoralogixRum.log: \`message\` must be a string; received ${value === null ? 'null' : 'undefined'}. Sending an empty message.`);
+    return '';
+  }
+  let coerced;
+  if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') {
+    coerced = String(value);
+  } else {
+    var _describeSpecialMessa;
+    coerced = (_describeSpecialMessa = describeSpecialMessage(value)) != null ? _describeSpecialMessa : stringifyUnknown(value);
+  }
+  logger.warn(`CoralogixRum.log: \`message\` must be a string; received ${describeArgument(value)}. Coerced to a string.`);
+  return coerced;
+}
+
 /**
  * The real init work. Runs at most once per in-flight/finished init: `CoralogixRum.init`
  * memoizes the promise this returns, so concurrent callers share this single run.
@@ -1961,6 +2065,13 @@ const CoralogixRum = {
       logger.debug('CoralogixRum must be initiated before setting labels');
       return;
     }
+
+    // Native reads this as a dictionary unchecked, so a non-object crashes the app.
+    // Return instead of sending `{}`, which would wipe existing labels.
+    if (!isPlainObjectArgument(labels)) {
+      logger.warn(`CoralogixRum.setLabels: \`labels\` must be a plain object; received ${describeArgument(labels)}. Ignoring.`);
+      return;
+    }
     CxSdk.setLabels(labels);
   },
   getLabels: async () => {
@@ -1982,9 +2093,16 @@ const CoralogixRum = {
       logger.debug('CoralogixRum must be initiated before using log');
       return;
     }
+
+    // A non-integer severity crashes Android while RN parses the arguments.
+    if (!isValidSeverity(severity)) {
+      logger.warn(`CoralogixRum.log: \`severity\` must be a CoralogixLogSeverity (1-6); received ${describeArgument(severity)}. Dropping the log.`);
+      return;
+    }
+    const safeMessage = toSafeMessage(message);
     const safeData = toSafeRecord('data', data);
     const safeLabels = toSafeRecord('labels', labels);
-    CxSdk.log(severity, message, safeData, safeLabels);
+    CxSdk.log(severity, safeMessage, safeData, safeLabels);
   },
   debug(message, data) {
     this.log(CoralogixLogSeverity.Debug, message, data);

package/index.esm.js

@@ -1138,7 +1138,7 @@ function stopJsRefreshRateSampler() {
   appStateSub = null;
 }
 
-var version = "0.11.2";
+var version = "0.11.3";
 var pkg = {
 	version: version};
 
@@ -1739,17 +1739,121 @@ let initPromise;
 // `CoralogixRum.isInited` be true while native has no RUM behind it.
 let nativeOwnsSamplingRoll = false;
 let fetchInstrumentation;
+
+/**
+ * Whether RN can send `value` as a dictionary; never throws. RN sends an object's
+ * enumerable properties, so plain objects and class instances with fields work,
+ * while `Map`, `Set` and `Date` (none enumerable) would arrive as `{}`.
+ */
+function isPlainObjectArgument(value) {
+  try {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+      return false;
+    }
+    const proto = Object.getPrototypeOf(value);
+    if (proto === Object.prototype || proto === null) {
+      return true;
+    }
+    for (const _key in value) {
+      return true;
+    }
+    return false;
+  } catch (_unused) {
+    return false;
+  }
+}
+
+/** Whether `severity` is one of the `CoralogixLogSeverity` values (1–6). */
+function isValidSeverity(severity) {
+  return Number.isInteger(severity) && severity >= 1 && severity <= 6;
+}
+
+/** Type name for warnings; never throws. */
+function describeArgument(value) {
+  if (value === null) {
+    return 'null';
+  }
+  try {
+    var _Object$getPrototypeO;
+    if (Array.isArray(value)) {
+      return 'array';
+    }
+    const name = typeof value === 'object' ? (_Object$getPrototypeO = Object.getPrototypeOf(value)) == null || (_Object$getPrototypeO = _Object$getPrototypeO.constructor) == null ? void 0 : _Object$getPrototypeO.name : undefined;
+    // Minified builds rename classes to one letter, which would only confuse.
+    return name && name !== 'Object' && name.length > 1 ? name : typeof value;
+  } catch (_unused2) {
+    return 'an uninspectable value';
+  }
+}
 function toSafeRecord(name, value) {
   if (value == null) {
     return {};
   }
-  if (typeof value !== 'object' || Array.isArray(value)) {
-    logger.warn(`CoralogixRum.log: \`${name}\` must be a plain object; received ${Array.isArray(value) ? 'array' : typeof value}. Ignoring.`);
+  if (!isPlainObjectArgument(value)) {
+    logger.warn(`CoralogixRum.log: \`${name}\` must be a plain object; received ${describeArgument(value)}. Ignoring.`);
     return {};
   }
   return value;
 }
 
+/** Stringifies any value without throwing (`JSON.stringify` and `String()` both can). */
+function stringifyUnknown(value) {
+  try {
+    const json = JSON.stringify(value);
+    if (typeof json === 'string') {
+      return json;
+    }
+  } catch (_unused3) {
+    // fall through to String()
+  }
+  try {
+    return String(value);
+  } catch (_unused4) {
+    return '[unserializable]';
+  }
+}
+
+/**
+ * Readable text for an `Error` or a function, which `JSON.stringify` renders as `"{}"`
+ * or source code. Returns undefined for anything else; never throws.
+ */
+function describeSpecialMessage(value) {
+  try {
+    if (value instanceof Error) {
+      return value.stack || String(value);
+    }
+    if (typeof value === 'function') {
+      return `[function ${value.name || 'anonymous'}]`;
+    }
+  } catch (_unused5) {
+    // fall through to stringifyUnknown
+  }
+  return undefined;
+}
+
+/**
+ * Coerces `message` to a string before the bridge. On Android a non-string throws
+ * inside RN's argument parsing, before native code runs, so only JS can guard it.
+ */
+function toSafeMessage(value) {
+  if (typeof value === 'string') {
+    return value;
+  }
+  if (value == null) {
+    logger.warn(`CoralogixRum.log: \`message\` must be a string; received ${value === null ? 'null' : 'undefined'}. Sending an empty message.`);
+    return '';
+  }
+  let coerced;
+  if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') {
+    coerced = String(value);
+  } else {
+    var _describeSpecialMessa;
+    coerced = (_describeSpecialMessa = describeSpecialMessage(value)) != null ? _describeSpecialMessa : stringifyUnknown(value);
+  }
+  logger.warn(`CoralogixRum.log: \`message\` must be a string; received ${describeArgument(value)}. Coerced to a string.`);
+  return coerced;
+}
+
 /**
  * The real init work. Runs at most once per in-flight/finished init: `CoralogixRum.init`
  * memoizes the promise this returns, so concurrent callers share this single run.
@@ -1959,6 +2063,13 @@ const CoralogixRum = {
       logger.debug('CoralogixRum must be initiated before setting labels');
       return;
     }
+
+    // Native reads this as a dictionary unchecked, so a non-object crashes the app.
+    // Return instead of sending `{}`, which would wipe existing labels.
+    if (!isPlainObjectArgument(labels)) {
+      logger.warn(`CoralogixRum.setLabels: \`labels\` must be a plain object; received ${describeArgument(labels)}. Ignoring.`);
+      return;
+    }
     CxSdk.setLabels(labels);
   },
   getLabels: async () => {
@@ -1980,9 +2091,16 @@ const CoralogixRum = {
       logger.debug('CoralogixRum must be initiated before using log');
       return;
     }
+
+    // A non-integer severity crashes Android while RN parses the arguments.
+    if (!isValidSeverity(severity)) {
+      logger.warn(`CoralogixRum.log: \`severity\` must be a CoralogixLogSeverity (1-6); received ${describeArgument(severity)}. Dropping the log.`);
+      return;
+    }
+    const safeMessage = toSafeMessage(message);
     const safeData = toSafeRecord('data', data);
     const safeLabels = toSafeRecord('labels', labels);
-    CxSdk.log(severity, message, safeData, safeLabels);
+    CxSdk.log(severity, safeMessage, safeData, safeLabels);
   },
   debug(message, data) {
     this.log(CoralogixLogSeverity.Debug, message, data);

package/ios/CxSdk.swift

@@ -79,11 +79,15 @@ class CxSdk: RCTEventEmitter {
   }
 
   @objc(setLabels:withResolver:withRejecter:)
-  func setLabels(labelsMap: NSDictionary,
+  func setLabels(labelsMap: NSDictionary?,
                  resolve:RCTPromiseResolveBlock,
                  reject:RCTPromiseRejectBlock) -> Void {
-    let labels = labelsMap as? [String: String] ?? [String: String]()
-    resolve(coralogixRum?.set(labels: labels))
+    // Ignore nil or a non-dictionary, as Android does, rather than wipe the labels.
+    guard let labelsMap = labelsMap, labelsMap.isKind(of: NSDictionary.self) else {
+      resolve(nil)
+      return
+    }
+    resolve(coralogixRum?.set(labels: bridgedDictionary(labelsMap)))
   }
 
   @objc(getLabels:withRejecter:)
@@ -128,18 +132,19 @@ class CxSdk: RCTEventEmitter {
 
   @objc(log:message:data:labels:withResolver:withRejecter:)
   func log(severity: Int,
-           message: String,
-           data: NSDictionary,
-           labels: NSDictionary,
+           message: NSString?,
+           data: NSDictionary?,
+           labels: NSDictionary?,
            resolve:RCTPromiseResolveBlock,
            reject:RCTPromiseRejectBlock) -> Void {
 
     guard let cxLogSeverity = CoralogixLogSeverity(rawValue: Int(severity)) else {
       return
     }
-    let data = data as? [String: Any] ?? [String: Any]()
-    let labels = labels as? [String: Any] ?? [String: Any]()
-    coralogixRum?.log(severity:cxLogSeverity, message: message, data: data, labels: labels)
+    coralogixRum?.log(severity: cxLogSeverity,
+                      message: bridgedString(message),
+                      data: bridgedDictionary(data),
+                      labels: bridgedDictionary(labels))
     resolve("log success")
   }
 
@@ -832,6 +837,30 @@ class CxSdk: RCTEventEmitter {
     return set
   }
 
+  /// Reads a bridged dictionary without trusting its type: release builds skip RN's
+  /// type check, so a JS array/string/number can arrive here. Must be `isKind(of:)` —
+  /// `as? NSDictionary` gets optimised away. Values pass through as `Any`, like Android.
+  private func bridgedDictionary(_ value: NSDictionary?) -> [String: Any] {
+    guard let object = value, object.isKind(of: NSDictionary.self) else {
+      return [String: Any]()
+    }
+
+    var result = [String: Any]()
+    object.enumerateKeysAndObjects { key, value, _ in
+      guard let name = key as? String else { return }
+      result[name] = value
+    }
+    return result
+  }
+
+  /// Same for strings: a Swift `String` parameter would force-cast an `NSNumber` and crash.
+  private func bridgedString(_ value: NSString?) -> String {
+    guard let object = value, object.isKind(of: NSString.self) else {
+      return ""
+    }
+    return object as String
+  }
+
   private func toAnyDict(_ dict: NSDictionary?) -> [String: Any]? {
     guard let dict = dict, dict.count > 0 else { return nil }
     var result = [String: Any]()

package/package.json

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