@luciq/react-native 19.6.0 → 19.7.0

package/dist/modules/NetworkLogger.d.ts

@@ -3,11 +3,6 @@ import { NetworkData, ProgressCallback } from '../utils/XhrNetworkInterceptor';
 import { NetworkListenerType } from '../native/NativeNetworkLogger';
 export type { NetworkData };
 export type NetworkDataObfuscationHandler = (data: NetworkData) => Promise<NetworkData>;
-/**
- * Sets whether network logs should be sent with bug reports.
- * It is enabled by default.
- * @param isEnabled
- */
 export declare const setEnabled: (isEnabled: boolean) => void;
 /**
  * @internal

package/dist/modules/NetworkLogger.js

@@ -20,21 +20,25 @@ function getPortFromUrl(url) {
  * It is enabled by default.
  * @param isEnabled
  */
+const NET_TAG = 'LCQ-RN-NET:';
 export const setEnabled = (isEnabled) => {
     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);
             if (!predicate(network)) {
                 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;
                         }
                     }
@@ -54,12 +58,16 @@ export const setEnabled = (isEnabled) => {
                         network.responseBody = `Body is omitted because content type ${network.contentType} isn't supported`;
                         Logger.warn(`LCQ-RN: The response body for the network request with URL ${network.url} has been omitted because the content type ${network.contentType} isn't supported.`);
                     }
+                    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/dist/utils/FeatureFlags.d.ts

