✨ Add requestUrl & responseUrl to LogInterceptor for more precise controls

dio/CHANGELOG.md

@@ -5,7 +5,7 @@ See the [Migration Guide][] for the complete breaking changes list.**
 
 ## Unreleased
 
-*None.*
+- Add `requestUrl` and `responseUrl` parameters to `LogInterceptor` for more precise control over URL logging.
 
 ## 5.9.0
 

dio/lib/src/interceptors/log.dart

@@ -15,36 +15,44 @@ import '../response.dart';
 /// ```dart
 /// dio.interceptors.add(
 ///   LogInterceptor(
-///    logPrint: (o) => debugPrint(o.toString()),
+///     logPrint: (o) => debugPrint(o.toString()),
 ///   ),
 /// );
 /// ```
 class LogInterceptor extends Interceptor {
   LogInterceptor({
     this.request = true,
+    this.requestUrl = true,
     this.requestHeader = true,
     this.requestBody = false,
+    this.responseUrl = true,
     this.responseHeader = true,
     this.responseBody = false,
     this.error = true,
     this.logPrint = _debugPrint,
   });
 
-  /// Print request [Options]
+  /// Print request [RequestOptions]
   bool request;
 
-  /// Print request header [Options.headers]
+  /// Print request URL [RequestOptions.uri]
+  bool requestUrl;
+
+  /// Print request headers [RequestOptions.headers]
   bool requestHeader;
 
-  /// Print request data [Options.data]
+  /// Print request data [RequestOptions.data]
   bool requestBody;
 
-  /// Print [Response.data]
-  bool responseBody;
+  /// Print [Response.realUri]
+  bool responseUrl;
 
   /// Print [Response.headers]
   bool responseHeader;
 
+  /// Print [Response.data]
+  bool responseBody;
+
   /// Print error message
   bool error;
 
@@ -65,9 +73,40 @@ class LogInterceptor extends Interceptor {
     RequestOptions options,
     RequestInterceptorHandler handler,
   ) {
-    logPrint('*** Request ***');
-    _printKV('uri', options.uri);
-    //options.headers;
+    _printRequest(options);
+    handler.next(options);
+  }
+
+  @override
+  void onResponse(Response response, ResponseInterceptorHandler handler) {
+    _printResponse(response);
+    handler.next(response);
+  }
+
+  @override
+  void onError(DioException err, ErrorInterceptorHandler handler) {
+    if (error) {
+      logPrint('*** DioException ***:');
+      logPrint('uri: ${err.requestOptions.uri}');
+      logPrint('$err');
+      if (err.response != null) {
+        _printResponse(err.response!);
+      }
+      logPrint('');
+    }
+
+    handler.next(err);
+  }
+
+  void _printRequest(RequestOptions options) {
+    if (!request && !requestUrl && !requestHeader && !requestBody) {
+      return;
+    }
+
+    if (requestUrl) {
+      logPrint('*** Request ***');
+      _printKV('uri', options.uri);
+    }
 
     if (request) {
       _printKV('method', options.method);
@@ -83,56 +122,48 @@ class LogInterceptor extends Interceptor {
       );
       _printKV('extra', options.extra);
     }
+
     if (requestHeader) {
       logPrint('headers:');
       options.headers.forEach((key, v) => _printKV(' $key', v));
     }
+
     if (requestBody) {
       logPrint('data:');
       _printAll(options.data);
     }
-    logPrint('');
-
-    handler.next(options);
-  }
 
-  @override
-  void onResponse(Response response, ResponseInterceptorHandler handler) {
-    logPrint('*** Response ***');
-    _printResponse(response);
-    handler.next(response);
+    logPrint('');
   }
 
-  @override
-  void onError(DioException err, ErrorInterceptorHandler handler) {
-    if (error) {
-      logPrint('*** DioException ***:');
-      logPrint('uri: ${err.requestOptions.uri}');
-      logPrint('$err');
-      if (err.response != null) {
-        _printResponse(err.response!);
-      }
-      logPrint('');
+  void _printResponse(Response response) {
+    if (!responseUrl && !responseHeader && !responseBody) {
+      return;
     }
 
-    handler.next(err);
-  }
+    if (responseUrl) {
+      logPrint('*** Response ***');
+      _printKV('uri', response.realUri);
+    }
 
-  void _printResponse(Response response) {
-    _printKV('uri', response.requestOptions.uri);
     if (responseHeader) {
       _printKV('statusCode', response.statusCode);
-      if (response.isRedirect == true) {
-        _printKV('redirect', response.realUri);
+      if (response.statusMessage != null) {
+        _printKV('statusMessage', response.statusMessage);
+      }
+      if (response.redirects.isNotEmpty) {
+        _printKV('redirects', response.redirects);
       }
 
       logPrint('headers:');
       response.headers.forEach((key, v) => _printKV(' $key', v.join('\r\n\t')));
     }
+
     if (responseBody) {
       logPrint('Response Text:');
       _printAll(response.toString());
     }
+
     logPrint('');
   }
 

dio/test/interceptor_test.dart

@@ -765,6 +765,217 @@ void main() {
     });
   });
 
+  group('LogInterceptor', () {
+    test('requestUrl controls URL logging in requests', () async {
+      final dio = Dio();
+      dio.options.baseUrl = MockAdapter.mockBase;
+      dio.httpClientAdapter = MockAdapter();
+
+      final logs = <String>[];
+      dio.interceptors.add(
+        LogInterceptor(
+          requestUrl: true,
+          requestHeader: false,
+          requestBody: false,
+          request: false,
+          responseUrl: false,
+          responseHeader: false,
+          responseBody: false,
+          logPrint: (o) => logs.add(o.toString()),
+        ),
+      );
+
+      await dio.get('/test');
+
+      expect(logs.any((log) => log.contains('*** Request ***')), true);
+      expect(logs.any((log) => log.contains('uri:')), true);
+      expect(logs.any((log) => log.contains('/test')), true);
+    });
+
+    test('requestUrl=false prevents URL logging in requests', () async {
+      final dio = Dio();
+      dio.options.baseUrl = MockAdapter.mockBase;
+      dio.httpClientAdapter = MockAdapter();
+
+      final logs = <String>[];
+      dio.interceptors.add(
+        LogInterceptor(
+          requestUrl: false,
+          requestHeader: false,
+          requestBody: false,
+          request: false,
+          responseUrl: false,
+          responseHeader: false,
+          responseBody: false,
+          logPrint: (o) => logs.add(o.toString()),
+        ),
+      );
+
+      await dio.get('/test');
+
+      expect(logs.any((log) => log.contains('*** Request ***')), false);
+      expect(logs.any((log) => log.contains('uri:')), false);
+    });
+
+    test('responseUrl controls URL logging in responses', () async {
+      final dio = Dio();
+      dio.options.baseUrl = MockAdapter.mockBase;
+      dio.httpClientAdapter = MockAdapter();
+
+      final logs = <String>[];
+      dio.interceptors.add(
+        LogInterceptor(
+          requestUrl: false,
+          requestHeader: false,
+          requestBody: false,
+          request: false,
+          responseUrl: true,
+          responseHeader: false,
+          responseBody: false,
+          logPrint: (o) => logs.add(o.toString()),
+        ),
+      );
+
+      await dio.get('/test');
+
+      expect(logs.any((log) => log.contains('*** Response ***')), true);
+      expect(logs.any((log) => log.contains('uri:')), true);
+      expect(logs.any((log) => log.contains('/test')), true);
+    });
+
+    test('responseUrl=false prevents URL logging in responses', () async {
+      final dio = Dio();
+      dio.options.baseUrl = MockAdapter.mockBase;
+      dio.httpClientAdapter = MockAdapter();
+
+      final logs = <String>[];
+      dio.interceptors.add(
+        LogInterceptor(
+          requestUrl: false,
+          requestHeader: false,
+          requestBody: false,
+          request: false,
+          responseUrl: false,
+          responseHeader: false,
+          responseBody: false,
+          logPrint: (o) => logs.add(o.toString()),
+        ),
+      );
+
+      await dio.get('/test');
+
+      expect(logs.any((log) => log.contains('*** Response ***')), false);
+    });
+
+    test('requestUrl and responseUrl work independently', () async {
+      final dio = Dio();
+      dio.options.baseUrl = MockAdapter.mockBase;
+      dio.httpClientAdapter = MockAdapter();
+
+      // Test: requestUrl=true, responseUrl=false
+      final logs1 = <String>[];
+      dio.interceptors.clear();
+      dio.interceptors.add(
+        LogInterceptor(
+          requestUrl: true,
+          requestHeader: false,
+          requestBody: false,
+          request: false,
+          responseUrl: false,
+          responseHeader: false,
+          responseBody: false,
+          logPrint: (o) => logs1.add(o.toString()),
+        ),
+      );
+
+      await dio.get('/test');
+
+      expect(logs1.any((log) => log.contains('*** Request ***')), true);
+      expect(logs1.any((log) => log.contains('*** Response ***')), false);
+
+      // Test: requestUrl=false, responseUrl=true
+      final logs2 = <String>[];
+      dio.interceptors.clear();
+      dio.interceptors.add(
+        LogInterceptor(
+          requestUrl: false,
+          requestHeader: false,
+          requestBody: false,
+          request: false,
+          responseUrl: true,
+          responseHeader: false,
+          responseBody: false,
+          logPrint: (o) => logs2.add(o.toString()),
+        ),
+      );
+
+      await dio.get('/test');
+
+      expect(logs2.any((log) => log.contains('*** Request ***')), false);
+      expect(logs2.any((log) => log.contains('*** Response ***')), true);
+    });
+
+    test('requestUrl can be combined with other request flags', () async {
+      final dio = Dio();
+      dio.options.baseUrl = MockAdapter.mockBase;
+      dio.httpClientAdapter = MockAdapter();
+
+      final logs = <String>[];
+      dio.interceptors.add(
+        LogInterceptor(
+          requestUrl: true,
+          requestHeader: true,
+          requestBody: true,
+          request: true,
+          responseUrl: false,
+          responseHeader: false,
+          responseBody: false,
+          logPrint: (o) => logs.add(o.toString()),
+        ),
+      );
+
+      await dio.get('/test');
+
+      expect(logs.any((log) => log.contains('*** Request ***')), true);
+      expect(logs.any((log) => log.contains('uri:')), true);
+      expect(logs.any((log) => log.contains('method:')), true);
+      expect(logs.any((log) => log.contains('headers:')), true);
+    });
+
+    test('responseUrl can be combined with other response flags', () async {
+      final dio = Dio();
+      dio.options.baseUrl = MockAdapter.mockBase;
+      dio.httpClientAdapter = MockAdapter();
+
+      final logs = <String>[];
+      dio.interceptors.add(
+        LogInterceptor(
+          requestUrl: false,
+          requestHeader: false,
+          requestBody: false,
+          request: false,
+          responseUrl: true,
+          responseHeader: true,
+          responseBody: true,
+          logPrint: (o) => logs.add(o.toString()),
+        ),
+      );
+
+      await dio.get('/test');
+
+      expect(logs.any((log) => log.contains('*** Response ***')), true);
+      expect(logs.any((log) => log.contains('uri:')), true);
+      expect(logs.any((log) => log.contains('statusCode:')), true);
+      expect(logs.any((log) => log.contains('headers:')), true);
+    });
+
+    test('default values enable requestUrl and responseUrl', () {
+      final interceptor = LogInterceptor();
+      expect(interceptor.requestUrl, true);
+      expect(interceptor.responseUrl, true);
+    });
+  });
+
   test('Size of Interceptors', () {
     final interceptors1 = Dio().interceptors;
     expect(interceptors1.length, equals(1));