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

package/src/utils/CustomSpansManager.ts

@@ -0,0 +1,202 @@
+import { NativeAPM } from '../native/NativeAPM';
+import { NativeLuciq } from '../native/NativeLuciq';
+import { CustomSpan } from '../models/CustomSpan';
+import { LuciqStrings } from '../constants/Strings';
+
+/**
+ * Tracks currently active custom spans
+ * @internal
+ */
+const activeSpans = new Set<CustomSpan>();
+
+/**
+ * Maximum concurrent custom spans allowed at any time
+ * @internal
+ */
+const MAX_CONCURRENT_SPANS = 100;
+
+/**
+ * Internal: unregister a span from active tracking
+ * @internal
+ */
+const unregisterSpan = (span: CustomSpan): void => {
+  activeSpans.delete(span);
+};
+
+/**
+ * Internal: sync custom span data to native SDK
+ * @internal
+ */
+const syncCustomSpan = async (
+  name: string,
+  startTimestamp: number,
+  endTimestamp: number,
+): Promise<void> => {
+  // Validate inputs (safety net)
+  if (!name || name.trim().length === 0) {
+    console.error(LuciqStrings.customSpanNameEmpty);
+    return;
+  }
+
+  if (endTimestamp <= startTimestamp) {
+    console.error(LuciqStrings.customSpanEndTimeBeforeStartTime);
+    return;
+  }
+
+  // Truncate name if needed (safety net)
+  let spanName = name.trim();
+  if (spanName.length > 150) {
+    spanName = spanName.substring(0, 150);
+  }
+
+  await NativeAPM.syncCustomSpan(spanName, startTimestamp, endTimestamp);
+};
+
+/**
+ * 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
+ */
+export const startCustomSpan = async (name: string): Promise<CustomSpan | null> => {
+  try {
+    // Validate name
+    const trimmedName = name.trim();
+    if (trimmedName.length === 0) {
+      console.error(LuciqStrings.customSpanNameEmpty);
+      return null;
+    }
+
+    // Check SDK initialization
+    const isInitialized = await NativeLuciq.isBuilt();
+    if (!isInitialized) {
+      console.error(LuciqStrings.customSpanSDKNotInitializedMessage);
+      return null;
+    }
+
+    // Check APM enabled
+    const isAPMEnabled = await NativeAPM.isAPMEnabled();
+    if (!isAPMEnabled) {
+      console.log(LuciqStrings.customSpanAPMDisabledMessage);
+      return null;
+    }
+
+    // Check custom spans enabled
+    const isCustomSpanEnabled = await NativeAPM.isCustomSpanEnabled();
+    if (!isCustomSpanEnabled) {
+      console.log(LuciqStrings.customSpanDisabled);
+      return null;
+    }
+
+    // Check concurrent span limit
+    if (activeSpans.size >= MAX_CONCURRENT_SPANS) {
+      console.error(LuciqStrings.customSpanLimitReached);
+      return null;
+    }
+
+    // Truncate name if needed
+    let spanName = trimmedName;
+    if (spanName.length > 150) {
+      spanName = spanName.substring(0, 150);
+      console.log(LuciqStrings.customSpanNameTruncated);
+    }
+
+    // Create and register span with callbacks
+    const span = new CustomSpan(spanName, unregisterSpan, syncCustomSpan);
+    activeSpans.add(span);
+    return span;
+  } catch (error) {
+    console.error('[CustomSpan] Error starting span:', error);
+    return null;
+  }
+};
+
+/**
+ * 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>
+ */
+export const addCompletedCustomSpan = async (
+  name: string,
+  startDate: Date,
+  endDate: Date,
+): Promise<void> => {
+  try {
+    // Validate name
+    const trimmedName = name.trim();
+    if (trimmedName.length === 0) {
+      console.error(LuciqStrings.customSpanNameEmpty);
+      return;
+    }
+
+    // Validate timestamps
+    if (endDate <= startDate) {
+      console.error(LuciqStrings.customSpanEndTimeBeforeStartTime);
+      return;
+    }
+
+    // Check SDK initialization
+    const isInitialized = await NativeLuciq.isBuilt();
+    if (!isInitialized) {
+      console.error(LuciqStrings.customSpanSDKNotInitializedMessage);
+      return;
+    }
+
+    // Check APM enabled
+    const isAPMEnabled = await NativeAPM.isAPMEnabled();
+    if (!isAPMEnabled) {
+      console.log(LuciqStrings.customSpanAPMDisabledMessage);
+      return;
+    }
+
+    // Check custom spans enabled
+    const isCustomSpanEnabled = await NativeAPM.isCustomSpanEnabled();
+    if (!isCustomSpanEnabled) {
+      console.log(LuciqStrings.customSpanDisabled);
+      return;
+    }
+
+    // Truncate name if needed
+    let spanName = trimmedName;
+    if (spanName.length > 150) {
+      spanName = spanName.substring(0, 150);
+      console.log(LuciqStrings.customSpanNameTruncated);
+    }
+
+    // Convert to microseconds
+    const startMicros = startDate.getTime() * 1000;
+    const endMicros = endDate.getTime() * 1000;
+
+    // Send to native SDK
+    await syncCustomSpan(spanName, startMicros, endMicros);
+  } catch (error) {
+    console.error('[CustomSpan] Error adding completed span:', error);
+  }
+};
+
+/**
+ * Test-only helper to clear active spans between tests.
+ * @internal
+ */
+export const __resetCustomSpansForTests = (): void => {
+  activeSpans.clear();
+};

