Make response body accessible via hint in beforeSendTransaction callback for SentryHttpClient

CHANGELOG.md

@@ -4,6 +4,17 @@
 
 ### Enhancements
 
+- Make response body accessible via hint in `beforSend` callback for failed web requests or if tracing is enabled in `SentryHttpClient` ([#2293](https://github.com/getsentry/sentry-dart/pull/2293))
+  ```dart
+  options.beforeSend = (event, hint) async {
+    final response = hint.get(TypeCheckHint.httpResponse);
+    if (response is StreamedResponse) {
+      final body = await response.stream.bytesToString();
+      // user can now use it
+    }
+    return event;
+  };
+  ```
 - Remove `sentry` frames if SDK falls back to current stack trace ([#2351](https://github.com/getsentry/sentry-dart/pull/2351))  
   - Flutter doesn't always provide stack traces for unhandled errors - this is normal Flutter behavior
   - When no stack trace is provided (in Flutter errors, `captureException`, or `captureMessage`):

dart/lib/sentry.dart

@@ -25,6 +25,7 @@ export 'src/throwable_mechanism.dart';
 export 'src/transport/transport.dart';
 export 'src/integration.dart';
 export 'src/event_processor.dart';
+// ignore: invalid_export_of_internal_element
 export 'src/http_client/sentry_http_client.dart';
 export 'src/http_client/sentry_http_client_error.dart';
 export 'src/sentry_attachment/sentry_attachment.dart';

dart/lib/src/http_client/failed_request_client.dart

@@ -1,12 +1,9 @@
 import 'package:http/http.dart';
-import '../hint.dart';
-import '../type_check_hint.dart';
+import '../utils/http_deep_copy_streamed_response.dart';
 import '../utils/tracing_utils.dart';
 import 'sentry_http_client_error.dart';
-import '../protocol.dart';
 import '../hub.dart';
 import '../hub_adapter.dart';
-import '../throwable_mechanism.dart';
 import 'sentry_http_client.dart';
 
 /// A [http](https://pub.dev/packages/http)-package compatible HTTP client
@@ -100,26 +97,29 @@ class FailedRequestClient extends BaseClient {
     Object? exception;
     StackTrace? stackTrace;
     StreamedResponse? response;
+    List<StreamedResponse> copiedResponses = [];
 
     final stopwatch = Stopwatch();
     stopwatch.start();
 
     try {
       response = await _client.send(request);
-      statusCode = response.statusCode;
-      return response;
+      copiedResponses = await deepCopyStreamedResponse(response, 2);
+      statusCode = copiedResponses[0].statusCode;
+      return copiedResponses[0];
     } catch (e, st) {
       exception = e;
       stackTrace = st;
       rethrow;
     } finally {
       stopwatch.stop();
+
       await _captureEventIfNeeded(
         request,
         statusCode,
         exception,
         stackTrace,
-        response,
+        copiedResponses.isNotEmpty ? copiedResponses[1] : null,
         stopwatch.elapsed,
       );
     }
@@ -148,10 +148,10 @@ class FailedRequestClient extends BaseClient {
     }
 
     final reason = 'HTTP Client Error with status code: $statusCode';
-    exception ??= SentryHttpClientError(reason);
 
-    await _captureEvent(
-      exception: exception,
+    await captureEvent(
+      _hub,
+      exception: exception ?? SentryHttpClientError(reason),
       stackTrace: stackTrace,
       request: request,
       requestDuration: duration,
@@ -162,90 +162,6 @@ class FailedRequestClient extends BaseClient {
 
   @override
   void close() => _client.close();
-
-  // See https://develop.sentry.dev/sdk/event-payloads/request/
-  Future<void> _captureEvent({
-    required Object? exception,
-    StackTrace? stackTrace,
-    String? reason,
-    required Duration requestDuration,
-    required BaseRequest request,
-    required StreamedResponse? response,
-  }) async {
-    final sentryRequest = SentryRequest.fromUri(
-      method: request.method,
-      headers: _hub.options.sendDefaultPii ? request.headers : null,
-      uri: request.url,
-      data: _hub.options.sendDefaultPii ? _getDataFromRequest(request) : null,
-      // ignore: deprecated_member_use_from_same_package
-      other: {
-        'content_length': request.contentLength.toString(),
-        'duration': requestDuration.toString(),
-      },
-    );
-
-    final mechanism = Mechanism(
-      type: 'SentryHttpClient',
-      description: reason,
-    );
-
-    bool? snapshot;
-    if (exception is SentryHttpClientError) {
-      snapshot = true;
-    }
-
-    final throwableMechanism = ThrowableMechanism(
-      mechanism,
-      exception,
-      snapshot: snapshot,
-    );
-
-    final event = SentryEvent(
-      throwable: throwableMechanism,
-      request: sentryRequest,
-      timestamp: _hub.options.clock(),
-    );
-
-    final hint = Hint.withMap({TypeCheckHint.httpRequest: request});
-
-    if (response != null) {
-      event.contexts.response = SentryResponse(
-        headers: _hub.options.sendDefaultPii ? response.headers : null,
-        bodySize: response.contentLength,
-        statusCode: response.statusCode,
-      );
-      hint.set(TypeCheckHint.httpResponse, response);
-    }
-
-    await _hub.captureEvent(
-      event,
-      stackTrace: stackTrace,
-      hint: hint,
-    );
-  }
-
-  // Types of Request can be found here:
-  // https://pub.dev/documentation/http/latest/http/http-library.html
-  Object? _getDataFromRequest(BaseRequest request) {
-    final contentLength = request.contentLength;
-    if (contentLength == null) {
-      return null;
-    }
-    if (!_hub.options.maxRequestBodySize.shouldAddBody(contentLength)) {
-      return null;
-    }
-    if (request is MultipartRequest) {
-      final data = <String, String>{...request.fields};
-      return data;
-    }
-
-    if (request is Request) {
-      return request.body;
-    }
-
-    // There's nothing we can do for a StreamedRequest
-    return null;
-  }
 }
 
 extension _ListX on List<SentryStatusCode> {

dart/lib/src/http_client/sentry_http_client.dart

@@ -1,7 +1,7 @@
 import 'package:http/http.dart';
+import 'package:meta/meta.dart';
+import '../../sentry.dart';
 import 'tracing_client.dart';
-import '../hub.dart';
-import '../hub_adapter.dart';
 import 'breadcrumb_client.dart';
 import 'failed_request_client.dart';
 
@@ -160,3 +160,88 @@
     return '$_min..$_max';
   }
 }
+
+@internal
+// See https://develop.sentry.dev/sdk/event-payloads/request/
+Future<void> captureEvent(
+  Hub hub, {
+  Object? exception,
+  StackTrace? stackTrace,
+  String? reason,
+  required Duration requestDuration,
+  required BaseRequest request,
+  required StreamedResponse? response,
+}) async {
+  final sentryRequest = SentryRequest.fromUri(
+    method: request.method,
+    headers: hub.options.sendDefaultPii ? request.headers : null,
+    uri: request.url,
+    data: hub.options.sendDefaultPii ? _getDataFromRequest(hub, request) : null,
+    // ignore: deprecated_member_use_from_same_package
+    other: {
+      'content_length': request.contentLength.toString(),
+      'duration': requestDuration.toString(),
+    },
+  );
+
+  final mechanism = Mechanism(
+    type: 'SentryHttpClient',
+    description: reason,
+  );
+
+  bool? snapshot;
+  if (exception is SentryHttpClientError) {
+    snapshot = true;
+  }
+
+  final throwableMechanism = ThrowableMechanism(
+    mechanism,
+    exception,
+    snapshot: snapshot,
+  );
+
+  final event = SentryEvent(
+    throwable: throwableMechanism,
+    request: sentryRequest,
+    timestamp: hub.options.clock(),
+  );
+
+  final hint = Hint.withMap({TypeCheckHint.httpRequest: request});
+
+  if (response != null) {
+    event.contexts.response = SentryResponse(
+        headers: hub.options.sendDefaultPii ? response.headers : null,
+        bodySize: response.contentLength,
+        statusCode: response.statusCode);
+    hint.set(TypeCheckHint.httpResponse, response);
+  }
+
+  await hub.captureEvent(
+    event,
+    stackTrace: stackTrace,
+    hint: hint,
+  );
+}
+
+// Types of Request can be found here:
+// https://pub.dev/documentation/http/latest/http/http-library.html
+Object? _getDataFromRequest(Hub hub, BaseRequest request) {
+  final contentLength = request.contentLength;
+  if (contentLength == null) {
+    return null;
+  }
+  if (!hub.options.maxRequestBodySize.shouldAddBody(contentLength)) {
+    return null;
+  }
+  if (request is MultipartRequest) {
+    final data = <String, String>{...request.fields};
+    return data;
+  }
+
+  if (request is Request) {
+    return request.body;
+  }
+
+  // There's nothing we can do for a StreamedRequest
+  return null;
+}

dart/lib/src/http_client/tracing_client.dart

@@ -1,11 +1,6 @@
 import 'package:http/http.dart';
-import '../hub.dart';
-import '../hub_adapter.dart';
-import '../protocol.dart';
-import '../sentry_trace_origins.dart';
-import '../tracing.dart';
-import '../utils/tracing_utils.dart';
-import '../utils/http_sanitizer.dart';
+import '../../sentry.dart';
+import '../utils/http_deep_copy_streamed_response.dart';
 
 /// A [http](https://pub.dev/packages/http)-package compatible HTTP client
 /// which adds support to Sentry Performance feature.
@@ -21,6 +16,9 @@ class TracingClient extends BaseClient {
   @override
   Future<StreamedResponse> send(BaseRequest request) async {
     // see https://develop.sentry.dev/sdk/performance/#header-sentry-trace
+    int? statusCode;
+    final stopwatch = Stopwatch();
+    stopwatch.start();
 
     final urlDetails = HttpSanitizer.sanitizeUrl(request.url.toString());
 
@@ -45,6 +43,7 @@ class TracingClient extends BaseClient {
     urlDetails?.applyToSpan(span);
 
     StreamedResponse? response;
+    List<StreamedResponse> copiedResponses = [];
     try {
       if (containsTargetOrMatchesRegExp(
           _hub.options.tracePropagationTargets, request.url.toString())) {
@@ -72,18 +71,30 @@ class TracingClient extends BaseClient {
       }
 
       response = await _client.send(request);
-      span?.setData('http.response.status_code', response.statusCode);
-      span?.setData('http.response_content_length', response.contentLength);
-      span?.status = SpanStatus.fromHttpStatusCode(response.statusCode);
+      copiedResponses = await deepCopyStreamedResponse(response, 2);
+      statusCode = copiedResponses[0].statusCode;
+      span?.setData('http.response.status_code', copiedResponses[1].statusCode);
+      span?.setData(
+          'http.response_content_length', copiedResponses[1].contentLength);
+      span?.status =
+          SpanStatus.fromHttpStatusCode(copiedResponses[1].statusCode);
     } catch (exception) {
       span?.throwable = exception;
       span?.status = SpanStatus.internalError();
 
       rethrow;
     } finally {
       await span?.finish();
+      stopwatch.stop();
+      await captureEvent(
+        _hub,
+        request: request,
+        requestDuration: stopwatch.elapsed,
+        response: copiedResponses.isNotEmpty ? copiedResponses[1] : null,
+        reason: 'HTTP Client Event with status code: $statusCode',
+      );
     }
-    return response;
+    return copiedResponses[0];
   }
 
   @override

dart/lib/src/utils/http_deep_copy_streamed_response.dart

@@ -0,0 +1,28 @@
+import 'package:http/http.dart';
+import 'package:meta/meta.dart';
+
+/// Helper to deep copy the StreamedResponse of a web request
+@internal
+Future<List<StreamedResponse>> deepCopyStreamedResponse(
+    StreamedResponse originalResponse, int copies) async {
+  final List<int> bufferedData = [];
+
+  await for (final List<int> chunk in originalResponse.stream) {
+    bufferedData.addAll(chunk);
+  }
+
+  List<StreamedResponse> copiedElements = [];
+  for (int i = 1; i <= copies; i++) {
+    copiedElements.add(StreamedResponse(
+      Stream.fromIterable([bufferedData]),
+      originalResponse.statusCode,
+      contentLength: originalResponse.contentLength,
+      request: originalResponse.request,
+      headers: originalResponse.headers,
+      reasonPhrase: originalResponse.reasonPhrase,
+      isRedirect: originalResponse.isRedirect,
+      persistentConnection: originalResponse.persistentConnection,
+    ));
+  }
+  return copiedElements;
+}