MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Flutter网络请求的日志记录：调试与监控的最佳实践

2023-03-185.3k 阅读

Flutter网络请求日志记录基础

在Flutter开发中，网络请求是常见操作，而日志记录对于调试和监控网络请求至关重要。它能帮助开发者快速定位问题，了解请求的执行过程和结果。

简单日志记录

在Flutter中，最基础的日志记录方式是使用print函数。比如，我们发起一个简单的HTTP GET请求，使用http包：

import 'package:http/http.dart' as http;

Future<void> fetchData() async {
  try {
    final response = await http.get(Uri.parse('https://example.com/api/data'));
    print('Response status: ${response.statusCode}');
    print('Response body: ${response.body}');
  } catch (e) {
    print('Error: $e');
  }
}

这里通过print输出了响应状态码和响应体，在开发阶段能快速看到请求是否成功以及返回的数据。但print有局限性，在复杂项目中不易管理和筛选日志，也不适合生产环境。

使用日志库

为了更好地管理日志，我们可以引入专门的日志库，如logging包。首先在pubspec.yaml文件中添加依赖：

dependencies:
  logging: ^1.0.2

然后在代码中使用：

import 'package:http/http.dart' as http;
import 'package:logging/logging.dart';

final Logger logger = Logger('NetworkLogger');

Future<void> fetchData() async {
  logger.info('Starting network request to https://example.com/api/data');
  try {
    final response = await http.get(Uri.parse('https://example.com/api/data'));
    logger.info('Response status: ${response.statusCode}');
    logger.info('Response body: ${response.body}');
  } catch (e) {
    logger.severe('Error: $e');
  }
}

logging包提供了不同级别的日志记录方法，如info、severe等。可以根据需求设置日志级别，方便在不同环境下控制日志输出。例如，在生产环境可以将日志级别设置为severe，只输出严重错误日志。

网络请求日志的结构化记录

简单的文本日志在处理大量日志数据时效率低下。结构化日志将日志数据以JSON等结构化格式记录，便于查询、分析和可视化。

使用json进行结构化记录

我们可以将网络请求的关键信息，如请求URL、方法、请求头、响应状态码、响应体等，整理成JSON格式。以http包的请求为例：

import 'package:http/http.dart' as http;
import 'package:logging/logging.dart';
import 'dart:convert';

final Logger logger = Logger('NetworkLogger');

Future<void> fetchData() async {
  final requestUrl = 'https://example.com/api/data';
  final requestMethod = 'GET';
  final headers = {'Content-Type': 'application/json'};

  logger.info('Starting network request: $requestMethod $requestUrl');

  try {
    final response = await http.get(Uri.parse(requestUrl), headers: headers);
    final logData = {
      'request': {
        'url': requestUrl,
      'method': requestMethod,
        'headers': headers
      },
     'response': {
      'statusCode': response.statusCode,
       'body': response.body
      }
    };
    logger.info(json.encode(logData));
  } catch (e) {
    final errorLog = {
      'request': {
        'url': requestUrl,
      'method': requestMethod,
        'headers': headers
      },
      'error': '$e'
    };
    logger.severe(json.encode(errorLog));
  }
}

这样记录的日志数据结构清晰，便于使用工具进行分析，例如通过ELK（Elasticsearch、Logstash、Kibana）堆栈进行可视化展示和查询。

自定义结构化日志类

为了更好地封装和管理结构化日志，可以创建自定义类。

import 'package:http/http.dart' as http;
import 'package:logging/logging.dart';
import 'dart:convert';

class NetworkLog {
  String requestUrl;
  String requestMethod;
  Map<String, String> headers;
  int? statusCode;
  String? responseBody;
  String? error;

  NetworkLog({
    required this.requestUrl,
    required this.requestMethod,
    required this.headers,
    this.statusCode,
    this.responseBody,
    this.error,
  });

  Map<String, dynamic> toJson() {
    final Map<String, dynamic> data = <String, dynamic>{};
    data['request'] = {
      'url': requestUrl,
     'method': requestMethod,
      'headers': headers
    };
    if (statusCode != null) {
      data['response'] = {
      'statusCode': statusCode,
       'body': responseBody
      };
    }
    if (error != null) {
      data['error'] = error;
    }
    return data;
  }
}

final Logger logger = Logger('NetworkLogger');

