feat: add body size checks inside network manager and cache retrieved in feature flags manager

- Added `_networkBodyMaxSize` to `FeatureFlagsManager` for managing network body size limits.
- Introduced `didRequestBodyExceedSizeLimit` and `didResponseBodyExceedSizeLimit` methods in `NetworkManager` to validate request and response body sizes against the limit.
- Created `InstabugConstants` for standardized logging messages related to network body size limits.
- Implemented caching for network body size retrieval to optimize performance.

Author: MoKamall

lib/src/utils/feature_flags_manager.dart

@@ -42,6 +42,9 @@ class FeatureFlagsManager implements FeatureFlagsFlutterApi {
   bool _isAndroidW3CExternalTraceID = false;
   bool _isAndroidW3CExternalGeneratedHeader = false;
   bool _isAndroidW3CCaughtHeader = false;
+  int _networkBodyMaxSize = 0;
+
+  int get networkBodyMaxSize => _networkBodyMaxSize;
 
   Future<W3cFeatureFlags> getW3CFeatureFlagsHeader() async {
     if (IBGBuildInfo.instance.isAndroid) {
@@ -89,4 +92,9 @@ class FeatureFlagsManager implements FeatureFlagsFlutterApi {
     _isAndroidW3CExternalTraceID = isW3cExternalTraceIDEnabled;
     _isAndroidW3CExternalGeneratedHeader = isW3cExternalGeneratedHeaderEnabled;
   }
+  
+  @override
+  void onNetworkLogBodyMaxSizeChange(int networkBodyMaxSize) {
+    _networkBodyMaxSize = networkBodyMaxSize;
+  }
 }

lib/src/utils/instabug_constants.dart

@@ -0,0 +1,31 @@
+/// Constants used throughout the Instabug Flutter SDK
+class InstabugConstants {
+  InstabugConstants._();
+
+  // Network logging constants
+  static const String networkLoggerTag = 'NetworkLogger';
+  static const String networkManagerTag = 'NetworkManager';
+
+  // Network body replacement messages
+  static const String requestBodyReplacedPrefix = '[REQUEST_BODY_REPLACED]';
+  static const String responseBodyReplacedPrefix = '[RESPONSE_BODY_REPLACED]';
+  static const String exceedsLimitSuffix = 'exceeds limit';
+
+  /// Generates a request body replacement message
+  static String getRequestBodyReplacementMessage(int size) {
+    return '$requestBodyReplacedPrefix - Size: $size $exceedsLimitSuffix';
+  }
+
+  /// Generates a response body replacement message
+  static String getResponseBodyReplacementMessage(int size) {
+    return '$responseBodyReplacedPrefix - Size: $size $exceedsLimitSuffix';
+  }
+
+  /// Generates a network body size limit exceeded log message
+  static String getNetworkBodyLimitExceededMessage({
+    required String type,
+    required int bodySize,
+  }) {
+    return 'Network body size limit exceeded for $type - Size: $bodySize';
+  }
+}

lib/src/utils/network_manager.dart

@@ -1,6 +1,10 @@
 import 'dart:async';
 
 import 'package:instabug_flutter/instabug_flutter.dart';
+import 'package:instabug_flutter/src/generated/instabug.api.g.dart';
+import 'package:instabug_flutter/src/utils/feature_flags_manager.dart';
+import 'package:instabug_flutter/src/utils/instabug_constants.dart';
+import 'package:instabug_flutter/src/utils/instabug_logger.dart';
 
 typedef ObfuscateLogCallback = FutureOr<NetworkData> Function(NetworkData data);
 typedef OmitLogCallback = FutureOr<bool> Function(NetworkData data);
@@ -10,6 +14,8 @@ typedef OmitLogCallback = FutureOr<bool> Function(NetworkData data);
 class NetworkManager {
   ObfuscateLogCallback? _obfuscateLogCallback;
   OmitLogCallback? _omitLogCallback;
+  int? _cachedNetworkBodyMaxSize;
+  final _host = InstabugHostApi();
 
   // ignore: use_setters_to_change_properties
   void setObfuscateLogCallback(ObfuscateLogCallback callback) {
@@ -36,4 +42,92 @@ class NetworkManager {
 
     return _omitLogCallback!(data);
   }
+
+  /// Checks if network request body exceeds backend size limits
+  ///
+  /// Returns true if request body size exceeds the limit
+  Future<bool> didRequestBodyExceedSizeLimit(NetworkData data) async {
+    try {
+      final limit = await _getNetworkBodyMaxSize();
+      if (limit == null) {
+        return false; // If we can't get the limit, don't block logging
+      }
+
+      final requestExceeds = data.requestBodySize > limit;
+      if (requestExceeds) {
+        InstabugLogger.I.d(
+          InstabugConstants.getNetworkBodyLimitExceededMessage(
+            type: 'request',
+            bodySize: data.requestBodySize,
+          ),
+          tag: InstabugConstants.networkManagerTag,
+        );
+      }
+
+      return requestExceeds;
+    } catch (error) {
+      InstabugLogger.I.e(
+        'Error checking network request body size limit: $error',
+        tag: InstabugConstants.networkManagerTag,
+      );
+      return false; // Don't block logging on error
+    }
+  }
+
+  /// Checks if network response body exceeds backend size limits
+  ///
+  /// Returns true if response body size exceeds the limit
+  Future<bool> didResponseBodyExceedSizeLimit(NetworkData data) async {
+    try {
+      final limit = await _getNetworkBodyMaxSize();
+      if (limit == null) {
+        return false; // If we can't get the limit, don't block logging
+      }
+
+      final responseExceeds = data.responseBodySize > limit;
+      if (responseExceeds) {
+        InstabugLogger.I.d(
+          InstabugConstants.getNetworkBodyLimitExceededMessage(
+            type: 'response',
+            bodySize: data.responseBodySize,
+          ),
+          tag: InstabugConstants.networkManagerTag,
+        );
+      }
+
+      return responseExceeds;
+    } catch (error) {
+      InstabugLogger.I.e(
+        'Error checking network response body size limit: $error',
+        tag: InstabugConstants.networkManagerTag,
+      );
+      return false; // Don't block logging on error
+    }
+  }
+
+  /// Gets the network body max size from native SDK, with caching
+  Future<int?> _getNetworkBodyMaxSize() async {
+    if (_cachedNetworkBodyMaxSize != null) {
+      return _cachedNetworkBodyMaxSize;
+    }
+
+    final ffmNetworkBodyLimit = FeatureFlagsManager().networkBodyMaxSize;
+
+    if (ffmNetworkBodyLimit > 0) {
+      _cachedNetworkBodyMaxSize = ffmNetworkBodyLimit;
+      return ffmNetworkBodyLimit;
+    }
+
+    try {
+      final limit = await _host.getNetworkBodyMaxSize();
+      _cachedNetworkBodyMaxSize = limit;
+      return limit;
+    } catch (error) {
+      InstabugLogger.I.e(
+        'Failed to get network body max size from native API: $error',
+        tag: InstabugConstants.networkManagerTag,
+      );
+      return null;
+    }
+  }
 }