feat: handle the nested promise on response.text

[miquelbeltran]

Evaluates and continues work from #434

[Copilot]

Pull Request Overview

This PR enhances network tracking by improving fetch interception to handle nested response.text() promises and by managing the original fetch reference.

• Store the original fetch in this.originalFetch and expose a disableFetchLogging method for restoration.
• Refactor fetch processing to clone responses, truncate text bodies, and handle promise rejections robustly.
• Remove wrapWithHandler around XHR’s send, load, and error callbacks, using inline handlers instead.

Comments suppressed due to low confidence (2)

src/raygun.network-tracking.js:206

• The newly added branch for handling response.text() fulfillment and rejection isn't covered by existing tests. Consider adding tests to exercise both the successful truncation and the rejection fallback paths.

            if (ourResponse && typeof ourResponse.text === 'function') {

src/raygun.network-tracking.js:250

• The new disableFetchLogging is attached to NetworkTracking.prototype, but it's unclear if NetworkTracking is the correct constructor or imported identifier. Additionally, brace alignment appears off and may cause a syntax error. Verify the target object and fix the mismatched braces.

  NetworkTracking.prototype.disableFetchLogging = function() {

[Copilot]

Removing wrapWithHandler from the XHR send enhancement means exceptions in this inline handler will no longer be caught and logged. Consider wrapping this function with self.wrapWithHandler or adding an explicit try/catch to preserve error handling.

Suggested change

	function() {
	self.wrapWithHandler(function() {

[Copilot]

The load event listener is now an inline function without the previous wrapWithHandler guard. If this callback throws, errors will be uncaught. Please reintroduce wrapWithHandler or a try/catch block here.

Suggested change

	function() {
	self.wrapWithHandler(function() {

[Copilot]

Similarly, the error event listener no longer uses wrapWithHandler, which may lead to uncaught exceptions. Consider restoring the wrapper or adding error handling locally.

[Copilot]

[nitpick] The nested promise chain for fetch response handling can be hard to follow. Refactoring this logic into an async function with await could improve readability and reduce nesting.

[miquelbeltran]

Looking at the original PR, it is removing the calls to wrapWithHandler.

This function is wrapping any call in a try/catch and then logging the error into Raygun. That works to catch any errors in our code, however if a customer needs that original exception to be passed up the fetch method, it would be lost.

    this.wrapWithHandler = function(method) {
      return function() {
        try {
          return method.apply(this, arguments);
        } catch (ex) {
          Raygun.Utilities.log(ex);
        }
      };
    };

I think that an alternative solution is instead to throw the exception after capturing it, like so:

    this.wrapWithHandler = function(method) {
      return function() {
        try {
          return method.apply(this, arguments);
        } catch (ex) {
          Raygun.Utilities.log(ex);
+++       throw ex;
        }
      };
    };