@luciq/react-native 19.6.0 → 19.7.0

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

@@ -4,7 +4,7 @@ package ai.luciq.reactlibrary;
 import static ai.luciq.apm.configuration.cp.APMFeature.APM_NETWORK_PLUGIN_INSTALLED;
 import static ai.luciq.apm.configuration.cp.APMFeature.CP_NATIVE_INTERCEPTION_ENABLED;
 
-import android.util.Log;
+import static ai.luciq.reactlibrary.Constants.NET_TAG;
 
 import androidx.annotation.NonNull;
 
@@ -20,6 +20,7 @@ import ai.luciq.apm.InternalAPM;
 import ai.luciq.apm.sanitization.OnCompleteCallback;
 import ai.luciq.library.logging.listeners.networklogs.NetworkLogSnapshot;
 import ai.luciq.reactlibrary.utils.EventEmitterModule;
+import ai.luciq.reactlibrary.utils.LuciqRNLogger;
 import ai.luciq.reactlibrary.utils.MainThreadHandler;
 
 import org.json.JSONException;
@@ -57,7 +58,9 @@ public class RNLuciqNetworkLoggerModule extends EventEmitterModule {
     }
 
     private boolean getFlagValue(String key) {
-        return InternalAPM._isFeatureEnabledCP(key, "");
+        boolean value = InternalAPM._isFeatureEnabledCP(key, "");
+        LuciqRNLogger.d(NET_TAG, "[getFlagValue] key=" + key + ", value=" + value);
+        return value;
     }
 
     private WritableMap convertFromMapToWritableMap(Map<String, Object> map) {
@@ -86,14 +89,18 @@ public class RNLuciqNetworkLoggerModule extends EventEmitterModule {
      */
     @ReactMethod
     public void isNativeInterceptionEnabled(Promise promise) {
+        LuciqRNLogger.d(NET_TAG, "[isNativeInterceptionEnabled] Querying CP_NATIVE_INTERCEPTION_ENABLED flag");
         MainThreadHandler.runOnMainThread(new Runnable() {
             @Override
             public void run() {
                 try {
-                    promise.resolve(getFlagValue(CP_NATIVE_INTERCEPTION_ENABLED));
+                    boolean enabled = getFlagValue(CP_NATIVE_INTERCEPTION_ENABLED);
+                    LuciqRNLogger.d(NET_TAG, "[isNativeInterceptionEnabled] Result=" + enabled);
+                    promise.resolve(enabled);
                 } catch (Exception e) {
+                    LuciqRNLogger.e(NET_TAG, "[isNativeInterceptionEnabled] Error — falling back to false (JS interceptor)", e);
                     e.printStackTrace();
-                    promise.resolve(false); // Will rollback to JS interceptor
+                    promise.resolve(false);
                 }
 
             }
@@ -107,14 +114,18 @@ public class RNLuciqNetworkLoggerModule extends EventEmitterModule {
      */
     @ReactMethod
     public void hasAPMNetworkPlugin(Promise promise) {
+        LuciqRNLogger.d(NET_TAG, "[hasAPMNetworkPlugin] Querying APM_NETWORK_PLUGIN_INSTALLED flag");
         MainThreadHandler.runOnMainThread(new Runnable() {
             @Override
             public void run() {
                 try {
-                    promise.resolve(getFlagValue(APM_NETWORK_PLUGIN_INSTALLED));
+                    boolean hasPlugin = getFlagValue(APM_NETWORK_PLUGIN_INSTALLED);
+                    LuciqRNLogger.d(NET_TAG, "[hasAPMNetworkPlugin] Result=" + hasPlugin);
+                    promise.resolve(hasPlugin);
                 } catch (Exception e) {
+                    LuciqRNLogger.e(NET_TAG, "[hasAPMNetworkPlugin] Error — falling back to false", e);
                     e.printStackTrace();
-                    promise.resolve(false);  // Will rollback to JS interceptor
+                    promise.resolve(false);
                 }
 
             }
@@ -124,12 +135,14 @@ public class RNLuciqNetworkLoggerModule extends EventEmitterModule {
 
     @ReactMethod
     public void registerNetworkLogsListener() {
+        LuciqRNLogger.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);
+                    LuciqRNLogger.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);
@@ -147,6 +160,7 @@ public class RNLuciqNetworkLoggerModule extends EventEmitterModule {
                     }
 
                     sendEvent(Constants.LCQ_NETWORK_LOGGER_HANDLER, networkSnapshotParams);
+                    LuciqRNLogger.d(NET_TAG, "[NetworkLogSanitizer] Sent event to JS: " + Constants.LCQ_NETWORK_LOGGER_HANDLER + " for " + networkLogSnapshot.getUrl());
                 });
             }
         });
@@ -154,10 +168,12 @@ public class RNLuciqNetworkLoggerModule extends EventEmitterModule {
 
     @ReactMethod
     public void resetNetworkLogsListener() {
+        LuciqRNLogger.d(NET_TAG, "[resetNetworkLogsListener] Clearing network log sanitizer, callbackMapSize=" + callbackMap.size());
         MainThreadHandler.runOnMainThread(new Runnable() {
             @Override
             public void run() {
                 InternalAPM._registerNetworkLogSanitizer(null);
+                LuciqRNLogger.d(NET_TAG, "[resetNetworkLogsListener] Sanitizer cleared");
             }
         });
     }
@@ -172,24 +188,28 @@ public class RNLuciqNetworkLoggerModule extends EventEmitterModule {
             ReadableMap requestHeaders,
             ReadableMap responseHeaders
     ) {
+        LuciqRNLogger.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 {
+                LuciqRNLogger.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);
+                LuciqRNLogger.d(NET_TAG, "[updateNetworkLogSnapshot] Callback invoked and removed for " + callbackID + ", remaining=" + callbackMap.size());
+            } else {
+                LuciqRNLogger.e(NET_TAG, "[updateNetworkLogSnapshot] No callback found for callbackID=" + callbackID + " — possible leak or duplicate call, mapKeys=" + callbackMap.keySet());
             }
         } catch (Exception e) {
-            // Reject the promise to indicate an error occurred
-            Log.e("IB-CP-Bridge", "LuciqNetworkLogger.updateNetworkLogSnapshot failed to parse the network snapshot object.");
+            LuciqRNLogger.e(NET_TAG, "[updateNetworkLogSnapshot] Exception processing snapshot: " + e.getMessage() + " for callbackID=" + callbackID, e);
         }
     }
 }