feat: respect be network body limit (#1397)

kholood-ea · kholood-ea · commit 83c5b9e3dadd · 2025-07-01T16:08:48.000+03:00
* chore(ios): add respect BE network body limit custom build * feat(ios): add getNetworkBodyMaxSize API * feat:add getNetworkBodyMaxSize API * chore(android): add respect network body limit snapshot * chore(ios): sync pdfile.lock * Revert "Merge pull request #1388 from Instabug/refactor/replace-reflection" This reverts commit 256e72a, reversing changes made to 196b481. * feat(android): add getNetworkBodyMaxSize API * feat:add feature flag change listener for android * chore: fix sync_generated_files CI job * feat(ios): add getNetworkBodyMaxSize API * chore: add change log * Revert duplicate "feat(ios): add getNetworkBodyMaxSize API" This reverts commit ef8710e. * chore: edit a change log * chore: update test cases titles
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -12,6 +12,8 @@
 
 - Add support for network spans. ([#1394](https://github.com/Instabug/Instabug-React-Native/pull/1394))
 
+- Add respect to backend network body limit. ([#1397](https://github.com/Instabug/Instabug-React-Native/pull/1397))
+
 ### Changed
 
 - Bump Instabug iOS SDK to v15.1.1 ([#1402](https://github.com/Instabug/Instabug-React-Native/pull/1402)). [See release notes](https://github.com/Instabug/Instabug-iOS/releases/tag/15.1.1).
diff --git a/android/src/main/java/com/instabug/reactlibrary/Constants.java b/android/src/main/java/com/instabug/reactlibrary/Constants.java
@@ -13,7 +13,7 @@ final class Constants {
     final static String IBG_ON_FEATURES_UPDATED_CALLBACK = "IBGOnFeatureUpdatedCallback";
     final static String IBG_NETWORK_LOGGER_HANDLER = "IBGNetworkLoggerHandler";
 
-    final static String IBG_ON_NEW_W3C_FLAGS_UPDATE_RECEIVED_CALLBACK = "IBGOnNewW3CFlagsUpdateReceivedCallback";
+    final static String IBG_ON_FEATURE_FLAGS_UPDATE_RECEIVED_CALLBACK = "IBGOnNewFeatureFlagsUpdateReceivedCallback";
 
     final static String IBG_SESSION_REPLAY_ON_SYNC_CALLBACK_INVOCATION = "IBGSessionReplayOnSyncCallback";
 
diff --git a/android/src/main/java/com/instabug/reactlibrary/RNInstabugReactnativeModule.java b/android/src/main/java/com/instabug/reactlibrary/RNInstabugReactnativeModule.java
@@ -1159,10 +1159,10 @@ public void run() {
     }
 
     /**
-     * Register a listener for W3C flags value change
+     * Register a listener for feature flags value change
      */
     @ReactMethod
-    public void registerW3CFlagsChangeListener() {
+    public void registerFeatureFlagsChangeListener() {
 
         MainThreadHandler.runOnMainThread(new Runnable() {
             @Override
@@ -1175,8 +1175,9 @@ public void invoke(@NonNull CoreFeaturesState featuresState) {
                             params.putBoolean("isW3ExternalTraceIDEnabled", featuresState.isW3CExternalTraceIdEnabled());
                             params.putBoolean("isW3ExternalGeneratedHeaderEnabled", featuresState.isAttachingGeneratedHeaderEnabled());
                             params.putBoolean("isW3CaughtHeaderEnabled", featuresState.isAttachingCapturedHeaderEnabled());
+                            params.putInt("networkBodyLimit",featuresState.getNetworkLogCharLimit());
 
-                            sendEvent(Constants.IBG_ON_NEW_W3C_FLAGS_UPDATE_RECEIVED_CALLBACK, params);
+                            sendEvent(Constants.IBG_ON_FEATURE_FLAGS_UPDATE_RECEIVED_CALLBACK, params);
                         }
                     });
                 } catch (Exception e) {
@@ -1306,7 +1307,7 @@ public void run() {
            }
        });
    }
-     /**
+
     /**
      * Sets the auto mask screenshots types.
      *
@@ -1331,4 +1332,23 @@ public void run() {
 
         });
     }
+
+    /**
+     * Get network body size limit
+     */
+    @ReactMethod
+    public void getNetworkBodyMaxSize(Promise promise) {
+
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    promise.resolve(InternalCore.INSTANCE.get_networkLogCharLimit());
+                } catch (Exception e) {
+                    e.printStackTrace();
+                    promise.resolve(false);
+                }
+            }
+        });
+    }
 }
diff --git a/android/src/test/java/com/instabug/reactlibrary/RNInstabugReactnativeModuleTest.java b/android/src/test/java/com/instabug/reactlibrary/RNInstabugReactnativeModuleTest.java
@@ -686,9 +686,22 @@ public void testEnableAutoMasking(){
             String maskTextInputs = "textInputs";
             String maskMedia = "media";
             String maskNone = "none";
-    
+
             rnModule.enableAutoMasking(JavaOnlyArray.of(maskLabel, maskMedia, maskTextInputs,maskNone));
-    
+
             mockInstabug.verify(() -> Instabug.setAutoMaskScreenshotsTypes(MaskingType.LABELS,MaskingType.MEDIA,MaskingType.TEXT_INPUTS,MaskingType.MASK_NOTHING));
     }
+
+    @Test
+    public void testGetNetworkBodyMaxSize_resolvesPromiseWithExpectedValue() {
+        Promise promise = mock(Promise.class);
+        InternalCore internalAPM = mock(InternalCore.class);
+        int expected = 10240;
+        when(internalAPM.get_networkLogCharLimit()).thenReturn(expected);
+
+        rnModule.getNetworkBodyMaxSize(promise);
+
+        verify(promise).resolve(expected);
+    }
+
 }
diff --git a/examples/default/ios/InstabugTests/InstabugSampleTests.m b/examples/default/ios/InstabugTests/InstabugSampleTests.m
@@ -634,4 +634,23 @@ - (void)testSetNetworkLogBodyEnabled {
     OCMVerify([mock setLogBodyEnabled:isEnabled]);
 }
 
+- (void)testGetNetworkBodyMaxSize {
+    id mock = OCMClassMock([IBGNetworkLogger class]);
+    double expectedValue = 10240.0;
+
+    OCMStub([mock getNetworkBodyMaxSize]).andReturn(expectedValue);
+
+    XCTestExpectation *expectation = [self expectationWithDescription:@"Call resolve block"];
+    RCTPromiseResolveBlock resolve = ^(NSNumber *result) {
+        XCTAssertEqual(result.doubleValue, expectedValue);
+        [expectation fulfill];
+    };
+
+    [self.instabugBridge getNetworkBodyMaxSize:resolve :nil];
+    [self waitForExpectationsWithTimeout:1.0 handler:nil];
+
+    OCMVerify(ClassMethod([mock getNetworkBodyMaxSize]));
+}
+
+
 @end
diff --git a/examples/default/src/App.tsx b/examples/default/src/App.tsx
@@ -50,7 +50,7 @@ export const App: React.FC = () => {
         token: 'deb1910a7342814af4e4c9210c786f35',
         invocationEvents: [InvocationEvent.floatingButton],
         debugLogsLevel: LogLevel.verbose,
-        networkInterceptionMode: NetworkInterceptionMode.native,
+        networkInterceptionMode: NetworkInterceptionMode.javascript,
       });
 
       CrashReporting.setNDKCrashesEnabled(true);
