intercept<BodyType> method

@override FutureOr<Response<BodyType>> intercept<BodyType>(Chain<BodyType> chain)

Implementation

@override
FutureOr<Response<BodyType>> intercept<BodyType>(
    Chain<BodyType> chain) async {
  final Request request = chain.request;

  final Stopwatch stopWatch = Stopwatch()..start();

  final Response<BodyType> response = await chain.proceed(request);

  stopWatch.stop();

  if (level == Level.none || (onlyErrors && response.statusCode < 400)) {
    return response;
  }

  final http.BaseRequest baseRequest = await request.toBaseRequest();

  final StringBuffer startRequestMessage = StringBuffer(
    '--> ${baseRequest.method} ${baseRequest.url.toString()}',
  );
  final StringBuffer bodyRequestMessage = StringBuffer();
  if (baseRequest is http.Request) {
    if (baseRequest.body.isNotEmpty) {
      bodyRequestMessage.write(baseRequest.body);

      if (!_logHeaders) {
        startRequestMessage.write(
          ' (${baseRequest.bodyBytes.length}-byte body)',
        );
      }
    }
  }

  // Always start on a new line
  _logger.info(ChopperLogRecord('', request: request));
  _logger.info(
    ChopperLogRecord(startRequestMessage.toString(), request: request),
  );

  if (_logHeaders) {
    baseRequest.headers.forEach(
      (String k, String v) => _logger.info(
        ChopperLogRecord('$k: $v', request: request),
      ),
    );

    if (baseRequest.contentLength != null &&
        baseRequest.headers['content-length'] == null) {
      _logger.info(
        ChopperLogRecord(
          'content-length: ${baseRequest.contentLength}',
          request: request,
        ),
      );
    }
  }

  if (_logBody && bodyRequestMessage.isNotEmpty) {
    _logger.info(ChopperLogRecord('', request: request));
    _logger.info(
      ChopperLogRecord(bodyRequestMessage.toString(), request: request),
    );
  }

  if (_logHeaders || _logBody) {
    _logger.info(
      ChopperLogRecord('--> END ${baseRequest.method}', request: request),
    );
  }

  final http.BaseResponse baseResponse = response.base;

  final StringBuffer bytes = StringBuffer();
  final StringBuffer reasonPhrase = StringBuffer(
    response.statusCode.toString(),
  );
  final StringBuffer bodyResponseMessage = StringBuffer();
  if (baseResponse is http.Response) {
    if (baseResponse.reasonPhrase != null) {
      if (baseResponse.reasonPhrase != reasonPhrase.toString()) {
        reasonPhrase.write(' ${baseResponse.reasonPhrase}');
      }
    }

    if (baseResponse.body.isNotEmpty) {
      bodyResponseMessage.write(baseResponse.body);

      if (!_logBody && !_logHeaders) {
        bytes.write(', ${response.bodyBytes.length}-byte body');
      }
    }
  }

  // Always start on a new line
  _logger.info(ChopperLogRecord('', response: response));
  _logger.info(
    ChopperLogRecord(
      '<-- $reasonPhrase ${baseResponse.request?.method} ${baseResponse.request?.url.toString()} (${stopWatch.elapsedMilliseconds}ms$bytes)',
      response: response,
    ),
  );

  if (_logHeaders) {
    baseResponse.headers.forEach(
      (String k, String v) => _logger.info(
        ChopperLogRecord('$k: $v', response: response),
      ),
    );

    if (baseResponse.contentLength != null &&
        baseResponse.headers['content-length'] == null) {
      _logger.info(
        ChopperLogRecord(
          'content-length: ${baseResponse.contentLength}',
          response: response,
        ),
      );
    }
  }

  if (_logBody && bodyResponseMessage.isNotEmpty) {
    _logger.info(ChopperLogRecord('', response: response));
    _logger.info(
      ChopperLogRecord(
        bodyResponseMessage.toString(),
        response: response,
      ),
    );
  }

  if (_logBody || _logHeaders) {
    _logger.info(ChopperLogRecord('<-- END HTTP', response: response));
  }

  return response;
}