@coralogix/react-native-plugin 0.3.2 → 0.4.0

package/CHANGELOG.md

@@ -1,3 +1,19 @@
+## 0.4.0 (2026-05-03)
+
+### 🚀 Features
+
+- Custom Spans & Traces Exporter (CX-36055)
+
+### 🩹 Fixes
+
+- import CoralogixIgnoredInstrument in index.ts for rollup build
+
+## 0.3.3 (2026-04-05)
+
+### 🩹 Fixes
+
+- bump Android SDK to 2.9.5 to fix ClassCastException with react-native-skia
+
 ## 0.3.2 (2026-03-29)
 
 ### 🩹 Patch

package/CxSdk.podspec

@@ -16,9 +16,9 @@ Pod::Spec.new do |s|
 
   s.source_files = "ios/**/*.{h,m,mm,swift}"
 
-  s.dependency 'Coralogix','2.4.1'
-  s.dependency 'CoralogixInternal','2.4.1'
-  s.dependency 'SessionReplay','2.4.1'
+  s.dependency 'Coralogix','2.6.2'
+  s.dependency 'CoralogixInternal','2.6.2'
+  s.dependency 'SessionReplay','2.6.2'
 
   # Use install_modules_dependencies helper to install the dependencies if React Native version >=0.71.0.
   # See https://github.com/facebook/react-native/blob/febf6b7f33fdb4904669f99d795eba4c0f95d7bf/scripts/cocoapods/new_architecture.rb#L79.

package/README.md