@@ -1,3 +1,9 @@
+export declare function initFeatureFlagsCache(): Promise<void>;
+export declare function getCachedW3cFlags(): {
+    isW3cExternalTraceIDEnabled: boolean;
+    isW3cExternalGeneratedHeaderEnabled: boolean;
+    isW3cCaughtHeaderEnabled: boolean;
+};
 export declare const FeatureFlags: {
     isW3ExternalTraceID: () => Promise<boolean>;
     isW3ExternalGeneratedHeader: () => Promise<boolean>;

package/dist/utils/FeatureFlags.js

@@ -1,5 +1,34 @@
 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(),
     isW3ExternalGeneratedHeader: () => NativeLuciq.isW3ExternalGeneratedHeaderEnabled(),
@@ -8,6 +37,12 @@ export const FeatureFlags = {
 };
 export const registerFeatureFlagsListener = () => {
     _registerFeatureFlagsChangeListener((res) => {
+        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/dist/utils/LuciqUtils.js

@@ -3,6 +3,7 @@ import parseErrorStackLib from 'react-native/Libraries/Core/Devtools/parseErrorS
 import { NativeCrashReporting } from '../native/NativeCrashReporting';
 import { NativeLuciq } from '../native/NativeLuciq';
 import { NativeAPM } from '../native/NativeAPM';
+import { Logger } from './logger';
 import * as NetworkLogger from '../modules/NetworkLogger';
 import { NativeNetworkLogger, NativeNetworkLoggerEvent, NetworkListenerType, NetworkLoggerEmitter, } from '../native/NativeNetworkLogger';
 let apmFlags = {
@@ -181,10 +182,12 @@ export const reportNetworkLog = (network) => {
     if (Platform.OS === 'android') {
         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, network.responseBody, network.method, network.responseCode, requestHeaders, responseHeaders, network.duration);
         if (!apmFlags.isNativeInterceptionFeatureEnabled ||
             !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, requestHeaders, network.requestBody, network.requestBodySize, network.method, network.url, network.requestContentType, responseHeaders, network.responseBody, network.responseBodySize, network.responseCode, network.contentType, network.errorDomain, {
                 isW3cHeaderFound: network.isW3cHeaderFound,
                 partialId: network.partialId,
@@ -193,8 +196,12 @@ export const reportNetworkLog = (network) => {
                 w3cCaughtHeader: network.w3cCaughtHeader,
             }, 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 {
+        Logger.debug('LCQ-RN-NET:', `[reportNetworkLog] Sending to NativeLuciq.networkLogIOS: ${network.method} ${network.url}, status=${network.responseCode}, duration=${network.duration}ms, error=${network.errorDomain || 'none'}`);
         NativeLuciq.networkLogIOS(network.url, network.method, network.requestBody, network.requestBodySize, network.responseBody, network.responseBodySize, network.responseCode, network.requestHeaders, network.responseHeaders, network.contentType, network.errorDomain, network.errorCode, network.startTime, network.duration, network.gqlQueryName, network.serverErrorMessage, {
             isW3cHeaderFound: network.isW3cHeaderFound,
             partialId: network.partialId,

package/dist/utils/XhrNetworkInterceptor.js

@@ -1,6 +1,8 @@
 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:';
 const XMLHttpRequest = global.XMLHttpRequest;
 let originalXHROpen = XMLHttpRequest.prototype.open;
 let originalXHRSend = XMLHttpRequest.prototype.send;
@@ -8,40 +10,34 @@ let originalXHRSetRequestHeader = XMLHttpRequest.prototype.setRequestHeader;
 let onProgressCallback;
 let onDoneCallback;
 let isInterceptorEnabled = false;
-let network;
-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) => {
-    const [isW3cExternalTraceIDEnabled, isW3cExternalGeneratedHeaderEnabled, isW3cCaughtHeaderEnabled,] = await Promise.all([
-        FeatureFlags.isW3ExternalTraceID(),
-        FeatureFlags.isW3ExternalGeneratedHeader(),
-        FeatureFlags.isW3CaughtHeader(),
-    ]);
+const networkMap = new WeakMap();
+const createNetworkData = () => ({
+    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) => {
+    const { isW3cExternalTraceIDEnabled, isW3cExternalGeneratedHeaderEnabled, isW3cCaughtHeaderEnabled, } = getCachedW3cFlags();
     return injectHeaders(networkData, {
         isW3cExternalTraceIDEnabled,
         isW3cExternalGeneratedHeaderEnabled,
@@ -85,39 +81,57 @@ 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) {
@@ -146,6 +160,7 @@ 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) {
                         cloneNetwork.duration = Date.now() - cloneNetwork.startTime;
@@ -166,11 +181,11 @@ export default {
                             cloneNetwork.requestBody =
                                 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) {
@@ -179,6 +194,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
                         if (!cloneNetwork.errorDomain) {
@@ -225,16 +241,20 @@ export default {
                         else {
                             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`);
+                        }
                     }
                 });
                 const downloadUploadProgressCallback = (event) => {
                     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;
@@ -243,31 +263,43 @@ 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;

package/ios/RNLuciq/LuciqNetworkLoggerBridge.m

@@ -6,10 +6,13 @@
 //
 #import "LuciqNetworkLoggerBridge.h"
 #import "Util/LCQNetworkLogger+CP.h"
+#import "Util/LuciqRNLogger.h"
 
 #import <React/RCTLog.h>
 #import <React/RCTConvert.h>
 
+static NSString *const LCQRNNetTag = @"LCQ-RN-NET";
+
 // Extend RCTConvert to handle NetworkListenerType enum conversion
 @implementation RCTConvert (NetworkListenerType)
 
@@ -60,22 +63,27 @@ bool lcq_hasListeners = NO;
 // Will be called when this module's first listener is added.
 -(void)startObserving {
     lcq_hasListeners = YES;
+    [LuciqRNLogger d:LCQRNNetTag format:@"[EventEmitter] startObserving - LCQNetworkLogger listeners ON"];
     // Set up any upstream listeners or background tasks as necessary
 }
 
 // Will be called when this module's last listener is removed, or on dealloc.
 -(void)stopObserving {
     lcq_hasListeners = NO;
+    [LuciqRNLogger d:LCQRNNetTag format:@"[EventEmitter] stopObserving - LCQNetworkLogger listeners OFF"];
     // Remove upstream listeners, stop unnecessary background tasks
 }
 
 RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(isNativeInterceptionEnabled) {
-    return @(LCQNetworkLogger.isNativeNetworkInterceptionFeatureEnabled);
+    BOOL enabled = LCQNetworkLogger.isNativeNetworkInterceptionFeatureEnabled;
+    [LuciqRNLogger d:LCQRNNetTag format:@"[isNativeInterceptionEnabled] Result=%d", enabled];
+    return @(enabled);
 }
 
 
 
 RCT_EXPORT_METHOD(registerNetworkLogsListener: (NetworkListenerType) listenerType) {
+    [LuciqRNLogger d:LCQRNNetTag format:@"[registerNetworkLogsListener] listenerType=%ld", (long)listenerType];
     switch (listenerType) {
          case NetworkListenerTypeFiltering:
              [self setupRequestFilteringHandler];
@@ -91,7 +99,7 @@ RCT_EXPORT_METHOD(registerNetworkLogsListener: (NetworkListenerType) listenerTyp
              break;
 
          default:
-             NSLog(@"Unknown NetworkListenerType");
+             [LuciqRNLogger e:LCQRNNetTag format:@"[registerNetworkLogsListener] Unknown NetworkListenerType=%ld", (long)listenerType];
              break;
      }
 }
@@ -105,10 +113,12 @@ RCT_EXPORT_METHOD(updateNetworkLogSnapshot:(NSString * _Nonnull)url
                   requestHeaders:(NSDictionary * _Nullable)requestHeaders
                   responseHeaders:(NSDictionary * _Nullable)responseHeaders)
 {
+    [LuciqRNLogger d:LCQRNNetTag format:@"[updateNetworkLogSnapshot] callbackID=%@, url=%@, responseCode=%d, obfuscationMapSize=%lu", callbackID, url, (int)responseCode, (unsigned long)self.requestObfuscationCompletionDictionary.count];
+
     // Validate and construct the URL
     NSURL *requestURL = [NSURL URLWithString:url];
     if (!requestURL) {
-        NSLog(@"Invalid URL: %@", url);
+        [LuciqRNLogger e:LCQRNNetTag format:@"[updateNetworkLogSnapshot] Invalid URL: %@", url];
         return;
     }
 
@@ -124,7 +134,7 @@ RCT_EXPORT_METHOD(updateNetworkLogSnapshot:(NSString * _Nonnull)url
     if (requestHeaders && [requestHeaders isKindOfClass:[NSDictionary class]]) {
         request.allHTTPHeaderFields = requestHeaders;
     } else {
-        NSLog(@"Invalid requestHeaders format, expected NSDictionary.");
+        [LuciqRNLogger e:LCQRNNetTag format:@"[updateNetworkLogSnapshot] Invalid requestHeaders format, expected NSDictionary - url=%@", url];
     }
 
     // Ensure callbackID is valid and the completion handler exists
@@ -132,18 +142,20 @@ RCT_EXPORT_METHOD(updateNetworkLogSnapshot:(NSString * _Nonnull)url
     if (callbackID && [callbackID isKindOfClass:[NSString class]] && completionHandler) {
         // Call the completion handler with the constructed request
         completionHandler(request);
+        [LuciqRNLogger d:LCQRNNetTag format:@"[updateNetworkLogSnapshot] Obfuscation completion invoked for callbackID=%@", callbackID];
     } else {
-        NSLog(@"CallbackID not found or completion handler is unavailable for CallbackID: %@", callbackID);
+        [LuciqRNLogger e:LCQRNNetTag format:@"[updateNetworkLogSnapshot] CallbackID not found or completion handler unavailable for callbackID=%@, mapSize=%lu", callbackID, (unsigned long)self.requestObfuscationCompletionDictionary.count];
     }
 }
 
 RCT_EXPORT_METHOD(setNetworkLoggingRequestFilterPredicateIOS: (NSString * _Nonnull) callbackID : (BOOL)value ){
+    [LuciqRNLogger d:LCQRNNetTag format:@"[setNetworkLoggingRequestFilterPredicateIOS] callbackID=%@, save=%d, filteringMapSize=%lu", callbackID, value, (unsigned long)self.requestFilteringCompletionDictionary.count];
 
     if (self.requestFilteringCompletionDictionary[callbackID] != nil) {
         // ⬇️ YES == Request will be saved, NO == will be ignored
         ((LCQURLRequestResponseAsyncFilteringCompletedHandler)self.requestFilteringCompletionDictionary[callbackID])(value);
     } else {
-        NSLog(@"Not Available Completion");
+        [LuciqRNLogger e:LCQRNNetTag format:@"[setNetworkLoggingRequestFilterPredicateIOS] Filtering completion not found for callbackID=%@", callbackID];
     }
 }
 
@@ -152,13 +164,18 @@ RCT_EXPORT_METHOD(setNetworkLoggingRequestFilterPredicateIOS: (NSString * _Nonnu
 
 // Set up the filtering handler
 - (void)setupRequestFilteringHandler {
+    [LuciqRNLogger d:LCQRNNetTag format:@"[setupRequestFilteringHandler] Registering filtering handler with LCQNetworkLogger"];
     [LCQNetworkLogger setCPRequestFilteringHandler:^(NSURLRequest * _Nonnull request, void (^ _Nonnull completion)(BOOL)) {
         NSString *callbackID = [[[NSUUID alloc] init] UUIDString];
         self.requestFilteringCompletionDictionary[callbackID] = completion;
+        [LuciqRNLogger d:LCQRNNetTag format:@"[FilteringHandler] Received request - callbackID=%@, url=%@, mapSize=%lu", callbackID, request.URL.absoluteString, (unsigned long)self.requestFilteringCompletionDictionary.count];
 
         NSDictionary *dict = [self createNetworkRequestDictForRequest:request callbackID:callbackID];
         if(lcq_hasListeners){
             [self sendEventWithName:@"LCQNetworkLoggerHandler" body:dict];
+            [LuciqRNLogger d:LCQRNNetTag format:@"[FilteringHandler] Sent event to JS for url=%@", request.URL.absoluteString];
+        } else {
+            [LuciqRNLogger w:LCQRNNetTag format:@"[FilteringHandler] Event DROPPED (no JS listeners) for url=%@", request.URL.absoluteString];
         }
 
     }];
@@ -166,14 +183,19 @@ RCT_EXPORT_METHOD(setNetworkLoggingRequestFilterPredicateIOS: (NSString * _Nonnu
 
 // Set up the obfuscation handler
 - (void)setupRequestObfuscationHandler {
+    [LuciqRNLogger d:LCQRNNetTag format:@"[setupRequestObfuscationHandler] Registering obfuscation handler with LCQNetworkLogger"];
     [LCQNetworkLogger setCPRequestAsyncObfuscationHandler:^(NSURLRequest * _Nonnull request, void (^ _Nonnull completion)(NSURLRequest * _Nonnull)) {
         NSString *callbackID = [[[NSUUID alloc] init] UUIDString];
         self.requestObfuscationCompletionDictionary[callbackID] = completion;
+        [LuciqRNLogger d:LCQRNNetTag format:@"[ObfuscationHandler] Received request - callbackID=%@, url=%@, mapSize=%lu", callbackID, request.URL.absoluteString, (unsigned long)self.requestObfuscationCompletionDictionary.count];
 
 
         NSDictionary *dict = [self createNetworkRequestDictForRequest:request callbackID:callbackID];
         if (lcq_hasListeners) {
             [self sendEventWithName:@"LCQNetworkLoggerHandler" body:dict];
+            [LuciqRNLogger d:LCQRNNetTag format:@"[ObfuscationHandler] Sent event to JS for url=%@", request.URL.absoluteString];
+        } else {
+            [LuciqRNLogger w:LCQRNNetTag format:@"[ObfuscationHandler] Event DROPPED (no JS listeners) for url=%@", request.URL.absoluteString];
         }
 
     }];
@@ -194,10 +216,12 @@ RCT_EXPORT_METHOD(setNetworkLoggingRequestFilterPredicateIOS: (NSString * _Nonnu
 }
 
 RCT_EXPORT_METHOD(forceStartNetworkLoggingIOS) {
+    [LuciqRNLogger d:LCQRNNetTag format:@"[forceStartNetworkLoggingIOS] Starting native network logging"];
     [LCQNetworkLogger forceStartNetworkLogging];
 }
 
 RCT_EXPORT_METHOD(forceStopNetworkLoggingIOS) {
+    [LuciqRNLogger d:LCQRNNetTag format:@"[forceStopNetworkLoggingIOS] Stopping native network logging"];
     [LCQNetworkLogger forceStopNetworkLogging];
 }
 

package/ios/RNLuciq/LuciqReactBridge.m

@@ -15,6 +15,9 @@
 #import <React/RCTUIManager.h>
 #import "RNLuciq.h"
 #import "Util/LCQNetworkLogger+CP.h"
+#import "Util/LuciqRNLogger.h"
+
+static NSString *const LCQRNNetTag = @"LCQ-RN-NET";
 
 @interface Luciq (PrivateWillSendAPI)
 + (void)setWillSendReportHandler_private:(void(^)(LCQReport *report, void(^reportCompletionHandler)(LCQReport *)))willSendReportHandler_private;
@@ -46,6 +49,8 @@ RCT_EXPORT_METHOD(init:(NSString *)token
           options:(nullable NSDictionary *)options
           overAirVersion :(NSDictionary *)overAirVersion
           ) {
+    [LuciqRNLogger setLevel:sdkDebugLogsLevel];
+    [LuciqRNLogger d:LCQRNNetTag format:@"[init] Called - logLevel=%ld, useNativeNetworkInterception=%d, codePushVersion=%@, appVariant=%@", (long)sdkDebugLogsLevel, useNativeNetworkInterception, codePushVersion, appVariant];
 
            if(appVariant != nil){
                   Luciq.appVariant = appVariant;
@@ -65,6 +70,7 @@ RCT_EXPORT_METHOD(init:(NSString *)token
              invocationEvents:invocationEvents
                debugLogsLevel:sdkDebugLogsLevel
  useNativeNetworkInterception:useNativeNetworkInterception];
+    [LuciqRNLogger d:LCQRNNetTag format:@"[init] SDK build complete"];
 }
 
 RCT_EXPORT_METHOD(setCodePushVersion:(NSString *)version) {
@@ -409,11 +415,13 @@ RCT_EXPORT_METHOD(networkLogIOS:(NSString * _Nonnull)url
                    gqlQueryName:(NSString * _Nullable)gqlQueryName
              serverErrorMessage:(NSString * _Nullable)serverErrorMessage
                   w3cExternalTraceAttributes:(NSDictionary * _Nullable)w3cExternalTraceAttributes){
+    [LuciqRNLogger d:LCQRNNetTag format:@"[networkLogIOS] Received from JS: %@ %@, status=%d, duration=%.0fms, startTime=%.0f, error=%@, gqlQuery=%@, reqBodyLen=%lu, resBodyLen=%lu", method, url, (int)responseCode, duration * 1000, startTime, errorDomain, gqlQueryName, (unsigned long)requestBody.length, (unsigned long)responseBody.length];
    NSNumber *isW3cCaught = (w3cExternalTraceAttributes[@"isW3cHeaderFound"] != [NSNull null]) ? w3cExternalTraceAttributes[@"isW3cHeaderFound"] : nil;
         NSNumber * partialID = (w3cExternalTraceAttributes[@"partialId"] != [NSNull null]) ? w3cExternalTraceAttributes[@"partialId"] : nil;
         NSNumber * timestamp = (w3cExternalTraceAttributes[@"networkStartTimeInSeconds"] != [NSNull null]) ? w3cExternalTraceAttributes[@"networkStartTimeInSeconds"] : nil;
         NSString * generatedW3CTraceparent = (w3cExternalTraceAttributes[@"w3cGeneratedHeader"] != [NSNull null]) ? w3cExternalTraceAttributes[@"w3cGeneratedHeader"] : nil;
         NSString * caughtW3CTraceparent = (w3cExternalTraceAttributes[@"w3cCaughtHeader"] != [NSNull null]) ? w3cExternalTraceAttributes[@"w3cCaughtHeader"] : nil;
+    [LuciqRNLogger d:LCQRNNetTag format:@"[networkLogIOS] W3C attrs - isW3cCaughted=%@, partialID=%@, timestamp=%@, generatedHeader=%@, caughtHeader=%@", isW3cCaught, partialID, timestamp, generatedW3CTraceparent, caughtW3CTraceparent];
 
     [LCQNetworkLogger addNetworkLogWithUrl:url
                                     method:method
@@ -437,6 +445,7 @@ RCT_EXPORT_METHOD(networkLogIOS:(NSString * _Nonnull)url
                         generatedW3CTraceparent:generatedW3CTraceparent
                         caughtedW3CTraceparent:caughtW3CTraceparent
                         ];
+    [LuciqRNLogger d:LCQRNNetTag format:@"[networkLogIOS] Forwarded to LCQNetworkLogger: %@ %@", method, url];
 }
 
 RCT_EXPORT_METHOD(addPrivateView: (nonnull NSNumber *)reactTag) {
@@ -501,13 +510,19 @@ RCT_EXPORT_METHOD(willRedirectToStore){
 }
 
 RCT_EXPORT_METHOD(isW3ExternalTraceIDEnabled:(RCTPromiseResolveBlock)resolve :(RCTPromiseRejectBlock)reject) {
-    resolve(@(LCQNetworkLogger.w3ExternalTraceIDEnabled));
+    BOOL enabled = LCQNetworkLogger.w3ExternalTraceIDEnabled;
+    [LuciqRNLogger d:LCQRNNetTag format:@"[isW3ExternalTraceIDEnabled] Result=%d", enabled];
+    resolve(@(enabled));
 }
 RCT_EXPORT_METHOD(isW3ExternalGeneratedHeaderEnabled:(RCTPromiseResolveBlock)resolve :(RCTPromiseRejectBlock)reject) {
-    resolve(@(LCQNetworkLogger.w3ExternalGeneratedHeaderEnabled));
+    BOOL enabled = LCQNetworkLogger.w3ExternalGeneratedHeaderEnabled;
+    [LuciqRNLogger d:LCQRNNetTag format:@"[isW3ExternalGeneratedHeaderEnabled] Result=%d", enabled];
+    resolve(@(enabled));
 }
 RCT_EXPORT_METHOD(isW3CaughtHeaderEnabled:(RCTPromiseResolveBlock)resolve :(RCTPromiseRejectBlock)reject) {
-    resolve(@(LCQNetworkLogger.w3CaughtHeaderEnabled));
+    BOOL enabled = LCQNetworkLogger.w3CaughtHeaderEnabled;
+    [LuciqRNLogger d:LCQRNNetTag format:@"[isW3CaughtHeaderEnabled] Result=%d", enabled];
+    resolve(@(enabled));
 }
 
 
@@ -550,7 +565,9 @@ RCT_EXPORT_METHOD(enableAutoMasking:(NSArray *)autoMaskingTypes) {
 };
 
 RCT_EXPORT_METHOD(getNetworkBodyMaxSize:(RCTPromiseResolveBlock)resolve :(RCTPromiseRejectBlock)reject) {
-    resolve(@(LCQNetworkLogger.getNetworkBodyMaxSize));
+    NSUInteger limit = LCQNetworkLogger.getNetworkBodyMaxSize;
+    [LuciqRNLogger d:LCQRNNetTag format:@"[getNetworkBodyMaxSize] Result=%lu", (unsigned long)limit];
+    resolve(@(limit));
 }
 
 RCT_EXPORT_METHOD(setNetworkLogBodyEnabled:(BOOL)isEnabled) {