@luciq/react-native 19.2.1 → 19.3.0-40271-SNAPSHOT

package/ios/RNLuciq/LuciqAPMBridge.m

@@ -90,6 +90,61 @@ RCT_EXPORT_METHOD(setScreenRenderingEnabled:(BOOL)isEnabled) {
     LCQAPM.screenRenderingEnabled = isEnabled;
 }
 
+// Syncs a custom span to the native SDK (currently logs only)
+RCT_EXPORT_METHOD(syncCustomSpan:(NSString *)name
+                  startTimestamp:(double)startTimestamp
+                  endTimestamp:(double)endTimestamp
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    @try {
+        // Convert microseconds → seconds (NSDate uses seconds)
+        NSTimeInterval startSeconds = startTimestamp / 1e6;
+        NSTimeInterval endSeconds   = endTimestamp / 1e6;
+
+        NSDate *startDate = [NSDate dateWithTimeIntervalSince1970:startSeconds];
+        NSDate *endDate   = [NSDate dateWithTimeIntervalSince1970:endSeconds];
+
+        // Add completed span to APM
+        [LCQAPM addCompletedCustomSpanWithName:name
+                                     startDate:startDate
+                                       endDate:endDate];
+
+        resolve(@YES);
+    }
+    @catch (NSException *exception) {
+        reject(
+            @"SYNC_CUSTOM_SPAN_ERROR",
+            exception.reason ?: @"Failed to sync custom span",
+            nil
+        );
+    }
+}
+
+// Checks if custom spans feature is enabled
+RCT_EXPORT_METHOD(isCustomSpanEnabled:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    @try {
+        BOOL enabled = LCQAPM.customSpansEnabled;
+        resolve(@(enabled));
+    } @catch (NSException *exception) {
+        NSLog(@"[CustomSpan] Error checking feature flag: %@", exception);
+        resolve(@NO);
+    }
+}
+
+// Checks if APM is enabled
+RCT_EXPORT_METHOD(isAPMEnabled:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    @try {
+        BOOL enabled = LCQAPM.enabled;
+        resolve(@(enabled));
+    } @catch (NSException *exception) {
+        NSLog(@"[CustomSpan] Error checking APM enabled: %@", exception);
+        resolve(@NO);
+    }
+}
+
 
 
 @synthesize description;

package/ios/RNLuciq/LuciqReactBridge.m

@@ -545,4 +545,16 @@ RCT_EXPORT_METHOD(setNetworkLogBodyEnabled:(BOOL)isEnabled) {
     LCQNetworkLogger.logBodyEnabled = isEnabled;
 }
 
+// Checks if Luciq SDK is initialized
+RCT_EXPORT_METHOD(isBuilt:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    @try {
+        BOOL isBuilt = YES;
+        resolve(@(isBuilt));
+    } @catch (NSException *exception) {
+        NSLog(@"[Luciq] Error checking if SDK is built: %@", exception);
+        resolve(@NO);
+    }
+}
+
 @end

package/ios/RNLuciq/Util/LCQAPM+PrivateAPIs.h

@@ -11,5 +11,6 @@
 
 @property (class, atomic, assign) BOOL networkEnabled;
 
++ (BOOL)customSpansEnabled;
 
 @end

package/ios/native.rb

@@ -1,4 +1,4 @@
-$luciq= { :version => '19.4.0' }
+$luciq= { :version => '19.5.0' }
 
 def use_luciq! (spec = nil)
   version = $luciq[:version]

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@luciq/react-native",
   "description": "Luciq is the Agentic Observability Platform built for Mobile.",
-  "version": "19.2.1",
+  "version": "19.3.0-40271-SNAPSHOT",
   "author": "Luciq (https://luciq.ai)",
   "repository": "github:luciqai/luciq-reactnative-sdk",
   "homepage": "https://www.luciq.ai/platforms/react-native",
