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

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [19.4.0](https://github.com/luciqai/luciq-reactnative-sdk/compare/v19.4.0...19.3.0)
+
+### Added
+
+- **WebView Monitoring**: Added comprehensive WebView monitoring to capture performance metrics, user interactions, and network requests from WebView components.
+  - `Luciq.setWebViewMonitoringEnabled(boolean)` - Enable/disable master WebView monitoring
+  - `Luciq.setWebViewUserInteractionsTrackingEnabled(boolean)` - Enable/disable user interaction tracking in WebViews
+  - `Luciq.setWebViewNetworkTrackingEnabled(boolean`) - Enable/disable network logging from WebViews
+
+### Changed
+
+- Bump Luciq iOS SDK to v19.5.1 ([#42](https://github.com/luciqai/luciq-reactnative-sdk/pull/42)). [See release notes](https://github.com/luciqai/Luciq-iOS-sdk/releases/tag/19.5.1).
+
+- Bump Luciq Android SDK to v19.4.0 ([#42](https://github.com/luciqai/luciq-reactnative-sdk/pull/42)). [See release notes](https://github.com/luciqai/Luciq-Android-sdk/releases/tag/v19.4.0).
+
 ## [19.3.0](https://github.com/luciqai/luciq-reactnative-sdk/compare/v19.3.0...19.2.1)
 
 ### Added

package/android/native.gradle

@@ -1,5 +1,5 @@
 project.ext.luciq = [
-    version: '19.3.0'
+    version: '19.4.0'
 ]
 
 dependencies {

package/android/src/main/java/ai/luciq/reactlibrary/RNLuciqAPMModule.java

@@ -30,8 +30,6 @@ import ai.luciq.reactlibrary.utils.MainThreadHandler;
 
 public class RNLuciqAPMModule extends EventEmitterModule {
 
-    private static final String NET_TAG = "LCQ-RN-NET";
-
     public RNLuciqAPMModule(ReactApplicationContext reactApplicationContext) {
         super(reactApplicationContext);
     }
@@ -330,7 +328,6 @@ public class RNLuciqAPMModule extends EventEmitterModule {
                                    @Nullable final String gqLCQueryName,
                                    @Nullable final String serverErrorMessage
     ) {
-        Log.d(NET_TAG, "[networkLogAndroid-APM] Received from JS: " + requestMethod + " " + requestUrl + ", status=" + (int) statusCode + ", duration=" + (long) requestDuration + "ms, startTime=" + (long) requestStartTime + ", error=" + errorDomain + ", gqlQuery=" + gqLCQueryName);
         try {
             APMNetworkLogger networkLogger = new APMNetworkLogger();
 
@@ -352,10 +349,8 @@ public class RNLuciqAPMModule extends EventEmitterModule {
                 }
 
             } catch (Exception e) {
-                Log.e(NET_TAG, "[networkLogAndroid-APM] Error parsing W3C attributes for " + requestMethod + " " + requestUrl, e);
                 e.printStackTrace();
             }
-            Log.d(NET_TAG, "[networkLogAndroid-APM] W3C attrs — isW3cHeaderFound=" + isW3cHeaderFound + ", partialId=" + partialId + ", networkStartTimeInSeconds=" + networkStartTimeInSeconds + ", generatedHeader=" + (w3cAttributes != null && !w3cAttributes.isNull("w3cGeneratedHeader") ? w3cAttributes.getString("w3cGeneratedHeader") : "null") + ", caughtHeader=" + (w3cAttributes != null && !w3cAttributes.isNull("w3cCaughtHeader") ? w3cAttributes.getString("w3cCaughtHeader") : "null"));
             APMCPNetworkLog.W3CExternalTraceAttributes w3cExternalTraceAttributes =
                     new APMCPNetworkLog.W3CExternalTraceAttributes(
                             isW3cHeaderFound,
@@ -387,17 +382,13 @@ public class RNLuciqAPMModule extends EventEmitterModule {
                             serverErrorMessage,
                             w3cExternalTraceAttributes
                     );
-                    Log.d(NET_TAG, "[networkLogAndroid-APM] Successfully invoked APMNetworkLogger.log via reflection: " + requestMethod + " " + requestUrl);
                 } else {
-                    Log.e(NET_TAG, "[networkLogAndroid-APM] APMNetworkLogger.log method NOT found by reflection — network log will be lost: " + requestMethod + " " + requestUrl);
                     Log.e("IB-CP-Bridge", "APMNetworkLogger.log was not found by reflection");
                 }
             } catch (Throwable e) {
-                Log.e(NET_TAG, "[networkLogAndroid-APM] Exception invoking APMNetworkLogger.log: " + e.getMessage() + " for " + requestMethod + " " + requestUrl, e);
                 e.printStackTrace();
             }
         } catch (Throwable e) {
-            Log.e(NET_TAG, "[networkLogAndroid-APM] Top-level exception: " + e.getMessage() + " for " + requestMethod + " " + requestUrl, e);
             e.printStackTrace();
         }
     }

package/android/src/main/java/ai/luciq/reactlibrary/RNLuciqNetworkLoggerModule.java

@@ -32,8 +32,6 @@ import java.util.concurrent.ConcurrentHashMap;
 
 public class RNLuciqNetworkLoggerModule extends EventEmitterModule {
 
-    private static final String NET_TAG = "LCQ-RN-NET";
-
     public final ConcurrentHashMap<String, OnCompleteCallback<NetworkLogSnapshot>> callbackMap = new ConcurrentHashMap<String, OnCompleteCallback<NetworkLogSnapshot>>();
 
     public RNLuciqNetworkLoggerModule(ReactApplicationContext reactContext) {
@@ -59,9 +57,7 @@ public class RNLuciqNetworkLoggerModule extends EventEmitterModule {
     }
 
     private boolean getFlagValue(String key) {
-        boolean value = InternalAPM._isFeatureEnabledCP(key, "");
-        Log.d(NET_TAG, "[getFlagValue] key=" + key + ", value=" + value);
-        return value;
+        return InternalAPM._isFeatureEnabledCP(key, "");
     }
 
     private WritableMap convertFromMapToWritableMap(Map<String, Object> map) {
@@ -90,18 +86,14 @@ public class RNLuciqNetworkLoggerModule extends EventEmitterModule {
      */
     @ReactMethod
     public void isNativeInterceptionEnabled(Promise promise) {
-        Log.d(NET_TAG, "[isNativeInterceptionEnabled] Querying CP_NATIVE_INTERCEPTION_ENABLED flag");
         MainThreadHandler.runOnMainThread(new Runnable() {
             @Override
             public void run() {
                 try {
-                    boolean enabled = getFlagValue(CP_NATIVE_INTERCEPTION_ENABLED);
-                    Log.d(NET_TAG, "[isNativeInterceptionEnabled] Result=" + enabled);
-                    promise.resolve(enabled);
+                    promise.resolve(getFlagValue(CP_NATIVE_INTERCEPTION_ENABLED));
                 } catch (Exception e) {
-                    Log.e(NET_TAG, "[isNativeInterceptionEnabled] Error — falling back to false (JS interceptor)", e);
                     e.printStackTrace();
-                    promise.resolve(false);
+                    promise.resolve(false); // Will rollback to JS interceptor
                 }
 
             }
@@ -115,18 +107,14 @@ public class RNLuciqNetworkLoggerModule extends EventEmitterModule {
      */
     @ReactMethod
     public void hasAPMNetworkPlugin(Promise promise) {
-        Log.d(NET_TAG, "[hasAPMNetworkPlugin] Querying APM_NETWORK_PLUGIN_INSTALLED flag");
         MainThreadHandler.runOnMainThread(new Runnable() {
             @Override
             public void run() {
                 try {
-                    boolean hasPlugin = getFlagValue(APM_NETWORK_PLUGIN_INSTALLED);
-                    Log.d(NET_TAG, "[hasAPMNetworkPlugin] Result=" + hasPlugin);
-                    promise.resolve(hasPlugin);
+                    promise.resolve(getFlagValue(APM_NETWORK_PLUGIN_INSTALLED));
                 } catch (Exception e) {
-                    Log.e(NET_TAG, "[hasAPMNetworkPlugin] Error — falling back to false", e);
                     e.printStackTrace();
-                    promise.resolve(false);
+                    promise.resolve(false);  // Will rollback to JS interceptor
                 }
 
             }
@@ -136,14 +124,12 @@ public class RNLuciqNetworkLoggerModule extends EventEmitterModule {
 
     @ReactMethod
     public void registerNetworkLogsListener() {
-        Log.d(NET_TAG, "[registerNetworkLogsListener] Registering network log sanitizer");
         MainThreadHandler.runOnMainThread(new Runnable() {
             @Override
             public void run() {
                 InternalAPM._registerNetworkLogSanitizer((networkLogSnapshot, onCompleteCallback) -> {
                     final String id = String.valueOf(onCompleteCallback.hashCode());
                     callbackMap.put(id, onCompleteCallback);
-                    Log.d(NET_TAG, "[NetworkLogSanitizer] Received snapshot — id=" + id + ", url=" + networkLogSnapshot.getUrl() + ", responseCode=" + networkLogSnapshot.getResponseCode() + ", callbackMapSize=" + callbackMap.size());
 
                     WritableMap networkSnapshotParams = Arguments.createMap();
                     networkSnapshotParams.putString("id", id);
@@ -161,7 +147,6 @@ public class RNLuciqNetworkLoggerModule extends EventEmitterModule {
                     }
 
                     sendEvent(Constants.LCQ_NETWORK_LOGGER_HANDLER, networkSnapshotParams);
-                    Log.d(NET_TAG, "[NetworkLogSanitizer] Sent event to JS: " + Constants.LCQ_NETWORK_LOGGER_HANDLER + " for " + networkLogSnapshot.getUrl());
                 });
             }
         });
@@ -169,12 +154,10 @@ public class RNLuciqNetworkLoggerModule extends EventEmitterModule {
 
     @ReactMethod
     public void resetNetworkLogsListener() {
-        Log.d(NET_TAG, "[resetNetworkLogsListener] Clearing network log sanitizer, callbackMapSize=" + callbackMap.size());
         MainThreadHandler.runOnMainThread(new Runnable() {
             @Override
             public void run() {
                 InternalAPM._registerNetworkLogSanitizer(null);
-                Log.d(NET_TAG, "[resetNetworkLogsListener] Sanitizer cleared");
             }
         });
     }
@@ -189,28 +172,23 @@ public class RNLuciqNetworkLoggerModule extends EventEmitterModule {
             ReadableMap requestHeaders,
             ReadableMap responseHeaders
     ) {
-        Log.d(NET_TAG, "[updateNetworkLogSnapshot] callbackID=" + callbackID + ", url=" + url + ", responseCode=" + responseCode + ", callbackMapSize=" + callbackMap.size());
         try {
+            // Convert ReadableMap to a Java Map for easier handling
             Map<String, Object> requestHeadersMap = convertReadableMapToMap(requestHeaders);
             Map<String, Object> responseHeadersMap = convertReadableMapToMap(responseHeaders);
 
             NetworkLogSnapshot modifiedSnapshot = null;
             if (!url.isEmpty()) {
                 modifiedSnapshot = new NetworkLogSnapshot(url, requestHeadersMap, requestBody, responseHeadersMap, responseBody, responseCode);
-            } else {
-                Log.d(NET_TAG, "[updateNetworkLogSnapshot] Empty URL — snapshot will be null (request filtered/removed)");
             }
 
             final OnCompleteCallback<NetworkLogSnapshot> callback = callbackMap.get(callbackID);
             if (callback != null) {
                 callback.onComplete(modifiedSnapshot);
                 callbackMap.remove(callbackID);
-                Log.d(NET_TAG, "[updateNetworkLogSnapshot] Callback invoked and removed for " + callbackID + ", remaining=" + callbackMap.size());
-            } else {
-                Log.e(NET_TAG, "[updateNetworkLogSnapshot] No callback found for callbackID=" + callbackID + " — possible leak or duplicate call, mapKeys=" + callbackMap.keySet());
             }
         } catch (Exception e) {
-            Log.e(NET_TAG, "[updateNetworkLogSnapshot] Exception processing snapshot: " + e.getMessage() + " for callbackID=" + callbackID, e);
+            // Reject the promise to indicate an error occurred
             Log.e("IB-CP-Bridge", "LuciqNetworkLogger.updateNetworkLogSnapshot failed to parse the network snapshot object.");
         }
     }

package/android/src/main/java/ai/luciq/reactlibrary/RNLuciqReactnativeModule.java

@@ -86,7 +86,6 @@ import javax.annotation.Nullable;
 public class RNLuciqReactnativeModule extends EventEmitterModule {
 
     private static final String TAG = "Luciq-RN-Core";
-    private static final String NET_TAG = "LCQ-RN-NET";
 
     private LuciqCustomTextPlaceHolder placeHolders;
     private static Report currentReport;
@@ -164,7 +163,6 @@ public class RNLuciqReactnativeModule extends EventEmitterModule {
 
 
     ) {
-        Log.d(NET_TAG, "[init] Called — logLevel=" + logLevel + ", useNativeNetworkInterception=" + useNativeNetworkInterception + ", codePushVersion=" + codePushVersion + ", appVariant=" + appVariant);
         MainThreadHandler.runOnMainThread(new Runnable() {
             @Override
             public void run() {
@@ -206,7 +204,6 @@ public class RNLuciqReactnativeModule extends EventEmitterModule {
                 }
 
                 builder.build();
-                Log.d(NET_TAG, "[init] SDK build complete");
             }
         });
     }
@@ -972,7 +969,6 @@ public class RNLuciqReactnativeModule extends EventEmitterModule {
                                   final String requestHeaders,
                                   final String responseHeaders,
                                   final double duration) {
-        Log.d(NET_TAG, "[networkLogAndroid-Core] Received from JS: " + method + " " + url + ", status=" + (int) responseCode + ", duration=" + (long) duration + "ms, reqBodyLen=" + (requestBody != null ? requestBody.length() : 0) + ", resBodyLen=" + (responseBody != null ? responseBody.length() : 0));
         try {
             final String date = String.valueOf(System.currentTimeMillis());
 
@@ -989,14 +985,11 @@ public class RNLuciqReactnativeModule extends EventEmitterModule {
                 networkLog.setRequestHeaders(requestHeaders);
                 networkLog.setResponseHeaders(responseHeaders);
             } catch (OutOfMemoryError | Exception exception) {
-                Log.e(NET_TAG, "[networkLogAndroid-Core] OOM/Error setting log contents: " + exception.getMessage() + " for " + method + " " + url);
                 Log.d(TAG, "Error: " + exception.getMessage() + "while trying to set network log contents (request body, response body, request headers, and response headers).");
             }
 
             networkLog.insert();
-            Log.d(NET_TAG, "[networkLogAndroid-Core] Successfully inserted NetworkLog: " + method + " " + url);
         } catch (OutOfMemoryError | Exception exception) {
-            Log.e(NET_TAG, "[networkLogAndroid-Core] OOM/Error inserting network log: " + exception.getMessage() + " for " + method + " " + url);
             Log.d(TAG, "Error: " + exception.getMessage() + "while trying to insert a network log");
         }
     }
@@ -1177,7 +1170,7 @@ public class RNLuciqReactnativeModule extends EventEmitterModule {
      */
     @ReactMethod
     public void registerFeatureFlagsChangeListener() {
-        Log.d(NET_TAG, "[registerFeatureFlagsChangeListener] Registering native feature flags listener");
+
         MainThreadHandler.runOnMainThread(new Runnable() {
             @Override
             public void run() {
@@ -1185,7 +1178,6 @@ public class RNLuciqReactnativeModule extends EventEmitterModule {
                     InternalCore.INSTANCE._setFeaturesStateListener(new FeaturesStateListener() {
                         @Override
                         public void invoke(@NonNull CoreFeaturesState featuresState) {
-                            Log.d(NET_TAG, "[FeatureFlagsListener] Received update — W3CTraceID=" + featuresState.isW3CExternalTraceIdEnabled() + ", generatedHeader=" + featuresState.isAttachingGeneratedHeaderEnabled() + ", caughtHeader=" + featuresState.isAttachingCapturedHeaderEnabled() + ", networkBodyLimit=" + featuresState.getNetworkLogCharLimit());
                             WritableMap params = Arguments.createMap();
                             params.putBoolean("isW3ExternalTraceIDEnabled", featuresState.isW3CExternalTraceIdEnabled());
                             params.putBoolean("isW3ExternalGeneratedHeaderEnabled", featuresState.isAttachingGeneratedHeaderEnabled());
@@ -1193,11 +1185,9 @@ public class RNLuciqReactnativeModule extends EventEmitterModule {
                             params.putInt("networkBodyLimit",featuresState.getNetworkLogCharLimit());
 
                             sendEvent(Constants.LCQ_ON_FEATURE_FLAGS_UPDATE_RECEIVED_CALLBACK, params);
-                            Log.d(NET_TAG, "[FeatureFlagsListener] Sent event to JS: " + Constants.LCQ_ON_FEATURE_FLAGS_UPDATE_RECEIVED_CALLBACK);
                         }
                     });
                 } catch (Exception e) {
-                    Log.e(NET_TAG, "[registerFeatureFlagsChangeListener] Failed to register listener", e);
                     e.printStackTrace();
                 }
 
@@ -1212,16 +1202,13 @@ public class RNLuciqReactnativeModule extends EventEmitterModule {
      */
     @ReactMethod
     public void isW3ExternalTraceIDEnabled(Promise promise) {
-        Log.d(NET_TAG, "[isW3ExternalTraceIDEnabled] Querying native flag");
+
         MainThreadHandler.runOnMainThread(new Runnable() {
             @Override
             public void run() {
                 try {
-                    boolean enabled = InternalCore.INSTANCE._isFeatureEnabled(CoreFeature.W3C_EXTERNAL_TRACE_ID);
-                    Log.d(NET_TAG, "[isW3ExternalTraceIDEnabled] Result=" + enabled);
-                    promise.resolve(enabled);
+                    promise.resolve(InternalCore.INSTANCE._isFeatureEnabled(CoreFeature.W3C_EXTERNAL_TRACE_ID));
                 } catch (Exception e) {
-                    Log.e(NET_TAG, "[isW3ExternalTraceIDEnabled] Error querying flag", e);
                     e.printStackTrace();
                     promise.resolve(false);
                 }
@@ -1237,16 +1224,13 @@ public class RNLuciqReactnativeModule extends EventEmitterModule {
      */
     @ReactMethod
     public void isW3ExternalGeneratedHeaderEnabled(Promise promise) {
-        Log.d(NET_TAG, "[isW3ExternalGeneratedHeaderEnabled] Querying native flag");
+
         MainThreadHandler.runOnMainThread(new Runnable() {
             @Override
             public void run() {
                 try {
-                    boolean enabled = InternalCore.INSTANCE._isFeatureEnabled(CoreFeature.W3C_ATTACHING_GENERATED_HEADER);
-                    Log.d(NET_TAG, "[isW3ExternalGeneratedHeaderEnabled] Result=" + enabled);
-                    promise.resolve(enabled);
+                    promise.resolve(InternalCore.INSTANCE._isFeatureEnabled(CoreFeature.W3C_ATTACHING_GENERATED_HEADER));
                 } catch (Exception e) {
-                    Log.e(NET_TAG, "[isW3ExternalGeneratedHeaderEnabled] Error querying flag", e);
                     e.printStackTrace();
                     promise.resolve(false);
                 }
@@ -1261,16 +1245,13 @@ public class RNLuciqReactnativeModule extends EventEmitterModule {
      */
     @ReactMethod
     public void isW3CaughtHeaderEnabled(Promise promise) {
-        Log.d(NET_TAG, "[isW3CaughtHeaderEnabled] Querying native flag");
+
         MainThreadHandler.runOnMainThread(new Runnable() {
             @Override
             public void run() {
                 try {
-                    boolean enabled = InternalCore.INSTANCE._isFeatureEnabled(CoreFeature.W3C_ATTACHING_CAPTURED_HEADER);
-                    Log.d(NET_TAG, "[isW3CaughtHeaderEnabled] Result=" + enabled);
-                    promise.resolve(enabled);
+                    promise.resolve(InternalCore.INSTANCE._isFeatureEnabled(CoreFeature.W3C_ATTACHING_CAPTURED_HEADER));
                 } catch (Exception e) {
-                    Log.e(NET_TAG, "[isW3CaughtHeaderEnabled] Error querying flag", e);
                     e.printStackTrace();
                     promise.resolve(false);
                 }
@@ -1364,16 +1345,13 @@ public class RNLuciqReactnativeModule extends EventEmitterModule {
      */
     @ReactMethod
     public void getNetworkBodyMaxSize(Promise promise) {
-        Log.d(NET_TAG, "[getNetworkBodyMaxSize] Querying network body size limit");
+
         MainThreadHandler.runOnMainThread(new Runnable() {
             @Override
             public void run() {
                 try {
-                    Object limit = InternalCore.INSTANCE.get_networkLogCharLimit();
-                    Log.d(NET_TAG, "[getNetworkBodyMaxSize] Result=" + limit);
-                    promise.resolve(limit);
+                    promise.resolve(InternalCore.INSTANCE.get_networkLogCharLimit());
                 } catch (Exception e) {
-                    Log.e(NET_TAG, "[getNetworkBodyMaxSize] Error querying limit", e);
                     e.printStackTrace();
                     promise.resolve(false);
                 }
@@ -1395,6 +1373,49 @@ public class RNLuciqReactnativeModule extends EventEmitterModule {
                 e.printStackTrace();
             }
         }
+
+    /**
+     * Enables or disables WebView monitoring.
+     *
+     * @param isEnabled A boolean to enable/disable WebView monitoring.
+     */
+    @ReactMethod
+    public void setWebViewMonitoringEnabled(final boolean isEnabled) {
+        try {
+            Luciq.setWebViewMonitoringEnabled(isEnabled);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * Enables or disables WebView network tracking.
+     *
+     * @param isEnabled A boolean to enable/disable WebView network tracking.
+     */
+    @ReactMethod
+    public void setWebViewNetworkTrackingEnabled(final boolean isEnabled) {
+        try {
+            Luciq.setWebViewNetworkTrackingEnabled(isEnabled);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * Enables or disables WebView user interactions tracking.
+     *
+     * @param isEnabled A boolean to enable/disable WebView user interactions tracking.
+     */
+    @ReactMethod
+    public void setWebViewUserInteractionsTrackingEnabled(final boolean isEnabled) {
+        try {
+            Luciq.setWebViewUserInteractionsTrackingEnabled(isEnabled);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
     /**
      * Sets the theme for Luciq using a configuration object.
      *

package/android/src/main/java/ai/luciq/reactlibrary/RNLuciqReactnativePackage.java

@@ -20,6 +20,8 @@ public class RNLuciqReactnativePackage implements ReactPackage {
     @NonNull
     @Override
     public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
+        RNLuciq.getInstance().setCurrentPlatform();
+
         List<NativeModule> modules = new ArrayList<>();
         modules.add(new RNLuciqReactnativeModule(reactContext));
         modules.add(new RNLuciqBugReportingModule(reactContext));

package/android/src/main/java/ai/luciq/reactlibrary/utils/EventEmitterModule.java

@@ -1,7 +1,5 @@
 package ai.luciq.reactlibrary.utils;
 
-import android.util.Log;
-
 import androidx.annotation.Nullable;
 import androidx.annotation.VisibleForTesting;
 
@@ -12,7 +10,6 @@ import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
 
 public abstract class EventEmitterModule extends ReactContextBaseJavaModule {
-    private static final String NET_TAG = "LCQ-RN-NET";
     private int listenerCount = 0;
 
     public EventEmitterModule(ReactApplicationContext context) {
@@ -25,18 +22,14 @@ public abstract class EventEmitterModule extends ReactContextBaseJavaModule {
             getReactApplicationContext()
                     .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
                     .emit(event, params);
-        } else {
-            Log.w(NET_TAG, "[EventEmitter] Event DROPPED (no JS listeners): event=" + event + ", module=" + getName() + ", listenerCount=0");
         }
     }
 
     protected void addListener(String ignoredEvent) {
         listenerCount++;
-        Log.d(NET_TAG, "[EventEmitter] addListener — module=" + getName() + ", event=" + ignoredEvent + ", listenerCount=" + listenerCount);
     }
 
     protected void removeListeners(Integer count) {
         listenerCount -= count;
-        Log.d(NET_TAG, "[EventEmitter] removeListeners — module=" + getName() + ", removed=" + count + ", listenerCount=" + listenerCount);
     }
 }

package/android/src/main/java/ai/luciq/reactlibrary/utils/ReportUtil.java

@@ -6,14 +6,7 @@ import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.ReadableMapKeySetIterator;
 import com.facebook.react.bridge.ReadableType;
-import com.facebook.react.bridge.WritableArray;
-import com.facebook.react.bridge.WritableNativeArray;
 import ai.luciq.library.model.Report;
-import ai.luciq.library.model.a;
-
-import org.json.JSONException;
-
-import java.util.ArrayList;
 
 
 /**

package/dist/modules/Luciq.d.ts

@@ -26,6 +26,21 @@ export declare const init: (config: LuciqConfig) => void;
  * @param appVariant the current App variant name
  */
 export declare const setAppVariant: (appVariant: string) => void;
+/**
+ * Enables or disables WebView monitoring.
+ * @param isEnabled A boolean to enable/disable WebView monitoring.
+ */
+export declare const setWebViewMonitoringEnabled: (isEnabled: boolean) => void;
+/**
+ * Enables or disables WebView network tracking.
+ * @param isEnabled A boolean to enable/disable WebView network tracking.
+ */
+export declare const setWebViewNetworkTrackingEnabled: (isEnabled: boolean) => void;
+/**
+ * Enables or disables WebView user interactions tracking.
+ * @param isEnabled A boolean to enable/disable WebView user interactions tracking.
+ */
+export declare const setWebViewUserInteractionsTrackingEnabled: (isEnabled: boolean) => void;
 /**
  * Sets the Code Push version to be sent with each report.
  * @param version the Code Push version.

package/dist/modules/Luciq.js

@@ -1,7 +1,7 @@
 import { AppState, findNodeHandle, Platform } from 'react-native';
 import Report from '../models/Report';
 import { emitter, NativeEvents, NativeLuciq } from '../native/NativeLuciq';
-import { registerFeatureFlagsListener, initFeatureFlagsCache } from '../utils/FeatureFlags';
+import { registerFeatureFlagsListener } from '../utils/FeatureFlags';
 import { LogLevel, NetworkInterceptionMode, ReproStepsMode, StringKey, } from '../utils/Enums';
 import LuciqUtils, { checkNetworkRequestHandlers, resetNativeObfuscationListener, setApmNetworkFlagsIfChanged, stringifyIfNotString, } from '../utils/LuciqUtils';
 import * as NetworkLogger from './NetworkLogger';
@@ -50,7 +50,6 @@ function reportCurrentViewForAndroid(screenName) {
  * @param config SDK configurations. See {@link LuciqConfig} for more info.
  */
 export const init = (config) => {
-    initFeatureFlagsCache();
     if (Platform.OS === 'android') {
         // Add android feature flags listener for android
         registerFeatureFlagsListener();
@@ -91,6 +90,27 @@ export const init = (config) => {
 export const setAppVariant = (appVariant) => {
     NativeLuciq.setAppVariant(appVariant);
 };
+/**
+ * Enables or disables WebView monitoring.
+ * @param isEnabled A boolean to enable/disable WebView monitoring.
+ */
+export const setWebViewMonitoringEnabled = (isEnabled) => {
+    NativeLuciq.setWebViewMonitoringEnabled(isEnabled);
+};
+/**
+ * Enables or disables WebView network tracking.
+ * @param isEnabled A boolean to enable/disable WebView network tracking.
+ */
+export const setWebViewNetworkTrackingEnabled = (isEnabled) => {
+    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) => {
+    NativeLuciq.setWebViewUserInteractionsTrackingEnabled(isEnabled);
+};
 /**
  * Handles app state changes and updates APM network flags if necessary.
  */

package/dist/modules/NetworkLogger.d.ts

@@ -3,6 +3,11 @@ 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,25 +20,21 @@ 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;
                         }
                     }
@@ -58,16 +54,12 @@ 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(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/dist/native/NativeLuciq.d.ts

@@ -77,6 +77,9 @@ export interface LuciqNativeModule extends NativeModule {
     getNetworkBodyMaxSize(): Promise<number>;
     setTheme(theme: ThemeConfig): void;
     setFullscreen(isEnabled: boolean): void;
+    setWebViewMonitoringEnabled(isEnabled: boolean): void;
+    setWebViewNetworkTrackingEnabled(isEnabled: boolean): void;
+    setWebViewUserInteractionsTrackingEnabled(isEnabled: boolean): void;
 }
 export declare const NativeLuciq: LuciqNativeModule;
 export declare enum NativeEvents {

package/dist/utils/FeatureFlags.d.ts

@@ -1,9 +1,3 @@
-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,34 +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(),
     isW3ExternalGeneratedHeader: () => NativeLuciq.isW3ExternalGeneratedHeaderEnabled(),
@@ -37,12 +8,6 @@ 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;
         };