diff --git a/ios/RNInstabug/InstabugReactBridge.h b/ios/RNInstabug/InstabugReactBridge.h
@@ -140,5 +140,6 @@ w3cExternalTraceAttributes:(NSDictionary * _Nullable)w3cExternalTraceAttributes;
 - (void)removeAllFeatureFlags;
 - (void)setNetworkLogBodyEnabled:(BOOL)isEnabled;
 - (void)enableAutoMasking:(NSArray *)autoMaskingTypes;
+- (void)getNetworkBodyMaxSize:(RCTPromiseResolveBlock)resolve :(RCTPromiseRejectBlock)reject;
 
 @end
diff --git a/ios/RNInstabug/InstabugReactBridge.m b/ios/RNInstabug/InstabugReactBridge.m
@@ -452,6 +452,10 @@ + (BOOL)iOSVersionIsLessThan:(NSString *)iOSVersion {
     [Instabug setAutoMaskScreenshots: autoMaskingOptions];
 };
 
+RCT_EXPORT_METHOD(getNetworkBodyMaxSize:(RCTPromiseResolveBlock)resolve :(RCTPromiseRejectBlock)reject) {
+    resolve(@(IBGNetworkLogger.getNetworkBodyMaxSize));
+}
+
 RCT_EXPORT_METHOD(setNetworkLogBodyEnabled:(BOOL)isEnabled) {
     IBGNetworkLogger.logBodyEnabled = isEnabled;
 }