Future<void> fetchData() async {
  final requestUrl = 'https://example.com/api/data';
  final requestMethod = 'GET';
  final headers = {'Content-Type': 'application/json'};

  final networkLog = NetworkLog(
    requestUrl: requestUrl,
    requestMethod: requestMethod,
    headers: headers,
  );

  logger.info('Starting network request: $requestMethod $requestUrl');

  try {
    final response = await http.get(Uri.parse(requestUrl), headers: headers);
    networkLog.statusCode = response.statusCode;
    networkLog.responseBody = response.body;
    logger.info(json.encode(networkLog.toJson()));
  } catch (e) {
    networkLog.error = '$e';
    logger.severe(json.encode(networkLog.toJson()));
  }
}

通过自定义类，代码结构更清晰，并且可以方便地添加更多功能，如日志格式化、日志上报等。

日志记录在不同网络请求库中的应用

Flutter中有多种网络请求库，不同库的日志记录方式会有差异。

Dio库的日志记录

Dio是一个强大的Flutter HTTP客户端，它内置了日志记录功能。首先在pubspec.yaml中添加依赖：

dependencies:
  dio: ^4.0.0

然后使用如下代码进行日志记录：

import 'package:dio/dio.dart';

void main() async {
  final dio = Dio();
  dio.interceptors.add(LogInterceptor(
    request: true,
    requestBody: true,
    requestHeader: true,
    responseBody: true,
    responseHeader: true,
    error: true,
  ));

  try {
    final response = await dio.get('https://example.com/api/data');
    print(response.data);
  } catch (e) {
    print(e);
  }
}

LogInterceptor可以方便地控制是否记录请求、请求体、请求头、响应体、响应头以及错误信息。它输出的日志格式相对友好，能直接展示请求和响应的详细信息。

http包结合拦截器记录日志

虽然http包没有内置像Dio那样的日志拦截器，但我们可以通过自定义拦截器实现类似功能。

import 'package:http/http.dart' as http;
import 'package:logging/logging.dart';

final Logger logger = Logger('NetworkLogger');

class HttpLoggingInterceptor extends http.BaseClient {
  final http.Client _inner;

  HttpLoggingInterceptor(this._inner);

  @override
  Future<http.StreamedResponse> send(http.BaseRequest request) async {
    logger.info('Request: ${request.url} ${request.method}');
    logger.info('Headers: ${request.headers}');
    if (request is http.Request && request.body != null) {
      logger.info('Body: ${request.body}');
    }

    final response = await _inner.send(request);
    logger.info('Response status: ${response.statusCode}');
    logger.info('Response headers: ${response.headers}');
    final responseBody = await response.stream.bytesToString();
    logger.info('Response body: $responseBody');

    return http.StreamedResponse(
      Stream.fromIterable(responseBody.codeUnits),
      response.statusCode,
      headers: response.headers,
    );
  }
}

Future<void> fetchData() async {
  final client = HttpLoggingInterceptor(http.Client());
  try {
    final response = await client.get(Uri.parse('https://example.com/api/data'));
    print(response.body);
  } catch (e) {
    print(e);
  }
}

通过自定义HttpLoggingInterceptor，我们在发送请求和接收响应时记录了详细的日志信息，模拟了类似Dio拦截器的功能。

日志的存储与远程上报

在实际项目中，仅在本地记录日志可能不足以满足需求，还需要将日志存储并上报到远程服务器进行分析。

本地文件存储日志

可以使用path_provider包将日志存储到本地文件。首先添加依赖：

dependencies:
  path_provider: ^2.0.10

然后编写如下代码：

import 'package:path_provider/path_provider.dart';
import 'dart:io';
import 'package:logging/logging.dart';

final Logger logger = Logger('NetworkLogger');

Future<void> logToFile(String logMessage) async {
  final directory = await getApplicationDocumentsDirectory();
  final file = File('${directory.path}/network_log.txt');
  await file.writeAsString('$logMessage\n', mode: FileMode.append);
}

Future<void> fetchData() async {
  try {
    final response = await http.get(Uri.parse('https://example.com/api/data'));
    final logMessage = 'Response status: ${response.statusCode}, Response body: ${response.body}';
    logger.info(logMessage);
    await logToFile(logMessage);
  } catch (e) {
    final logMessage = 'Error: $e';
    logger.severe(logMessage);
    await logToFile(logMessage);
  }
}

这样，每次网络请求的日志都会追加到本地文件network_log.txt中，方便在本地查看和分析。

远程上报日志

为了将日志上报到远程服务器，可以使用HTTP POST请求将日志数据发送到服务器接口。

import 'package:http/http.dart' as http;
import 'package:path_provider/path_provider.dart';
import 'dart:io';
import 'package:logging/logging.dart';

final Logger logger = Logger('NetworkLogger');

Future<void> logToFile(String logMessage) async {
  final directory = await getApplicationDocumentsDirectory();
  final file = File('${directory.path}/network_log.txt');
  await file.writeAsString('$logMessage\n', mode: FileMode.append);
}

