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

package/dist/utils/LuciqUtils.js

@@ -3,7 +3,6 @@ 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 = {
@@ -182,12 +181,10 @@ 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,
@@ -196,9 +193,6 @@ 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 {
         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, {

package/dist/utils/XhrNetworkInterceptor.js

@@ -1,8 +1,6 @@
 import LuciqConstants from './LuciqConstants';
 import { stringifyIfNotString, generateW3CHeader } from './LuciqUtils';
-import { getCachedW3cFlags } from './FeatureFlags';
-import { Logger } from './logger';
-const TAG = 'LCQ-RN-NET:';
+import { FeatureFlags } from '../utils/FeatureFlags';
 const XMLHttpRequest = global.XMLHttpRequest;
 let originalXHROpen = XMLHttpRequest.prototype.open;
 let originalXHRSend = XMLHttpRequest.prototype.send;
@@ -10,34 +8,40 @@ let originalXHRSetRequestHeader = XMLHttpRequest.prototype.setRequestHeader;
 let onProgressCallback;
 let onDoneCallback;
 let isInterceptorEnabled = false;
-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();
+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(),
+    ]);
     return injectHeaders(networkData, {
         isW3cExternalTraceIDEnabled,
         isW3cExternalGeneratedHeaderEnabled,
@@ -81,57 +85,39 @@ 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) {
-            const networkData = createNetworkData();
-            networkData.url = url;
-            networkData.method = method;
-            networkMap.set(this, networkData);
-            Logger.debug(TAG, `[open] ${method} ${url}`);
+            _reset();
+            network.url = url;
+            network.method = method;
             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();
-            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`);
-            }
+            network.requestHeaders[key] = stringifyIfNotString(value);
             originalXHRSetRequestHeader.apply(this, [header, value]);
         };
-        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));
+        XMLHttpRequest.prototype.send = async function (data) {
+            const cloneNetwork = JSON.parse(JSON.stringify(network));
             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) {
@@ -160,7 +146,6 @@ 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;
@@ -181,11 +166,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) {
@@ -194,7 +179,6 @@ 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) {
@@ -241,20 +225,16 @@ 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;
@@ -263,43 +243,31 @@ 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 = getTraceparentHeader(cloneNetwork);
+            const traceparent = await getTraceparentHeader(cloneNetwork);
             if (traceparent) {
                 this.setRequestHeader('Traceparent', traceparent);
-                Logger.debug(TAG, `[send] Injected traceparent header for ${cloneNetwork.url}`);
+            }
+            if (this.readyState === this.UNSENT) {
+                return; // Prevent sending the request if not opened
             }
             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/LuciqReactBridge.m

@@ -98,6 +98,18 @@ RCT_EXPORT_METHOD(setTrackUserSteps:(BOOL)isEnabled) {
     [Luciq setTrackUserSteps:isEnabled];
 }
 
+RCT_EXPORT_METHOD(setWebViewMonitoringEnabled:(BOOL)isEnabled) {
+    [Luciq setWebViewMonitoringEnabled:isEnabled];
+}
+
+RCT_EXPORT_METHOD(setWebViewNetworkTrackingEnabled:(BOOL)isEnabled) {
+    [Luciq setWebViewNetworkTrackingEnabled:isEnabled];
+}
+
+RCT_EXPORT_METHOD(setWebViewUserInteractionsTrackingEnabled:(BOOL)isEnabled) {
+    [Luciq setWebViewUserInteractionsTrackingEnabled:isEnabled];
+}
+
 LCQReport *currentReport = nil;
 RCT_EXPORT_METHOD(setPreSendingHandler:(RCTResponseSenderBlock)callBack) {
     if (callBack != nil) {

package/ios/native.rb

@@ -1,4 +1,4 @@
-$luciq= { :version => '19.5.0' }
+$luciq= { :version => '19.5.1' }
 
 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.3.0-40271-SNAPSHOT",
+  "version": "19.4.0",
   "author": "Luciq (https://luciq.ai)",
   "repository": "github:luciqai/luciq-reactnative-sdk",
   "homepage": "https://www.luciq.ai/platforms/react-native",
@@ -43,6 +43,7 @@
   },
   "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/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, initFeatureFlagsCache } from '../utils/FeatureFlags';
+import { registerFeatureFlagsListener } from '../utils/FeatureFlags';
 import {
   AutoMaskingType,
   ColorTheme,
@@ -81,8 +81,6 @@ 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();
@@ -132,6 +130,30 @@ export const setAppVariant = (appVariant: string) => {
   NativeLuciq.setAppVariant(appVariant);
 };
 
+/**
+ * Enables or disables WebView monitoring.
+ * @param isEnabled A boolean to enable/disable WebView monitoring.
+ */
+export const setWebViewMonitoringEnabled = (isEnabled: boolean) => {
+  NativeLuciq.setWebViewMonitoringEnabled(isEnabled);
+};
+
+/**
+ * Enables or disables WebView network tracking.
+ * @param isEnabled A boolean to enable/disable WebView network tracking.
+ */
+export const setWebViewNetworkTrackingEnabled = (isEnabled: boolean) => {
+  NativeLuciq.setWebViewNetworkTrackingEnabled(isEnabled);
+};
+
+/**
+ * Enables or disables WebView user interactions tracking.
+ * @param isEnabled A boolean to enable/disable WebView user interactions tracking.
+ */
+export const setWebViewUserInteractionsTrackingEnabled = (isEnabled: boolean) => {
+  NativeLuciq.setWebViewUserInteractionsTrackingEnabled(isEnabled);
+};
+
 /**
  * Handles app state changes and updates APM network flags if necessary.
  */

package/src/modules/NetworkLogger.ts

@@ -39,17 +39,10 @@ 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);
 
@@ -57,17 +50,12 @@ 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;
             }
           }
@@ -109,23 +97,10 @@ 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(
-            NET_TAG,
-            `[NetworkLogger] Error processing network log for ${network.url}:`,
-            e,
-          );
+          Logger.error(e);
         }
-      } else {
-        Logger.debug(
-          NET_TAG,
-          `[NetworkLogger] Request filtered out by predicate: ${network.method} ${network.url}, expression="${_requestFilterExpression}"`,
-        );
       }
     });
   } else {

package/src/native/NativeLuciq.ts

@@ -167,6 +167,11 @@ export interface LuciqNativeModule extends NativeModule {
 
   setTheme(theme: ThemeConfig): void;
   setFullscreen(isEnabled: boolean): void;
+
+  // WebView APIs //
+  setWebViewMonitoringEnabled(isEnabled: boolean): void;
+  setWebViewNetworkTrackingEnabled(isEnabled: boolean): void;
+  setWebViewUserInteractionsTrackingEnabled(isEnabled: boolean): void;
 }
 
 export const NativeLuciq = NativeModules.Luciq as LuciqNativeModule;

package/src/utils/FeatureFlags.ts

@@ -1,40 +1,5 @@
 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(),
@@ -51,15 +16,6 @@ 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,7 +12,6 @@ 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,
@@ -232,11 +231,6 @@ 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,
@@ -252,10 +246,6 @@ 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,
@@ -281,11 +271,6 @@ 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(