@sentry/nextjs/build/cjs/edge/wrapApiHandlerWithSentry.js

Official Sentry SDK for Next.js

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

const core = require('@sentry/core');
const addHeadersAsAttributes = require('../common/utils/addHeadersAsAttributes.js');
const responseEnd = require('../common/utils/responseEnd.js');
const attributes = require('@sentry/conventions/attributes');

function wrapApiHandlerWithSentry(handler, parameterizedRoute) {
  return new Proxy(handler, {
    apply: async (wrappingTarget, thisArg, args) => {
      return core.withIsolationScope((isolationScope) => {
        const req = args[0];
        const currentScope = core.getCurrentScope();
        let headerAttributes = {};
        if (req instanceof Request) {
          isolationScope.setSDKProcessingMetadata({
            normalizedRequest: core.winterCGRequestToRequestData(req)
          });
          currentScope.setTransactionName(`${req.method} ${parameterizedRoute}`);
          headerAttributes = addHeadersAsAttributes.addHeadersAsAttributes(req.headers);
        } else {
          currentScope.setTransactionName(`handler (${parameterizedRoute})`);
        }
        let spanName;
        let op = "http.server";
        const urlObject = req instanceof Request ? core.parseStringToURLObject(req.url) : void 0;
        const urlAttributes = {
          [attributes.URL_FULL]: urlObject && !core.isURLObjectRelative(urlObject) ? urlObject.href : void 0,
          [attributes.URL_PATH]: urlObject?.pathname
        };
        const activeSpan = core.getActiveSpan();
        if (activeSpan) {
          spanName = `handler (${parameterizedRoute})`;
          op = void 0;
          const rootSpan = core.getRootSpan(activeSpan);
          if (rootSpan) {
            const rootSpanAttributes = core.spanToJSON(rootSpan).data;
            rootSpan.updateName(
              req instanceof Request ? `${req.method} ${parameterizedRoute}` : `handler ${parameterizedRoute}`
            );
            rootSpan.setAttributes({
              [core.SEMANTIC_ATTRIBUTE_SENTRY_OP]: "http.server",
              [core.SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: "route",
              [attributes.URL_FULL]: rootSpanAttributes[attributes.URL_FULL] ?? urlAttributes[attributes.URL_FULL],
              [attributes.URL_PATH]: rootSpanAttributes[attributes.URL_PATH] ?? urlAttributes[attributes.URL_PATH],
              [attributes.HTTP_ROUTE]: parameterizedRoute,
              ...headerAttributes
            });
            core.setCapturedScopesOnSpan(rootSpan, currentScope, isolationScope);
          }
        } else if (req instanceof Request) {
          spanName = `${req.method} ${parameterizedRoute}`;
        } else {
          spanName = `handler ${parameterizedRoute}`;
        }
        return core.startSpan(
          {
            name: spanName,
            op,
            attributes: {
              [core.SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: "route",
              [core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.function.nextjs.wrap_api_handler",
              [attributes.HTTP_ROUTE]: parameterizedRoute,
              ...urlAttributes,
              ...headerAttributes
            }
          },
          () => {
            return core.handleCallbackErrors(
              () => wrappingTarget.apply(thisArg, args),
              (error) => {
                core.captureException(error, {
                  mechanism: {
                    type: "auto.function.nextjs.wrap_api_handler",
                    handled: false
                  }
                });
              },
              () => {
                responseEnd.waitUntil(responseEnd.flushSafelyWithTimeout());
              }
            );
          }
        );
      });
    }
  });
}

exports.wrapApiHandlerWithSentry = wrapApiHandlerWithSentry;
//# sourceMappingURL=wrapApiHandlerWithSentry.js.map