@@ -184,6 +184,102 @@ await CoralogixRum.init({
 });
 ```
 
+### Custom Spans
+
+Create manual RUM spans to instrument custom flows in your application. Requires `traceParentInHeader.enabled: true`.
+
+**Prerequisite:**
+```javascript
+await CoralogixRum.init({
+  // ...
+  traceParentInHeader: { enabled: true },
+});
+```
+
+**Basic usage — global span with a child:**
+```javascript
+import { CoralogixRum } from '@coralogix/react-native-plugin';
+
+const tracer = CoralogixRum.getCustomTracer();
+
+const globalSpan = await tracer.startGlobalSpan('checkout', { step: 'start' });
+if (!globalSpan) return; // another global span is already active
+
+const childSpan = await globalSpan.startCustomSpan('validate-cart');
+await childSpan?.endSpan();
+
+await globalSpan.endSpan();
+```
+
+**Linking network requests with `withContext`:**
+
+When you call `fetch` inside `withContext`, the network request is automatically linked to the active global span's trace.
+
+```javascript
+const globalSpan = await tracer.startGlobalSpan('checkout');
+
+await globalSpan.withContext(async () => {
+  await fetch('https://api.example.com/cart'); // linked to globalSpan's traceId
+});
+
+await globalSpan.endSpan();
+```
+
+**`ignoredInstruments` — exclude auto-instrumentation from the trace:**
+
+Pass instrument names to prevent network requests, errors, or interactions fired during this tracer's spans from being linked to your custom trace.
+
+```javascript
+const tracer = CoralogixRum.getCustomTracer(['networkRequests', 'userInteractions', 'errors']);
+```
+
+> **Note:** Only one global span may be active at a time. `startGlobalSpan` returns `null` if a global span is already open.
+
+### Traces Exporter
+
+Receive OTLP-formatted trace batches from the native SDK in your JavaScript code. Use this to forward spans to an OTLP-compatible backend (e.g. Jaeger, custom collector) alongside Coralogix.
+
+```javascript
+await CoralogixRum.init({
+  // ...
+  tracesExporter: (data) => {
+    // data.resource_spans contains OTLP JSON-format span data
+    sendToMyOtlpBackend(JSON.stringify(data));
+  },
+});
+```
+
+The callback receives a `TraceExporterData` object following the OTLP JSON format:
+
+```typescript
+{
+  resource_spans: [
+    {
+      resource: { attributes: [{ key: string, value: { string_value: string } }] },
+      scope_spans: [
+        {
+          scope: { name: string, version?: string },
+          spans: [
+            {
+              trace_id: string,
+              span_id: string,
+              parent_span_id?: string,
+              name: string,
+              start_time_unix_nano: string,
+              end_time_unix_nano: string,
+              attributes: [{ key: string, value: {...} }],
+              status: { code: string },
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}
+```
+
+> **Note:** The callback fires once per native export batch, which typically contains several spans rather than one per span.
+
 ### beforeSend
 
 Enable event access and modification before sending to Coralogix, supporting content modification, and event discarding.

package/android/build.gradle

@@ -61,6 +61,15 @@ android {
         "generated/jni"
       ]
     }
+    test {
+      java.srcDirs += ["src/test/kotlin"]
+    }
+  }
+
+  testOptions {
+    unitTests.all {
+      useJUnitPlatform()
+    }
   }
 }
 
@@ -75,7 +84,10 @@ dependencies {
   implementation "com.facebook.react:react-android"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
 
-  implementation "com.coralogix:android-sdk:2.9.3"
+  implementation "com.coralogix:android-sdk:2.11.2"
+
+  testImplementation "org.jetbrains.kotlin:kotlin-test:$kotlin_version"
+  testImplementation "org.mockito:mockito-core:5.12.0"
 }
 
 react {

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

@@ -5,6 +5,10 @@ import android.os.Handler
 import android.os.Looper
 import android.util.Log
 import com.coralogix.android.sdk.CoralogixRum
+import com.coralogix.android.sdk.customspans.CoralogixCustomSpan
+import com.coralogix.android.sdk.customspans.CoralogixGlobalSpan
+import com.coralogix.android.sdk.customspans.CoralogixIgnoredInstrument
+import com.coralogix.android.sdk.traceexporter.CoralogixTraceExporterData
 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
@@ -39,10 +43,14 @@ import com.facebook.react.modules.core.DeviceEventManagerModule
 import org.json.JSONArray
 import org.json.JSONObject
 import com.facebook.react.uimanager.UIManagerModule
+import java.util.concurrent.ConcurrentHashMap
 
 class CxSdkModule(reactContext: ReactApplicationContext) :
   ReactContextBaseJavaModule(reactContext), RUMClient, SessionReplayClient {
 
+  private val globalSpans = ConcurrentHashMap<String, CoralogixGlobalSpan>()
+  private val customSpans = ConcurrentHashMap<String, CoralogixCustomSpan>()
+
   override fun getName(): String {
     return NAME
   }
@@ -290,10 +298,73 @@ class CxSdkModule(reactContext: ReactApplicationContext) :
   }
   // endregion
 
+  // region - Custom Spans
+
+  @ReactMethod
+  override fun startGlobalSpan(name: String, labels: ReadableMap?, ignoredInstruments: ReadableArray?, promise: Promise) {
+    val ignoredSet = ignoredInstruments?.toIgnoredInstrumentSet() ?: emptySet()
+    val tracer = CoralogixRum.getCustomTracer(ignoredSet)
+    if (tracer == null) {
+      promise.resolve(null)
+      return
+    }
+    val globalSpan = tracer.startGlobalSpan(name, labels?.toStringAnyMap())
+    if (globalSpan == null) {
+      promise.resolve(null)
+      return
+    }
+    globalSpans[globalSpan.spanId] = globalSpan
+    val result = Arguments.createMap()
+    result.putString("spanId", globalSpan.spanId)
+    result.putString("traceId", globalSpan.traceId)
+    promise.resolve(result)
+  }
+
+  @ReactMethod
+  override fun startCustomSpan(parentSpanId: String, name: String, labels: ReadableMap?, promise: Promise) {
+    val globalSpan = globalSpans[parentSpanId]
+    if (globalSpan == null) {
+      promise.resolve(null)
+      return
+    }
+    val customSpan = globalSpan.startCustomSpan(name, labels?.toStringAnyMap())
+    val otelIds = extractOtelIds(customSpan)
+    if (otelIds == null) {
+      Log.e(NAME, "startCustomSpan: failed to extract OTel IDs via reflection — resolving null")
+      promise.resolve(null)
+      return
+    }
+    customSpans[otelIds.first] = customSpan
+    val result = Arguments.createMap()
+    result.putString("spanId", otelIds.first)
+    result.putString("traceId", otelIds.second)
+    promise.resolve(result)
+  }
+
+
+  @ReactMethod
+  override fun endSpan(spanId: String, promise: Promise) {
+    globalSpans.remove(spanId)?.let {
+      it.endSpan()
+      promise.resolve(null)
+      return
+    }
+    customSpans.remove(spanId)?.let {
+      it.endSpan()
+      promise.resolve(null)
+      return
+    }
+    Log.w(NAME, "endSpan: unknown spanId $spanId")
+    promise.resolve(null)
+  }
+
+  // endregion
+
   // region - utils
   override fun invalidate() {
     super.invalidate()
-
+    globalSpans.clear()
+    customSpans.clear()
     Handler(Looper.getMainLooper()).post {
       Log.d("CxSdkModule", "Bridge destroyed — shutting down CoralogixRum")
       CoralogixRum.shutdown()
@@ -373,7 +444,16 @@ class CxSdkModule(reactContext: ReactApplicationContext) :
       proxyUrl = getString("proxyUrl"),
       beforeSendCallback = if (hasKey("hasBeforeSend") && getBoolean("hasBeforeSend")) ::beforeSendCallback else null,
       collectIPData = collectIpData,
-      networkCaptureConfig = networkExtraConfig
+      networkCaptureConfig = networkExtraConfig,
+      tracesExporter = if (hasKey("hasTracesExporter") && getBoolean("hasTracesExporter")) {
+        { data: CoralogixTraceExporterData ->
+          if (reactApplicationContext.hasActiveReactInstance()) {
+            reactApplicationContext
+              .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+              .emit("onTracesExport", data.toJson())
+          }
+        }
+      } else null
     )
   }
 
@@ -523,8 +603,9 @@ class CxSdkModule(reactContext: ReactApplicationContext) :
       "AP1" -> CoralogixDomain.AP1
       "AP2" -> CoralogixDomain.AP2
       "AP3" -> CoralogixDomain.AP3
+      "US3" -> CoralogixDomain.US3
       "STAGING" -> CoralogixDomain.STAGING
-      else -> throw IllegalArgumentException("Invalid coralogixDomain: $this. Must be one of [EU1, EU2, US1, US2, AP1, AP2, AP3, STAGING]")
+      else -> throw IllegalArgumentException("Invalid coralogixDomain: $this. Must be one of [EU1, EU2, US1, US2, US3, AP1, AP2, AP3, STAGING]")
     }
   }
 
@@ -758,6 +839,18 @@ class CxSdkModule(reactContext: ReactApplicationContext) :
     return result
   }
 
+  private fun ReadableArray.toIgnoredInstrumentSet(): Set<CoralogixIgnoredInstrument> {
+    val set = mutableSetOf<CoralogixIgnoredInstrument>()
+    for (i in 0 until size()) {
+      when (getString(i)) {
+        "networkRequests" -> set.add(CoralogixIgnoredInstrument.NETWORK_REQUESTS)
+        "userInteractions" -> set.add(CoralogixIgnoredInstrument.USER_INTERACTIONS)
+        "errors" -> set.add(CoralogixIgnoredInstrument.ERRORS)
+      }
+    }
+    return set
+  }
+
   private fun ReadableArray.toHybridMetricList(): List<HybridMetric> {
     val out = ArrayList<HybridMetric>(size())
     for (i in 0 until size()) {
@@ -778,5 +871,22 @@ class CxSdkModule(reactContext: ReactApplicationContext) :
 
   companion object {
     const val NAME = "CxSdk"
+
+    // TODO: replace reflection with a public accessor once the Coralogix Android SDK exposes one —
+    // 'getSpan$library_release' is a Kotlin-internal name that may be renamed in a future SDK version.
+    internal fun extractOtelIds(child: CoralogixCustomSpan): Pair<String, String>? =
+      extractOtelIds(child, "getSpan\$library_release")
+
+    internal fun extractOtelIds(child: CoralogixCustomSpan, accessorName: String): Pair<String, String>? = try {
+      val span = child.javaClass.getMethod(accessorName).invoke(child) ?: return null
+      val ctx = span.javaClass.getMethod("getSpanContext").invoke(span) ?: return null
+      val spanId = ctx.javaClass.getMethod("getSpanId").invoke(ctx) as? String
+      val traceId = ctx.javaClass.getMethod("getTraceId").invoke(ctx) as? String
+      if (spanId.isNullOrEmpty() || traceId.isNullOrEmpty()) null
+      else Pair(spanId, traceId)
+    } catch (e: Throwable) {
+      Log.w(NAME, "extractOtelIds: reflection failed — $e")
+      null
+    }
   }
 }

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

@@ -22,4 +22,9 @@ interface RUMClient {
   fun reportMobileVitalsMeasurementSet(type: String, metrics: ReadableArray)
   fun isCoralogixGradlePluginApplied(promise: Promise)
   fun shutdown(promise: Promise)
+
+  // custom spans
+  fun startGlobalSpan(name: String, labels: ReadableMap?, ignoredInstruments: ReadableArray?, promise: Promise)
+  fun startCustomSpan(parentSpanId: String, name: String, labels: ReadableMap?, promise: Promise)
+  fun endSpan(spanId: String, promise: Promise)
 }

package/android/src/test/kotlin/com/cxsdk/ExtractOtelIdsTest.kt

@@ -0,0 +1,49 @@
+package com.cxsdk
+
+import com.coralogix.android.sdk.customspans.CoralogixCustomSpan
+import io.opentelemetry.api.trace.Span
+import io.opentelemetry.api.trace.SpanContext
+import io.opentelemetry.api.trace.TraceFlags
+import io.opentelemetry.api.trace.TraceState
+import org.mockito.Mockito.mock
+import org.mockito.Mockito.`when`
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNull
+
+class ExtractOtelIdsTest {
+
+    @Test
+    fun `extractOtelIds returns correct spanId and traceId via reflection`() {
+        val spanId  = "1234567890abcdef"
+        val traceId = "abcdef1234567890abcdef1234567890"
+
+        val mockSpan = mock(Span::class.java)
+        `when`(mockSpan.spanContext).thenReturn(
+            SpanContext.create(traceId, spanId, TraceFlags.getDefault(), TraceState.getDefault())
+        )
+
+        val result = CxSdkModule.extractOtelIds(CoralogixCustomSpan(mockSpan))
+
+        assertEquals(Pair(spanId, traceId), result)
+    }
+
+    @Test
+    fun `extractOtelIds returns null when spanContext returns null`() {
+        val mockSpan = mock(Span::class.java)
+        `when`(mockSpan.spanContext).thenReturn(null)
+
+        val result = CxSdkModule.extractOtelIds(CoralogixCustomSpan(mockSpan))
+
+        assertNull(result)
+    }
+
+    @Test
+    fun `extractOtelIds returns null when accessor method does not exist`() {
+        val mockSpan = mock(Span::class.java)
+
+        val result = CxSdkModule.extractOtelIds(CoralogixCustomSpan(mockSpan), "nonExistentMethod")
+
+        assertNull(result)
+    }
+}

package/index.cjs.js

@@ -27,6 +27,14 @@ let CoralogixLogSeverity = /*#__PURE__*/function (CoralogixLogSeverity) {
   return CoralogixLogSeverity;
 }({});
 
+/**
+ * Instrumentation names that can be excluded from a custom tracer's span context.
+ * Pass one or more values to `getCustomTracer()` to prevent those event types from
+ * being linked to spans created by that tracer.
+ */
+
+/** OTLP JSON-format trace data delivered to the `tracesExporter` callback. */
+
 const ERROR_INSTRUMENTATION_NAME = 'errors';
 const ERROR_INSTRUMENTATION_VERSION = '1';
 
@@ -523,7 +531,7 @@ function stopJsRefreshRateSampler() {
   appStateSub = null;
 }
 
-var version = "0.3.2";
+var version = "0.4.0";
 var pkg = {
 	version: version};
 
@@ -561,6 +569,128 @@ class Logger {
 }
 const logger = new Logger();
 
+let activeGlobalSpanId = null;
+const spanTraceIds = new Map();
+let ignoredInstruments = new Set();
+const CustomSpanRegistry = {
+  getActive: () => activeGlobalSpanId,
+  setActive: id => {
+    activeGlobalSpanId = id;
+  },
+  clearActive: () => {
+    activeGlobalSpanId = null;
+  },
+  registerSpan: (spanId, traceId) => {
+    spanTraceIds.set(spanId, traceId);
+  },
+  unregisterSpan: spanId => {
+    spanTraceIds.delete(spanId);
+  },
+  getTraceId: spanId => spanTraceIds.get(spanId),
+  setIgnoredInstruments: set => {
+    ignoredInstruments = set;
+  },
+  getIgnoredInstruments: () => ignoredInstruments,
+  clear: () => {
+    activeGlobalSpanId = null;
+    spanTraceIds.clear();
+    ignoredInstruments.clear();
+  }
+};
+
+/** A child span nested under a {@link CoralogixGlobalSpan}. */
+class CoralogixCustomSpan {
+  constructor(spanId, traceId, bridge) {
+    this.spanId = void 0;
+    this.traceId = void 0;
+    this.bridge = void 0;
+    this.spanId = spanId;
+    this.traceId = traceId;
+    this.bridge = bridge;
+  }
+  async endSpan() {
+    CustomSpanRegistry.unregisterSpan(this.spanId);
+    await this.bridge.endSpan(this.spanId);
+  }
+}
+
+/** A root-level custom span. All child spans and `withContext` network calls share its traceId. */
+class CoralogixGlobalSpan {
+  constructor(spanId, traceId, bridge) {
+    this.spanId = void 0;
+    this.traceId = void 0;
+    this.bridge = void 0;
+    this.spanId = spanId;
+    this.traceId = traceId;
+    this.bridge = bridge;
+  }
+
+  /** Creates a child span nested under this global span. */
+  async startCustomSpan(name, labels) {
+    const raw = await this.bridge.startCustomSpan(this.spanId, name, labels != null ? labels : null);
+    if (!raw) return null;
+    CustomSpanRegistry.registerSpan(raw.spanId, raw.traceId);
+    return new CoralogixCustomSpan(raw.spanId, raw.traceId, this.bridge);
+  }
+
+  /**
+   * Runs fn() with this span set as the active global span for the duration of
+   * the returned promise. The active span ID remains set throughout the full
+   * async chain — including code after intermediate awaits — because we await
+   * fn() before clearing. Only detached callbacks (e.g. setTimeout) that fire
+   * after withContext resolves won't be linked.
+   */
+  async withContext(fn) {
+    const prev = CustomSpanRegistry.getActive();
+    CustomSpanRegistry.setActive(this.spanId);
+    try {
+      return await fn();
+    } finally {
+      if (prev !== null) {
+        CustomSpanRegistry.setActive(prev);
+      } else {
+        CustomSpanRegistry.clearActive();
+      }
+    }
+  }
+  async endSpan() {
+    CustomSpanRegistry.unregisterSpan(this.spanId);
+    if (CustomSpanRegistry.getActive() === this.spanId) {
+      CustomSpanRegistry.clearActive();
+    }
+    await this.bridge.endSpan(this.spanId);
+  }
+}
+
+/**
+ * Entry point for manual RUM tracing. Obtain an instance via `CoralogixRum.getCustomTracer()`.
+ * The `ignoredInstruments` list controls which auto-instrumented events are NOT linked to spans
+ * created by this tracer (e.g. passing `['networkRequests']` keeps network spans independent).
+ */
+class CoralogixCustomTracer {
+  constructor(ignoredInstruments, bridge) {
+    this.ignoredInstruments = void 0;
+    this.bridge = void 0;
+    this.ignoredInstruments = ignoredInstruments;
+    this.bridge = bridge;
+  }
+
+  /**
+   * Starts a new global (root) span. Returns `null` if a global span is already active —
+   * only one global span may exist at a time across the entire app.
+   */
+  async startGlobalSpan(name, labels) {
+    const raw = await this.bridge.startGlobalSpan(name, labels != null ? labels : null, this.ignoredInstruments);
+    if (!raw) {
+      logger.debug('CoralogixCustomTracer: startGlobalSpan returned null — check that the SDK is initialized, traceParentInHeader is enabled, and no other global span is already active');
+      return null;
+    }
+    CustomSpanRegistry.registerSpan(raw.spanId, raw.traceId);
+    CustomSpanRegistry.setIgnoredInstruments(new Set(this.ignoredInstruments));
+    return new CoralogixGlobalSpan(raw.spanId, raw.traceId, this.bridge);
+  }
+}
+
 const CORALOGIX_LOGS_URL_SUFFIX = '/browser/v1beta/logs';
 const CORALOGIX_RECORDING_URL_SUFFIX = '/sessionrecording';
 const OPTIONS_DEFAULTS = {
@@ -838,6 +968,7 @@ let CoralogixDomain = /*#__PURE__*/function (CoralogixDomain) {
   CoralogixDomain["AP1"] = "AP1";
   CoralogixDomain["AP2"] = "AP2";
   CoralogixDomain["AP3"] = "AP3";
+  CoralogixDomain["US3"] = "US3";
   CoralogixDomain["STAGING"] = "staging";
   return CoralogixDomain;
 }({});
@@ -847,6 +978,7 @@ const LINKING_ERROR = `The package 'cx-plugin' doesn't seem to be linked. Make s
   default: ''
 }) + '- You rebuilt the app after installing the package\n' + '- You are not using Expo Go\n';
 let beforeSendCallback;
+let tracesExporterSubscription;
 let _deregisterInstrumentations;
 const CxSdk = reactNative.NativeModules.CxSdk ? reactNative.NativeModules.CxSdk : createErrorProxy(LINKING_ERROR);
 function createErrorProxy(errorMessage) {
@@ -886,10 +1018,28 @@ const CoralogixRum = {
     } else {
       finalOptions = resolvedOptions;
     }
+    if (finalOptions.tracesExporter) {
+      const callback = finalOptions.tracesExporter;
+      tracesExporterSubscription = eventEmitter.addListener('onTracesExport', jsonString => {
+        let data;
+        try {
+          data = JSON.parse(jsonString);
+        } catch (e) {
+          logger.warn('Error parsing onTracesExport payload:', e);
+          return;
+        }
+        try {
+          callback(data);
+        } catch (e) {
+          logger.warn('tracesExporter callback threw:', e);
+        }
+      });
+    }
     await CxSdk.initialize(_extends({}, finalOptions, {
       frameworkVersion: pkg.version,
       networkExtraConfig: finalOptions.networkExtraConfig ? serializeNetworkCaptureRules(finalOptions.networkExtraConfig) : undefined,
-      hasBeforeSend: !!finalOptions.beforeSend
+      hasBeforeSend: !!finalOptions.beforeSend,
+      hasTracesExporter: !!finalOptions.tracesExporter
     }));
     isInited = true;
   },
@@ -901,6 +1051,10 @@ const CoralogixRum = {
     if (subscription) {
       subscription.remove();
     }
+    if (tracesExporterSubscription) {
+      tracesExporterSubscription.remove();
+      tracesExporterSubscription = undefined;
+    }
     isInited = false;
     _deregisterInstrumentations == null || _deregisterInstrumentations();
     _deregisterInstrumentations = undefined;
@@ -992,6 +1146,19 @@ const CoralogixRum = {
   reportNetworkRequest: details => {
     CxSdk.reportNetworkRequest(details);
   },
+  /**
+   * Returns a tracer for creating manual custom spans.
+   * Pass `ignoredInstruments` to prevent specific auto-instrumented event types from being
+   * linked to spans created by this tracer.
+   */
+  getCustomTracer(ignoredInstruments = []) {
+    const bridge = {
+      startGlobalSpan: (name, labels, instruments) => CxSdk.startGlobalSpan(name, labels, instruments),
+      startCustomSpan: (parentSpanId, name, labels) => CxSdk.startCustomSpan(parentSpanId, name, labels),
+      endSpan: spanId => CxSdk.endSpan(spanId)
+    };
+    return new CoralogixCustomTracer(ignoredInstruments, bridge);
+  },
   sendCustomMeasurement: measurement => {
     if (!isInited) {
       logger.debug('CoralogixRum must be initiated before sending custom measurements');
@@ -1221,7 +1388,10 @@ const subscription = eventEmitter.addListener('onBeforeSend', events => {
   }
 });
 
+exports.CoralogixCustomSpan = CoralogixCustomSpan;
+exports.CoralogixCustomTracer = CoralogixCustomTracer;
 exports.CoralogixDomain = CoralogixDomain;
+exports.CoralogixGlobalSpan = CoralogixGlobalSpan;
 exports.CoralogixLogSeverity = CoralogixLogSeverity;
 exports.CoralogixRum = CoralogixRum;
 exports.CxSdk = CxSdk;

package/index.esm.js

@@ -25,6 +25,14 @@ let CoralogixLogSeverity = /*#__PURE__*/function (CoralogixLogSeverity) {
   return CoralogixLogSeverity;
 }({});
 
+/**
+ * Instrumentation names that can be excluded from a custom tracer's span context.
+ * Pass one or more values to `getCustomTracer()` to prevent those event types from
+ * being linked to spans created by that tracer.
+ */
+
+/** OTLP JSON-format trace data delivered to the `tracesExporter` callback. */
+
 const ERROR_INSTRUMENTATION_NAME = 'errors';
 const ERROR_INSTRUMENTATION_VERSION = '1';
 
@@ -521,7 +529,7 @@ function stopJsRefreshRateSampler() {
   appStateSub = null;
 }
 
-var version = "0.3.2";
+var version = "0.4.0";
 var pkg = {
 	version: version};
 
@@ -559,6 +567,128 @@ class Logger {
 }
 const logger = new Logger();
 
+let activeGlobalSpanId = null;
+const spanTraceIds = new Map();
+let ignoredInstruments = new Set();
+const CustomSpanRegistry = {
+  getActive: () => activeGlobalSpanId,
+  setActive: id => {
+    activeGlobalSpanId = id;
+  },
+  clearActive: () => {
+    activeGlobalSpanId = null;
+  },
+  registerSpan: (spanId, traceId) => {
+    spanTraceIds.set(spanId, traceId);
+  },
+  unregisterSpan: spanId => {
+    spanTraceIds.delete(spanId);
+  },
+  getTraceId: spanId => spanTraceIds.get(spanId),
+  setIgnoredInstruments: set => {
+    ignoredInstruments = set;
+  },
+  getIgnoredInstruments: () => ignoredInstruments,
+  clear: () => {
+    activeGlobalSpanId = null;
+    spanTraceIds.clear();
+    ignoredInstruments.clear();
+  }
+};
+
+/** A child span nested under a {@link CoralogixGlobalSpan}. */
+class CoralogixCustomSpan {
+  constructor(spanId, traceId, bridge) {
+    this.spanId = void 0;
+    this.traceId = void 0;
+    this.bridge = void 0;
+    this.spanId = spanId;
+    this.traceId = traceId;
+    this.bridge = bridge;
+  }
+  async endSpan() {
+    CustomSpanRegistry.unregisterSpan(this.spanId);
+    await this.bridge.endSpan(this.spanId);
+  }
+}
+
+/** A root-level custom span. All child spans and `withContext` network calls share its traceId. */
+class CoralogixGlobalSpan {
+  constructor(spanId, traceId, bridge) {
+    this.spanId = void 0;
+    this.traceId = void 0;
+    this.bridge = void 0;
+    this.spanId = spanId;
+    this.traceId = traceId;
+    this.bridge = bridge;
+  }
+
+  /** Creates a child span nested under this global span. */
+  async startCustomSpan(name, labels) {
+    const raw = await this.bridge.startCustomSpan(this.spanId, name, labels != null ? labels : null);
+    if (!raw) return null;
+    CustomSpanRegistry.registerSpan(raw.spanId, raw.traceId);
+    return new CoralogixCustomSpan(raw.spanId, raw.traceId, this.bridge);
+  }
+
+  /**
+   * Runs fn() with this span set as the active global span for the duration of
+   * the returned promise. The active span ID remains set throughout the full
+   * async chain — including code after intermediate awaits — because we await
+   * fn() before clearing. Only detached callbacks (e.g. setTimeout) that fire
+   * after withContext resolves won't be linked.
+   */
+  async withContext(fn) {
+    const prev = CustomSpanRegistry.getActive();
+    CustomSpanRegistry.setActive(this.spanId);
+    try {
+      return await fn();
+    } finally {
+      if (prev !== null) {
+        CustomSpanRegistry.setActive(prev);
+      } else {
+        CustomSpanRegistry.clearActive();
+      }
+    }
+  }
+  async endSpan() {
+    CustomSpanRegistry.unregisterSpan(this.spanId);
+    if (CustomSpanRegistry.getActive() === this.spanId) {
+      CustomSpanRegistry.clearActive();
+    }
+    await this.bridge.endSpan(this.spanId);
+  }
+}
+
+/**
+ * Entry point for manual RUM tracing. Obtain an instance via `CoralogixRum.getCustomTracer()`.
+ * The `ignoredInstruments` list controls which auto-instrumented events are NOT linked to spans
+ * created by this tracer (e.g. passing `['networkRequests']` keeps network spans independent).
+ */
+class CoralogixCustomTracer {
+  constructor(ignoredInstruments, bridge) {
+    this.ignoredInstruments = void 0;
+    this.bridge = void 0;
+    this.ignoredInstruments = ignoredInstruments;
+    this.bridge = bridge;
+  }
+
+  /**
+   * Starts a new global (root) span. Returns `null` if a global span is already active —
+   * only one global span may exist at a time across the entire app.
+   */
+  async startGlobalSpan(name, labels) {
+    const raw = await this.bridge.startGlobalSpan(name, labels != null ? labels : null, this.ignoredInstruments);
+    if (!raw) {
+      logger.debug('CoralogixCustomTracer: startGlobalSpan returned null — check that the SDK is initialized, traceParentInHeader is enabled, and no other global span is already active');
+      return null;
+    }
+    CustomSpanRegistry.registerSpan(raw.spanId, raw.traceId);
+    CustomSpanRegistry.setIgnoredInstruments(new Set(this.ignoredInstruments));
+    return new CoralogixGlobalSpan(raw.spanId, raw.traceId, this.bridge);
+  }
+}
+
 const CORALOGIX_LOGS_URL_SUFFIX = '/browser/v1beta/logs';
 const CORALOGIX_RECORDING_URL_SUFFIX = '/sessionrecording';
 const OPTIONS_DEFAULTS = {
@@ -836,6 +966,7 @@ let CoralogixDomain = /*#__PURE__*/function (CoralogixDomain) {
   CoralogixDomain["AP1"] = "AP1";
   CoralogixDomain["AP2"] = "AP2";
   CoralogixDomain["AP3"] = "AP3";
+  CoralogixDomain["US3"] = "US3";
   CoralogixDomain["STAGING"] = "staging";
   return CoralogixDomain;
 }({});
@@ -845,6 +976,7 @@ const LINKING_ERROR = `The package 'cx-plugin' doesn't seem to be linked. Make s
   default: ''
 }) + '- You rebuilt the app after installing the package\n' + '- You are not using Expo Go\n';
 let beforeSendCallback;
+let tracesExporterSubscription;
 let _deregisterInstrumentations;
 const CxSdk = NativeModules.CxSdk ? NativeModules.CxSdk : createErrorProxy(LINKING_ERROR);
 function createErrorProxy(errorMessage) {
@@ -884,10 +1016,28 @@ const CoralogixRum = {
     } else {
       finalOptions = resolvedOptions;
     }
+    if (finalOptions.tracesExporter) {
+      const callback = finalOptions.tracesExporter;
+      tracesExporterSubscription = eventEmitter.addListener('onTracesExport', jsonString => {
+        let data;
+        try {
+          data = JSON.parse(jsonString);
+        } catch (e) {
+          logger.warn('Error parsing onTracesExport payload:', e);
+          return;
+        }
+        try {
+          callback(data);
+        } catch (e) {
+          logger.warn('tracesExporter callback threw:', e);
+        }
+      });
+    }
     await CxSdk.initialize(_extends({}, finalOptions, {
       frameworkVersion: pkg.version,
       networkExtraConfig: finalOptions.networkExtraConfig ? serializeNetworkCaptureRules(finalOptions.networkExtraConfig) : undefined,
-      hasBeforeSend: !!finalOptions.beforeSend
+      hasBeforeSend: !!finalOptions.beforeSend,
+      hasTracesExporter: !!finalOptions.tracesExporter
     }));
     isInited = true;
   },
@@ -899,6 +1049,10 @@ const CoralogixRum = {
     if (subscription) {
       subscription.remove();
     }
+    if (tracesExporterSubscription) {
+      tracesExporterSubscription.remove();
+      tracesExporterSubscription = undefined;
+    }
     isInited = false;
     _deregisterInstrumentations == null || _deregisterInstrumentations();
     _deregisterInstrumentations = undefined;
@@ -990,6 +1144,19 @@ const CoralogixRum = {
   reportNetworkRequest: details => {
     CxSdk.reportNetworkRequest(details);
   },
+  /**
+   * Returns a tracer for creating manual custom spans.
+   * Pass `ignoredInstruments` to prevent specific auto-instrumented event types from being
+   * linked to spans created by this tracer.
+   */
+  getCustomTracer(ignoredInstruments = []) {
+    const bridge = {
+      startGlobalSpan: (name, labels, instruments) => CxSdk.startGlobalSpan(name, labels, instruments),
+      startCustomSpan: (parentSpanId, name, labels) => CxSdk.startCustomSpan(parentSpanId, name, labels),
+      endSpan: spanId => CxSdk.endSpan(spanId)
+    };
+    return new CoralogixCustomTracer(ignoredInstruments, bridge);
+  },
   sendCustomMeasurement: measurement => {
     if (!isInited) {
       logger.debug('CoralogixRum must be initiated before sending custom measurements');
@@ -1219,4 +1386,4 @@ const subscription = eventEmitter.addListener('onBeforeSend', events => {
   }
 });
 
-export { CoralogixDomain, CoralogixLogSeverity, CoralogixRum, CxSdk, SessionReplay, attachReactNavigationObserver, parseErrorStack };
+export { CoralogixCustomSpan, CoralogixCustomTracer, CoralogixDomain, CoralogixGlobalSpan, CoralogixLogSeverity, CoralogixRum, CxSdk, SessionReplay, attachReactNavigationObserver, parseErrorStack };

package/ios/CxSdk.mm

@@ -106,6 +106,22 @@ RCT_EXTERN_METHOD(maskViewByTag:(nonnull NSNumber *)viewTag
                   withResolver:(RCTPromiseResolveBlock)resolve
                   withRejecter:(RCTPromiseRejectBlock)reject)
 
+RCT_EXTERN_METHOD(startGlobalSpan:(NSString *)name
+                  labels:(NSDictionary *)labels
+                  ignoredInstruments:(NSArray *)ignoredInstruments
+                  withResolver:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(startCustomSpan:(NSString *)parentSpanId
+                  name:(NSString *)name
+                  labels:(NSDictionary *)labels
+                  withResolver:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(endSpan:(NSString *)spanId
+                  withResolver:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
 + (BOOL)requiresMainQueueSetup
 {
   return NO;

package/ios/CxSdk.swift

@@ -1,5 +1,6 @@
 import Foundation
 import Coralogix
+import CoralogixInternal
 import SessionReplay
 import React
 
@@ -11,6 +12,9 @@ enum CxSdkError: Error {
 @objc(CxSdk)
 class CxSdk: RCTEventEmitter {
   var coralogixRum: CoralogixRum?
+  // Accessed only from the RN methodQueue (serial); no explicit locking required.
+  private var globalSpans: [String: CoralogixGlobalSpan] = [:]
+  private var customSpans: [String: CoralogixCustomSpan] = [:]
 
   override init() {
     super.init()
@@ -21,7 +25,7 @@ class CxSdk: RCTEventEmitter {
   }
 
   override func supportedEvents() -> [String]! {
-    return ["onBeforeSend"]
+    return ["onBeforeSend", "onTracesExport"]
   }
 
   @objc(initialize:withResolver:withRejecter:)
@@ -39,6 +43,15 @@ class CxSdk: RCTEventEmitter {
 
       var options = try self.toCoralogixOptions(parameter: parameter)
       options.beforeSendCallBack = beforeSendCallBack
+
+      let hasTracesExporter = parameter["hasTracesExporter"] as? Bool ?? false
+      if hasTracesExporter {
+        options.tracesExporter = { [weak self] data in
+          guard let jsonString = data.jsonString else { return }
+          self?.sendEvent(withName: "onTracesExport", body: jsonString)
+        }
+      }
+
       let rnPluginVersion =  parameter["frameworkVersion"] as? String ?? ""
 
       self.coralogixRum = CoralogixRum(options: options, sdkFramework: .reactNative(version: rnPluginVersion))
@@ -195,6 +208,8 @@ class CxSdk: RCTEventEmitter {
   @objc(shutdown:withRejecter:)
   func shutdown(resolve:RCTPromiseResolveBlock,
                 reject:RCTPromiseRejectBlock) -> Void {
+    globalSpans.removeAll()
+    customSpans.removeAll()
     coralogixRum?.shutdown()
     resolve("shutdown success")
   }
@@ -600,6 +615,78 @@ class CxSdk: RCTEventEmitter {
     }
   }
 
+  // MARK: - Custom Spans
+
+  @objc(startGlobalSpan:labels:ignoredInstruments:withResolver:withRejecter:)
+  func startGlobalSpan(name: String,
+                       labels: NSDictionary?,
+                       ignoredInstruments: NSArray?,
+                       resolve: RCTPromiseResolveBlock,
+                       reject: RCTPromiseRejectBlock) {
+    guard let rum = coralogixRum else { resolve(nil); return }
+    let ignored = toIgnoredInstrumentSet(ignoredInstruments)
+    guard let tracer = rum.getCustomTracer(ignoredInstruments: ignored) else { resolve(nil); return }
+    let labelsDict = toAnyDict(labels)
+    guard let globalSpan = tracer.startGlobalSpan(name: name, labels: labelsDict) else { resolve(nil); return }
+    let spanId = globalSpan.spanId
+    let traceId = globalSpan.traceId
+    globalSpans[spanId] = globalSpan
+    resolve(["spanId": spanId, "traceId": traceId])
+  }
+
+  @objc(startCustomSpan:name:labels:withResolver:withRejecter:)
+  func startCustomSpan(parentSpanId: String,
+                       name: String,
+                       labels: NSDictionary?,
+                       resolve: RCTPromiseResolveBlock,
+                       reject: RCTPromiseRejectBlock) {
+    guard let globalSpan = globalSpans[parentSpanId] else { resolve(nil); return }
+    let labelsDict = toAnyDict(labels)
+    let customSpan = globalSpan.startCustomSpan(name: name, labels: labelsDict)
+    let spanId = customSpan.span.context.spanId.hexString
+    let traceId = globalSpan.traceId
+    guard !spanId.isEmpty else { resolve(nil); return }
+    customSpans[spanId] = customSpan
+    resolve(["spanId": spanId, "traceId": traceId])
+  }
+
+  @objc(endSpan:withResolver:withRejecter:)
+  func endSpan(spanId: String,
+               resolve: RCTPromiseResolveBlock,
+               reject: RCTPromiseRejectBlock) {
+    if let globalSpan = globalSpans.removeValue(forKey: spanId) {
+      globalSpan.endSpan()
+    } else if let customSpan = customSpans.removeValue(forKey: spanId) {
+      customSpan.endSpan()
+    }
+    resolve(nil)
+  }
+
+  private func toIgnoredInstrumentSet(_ array: NSArray?) -> Set<CoralogixIgnoredInstrument> {
+    guard let array = array else { return [] }
+    var set = Set<CoralogixIgnoredInstrument>()
+    for item in array {
+      switch item as? String {
+      case "networkRequests": set.insert(.networkRequests)
+      case "userInteractions": set.insert(.userInteractions)
+      case "errors": set.insert(.errors)
+      default: break
+      }
+    }
+    return set
+  }
+
+  private func toAnyDict(_ dict: NSDictionary?) -> [String: Any]? {
+    guard let dict = dict, dict.count > 0 else { return nil }
+    var result = [String: Any]()
+    for (key, value) in dict {
+      if let k = key as? String {
+        result[k] = value
+      }
+    }
+    return result.isEmpty ? nil : result
+  }
+
   private func getCoralogixDomain(domain: String) -> CoralogixDomain {
     switch domain.uppercased() {
     case "EU1":
@@ -616,6 +703,8 @@ class CxSdk: RCTEventEmitter {
       return .AP2
     case "AP3":
       return .AP3
+    case "US3":
+      return .US3
     case "STAGING":
       return .STG
     default:

package/package.json

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

package/src/custom-spans/CoralogixCustomSpan.d.ts

@@ -0,0 +1,9 @@
+import type { CustomSpanBridge } from './CustomSpanBridge';
+/** A child span nested under a {@link CoralogixGlobalSpan}. */
+export declare class CoralogixCustomSpan {
+    readonly spanId: string;
+    readonly traceId: string;
+    private readonly bridge;
+    constructor(spanId: string, traceId: string, bridge: CustomSpanBridge);
+    endSpan(): Promise<void>;
+}

package/src/custom-spans/CoralogixCustomTracer.d.ts

@@ -0,0 +1,18 @@
+import type { CoralogixIgnoredInstrument } from '../model/Types';
+import { CoralogixGlobalSpan } from './CoralogixGlobalSpan';
+import type { CustomSpanBridge } from './CustomSpanBridge';
+/**
+ * Entry point for manual RUM tracing. Obtain an instance via `CoralogixRum.getCustomTracer()`.
+ * The `ignoredInstruments` list controls which auto-instrumented events are NOT linked to spans
+ * created by this tracer (e.g. passing `['networkRequests']` keeps network spans independent).
+ */
+export declare class CoralogixCustomTracer {
+    private readonly ignoredInstruments;
+    private readonly bridge;
+    constructor(ignoredInstruments: CoralogixIgnoredInstrument[], bridge: CustomSpanBridge);
+    /**
+     * Starts a new global (root) span. Returns `null` if a global span is already active —
+     * only one global span may exist at a time across the entire app.
+     */
+    startGlobalSpan(name: string, labels?: Record<string, any>): Promise<CoralogixGlobalSpan | null>;
+}

package/src/custom-spans/CoralogixGlobalSpan.d.ts

@@ -0,0 +1,20 @@
+import { CoralogixCustomSpan } from './CoralogixCustomSpan';
+import type { CustomSpanBridge } from './CustomSpanBridge';
+/** A root-level custom span. All child spans and `withContext` network calls share its traceId. */
+export declare class CoralogixGlobalSpan {
+    readonly spanId: string;
+    readonly traceId: string;
+    private readonly bridge;
+    constructor(spanId: string, traceId: string, bridge: CustomSpanBridge);
+    /** Creates a child span nested under this global span. */
+    startCustomSpan(name: string, labels?: Record<string, any>): Promise<CoralogixCustomSpan | null>;
+    /**
+     * Runs fn() with this span set as the active global span for the duration of
+     * the returned promise. The active span ID remains set throughout the full
+     * async chain — including code after intermediate awaits — because we await
+     * fn() before clearing. Only detached callbacks (e.g. setTimeout) that fire
+     * after withContext resolves won't be linked.
+     */
+    withContext<T>(fn: () => Promise<T>): Promise<T>;
+    endSpan(): Promise<void>;
+}

package/src/custom-spans/CustomSpanBridge.d.ts

@@ -0,0 +1,11 @@
+export interface CustomSpanBridge {
+    startGlobalSpan(name: string, labels: Record<string, any> | null, ignoredInstruments: string[]): Promise<{
+        spanId: string;
+        traceId: string;
+    } | null>;
+    startCustomSpan(parentSpanId: string, name: string, labels: Record<string, any> | null): Promise<{
+        spanId: string;
+        traceId: string;
+    } | null>;
+    endSpan(spanId: string): Promise<void>;
+}

package/src/custom-spans/CustomSpanRegistry.d.ts

@@ -0,0 +1,12 @@
+import type { CoralogixIgnoredInstrument } from '../model/Types';
+export declare const CustomSpanRegistry: {
+    getActive: () => string | null;
+    setActive: (id: string) => void;
+    clearActive: () => void;
+    registerSpan: (spanId: string, traceId: string) => void;
+    unregisterSpan: (spanId: string) => void;
+    getTraceId: (spanId: string) => string | undefined;
+    setIgnoredInstruments: (set: Set<CoralogixIgnoredInstrument>) => void;
+    getIgnoredInstruments: () => Set<CoralogixIgnoredInstrument>;
+    clear: () => void;
+};

package/src/index.d.ts

@@ -10,6 +10,7 @@ interface CxSdkClient {
     initialize(options: CoralogixBrowserSdkConfig & {
         frameworkVersion?: string;
         hasBeforeSend?: boolean;
+        hasTracesExporter?: boolean;
     }): Promise<boolean>;
     setUserContext(userContext: UserContextConfig): void;
     getUserContext(): Promise<UserContextConfig>;
@@ -38,6 +39,15 @@ interface CxSdkClient {
     captureScreenshot(): void;
     maskViewByTag(viewTag: number): void;
     reportUserInteraction(interaction: InteractionContext): void;
+    startGlobalSpan(name: string, labels: Record<string, any> | null, ignoredInstruments: string[]): Promise<{
+        spanId: string;
+        traceId: string;
+    } | null>;
+    startCustomSpan(parentSpanId: string, name: string, labels: Record<string, any> | null): Promise<{
+        spanId: string;
+        traceId: string;
+    } | null>;
+    endSpan(spanId: string): Promise<void>;
 }
 export declare const CxSdk: CxSdkClient;
 export declare const CoralogixRum: CoralogixOtelWebType;
@@ -47,9 +57,12 @@ export { type ApplicationContextConfig } from './model/ApplicationContextConfig'
 export { type ViewContextConfig } from './model/ViewContextConfig';
 export { CoralogixDomain } from './model/CoralogixDomain';
 export { type UserContextConfig } from './model/UserContextConfig';
-export { type CoralogixBrowserSdkConfig, type NetworkCaptureRule, CoralogixLogSeverity, } from './model/Types';
+export { type CoralogixBrowserSdkConfig, type CoralogixIgnoredInstrument, type NetworkCaptureRule, type TraceExporterData, CoralogixLogSeverity, } from './model/Types';
 export { type CoralogixOtelWebOptionsInstrumentations } from './model/CoralogixOtelWebOptionsInstrumentations';
 export { type CustomMeasurement } from './model/CustomMeasurement';
 export { type NetworkRequestDetails } from './model/NetworkRequestDetails';
 export { type CoralogixMobileVitals } from './model/CoralogixMobileVitals';
 export { attachReactNavigationObserver } from './instrumentations/navigation/NavigationInstrumentation';
+export { CoralogixCustomTracer } from './custom-spans/CoralogixCustomTracer';
+export { CoralogixGlobalSpan } from './custom-spans/CoralogixGlobalSpan';
+export { CoralogixCustomSpan } from './custom-spans/CoralogixCustomSpan';

package/src/model/CoralogixDomain.d.ts

@@ -6,5 +6,6 @@ export declare enum CoralogixDomain {
     AP1 = "AP1",
     AP2 = "AP2",
     AP3 = "AP3",
+    US3 = "US3",
     STAGING = "staging"
 }

package/src/model/CoralogixOtelWebType.d.ts

@@ -1,11 +1,12 @@
 import type { SendLog } from './SendLog';
 import type { CoralogixRumLabels } from './CoralogixRumLabels';
-import { CoralogixBrowserSdkConfig } from './Types';
+import { CoralogixBrowserSdkConfig, CoralogixIgnoredInstrument } from './Types';
 import { UserContextConfig } from './UserContextConfig';
 import { ViewContextConfig } from './ViewContextConfig';
 import { ApplicationContextConfig } from './ApplicationContextConfig';
 import { CustomMeasurement } from './CustomMeasurement';
 import { NetworkRequestDetails } from './NetworkRequestDetails';
+import { CoralogixCustomTracer } from '../custom-spans/CoralogixCustomTracer';
 export interface CoralogixOtelWebType extends SendLog {
     /**
      * Init CoralogixRum.
@@ -46,5 +47,10 @@ export interface CoralogixOtelWebType extends SendLog {
      * @param details
      */
     reportNetworkRequest: (details: NetworkRequestDetails) => void;
+    /**
+     * Returns a tracer for creating custom spans. Instruments listed in
+     * ignoredInstruments will not be auto-parented to the active global span.
+     */
+    getCustomTracer: (ignoredInstruments?: CoralogixIgnoredInstrument[]) => CoralogixCustomTracer;
     readonly isInited: boolean;
 }

package/src/model/Types.d.ts

@@ -218,12 +218,24 @@ export interface CoralogixBrowserSdkConfig {
         sampleIntervalMs?: number;
     };
     mobileVitals?: CoralogixMobileVitals;
+    /** Callback invoked with each OTLP trace batch exported by the native SDK. */
+    tracesExporter?: (data: TraceExporterData) => void;
 }
 export type HybridMetric = {
     name: string;
     value: number;
     units: string;
 };
+/**
+ * Instrumentation names that can be excluded from a custom tracer's span context.
+ * Pass one or more values to `getCustomTracer()` to prevent those event types from
+ * being linked to spans created by that tracer.
+ */
+export type CoralogixIgnoredInstrument = 'networkRequests' | 'userInteractions' | 'errors';
+/** OTLP JSON-format trace data delivered to the `tracesExporter` callback. */
+export interface TraceExporterData {
+    resource_spans: Record<string, unknown>[];
+}
 export interface InteractionContext {
     type: 'click' | 'scroll' | 'swipe';
     /** Required. Element identifier: accessibilityLabel ?? componentName for clicks; 'ScrollView' for scroll/swipe. */