package/src/utils/FeatureFlags.ts

@@ -1,5 +1,40 @@
 import { NativeLuciq } from '../native/NativeLuciq';
 import { _registerFeatureFlagsChangeListener } from '../modules/Luciq';
+import { Logger } from './logger';
+
+const TAG = 'LCQ-RN-NET:';
+
+let cachedW3cFlags = {
+  isW3cExternalTraceIDEnabled: false,
+  isW3cExternalGeneratedHeaderEnabled: false,
+  isW3cCaughtHeaderEnabled: false,
+};
+
+export async function initFeatureFlagsCache() {
+  Logger.debug(TAG, '[FeatureFlags] Initializing W3C feature flags cache from native bridge...');
+  try {
+    const [traceID, generatedHeader, caughtHeader] = await Promise.all([
+      NativeLuciq.isW3ExternalTraceIDEnabled(),
+      NativeLuciq.isW3ExternalGeneratedHeaderEnabled(),
+      NativeLuciq.isW3CaughtHeaderEnabled(),
+    ]);
+    cachedW3cFlags = {
+      isW3cExternalTraceIDEnabled: traceID,
+      isW3cExternalGeneratedHeaderEnabled: generatedHeader,
+      isW3cCaughtHeaderEnabled: caughtHeader,
+    };
+    Logger.debug(
+      TAG,
+      `[FeatureFlags] Cache initialized: traceID=${traceID}, generatedHeader=${generatedHeader}, caughtHeader=${caughtHeader}`,
+    );
+  } catch (e) {
+    Logger.debug(TAG, '[FeatureFlags] Failed to initialize cache, using defaults (all false):', e);
+  }
+}
+
+export function getCachedW3cFlags() {
+  return cachedW3cFlags;
+}
 
 export const FeatureFlags = {
   isW3ExternalTraceID: () => NativeLuciq.isW3ExternalTraceIDEnabled(),
@@ -16,6 +51,15 @@ export const registerFeatureFlagsListener = () => {
       isW3CaughtHeaderEnabled: boolean;
       networkBodyLimit: number;
     }) => {
+      Logger.debug(
+        TAG,
+        `[FeatureFlags] Flags updated from native listener: traceID=${res.isW3ExternalTraceIDEnabled}, generatedHeader=${res.isW3ExternalGeneratedHeaderEnabled}, caughtHeader=${res.isW3CaughtHeaderEnabled}, bodyLimit=${res.networkBodyLimit}`,
+      );
+      cachedW3cFlags = {
+        isW3cExternalTraceIDEnabled: res.isW3ExternalTraceIDEnabled,
+        isW3cExternalGeneratedHeaderEnabled: res.isW3ExternalGeneratedHeaderEnabled,
+        isW3cCaughtHeaderEnabled: res.isW3CaughtHeaderEnabled,
+      };
       FeatureFlags.isW3ExternalTraceID = async () => {
         return res.isW3ExternalTraceIDEnabled;
       };

package/src/utils/LuciqUtils.ts

@@ -12,6 +12,7 @@ import { NativeCrashReporting } from '../native/NativeCrashReporting';
 import type { NetworkData } from './XhrNetworkInterceptor';
 import { NativeLuciq } from '../native/NativeLuciq';
 import { NativeAPM } from '../native/NativeAPM';
+import { Logger } from './logger';
 import * as NetworkLogger from '../modules/NetworkLogger';
 import {
   NativeNetworkLogger,
@@ -231,6 +232,11 @@ export const reportNetworkLog = (network: NetworkData) => {
     const requestHeaders = JSON.stringify(network.requestHeaders);
     const responseHeaders = JSON.stringify(network.responseHeaders);
 
+    Logger.debug(
+      'LCQ-RN-NET:',
+      `[reportNetworkLog] Sending to NativeLuciq.networkLogAndroid: ${network.method} ${network.url}, status=${network.responseCode}, duration=${network.duration}ms, error=${network.errorDomain || 'none'}`,
+    );
+
     NativeLuciq.networkLogAndroid(
       network.url,
       network.requestBody,
@@ -246,6 +252,10 @@ export const reportNetworkLog = (network: NetworkData) => {
       !apmFlags.hasAPMNetworkPlugin ||
       !apmFlags.shouldEnableNativeInterception
     ) {
+      Logger.debug(
+        'LCQ-RN-NET:',
+        `[reportNetworkLog] Also sending to NativeAPM.networkLogAndroid (native interception disabled): ${network.method} ${network.url}`,
+      );
       NativeAPM.networkLogAndroid(
         network.startTime,
         network.duration,
@@ -271,6 +281,11 @@ export const reportNetworkLog = (network: NetworkData) => {
         network.gqlQueryName,
         network.serverErrorMessage,
       );
+    } else {
+      Logger.debug(
+        'LCQ-RN-NET:',
+        `[reportNetworkLog] Skipping NativeAPM.networkLogAndroid (native interception enabled): nativeFeature=${apmFlags.isNativeInterceptionFeatureEnabled}, hasPlugin=${apmFlags.hasAPMNetworkPlugin}, shouldEnable=${apmFlags.shouldEnableNativeInterception}`,
+      );
     }
   } else {
     NativeLuciq.networkLogIOS(

package/src/utils/XhrNetworkInterceptor.ts

@@ -1,7 +1,10 @@
 import LuciqConstants from './LuciqConstants';
 import { stringifyIfNotString, generateW3CHeader } from './LuciqUtils';
 
-import { FeatureFlags } from '../utils/FeatureFlags';
+import { getCachedW3cFlags } from './FeatureFlags';
+import { Logger } from './logger';
+
+const TAG = 'LCQ-RN-NET:';
 
 export type ProgressCallback = (totalBytesSent: number, totalBytesExpectedToSend: number) => void;
 export type NetworkDataCallback = (data: NetworkData) => void;
@@ -40,45 +43,41 @@ let originalXHRSetRequestHeader = XMLHttpRequest.prototype.setRequestHeader;
 let onProgressCallback: ProgressCallback | null;
 let onDoneCallback: NetworkDataCallback | null;
 let isInterceptorEnabled = false;
-let network: NetworkData;
-
-const _reset = () => {
-  network = {
-    id: '',
-    url: '',
-    method: '',
-    requestBody: '',
-    requestBodySize: 0,
-    responseBody: '',
-    responseBodySize: 0,
-    responseCode: 0,
-    requestHeaders: {},
-    responseHeaders: {},
-    contentType: '',
-    errorDomain: '',
-    errorCode: 0,
-    startTime: 0,
-    duration: 0,
-    gqlQueryName: '',
-    serverErrorMessage: '',
-    requestContentType: '',
-    isW3cHeaderFound: null,
-    partialId: null,
-    networkStartTimeInSeconds: null,
-    w3cGeneratedHeader: null,
-    w3cCaughtHeader: null,
-  };
-};
-const getTraceparentHeader = async (networkData: NetworkData) => {
-  const [
+
+const networkMap = new WeakMap<XMLHttpRequest, NetworkData>();
+
+const createNetworkData = (): NetworkData => ({
+  id: '',
+  url: '',
+  method: '',
+  requestBody: '',
+  requestBodySize: 0,
+  responseBody: '',
+  responseBodySize: 0,
+  responseCode: 0,
+  requestHeaders: {},
+  responseHeaders: {},
+  contentType: '',
+  errorDomain: '',
+  errorCode: 0,
+  startTime: 0,
+  duration: 0,
+  gqlQueryName: '',
+  serverErrorMessage: '',
+  requestContentType: '',
+  isW3cHeaderFound: null,
+  partialId: null,
+  networkStartTimeInSeconds: null,
+  w3cGeneratedHeader: null,
+  w3cCaughtHeader: null,
+});
+
+const getTraceparentHeader = (networkData: NetworkData) => {
+  const {
     isW3cExternalTraceIDEnabled,
     isW3cExternalGeneratedHeaderEnabled,
     isW3cCaughtHeaderEnabled,
-  ] = await Promise.all([
-    FeatureFlags.isW3ExternalTraceID(),
-    FeatureFlags.isW3ExternalGeneratedHeader(),
-    FeatureFlags.isW3CaughtHeader(),
-  ]);
+  } = getCachedW3cFlags();
 
   return injectHeaders(networkData, {
     isW3cExternalTraceIDEnabled,
@@ -147,44 +146,77 @@ export default {
     onProgressCallback = callback;
   },
   enableInterception() {
-    // Prevents infinite calls to XMLHttpRequest.open when enabling interception multiple times
     if (isInterceptorEnabled) {
+      Logger.debug(TAG, 'enableInterception called but already enabled, skipping');
       return;
     }
 
+    Logger.debug(TAG, 'Enabling XHR network interception');
+
     originalXHROpen = XMLHttpRequest.prototype.open;
     originalXHRSend = XMLHttpRequest.prototype.send;
     originalXHRSetRequestHeader = XMLHttpRequest.prototype.setRequestHeader;
     // An error code that signifies an issue with the RN client.
     const clientErrorCode = 9876;
     XMLHttpRequest.prototype.open = function (method, url, ...args) {
-      _reset();
-      network.url = url;
-      network.method = method;
+      const networkData = createNetworkData();
+      networkData.url = url;
+      networkData.method = method;
+      networkMap.set(this, networkData);
+      Logger.debug(TAG, `[open] ${method} ${url}`);
       originalXHROpen.apply(this, [method, url, ...args]);
     };
 
     XMLHttpRequest.prototype.setRequestHeader = function (header, value) {
-      // According to the HTTP RFC, headers are case-insensitive, so we convert
-      // them to lower-case to make accessing headers predictable.
-      // This avoid issues like failing to get the Content-Type header for a request
-      // because the header is set as 'Content-Type' instead of 'content-type'.
       const key = header.toLowerCase();
-      network.requestHeaders[key] = stringifyIfNotString(value);
+      const networkData = networkMap.get(this);
+      if (networkData) {
+        networkData.requestHeaders[key] = stringifyIfNotString(value);
+      } else {
+        Logger.debug(
+          TAG,
+          `[setRequestHeader] No networkData found in WeakMap for header "${key}" — request may have been GC'd or open() was not called`,
+        );
+      }
       originalXHRSetRequestHeader.apply(this, [header, value]);
     };
 
-    XMLHttpRequest.prototype.send = async function (data) {
-      const cloneNetwork = JSON.parse(JSON.stringify(network));
+    XMLHttpRequest.prototype.send = function (data) {
+      const networkData = networkMap.get(this);
+      if (!networkData) {
+        Logger.debug(
+          TAG,
+          '[send] No networkData found in WeakMap — falling back to original send (open() was not intercepted)',
+        );
+        originalXHRSend.apply(this, [data]);
+        return;
+      }
+
+      Logger.debug(TAG, `[send] ${networkData.method} ${networkData.url}`);
+
+      const cloneNetwork = JSON.parse(JSON.stringify(networkData));
       cloneNetwork.requestBody = data ? data : '';
 
       if (typeof cloneNetwork.requestBody !== 'string') {
         cloneNetwork.requestBody = JSON.stringify(cloneNetwork.requestBody);
       }
 
+      let isReported = false;
+
       if (this.addEventListener) {
         this.addEventListener('readystatechange', async () => {
           if (!isInterceptorEnabled) {
+            Logger.debug(
+              TAG,
+              `[readystatechange] Interceptor disabled, ignoring state=${this.readyState} for ${cloneNetwork.url}`,
+            );
+            return;
+          }
+          if (isReported) {
+            Logger.debug(
+              TAG,
+              `[readystatechange] Already reported, ignoring state=${this.readyState} for ${cloneNetwork.url}`,
+            );
             return;
           }
           if (this.readyState === this.HEADERS_RECEIVED) {
@@ -217,6 +249,11 @@ export default {
               cloneNetwork.requestContentType =
                 cloneNetwork.requestHeaders['content-type'].split(';')[0];
             }
+
+            Logger.debug(
+              TAG,
+              `[readystatechange] HEADERS_RECEIVED for ${cloneNetwork.url}, contentType=${cloneNetwork.contentType}`,
+            );
           }
 
           if (this.readyState === this.DONE) {
@@ -239,12 +276,15 @@ export default {
                 typeof _response === 'string' ? _response : JSON.stringify(_response);
               cloneNetwork.responseBody = '';
 
-              // Detect a more descriptive error message.
               if (typeof _response === 'string' && _response.length > 0) {
                 cloneNetwork.errorDomain = _response;
               }
 
               cloneNetwork.responseBody = `ERROR: ${cloneNetwork.errorDomain}`;
+              Logger.debug(
+                TAG,
+                `[readystatechange] DONE with client error for ${cloneNetwork.url}, errorDomain=${cloneNetwork.errorDomain}`,
+              );
 
               // @ts-ignore
             } else if (this._timedOut) {
@@ -253,6 +293,7 @@ export default {
               cloneNetwork.responseCode = 0;
               cloneNetwork.contentType = 'text/plain';
               cloneNetwork.responseBody = `ERROR: ${cloneNetwork.errorDomain}`;
+              Logger.debug(TAG, `[readystatechange] DONE with timeout for ${cloneNetwork.url}`);
             }
 
             // Only set response body if not already set by error handlers
@@ -300,8 +341,18 @@ export default {
               delete cloneNetwork.gqlQueryName;
             }
 
+            isReported = true;
+            Logger.debug(
+              TAG,
+              `[readystatechange] DONE for ${cloneNetwork.method} ${cloneNetwork.url} — status=${cloneNetwork.responseCode}, duration=${cloneNetwork.duration}ms, hasCallback=${!!onDoneCallback}`,
+            );
             if (onDoneCallback) {
               onDoneCallback(cloneNetwork);
+            } else {
+              Logger.debug(
+                TAG,
+                `[readystatechange] WARNING: onDoneCallback is null, network log for ${cloneNetwork.url} will be LOST`,
+              );
             }
           }
         });
@@ -310,7 +361,6 @@ export default {
           if (!isInterceptorEnabled) {
             return;
           }
-          // check if will be able to compute progress
           if (event.lengthComputable && onProgressCallback) {
             const totalBytesSent = event.loaded;
             const totalBytesExpectedToSend = event.total - event.loaded;
@@ -320,34 +370,57 @@ export default {
         this.addEventListener('progress', downloadUploadProgressCallback);
         this.upload.addEventListener('progress', downloadUploadProgressCallback);
 
-        // Handler for abort events (works with fetch, Axios, and any XHR-based requests)
         this.addEventListener('abort', () => {
           if (!isInterceptorEnabled) {
+            Logger.debug(
+              TAG,
+              `[abort] Interceptor disabled, ignoring abort for ${cloneNetwork.url}`,
+            );
             return;
           }
+          if (isReported) {
+            Logger.debug(
+              TAG,
+              `[abort] Already reported via readystatechange DONE, ignoring duplicate abort for ${cloneNetwork.url}`,
+            );
+            return;
+          }
+          isReported = true;
           cloneNetwork.duration = Date.now() - cloneNetwork.startTime;
           cloneNetwork.responseCode = 0;
           cloneNetwork.errorCode = clientErrorCode;
           cloneNetwork.errorDomain = 'cancelled';
           cloneNetwork.responseBody = `ERROR: ${cloneNetwork.errorDomain}`;
+          Logger.debug(
+            TAG,
+            `[abort] Request cancelled: ${cloneNetwork.method} ${cloneNetwork.url}, duration=${cloneNetwork.duration}ms, hasCallback=${!!onDoneCallback}`,
+          );
+          if (onDoneCallback) {
+            onDoneCallback(cloneNetwork);
+          } else {
+            Logger.debug(
+              TAG,
+              `[abort] WARNING: onDoneCallback is null, cancelled log for ${cloneNetwork.url} will be LOST`,
+            );
+          }
         });
       }
 
       cloneNetwork.startTime = Date.now();
-      const traceparent = await getTraceparentHeader(cloneNetwork);
+      const traceparent = getTraceparentHeader(cloneNetwork);
       if (traceparent) {
         this.setRequestHeader('Traceparent', traceparent);
-      }
-      if (this.readyState === this.UNSENT) {
-        return; // Prevent sending the request if not opened
+        Logger.debug(TAG, `[send] Injected traceparent header for ${cloneNetwork.url}`);
       }
 
       originalXHRSend.apply(this, [data]);
     };
     isInterceptorEnabled = true;
+    Logger.debug(TAG, 'XHR network interception enabled');
   },
 
   disableInterception() {
+    Logger.debug(TAG, 'Disabling XHR network interception');
     isInterceptorEnabled = false;
     XMLHttpRequest.prototype.send = originalXHRSend;
     XMLHttpRequest.prototype.open = originalXHROpen;