diff --git a/ios/RNInstabug/Util/IBGNetworkLogger+CP.h b/ios/RNInstabug/Util/IBGNetworkLogger+CP.h
@@ -61,6 +61,7 @@ NS_ASSUME_NONNULL_BEGIN
 + (void)setCPRequestAsyncObfuscationHandler:(void (^)(NSURLRequest * requestToBeObfuscated, void (^ completion)(NSURLRequest * obfuscatedRequest)))asyncObfuscationHandler;
 + (void)setCPRequestFilteringHandler:(void (^)(NSURLRequest * request, void (^completion)(BOOL keep)))requestFilteringHandler;
 + (void)setCPResponseFilteringHandler:(void (^)(NSURLResponse * response, void (^comppletion)(BOOL keep)))responseFilteringHandler;
++ (double)getNetworkBodyMaxSize;
 
 @end
 
diff --git a/src/modules/Instabug.ts b/src/modules/Instabug.ts
@@ -16,7 +16,7 @@ import type { NavigationAction, NavigationState as NavigationStateV4 } from 'rea
 import type { InstabugConfig } from '../models/InstabugConfig';
 import Report from '../models/Report';
 import { emitter, NativeEvents, NativeInstabug } from '../native/NativeInstabug';
-import { registerW3CFlagsListener } from '../utils/FeatureFlags';
+import { registerFeatureFlagsListener } from '../utils/FeatureFlags';
 import {
   AutoMaskingType,
   ColorTheme,
@@ -87,7 +87,7 @@ function reportCurrentViewForAndroid(screenName: string | null) {
 export const init = async (config: InstabugConfig) => {
   if (Platform.OS === 'android') {
     // Add android feature flags listener for android
-    registerW3CFlagsListener();
+    registerFeatureFlagsListener();
     addOnFeatureUpdatedListener(config);
   } else {
     isNativeInterceptionFeatureEnabled = await NativeNetworkLogger.isNativeInterceptionEnabled();
@@ -871,20 +871,21 @@ export const componentDidAppearListener = (event: ComponentDidAppearEvent) => {
 };
 
 /**
- * Sets listener to W3ExternalTraceID flag changes
+ * Sets listener to feature flag changes
  * @param handler A callback that gets the update value of the flag
  */
-export const _registerW3CFlagsChangeListener = (
+export const _registerFeatureFlagsChangeListener = (
   handler: (payload: {
     isW3ExternalTraceIDEnabled: boolean;
     isW3ExternalGeneratedHeaderEnabled: boolean;
     isW3CaughtHeaderEnabled: boolean;
+    networkBodyLimit: number;
   }) => void,
 ) => {
-  emitter.addListener(NativeEvents.ON_W3C_FLAGS_CHANGE, (payload) => {
+  emitter.addListener(NativeEvents.ON_FEATURE_FLAGS_CHANGE, (payload) => {
     handler(payload);
   });
-  NativeInstabug.registerW3CFlagsChangeListener();
+  NativeInstabug.registerFeatureFlagsChangeListener();
 };
 
 /**
diff --git a/src/modules/NetworkLogger.ts b/src/modules/NetworkLogger.ts
@@ -45,7 +45,9 @@ export const setEnabled = (isEnabled: boolean) => {
     xhr.setOnDoneCallback(async (network) => {
       // eslint-disable-next-line no-new-func
       const predicate = Function('network', 'return ' + _requestFilterExpression);
+
       if (!predicate(network)) {
+        const MAX_NETWORK_BODY_SIZE_IN_BYTES = await NativeInstabug.getNetworkBodyMaxSize();
         try {
           if (_networkDataObfuscationHandler) {
             network = await _networkDataObfuscationHandler(network);
@@ -57,14 +59,28 @@ export const setEnabled = (isEnabled: boolean) => {
               return;
             }
           }
-          if (network.requestBodySize > InstabugConstants.MAX_NETWORK_BODY_SIZE_IN_BYTES) {
-            network.requestBody = InstabugConstants.MAX_REQUEST_BODY_SIZE_EXCEEDED_MESSAGE;
-            Logger.warn('IBG-RN:', InstabugConstants.MAX_REQUEST_BODY_SIZE_EXCEEDED_MESSAGE);
+          if (network.requestBodySize > MAX_NETWORK_BODY_SIZE_IN_BYTES) {
+            network.requestBody = `${InstabugConstants.MAX_REQUEST_BODY_SIZE_EXCEEDED_MESSAGE}${
+              MAX_NETWORK_BODY_SIZE_IN_BYTES / 1024
+            } Kb`;
+            Logger.warn(
+              'IBG-RN:',
+              `${InstabugConstants.MAX_REQUEST_BODY_SIZE_EXCEEDED_MESSAGE}${
+                MAX_NETWORK_BODY_SIZE_IN_BYTES / 1024
+              } Kb`,
+            );
           }
 
-          if (network.responseBodySize > InstabugConstants.MAX_NETWORK_BODY_SIZE_IN_BYTES) {
-            network.responseBody = InstabugConstants.MAX_RESPONSE_BODY_SIZE_EXCEEDED_MESSAGE;
-            Logger.warn('IBG-RN:', InstabugConstants.MAX_RESPONSE_BODY_SIZE_EXCEEDED_MESSAGE);
+          if (network.responseBodySize > MAX_NETWORK_BODY_SIZE_IN_BYTES) {
+            network.responseBody = `${InstabugConstants.MAX_RESPONSE_BODY_SIZE_EXCEEDED_MESSAGE}${
+              MAX_NETWORK_BODY_SIZE_IN_BYTES / 1024
+            } Kb`;
+            Logger.warn(
+              'IBG-RN:',
+              `${InstabugConstants.MAX_RESPONSE_BODY_SIZE_EXCEEDED_MESSAGE}${
+                MAX_NETWORK_BODY_SIZE_IN_BYTES / 1024
+              } Kb`,
+            );
           }
 
           if (network.requestBody && isContentTypeNotAllowed(network.requestContentType)) {
diff --git a/src/native/NativeInstabug.ts b/src/native/NativeInstabug.ts
@@ -152,19 +152,20 @@ export interface InstabugNativeModule extends NativeModule {
 
   isW3CaughtHeaderEnabled(): Promise<boolean>;
 
-  // W3C Feature Flags Listener for Android
-  registerW3CFlagsChangeListener(): void;
+  // Feature Flags Listener for Android
+  registerFeatureFlagsChangeListener(): void;
 
   setOnFeaturesUpdatedListener(handler?: (params: any) => void): void; // android only
   enableAutoMasking(autoMaskingTypes: AutoMaskingType[]): void;
+  getNetworkBodyMaxSize(): Promise<number>;
 }
 
 export const NativeInstabug = NativeModules.Instabug;
 
 export enum NativeEvents {
   PRESENDING_HANDLER = 'IBGpreSendingHandler',
   IBG_ON_FEATURES_UPDATED_CALLBACK = 'IBGOnFeatureUpdatedCallback',
-  ON_W3C_FLAGS_CHANGE = 'IBGOnNewW3CFlagsUpdateReceivedCallback',
+  ON_FEATURE_FLAGS_CHANGE = 'IBGOnNewFeatureFlagsUpdateReceivedCallback',
 }
 
 export const emitter = new NativeEventEmitter(NativeInstabug);
diff --git a/src/utils/FeatureFlags.ts b/src/utils/FeatureFlags.ts
@@ -1,18 +1,20 @@
 import { NativeInstabug } from '../native/NativeInstabug';
-import { _registerW3CFlagsChangeListener } from '../modules/Instabug';
+import { _registerFeatureFlagsChangeListener } from '../modules/Instabug';
 
 export const FeatureFlags = {
   isW3ExternalTraceID: () => NativeInstabug.isW3ExternalTraceIDEnabled(),
   isW3ExternalGeneratedHeader: () => NativeInstabug.isW3ExternalGeneratedHeaderEnabled(),
   isW3CaughtHeader: () => NativeInstabug.isW3CaughtHeaderEnabled(),
+  networkLogLimit: () => NativeInstabug.getNetworkBodyMaxSize(),
 };
 
-export const registerW3CFlagsListener = () => {
-  _registerW3CFlagsChangeListener(
+export const registerFeatureFlagsListener = () => {
+  _registerFeatureFlagsChangeListener(
     (res: {
       isW3ExternalTraceIDEnabled: boolean;
       isW3ExternalGeneratedHeaderEnabled: boolean;
       isW3CaughtHeaderEnabled: boolean;
+      networkBodyLimit: number;
     }) => {
       FeatureFlags.isW3ExternalTraceID = async () => {
         return res.isW3ExternalTraceIDEnabled;
@@ -23,6 +25,9 @@ export const registerW3CFlagsListener = () => {
       FeatureFlags.isW3CaughtHeader = async () => {
         return res.isW3CaughtHeaderEnabled;
       };
+      FeatureFlags.networkLogLimit = async () => {
+        return res.networkBodyLimit;
+      };
     },
   );
 };
diff --git a/src/utils/InstabugConstants.ts b/src/utils/InstabugConstants.ts
@@ -4,9 +4,9 @@ const InstabugConstants = {
   // TODO: dyanmically get the max size from the native SDK and update the error message to reflect the dynamic size.
   MAX_NETWORK_BODY_SIZE_IN_BYTES: 1024 * 10, // 10 KB
   MAX_RESPONSE_BODY_SIZE_EXCEEDED_MESSAGE:
-    'The response body has not been logged because it exceeds the maximum size of 10 Kb',
+    'The response body has not been logged because it exceeds the maximum size of ',
   MAX_REQUEST_BODY_SIZE_EXCEEDED_MESSAGE:
-    'The request body has not been logged because it exceeds the maximum size of 10 Kb',
+    'The request body has not been logged because it exceeds the maximum size of ',
   SET_USER_ATTRIBUTES_ERROR_TYPE_MESSAGE:
     'IBG-RN: Expected key and value passed to setUserAttribute to be of type string',
   REMOVE_USER_ATTRIBUTES_ERROR_TYPE_MESSAGE:
diff --git a/test/mocks/mockInstabug.ts b/test/mocks/mockInstabug.ts
@@ -72,10 +72,11 @@ const mockInstabug: InstabugNativeModule = {
   isW3ExternalTraceIDEnabled: jest.fn(),
   isW3ExternalGeneratedHeaderEnabled: jest.fn(),
   isW3CaughtHeaderEnabled: jest.fn(),
-  registerW3CFlagsChangeListener: jest.fn(),
+  registerFeatureFlagsChangeListener: jest.fn(),
   setNetworkLogBodyEnabled: jest.fn(),
   setOnFeaturesUpdatedListener: jest.fn(),
   enableAutoMasking: jest.fn(),
+  getNetworkBodyMaxSize: jest.fn().mockResolvedValue(10240), // 10 KB
 };
 
 export default mockInstabug;
diff --git a/test/modules/Instabug.spec.ts b/test/modules/Instabug.spec.ts
@@ -900,19 +900,19 @@ describe('Instabug Module', () => {
     expect(NativeInstabug.willRedirectToStore).toBeCalledTimes(1);
   });
 
-  it('should register W3C flag listener', async () => {
+  it('should register feature flag listener', async () => {
     const callback = jest.fn();
-    Instabug._registerW3CFlagsChangeListener(callback);
+    Instabug._registerFeatureFlagsChangeListener(callback);
 
-    expect(NativeInstabug.registerW3CFlagsChangeListener).toBeCalledTimes(1);
+    expect(NativeInstabug.registerFeatureFlagsChangeListener).toBeCalledTimes(1);
   });
 
-  it('should invoke callback on emitting the event IBGOnNewW3CFlagsUpdateReceivedCallback', () => {
+  it('should invoke callback on emitting the event IBGOnNewFeatureFlagsUpdateReceivedCallback', () => {
     const callback = jest.fn();
-    Instabug._registerW3CFlagsChangeListener(callback);
-    emitter.emit(NativeEvents.ON_W3C_FLAGS_CHANGE);
+    Instabug._registerFeatureFlagsChangeListener(callback);
+    emitter.emit(NativeEvents.ON_FEATURE_FLAGS_CHANGE);
 
-    expect(emitter.listenerCount(NativeEvents.ON_W3C_FLAGS_CHANGE)).toBe(1);
+    expect(emitter.listenerCount(NativeEvents.ON_FEATURE_FLAGS_CHANGE)).toBe(1);
     expect(callback).toHaveBeenCalled();
   });
 
diff --git a/test/modules/NetworkLogger.spec.ts b/test/modules/NetworkLogger.spec.ts