@@ -43,7 +43,6 @@
   },
   "devDependencies": {
     "@apollo/client": "^3.7.0",
-    "@instabug/danger-plugin-coverage": "Instabug/danger-plugin-coverage",
     "@react-native-community/eslint-config": "^3.1.0",
     "@react-navigation/native": "^6.1.7",
     "@rollup/plugin-commonjs": "^25.0.3",

package/plugin/build/index.js

@@ -42044,9 +42044,16 @@ function addLuciqBuildPhase(xcodeProject, packageName) {
 // Inject source map export line into the shell script
 function injectSourceMapExport(script) {
     var exportLine = 'export SOURCEMAP_FILE="$DERIVED_FILE_DIR/main.jsbundle.map"';
-    var escapedLine = exportLine.replace(/\$/g, '\\$').replace(/"/g, '\\"');
+    var escapedLine = exportLine.replace(/"/g, '\\"');
     var injectedLine = "".concat(escapedLine, "\\n");
-    return script.includes(escapedLine) ? script : script.replace(/^"/, "\"".concat(injectedLine));
+    if (script.includes(escapedLine)) {
+        return script;
+    }
+    var buggyLine = exportLine.replace(/\$/g, '\\$').replace(/"/g, '\\"');
+    if (script.includes(buggyLine)) {
+        return script.split(buggyLine).join(escapedLine);
+    }
+    return script.replace(/^"/, "\"".concat(injectedLine));
 }
 
 var luciqPackage = require('../../package.json');

package/plugin/src/withLuciqIOS.ts

@@ -102,8 +102,15 @@ function addLuciqBuildPhase(xcodeProject: XcodeProject, packageName: string): vo
 // Inject source map export line into the shell script
 function injectSourceMapExport(script: string): string {
   const exportLine = 'export SOURCEMAP_FILE="$DERIVED_FILE_DIR/main.jsbundle.map"';
-  const escapedLine = exportLine.replace(/\$/g, '\\$').replace(/"/g, '\\"');
+  const escapedLine = exportLine.replace(/"/g, '\\"');
   const injectedLine = `${escapedLine}\\n`;
 
-  return script.includes(escapedLine) ? script : script.replace(/^"/, `"${injectedLine}`);
+  if (script.includes(escapedLine)) {
+    return script;
+  }
+  const buggyLine = exportLine.replace(/\$/g, '\\$').replace(/"/g, '\\"');
+  if (script.includes(buggyLine)) {
+    return script.split(buggyLine).join(escapedLine);
+  }
+  return script.replace(/^"/, `"${injectedLine}`);
 }

package/scripts/releases/changelog_to_slack_formatter.sh

@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+input=$(cat)
+
+input=$(sed -E \
+          -e 's/\[([^]]+)\]\(([^)]+)\)/<\2|\1>/g' \
+          -e 's/^#{1,6}[[:space:]]*([^[:space:]].*)$/\*\1\*/' \
+          -e 's/^- /• /' <<< "$input")
+
+echo "$input"

package/scripts/releases/get_job_approver.sh

@@ -0,0 +1,60 @@
+if [ -z "$CIRCLE_TOKEN" ]; then
+  echo "Error: CIRCLE_TOKEN is not set" >&2
+  exit 1
+fi
+
+if [ -z "$CIRCLE_WORKFLOW_ID" ]; then
+  if [ -z "$CIRCLE_PIPELINE_ID" ]; then
+    echo "Error: Neither CIRCLE_WORKFLOW_ID nor CIRCLE_PIPELINE_ID is set" >&2
+    exit 1
+  fi
+  pipelineJson=$(curl -s -X GET "https://circleci.com/api/v2/pipeline/$CIRCLE_PIPELINE_ID/workflow" --header "Circle-Token: $CIRCLE_TOKEN")
+  CIRCLE_WORKFLOW_ID=$(echo "$pipelineJson" | jq -r '.items[0].id // empty')
+  if [ -z "$CIRCLE_WORKFLOW_ID" ]; then
+    echo "Error: Failed to get workflow ID from pipeline" >&2
+    exit 1
+  fi
+fi
+
+response=$(curl -s -w "\n%{http_code}" -X GET "https://circleci.com/api/v2/workflow/$CIRCLE_WORKFLOW_ID/job" --header "Circle-Token: $CIRCLE_TOKEN")
+http_code=$(echo "$response" | tail -n1)
+jobsJson=$(echo "$response" | sed '$d')
+
+if [ "$http_code" != "200" ]; then
+  echo "Error: CircleCI API returned HTTP $http_code" >&2
+  echo "Workflow ID: $CIRCLE_WORKFLOW_ID" >&2
+  echo "Response: $jobsJson" >&2
+  exit 1
+fi
+
+if [ -z "$jobsJson" ]; then
+  echo "Error: Failed to fetch jobs from CircleCI API (empty response)" >&2
+  exit 1
+fi
+
+if ! echo "$jobsJson" | jq -e '.items' > /dev/null 2>&1; then
+  echo "Error: Invalid JSON response from CircleCI API" >&2
+  echo "Response: $jobsJson" >&2
+  exit 1
+fi
+
+job=$(jq '.items[] | select(.name == "hold_publish" or .name == "hold_slack_notification") | select(.approved_by != null)' <<< "$jobsJson")
+
+if [ -z "$job" ] || [ "$job" == "null" ]; then
+  echo "Error: Could not find approved job in workflow" >&2
+  exit 1
+fi
+
+approver_id=$(jq '.approved_by' <<< "$job")
+
+approver_id=$(tr -d '"' <<< "$approver_id")
+
+user=$(curl -s -X GET "https://circleci.com/api/v2/user/$approver_id" --header "Circle-Token: $CIRCLE_TOKEN")
+
+username=$(jq '.login' <<< "$user")
+
+username=$(tr -d '"' <<< "$username")
+
+slack_id=$(./scripts/releases/get_slack_id_from_username.sh "$username")
+
+echo "$slack_id"

package/scripts/releases/get_release_notes.sh

@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+latest_release=""
+capturing=false
+
+while IFS= read -r line; do
+  if [[ "$line" == "## ["* ]]; then
+      if $capturing; then
+        break
+      fi
+  fi
+
+  if [[ "$line" == "### "* ]]; then
+    capturing=true
+  fi
+
+  if $capturing; then
+    line=$(./scripts/releases/changelog_to_slack_formatter.sh <<< "$line")
+    latest_release+="$line\n"
+  fi
+done < CHANGELOG.md
+
+echo "$latest_release"

package/scripts/releases/get_sdk_version.sh

@@ -0,0 +1,5 @@
+sdk_version=$(grep -i 'version' package.json) #"version": "xx.x.x+x",
+sdk_version=$(cut -f2 -d' ' <<< $sdk_version | tr -d '" ,') #xx.x.x+x,
+sdk_version=$(cut -f1 -d'+' <<< $sdk_version) #xx.x.x
+
+echo "$sdk_version"

package/scripts/releases/get_slack_id_from_username.sh

@@ -0,0 +1,24 @@
+github_username=$1
+
+case $github_username in
+    'mzelzoghbi')
+        sid='U5697F4EL'
+        ;;
+    'AndrewAminInstabug')
+        sid='U06JVRNMKE1'
+        ;;
+    'ahmedAlaaInstabug')
+        sid='U06AE2G1161'
+        ;;
+    'kholood-ea')
+        sid='U06SU2QR280'
+        ;;
+   'AyaMahmoud148')
+        sid='U07GZSURC8K'
+        ;;
+    'MoKamall')
+        sid='U06JHDS3JJK'
+        ;;
+    *)
+esac
+echo "$sid"

package/src/constants/Strings.ts

@@ -0,0 +1,24 @@
+export class LuciqStrings {
+  static readonly customSpanAPMDisabledMessage: string =
+    'APM is disabled, custom span not created. Please enable APM by following the instructions at this link:\n' +
+    'https://docs.luciq.ai/product-guides-and-integrations/product-guides/application-performance-monitoring';
+
+  static readonly customSpanDisabled: string =
+    'Custom span is disabled, custom span not created. Please enable Custom Span by following the instructions at this link:\n' +
+    'https://docs.luciq.ai/product-guides-and-integrations/product-guides/application-performance-monitoring';
+
+  static readonly customSpanSDKNotInitializedMessage: string =
+    'Luciq API was called before the SDK is built. To build it, first by following the instructions at this link:\n' +
+    'https://docs.luciq.ai/product-guides-and-integrations/product-guides/application-performance-monitoring';
+
+  static readonly customSpanNameEmpty: string =
+    'Custom span name cannot be empty. Please provide a valid name for the custom span.';
+
+  static readonly customSpanEndTimeBeforeStartTime: string =
+    'Custom span end time must be after start time. Please provide a valid start and end time for the custom span.';
+
+  static readonly customSpanNameTruncated: string = 'Custom span name truncated to 150 characters';
+
+  static readonly customSpanLimitReached: string =
+    'Maximum number of concurrent custom spans (100) reached. Please end some spans before starting new ones.';
+}

package/src/index.ts

@@ -2,6 +2,7 @@
 import type { LuciqConfig } from './models/LuciqConfig';
 import Report from './models/Report';
 import type { ThemeConfig } from './models/ThemeConfig';
+import { CustomSpan } from './models/CustomSpan';
 // Modules
 import * as APM from './modules/APM';
 import * as BugReporting from './modules/BugReporting';
@@ -23,6 +24,7 @@ import type { SessionMetadata } from './models/SessionMetadata';
 export * from './utils/Enums';
 export {
   Report,
+  CustomSpan,
   APM,
   BugReporting,
   CrashReporting,

package/src/models/CustomSpan.ts

@@ -0,0 +1,102 @@
+/**
+ * Callback to unregister a span from tracking
+ */
+type UnregisterCallback = (span: CustomSpan) => void;
+
+/**
+ * Callback to sync span data to native SDK
+ */
+type SyncCallback = (name: string, startTimestamp: number, endTimestamp: number) => Promise<void>;
+
+/**
+ * Represents a custom span for performance tracking.
+ * A span measures the duration of an operation and reports it to the native SDK.
+ */
+export class CustomSpan {
+  private name: string;
+  private startTime: number; // Date.now() in milliseconds
+  private startMonotonic: number; // performance.now() in milliseconds
+  private endTime?: number;
+  private duration?: number;
+  private hasEnded: boolean = false;
+  private endPromise?: Promise<void>;
+  private unregisterCallback: UnregisterCallback;
+  private syncCallback: SyncCallback;
+
+  /**
+   * Creates a new custom span. The span starts immediately upon creation.
+   * @internal - Use APM.startCustomSpan() instead
+   */
+  constructor(name: string, unregisterCallback: UnregisterCallback, syncCallback: SyncCallback) {
+    this.name = name;
+    this.startTime = Date.now();
+    this.startMonotonic = performance.now();
+    this.unregisterCallback = unregisterCallback;
+    this.syncCallback = syncCallback;
+  }
+
+  /**
+   * Ends this custom span and reports it to the native SDK.
+   * This method is idempotent - calling it multiple times is safe.
+   * Subsequent calls will wait for the first call to complete.
+   */
+  async end(): Promise<void> {
+    // Thread-safe check using Promise-based locking
+    if (this.hasEnded) {
+      if (this.endPromise) {
+        await this.endPromise;
+      }
+      return;
+    }
+
+    // Create lock and mark as ended
+    let resolveEnd: () => void;
+    this.endPromise = new Promise((resolve) => {
+      resolveEnd = resolve;
+    });
+    this.hasEnded = true;
+
+    try {
+      // Unregister from active spans
+      this.unregisterCallback(this);
+
+      // Calculate duration using monotonic clock
+      const endMonotonic = performance.now();
+      this.duration = endMonotonic - this.startMonotonic;
+
+      // Calculate end time using wall clock
+      this.endTime = this.startTime + this.duration;
+
+      // Convert to microseconds for native SDK
+      const startMicros = this.startTime * 1000;
+      const endMicros = this.endTime * 1000;
+
+      // Send to native SDK
+      await this.syncCallback(this.name, startMicros, endMicros);
+    } finally {
+      // Release lock
+      resolveEnd!();
+    }
+  }
+
+  /**
+   * Get the span name
+   */
+  getName(): string {
+    return this.name;
+  }
+
+  /**
+   * Check if the span has ended
+   */
+  isEnded(): boolean {
+    return this.hasEnded;
+  }
+
+  /**
+   * Get the span duration in milliseconds (only available after end())
+   */
+  getDuration(): number | undefined {
+    return this.duration;
+  }
+}

package/src/modules/APM.ts

@@ -2,6 +2,11 @@ import { Platform } from 'react-native';
 
 import { NativeAPM } from '../native/NativeAPM';
 import { NativeLuciq } from '../native/NativeLuciq';
+import {
+  startCustomSpan as startCustomSpanInternal,
+  addCompletedCustomSpan as addCompletedCustomSpanInternal,
+} from '../utils/CustomSpansManager';
+import type { CustomSpan } from '../models/CustomSpan';
 
 /**
  * Enables or disables APM
@@ -123,3 +128,70 @@ export const _lcqSleep = () => {
 export const setScreenRenderingEnabled = (isEnabled: boolean) => {
   NativeAPM.setScreenRenderingEnabled(isEnabled);
 };
+
+/**
+ * Starts a custom span for performance tracking.
+ *
+ * A custom span measures the duration of an arbitrary operation that is not
+ * automatically tracked by the SDK. The span must be manually ended by calling
+ * the `end()` method on the returned span object.
+ *
+ * @param name - The name of the span. Cannot be empty. Max 150 characters.
+ *               Leading and trailing whitespace will be trimmed.
+ *
+ * @returns Promise<CustomSpan | null> - The span object to end later, or null if:
+ *   - Name is empty after trimming
+ *   - SDK is not initialized
+ *   - APM is disabled
+ *   - Custom spans feature is disabled
+ *   - Maximum concurrent spans limit (100) reached
+ *
+ * @example
+ * ```typescript
+ * const span = await APM.startCustomSpan('Load User Profile');
+ * if (span) {
+ *   try {
+ *     // ... perform operation ...
+ *   } finally {
+ *     await span.end();
+ *   }
+ * }
+ * ```
+ */
+export const startCustomSpan = async (name: string): Promise<CustomSpan | null> => {
+  return startCustomSpanInternal(name);
+};
+
+/**
+ * Records a completed custom span with pre-recorded timestamps.
+ *
+ * Use this method when you have already recorded the start and end times
+ * of an operation and want to report it retroactively.
+ *
+ * @param name - The name of the span. Cannot be empty. Max 150 characters.
+ *               Leading and trailing whitespace will be trimmed.
+ * @param startDate - The start time of the operation
+ * @param endDate - The end time of the operation (must be after startDate)
+ *
+ * @returns Promise<void> - Resolves when the span has been recorded, or logs error if:
+ *   - Name is empty after trimming
+ *   - End date is not after start date
+ *   - SDK is not initialized
+ *   - APM is disabled
+ *   - Custom spans feature is disabled
+ *
+ * @example
+ * ```typescript
+ * const start = new Date();
+ * // ... operation already completed ...
+ * const end = new Date();
+ * await APM.addCompletedCustomSpan('Cache Lookup', start, end);
+ * ```
+ */
+export const addCompletedCustomSpan = async (
+  name: string,
+  startDate: Date,
+  endDate: Date,
+): Promise<void> => {
+  return addCompletedCustomSpanInternal(name, startDate, endDate);
+};

package/src/modules/Luciq.ts

@@ -10,7 +10,7 @@ import type { NavigationAction, NavigationState as NavigationStateV4 } from 'rea
 import type { LuciqConfig } from '../models/LuciqConfig';
 import Report from '../models/Report';
 import { emitter, NativeEvents, NativeLuciq } from '../native/NativeLuciq';
-import { registerFeatureFlagsListener } from '../utils/FeatureFlags';
+import { registerFeatureFlagsListener, initFeatureFlagsCache } from '../utils/FeatureFlags';
 import {
   AutoMaskingType,
   ColorTheme,
@@ -81,6 +81,8 @@ function reportCurrentViewForAndroid(screenName: string | null) {
  * @param config SDK configurations. See {@link LuciqConfig} for more info.
  */
 export const init = (config: LuciqConfig) => {
+  initFeatureFlagsCache();
+
   if (Platform.OS === 'android') {
     // Add android feature flags listener for android
     registerFeatureFlagsListener();

package/src/modules/NetworkLogger.ts

@@ -39,10 +39,17 @@ function getPortFromUrl(url: string) {
  * It is enabled by default.
  * @param isEnabled
  */
+const NET_TAG = 'LCQ-RN-NET:';
+
 export const setEnabled = (isEnabled: boolean) => {
   if (isEnabled) {
     xhr.enableInterception();
     xhr.setOnDoneCallback(async (network) => {
+      Logger.debug(
+        NET_TAG,
+        `[NetworkLogger] onDoneCallback received: ${network.method} ${network.url}, status=${network.responseCode}`,
+      );
+
       // eslint-disable-next-line no-new-func
       const predicate = Function('network', 'return ' + _requestFilterExpression);
 
@@ -50,12 +57,17 @@ export const setEnabled = (isEnabled: boolean) => {
         const MAX_NETWORK_BODY_SIZE_IN_BYTES = await NativeLuciq.getNetworkBodyMaxSize();
         try {
           if (_networkDataObfuscationHandler) {
+            Logger.debug(NET_TAG, `[NetworkLogger] Running obfuscation handler for ${network.url}`);
             network = await _networkDataObfuscationHandler(network);
           }
 
           if (__DEV__) {
             const urlPort = getPortFromUrl(network.url);
             if (urlPort === LuciqRNConfig.metroDevServerPort) {
+              Logger.debug(
+                NET_TAG,
+                `[NetworkLogger] Skipping Metro dev server request: ${network.url}`,
+              );
               return;
             }
           }
@@ -97,10 +109,23 @@ export const setEnabled = (isEnabled: boolean) => {
             );
           }
 
+          Logger.debug(
+            NET_TAG,
+            `[NetworkLogger] Reporting network log to native: ${network.method} ${network.url}`,
+          );
           reportNetworkLog(network);
         } catch (e) {
-          Logger.error(e);
+          Logger.error(
+            NET_TAG,
+            `[NetworkLogger] Error processing network log for ${network.url}:`,
+            e,
+          );
         }
+      } else {
+        Logger.debug(
+          NET_TAG,
+          `[NetworkLogger] Request filtered out by predicate: ${network.method} ${network.url}, expression="${_requestFilterExpression}"`,
+        );
       }
     });
   } else {

package/src/native/NativeAPM.ts

@@ -47,6 +47,13 @@ export interface ApmNativeModule extends NativeModule {
 
   // Screen Rendering //
   setScreenRenderingEnabled(isEnabled: boolean): void;
+
+  // Custom Spans APIs //
+  syncCustomSpan(name: string, startTimestamp: number, endTimestamp: number): Promise<void>;
+
+  isCustomSpanEnabled(): Promise<boolean>;
+
+  isAPMEnabled(): Promise<boolean>;
 }
 
 export const NativeAPM = NativeModules.LCQAPM;

package/src/native/NativeLuciq.ts

@@ -22,6 +22,7 @@ export interface LuciqNativeModule extends NativeModule {
 
   // Essential APIs //
   setEnabled(isEnabled: boolean): void;
+  isBuilt(): Promise<boolean>;
   init(
     token: string,
     invocationEvents: InvocationEvent[],