@sentry/remix/build/cjs/server/errors.js

Official Sentry SDK for Remix

Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });

const router = require('@remix-run/router');
const core = require('@sentry/core');
const debugBuild = require('../utils/debug-build.js');
const formData = require('../utils/formData.js');
const utils = require('../utils/utils.js');
const response = require('../utils/vendor/response.js');

async function captureRemixServerException(err, name, request) {
  if (router.isRouteErrorResponse(err) && err.status < 500) {
    return;
  }
  if (response.isResponse(err) && err.status < 500) {
    return;
  }
  if (request.signal.aborted) {
    debugBuild.DEBUG_BUILD && core.debug.warn("Skipping capture of aborted request");
    return;
  }
  let normalizedRequest = {};
  try {
    normalizedRequest = core.winterCGRequestToRequestData(request);
  } catch {
    debugBuild.DEBUG_BUILD && core.debug.warn("Failed to normalize Remix request");
  }
  const objectifiedErr = core.objectify(err);
  core.captureException(response.isResponse(objectifiedErr) ? await extractResponseError(objectifiedErr) : objectifiedErr, (scope) => {
    scope.setSDKProcessingMetadata({ normalizedRequest });
    scope.addEventProcessor((event) => {
      core.addExceptionMechanism(event, {
        type: "auto.function.remix.server",
        handled: false,
        data: {
          function: name
        }
      });
      return event;
    });
    return scope;
  });
}
async function errorHandleDataFunction(origFn, name, args, span) {
  return core.handleCallbackErrors(
    async () => {
      if (name === "action" && span) {
        const formDataCapture = formData.resolveFormDataCapture(core.getClient());
        if (formDataCapture) {
          await utils.storeFormDataKeys(args, span, formDataCapture);
        }
      }
      return origFn.call(this, args);
    },
    (err) => {
      if (response.isResponse(err)) {
        captureRemixServerException(err, name, args.request);
      }
      throw err;
    }
  );
}
async function extractResponseError(response$1) {
  const responseData = await response.extractData(response$1);
  if (typeof responseData === "string" && responseData.length > 0) {
    return new Error(responseData);
  }
  if (response$1.statusText) {
    return new Error(response$1.statusText);
  }
  return responseData;
}

exports.captureRemixServerException = captureRemixServerException;
exports.errorHandleDataFunction = errorHandleDataFunction;
//# sourceMappingURL=errors.js.map