Future<void> uploadLog() async {
  final directory = await getApplicationDocumentsDirectory();
  final file = File('${directory.path}/network_log.txt');
  if (file.existsSync()) {
    final logData = await file.readAsString();
    final response = await http.post(
      Uri.parse('https://example.com/api/logs'),
      headers: {'Content-Type': 'application/json'},
      body: json.encode({'log': logData}),
    );
    if (response.statusCode == 200) {
      logger.info('Log uploaded successfully');
    } else {
      logger.severe('Log upload failed: ${response.statusCode}');
    }
  }
}

Future<void> fetchData() async {
  try {
    final response = await http.get(Uri.parse('https://example.com/api/data'));
    final logMessage = 'Response status: ${response.statusCode}, Response body: ${response.body}';
    logger.info(logMessage);
    await logToFile(logMessage);
    await uploadLog();
  } catch (e) {
    final logMessage = 'Error: $e';
    logger.severe(logMessage);
    await logToFile(logMessage);
    await uploadLog();
  }
}

在这个示例中，每次记录日志到本地文件后，都会尝试将日志文件内容上报到远程服务器。服务器接收到日志数据后，可以进行进一步的处理和分析，如存储到数据库、进行可视化展示等。

日志监控与报警

仅仅记录和上报日志还不够，我们还需要对日志进行监控，及时发现异常并发出报警。

基于日志数据分析的监控

可以使用一些数据分析工具，如Elasticsearch和Kibana，对上报的日志数据进行分析。在Kibana中，可以创建各种可视化图表，如请求成功率图表、错误类型分布图表等。 通过设置阈值，当请求成功率低于某个值，或者某种错误类型的出现次数超过一定数量时，触发报警。例如，设置请求成功率低于80%时发送邮件或短信通知开发者。

自定义监控逻辑

在Flutter应用中，也可以编写简单的自定义监控逻辑。比如，统计一定时间内的错误请求次数：

import 'package:http/http.dart' as http;
import 'package:logging/logging.dart';
import 'dart:async';

final Logger logger = Logger('NetworkLogger');
int errorCount = 0;
Timer? errorTimer;

Future<void> fetchData() async {
  try {
    final response = await http.get(Uri.parse('https://example.com/api/data'));
    logger.info('Response status: ${response.statusCode}');
  } catch (e) {
    errorCount++;
    logger.severe('Error: $e');
    if (errorTimer == null) {
      errorTimer = Timer.periodic(const Duration(seconds: 60), (timer) {
        if (errorCount > 10) {
          logger.severe('More than 10 errors in 1 minute, take action!');
          // 这里可以添加发送报警信息的逻辑，如调用短信或邮件发送接口
        }
        errorCount = 0;
      });
    }
  }
}

在这个示例中，每出现一次错误请求，errorCount加1。通过Timer定时检查errorCount，如果1分钟内错误请求次数超过10次，就记录严重日志并可以触发报警逻辑。

生产环境中的日志记录优化

在生产环境中，日志记录需要更加谨慎，以避免影响应用性能和用户体验。

日志级别控制

在生产环境中，将日志级别设置为较高等级，如severe，只记录严重错误日志。可以在应用启动时根据环境变量来动态设置日志级别。

import 'package:logging/logging.dart';

void setupLogging() {
  final Logger rootLogger = Logger.root;
  rootLogger.level = Level.SEVERE;
  rootLogger.onRecord.listen((record) {
    print('${record.level.name}: ${record.message}');
  });
}

通过这种方式，在生产环境中只输出严重错误日志，减少日志输出量，降低对应用性能的影响。

日志采样

对于高频率的网络请求，可以采用日志采样的方式，只记录部分请求的日志。例如，每10次请求记录一次日志。

import 'package:http/http.dart' as http;
import 'package:logging/logging.dart';
import 'dart:math';

final Logger logger = Logger('NetworkLogger');
int requestCount = 0;

Future<void> fetchData() async {
  requestCount++;
  final shouldLog = Random().nextInt(10) == 0;
  try {
    final response = await http.get(Uri.parse('https://example.com/api/data'));
    if (shouldLog) {
      logger.info('Response status: ${response.statusCode}');
    }
  } catch (e) {
    if (shouldLog) {
      logger.severe('Error: $e');
    }
  }
}

在这个示例中，通过Random生成随机数来决定是否记录日志，从而减少日志记录频率，降低性能开销。

通过上述各种日志记录、存储、上报、监控和优化的方法，可以在Flutter网络请求开发中建立一套完善的调试与监控体系，提高开发效率和应用的稳定性。