@sentry/react-router 10.53.1 → 10.54.0

package/build/cjs/common/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","sources":["../../../src/common/utils.ts"],"sourcesContent":["import { captureException, debug } from '@sentry/core';\nimport { DEBUG_BUILD } from './debug-build';\nimport type { InstrumentationResult } from './types';\n\n/**\n * Extracts pathname from request URL.\n * Falls back to '<unknown>' with DEBUG warning if URL cannot be parsed.\n */\nexport function getPathFromRequest(request: { url: string }): string {\n  try {\n    return new URL(request.url).pathname;\n  } catch {\n    try {\n      // Fallback: use a dummy base URL since we only care about the pathname\n      return new URL(request.url, 'http://example.com').pathname;\n    } catch (error) {\n      DEBUG_BUILD && debug.warn('Failed to parse URL from request:', request.url, error);\n      return '<unknown>';\n    }\n  }\n}\n\n/**\n * Extracts route pattern from instrumentation info.\n * Prefers `pattern` (planned for v8) over `unstable_pattern` (v7.x).\n */\nexport function getPattern(info: { pattern?: string; unstable_pattern?: string }): string | undefined {\n  return info.pattern ?? info.unstable_pattern;\n}\n\n/**\n * Normalizes route path by ensuring it starts with a slash.\n * Returns undefined if the input is falsy.\n */\nexport function normalizeRoutePath(pattern?: string): string | undefined {\n  if (!pattern) {\n    return undefined;\n  }\n  return pattern.startsWith('/') ? pattern : `/${pattern}`;\n}\n\n/**\n * Captures an error from instrumentation result.\n * Caller must verify result contains an Error before calling.\n */\nexport function captureInstrumentationError(\n  result: InstrumentationResult,\n  captureErrors: boolean,\n  mechanismType: string,\n  data: Record<string, string | boolean>,\n): void {\n  if (captureErrors) {\n    captureException(result.error, {\n      mechanism: {\n        type: mechanismType,\n        handled: false,\n        data,\n      },\n    });\n  }\n}\n"],"names":["DEBUG_BUILD","debug","captureException"],"mappings":";;;;;AAIA;AACA;AACA;AACA;AACO,SAAS,kBAAkB,CAAC,OAAO,EAA2B;AACrE,EAAE,IAAI;AACN,IAAI,OAAO,IAAI,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,QAAQ;AACxC,EAAE,EAAE,MAAM;AACV,IAAI,IAAI;AACR;AACA,MAAM,OAAO,IAAI,GAAG,CAAC,OAAO,CAAC,GAAG,EAAE,oBAAoB,CAAC,CAAC,QAAQ;AAChE,IAAI,CAAA,CAAE,OAAO,KAAK,EAAE;AACpB,MAAMA,sBAAA,IAAeC,UAAK,CAAC,IAAI,CAAC,mCAAmC,EAAE,OAAO,CAAC,GAAG,EAAE,KAAK,CAAC;AACxF,MAAM,OAAO,WAAW;AACxB,IAAI;AACJ,EAAE;AACF;;AAEA;AACA;AACA;AACA;AACO,SAAS,UAAU,CAAC,IAAI,EAAuE;AACtG,EAAE,OAAO,IAAI,CAAC,WAAW,IAAI,CAAC,gBAAgB;AAC9C;;AAEA;AACA;AACA;AACA;AACO,SAAS,kBAAkB,CAAC,OAAO,EAA+B;AACzE,EAAE,IAAI,CAAC,OAAO,EAAE;AAChB,IAAI,OAAO,SAAS;AACpB,EAAE;AACF,EAAE,OAAO,OAAO,CAAC,UAAU,CAAC,GAAG,CAAA,GAAI,OAAA,GAAU,CAAC,CAAC,EAAE,OAAO,CAAC,CAAA;AACA;;AAEA;AACA;AACA;AACA;AACA,SAAA,2BAAA;AACA,EAAA,MAAA;AACA,EAAA,aAAA;AACA,EAAA,aAAA;AACA,EAAA,IAAA;AACA,EAAA;AACA,EAAA,IAAA,aAAA,EAAA;AACA,IAAAC,qBAAA,CAAA,MAAA,CAAA,KAAA,EAAA;AACA,MAAA,SAAA,EAAA;AACA,QAAA,IAAA,EAAA,aAAA;AACA,QAAA,OAAA,EAAA,KAAA;AACA,QAAA,IAAA;AACA,OAAA;AACA,KAAA,CAAA;AACA,EAAA;AACA;;;;;;;"}
+{"version":3,"file":"utils.js","sources":["../../../src/common/utils.ts"],"sourcesContent":["import { captureException, debug } from '@sentry/core';\nimport { DEBUG_BUILD } from './debug-build';\nimport type { InstrumentationResult } from './types';\n\n/**\n * Extracts pathname from request URL.\n * Falls back to '<unknown>' with DEBUG warning if URL cannot be parsed.\n */\nexport function getPathFromRequest(request: { url: string }): string {\n  try {\n    return new URL(request.url).pathname;\n  } catch {\n    try {\n      // Fallback: use a dummy base URL since we only care about the pathname\n      return new URL(request.url, 'http://example.com').pathname;\n    } catch (error) {\n      DEBUG_BUILD && debug.warn('Failed to parse URL from request:', request.url, error);\n      return '<unknown>';\n    }\n  }\n}\n\n/**\n * Extracts route pattern from instrumentation info.\n * Prefers `pattern` (planned for v8) over `unstable_pattern` (v7.x).\n */\nexport function getPattern(info: { pattern?: string; unstable_pattern?: string }): string | undefined {\n  return info.pattern ?? info.unstable_pattern;\n}\n\n/**\n * Normalizes route path by ensuring it starts with a slash.\n * Returns undefined if the input is falsy.\n */\nexport function normalizeRoutePath(pattern?: string): string | undefined {\n  if (!pattern) {\n    return undefined;\n  }\n  return pattern.startsWith('/') ? pattern : `/${pattern}`;\n}\n\n/**\n * Captures an error from instrumentation result.\n * Caller must verify result contains an Error before calling.\n */\nexport function captureInstrumentationError(\n  result: InstrumentationResult,\n  captureErrors: boolean,\n  mechanismType: string,\n  data: Record<string, string | boolean>,\n): void {\n  if (captureErrors) {\n    captureException(result.error, {\n      mechanism: {\n        type: mechanismType,\n        handled: false,\n        data,\n      },\n    });\n  }\n}\n"],"names":["DEBUG_BUILD","debug","captureException"],"mappings":";;;;;AAQO,SAAS,mBAAmB,OAAA,EAAkC;AACnE,EAAA,IAAI;AACF,IAAA,OAAO,IAAI,GAAA,CAAI,OAAA,CAAQ,GAAG,CAAA,CAAE,QAAA;AAAA,EAC9B,CAAA,CAAA,MAAQ;AACN,IAAA,IAAI;AAEF,MAAA,OAAO,IAAI,GAAA,CAAI,OAAA,CAAQ,GAAA,EAAK,oBAAoB,CAAA,CAAE,QAAA;AAAA,IACpD,SAAS,KAAA,EAAO;AACd,MAAAA,sBAAA,IAAeC,UAAA,CAAM,IAAA,CAAK,mCAAA,EAAqC,OAAA,CAAQ,KAAK,KAAK,CAAA;AACjF,MAAA,OAAO,WAAA;AAAA,IACT;AAAA,EACF;AACF;AAMO,SAAS,WAAW,IAAA,EAA2E;AACpG,EAAA,OAAO,IAAA,CAAK,WAAW,IAAA,CAAK,gBAAA;AAC9B;AAMO,SAAS,mBAAmB,OAAA,EAAsC;AACvE,EAAA,IAAI,CAAC,OAAA,EAAS;AACZ,IAAA,OAAO,MAAA;AAAA,EACT;AACA,EAAA,OAAO,QAAQ,UAAA,CAAW,GAAG,CAAA,GAAI,OAAA,GAAU,IAAI,OAAO,CAAA,CAAA;AACxD;AAMO,SAAS,2BAAA,CACd,MAAA,EACA,aAAA,EACA,aAAA,EACA,IAAA,EACM;AACN,EAAA,IAAI,aAAA,EAAe;AACjB,IAAAC,qBAAA,CAAiB,OAAO,KAAA,EAAO;AAAA,MAC7B,SAAA,EAAW;AAAA,QACT,IAAA,EAAM,aAAA;AAAA,QACN,OAAA,EAAS,KAAA;AAAA,QACT;AAAA;AACF,KACD,CAAA;AAAA,EACH;AACF;;;;;;;"}

package/build/cjs/server/createSentryHandleError.js

@@ -2,33 +2,24 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 const core = require('@sentry/core');
 
-/**
- * A complete Sentry-instrumented handleError implementation that handles error reporting
- *
- * @returns A Sentry-instrumented handleError function
- */
 function createSentryHandleError({ logErrors = false }) {
-  const handleError = async function handleError(error, args) {
-    // React Router may abort some interrupted requests, don't report those
+  const handleError = async function handleError2(error, args) {
     if (!args.request.signal.aborted) {
       core.captureException(error, {
         mechanism: {
-          type: 'react-router',
-          handled: false,
-        },
+          type: "react-router",
+          handled: false
+        }
       });
       if (logErrors) {
-        // eslint-disable-next-line no-console
         console.error(error);
       }
       try {
         await core.flushIfServerless();
       } catch {
-        // Ignore flush errors to ensure error handling completes gracefully
       }
     }
   };
-
   return handleError;
 }
 

package/build/cjs/server/createSentryHandleError.js.map

@@ -1 +1 @@
-{"version":3,"file":"createSentryHandleError.js","sources":["../../../src/server/createSentryHandleError.ts"],"sourcesContent":["import { captureException, flushIfServerless } from '@sentry/core';\nimport type { HandleErrorFunction } from 'react-router';\n\nexport type SentryHandleErrorOptions = {\n  logErrors?: boolean;\n};\n\n/**\n * A complete Sentry-instrumented handleError implementation that handles error reporting\n *\n * @returns A Sentry-instrumented handleError function\n */\nexport function createSentryHandleError({ logErrors = false }: SentryHandleErrorOptions): HandleErrorFunction {\n  const handleError: HandleErrorFunction = async function handleError(error, args): Promise<void> {\n    // React Router may abort some interrupted requests, don't report those\n    if (!args.request.signal.aborted) {\n      captureException(error, {\n        mechanism: {\n          type: 'react-router',\n          handled: false,\n        },\n      });\n      if (logErrors) {\n        // eslint-disable-next-line no-console\n        console.error(error);\n      }\n      try {\n        await flushIfServerless();\n      } catch {\n        // Ignore flush errors to ensure error handling completes gracefully\n      }\n    }\n  };\n\n  return handleError;\n}\n"],"names":["captureException","flushIfServerless"],"mappings":";;;;AAOA;AACA;AACA;AACA;AACA;AACO,SAAS,uBAAuB,CAAC,EAAE,YAAY,KAAA,EAAO,EAAiD;AAC9G,EAAE,MAAM,WAAW,GAAwB,eAAe,WAAW,CAAC,KAAK,EAAE,IAAI,EAAiB;AAClG;AACA,IAAI,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,EAAE;AACtC,MAAMA,qBAAgB,CAAC,KAAK,EAAE;AAC9B,QAAQ,SAAS,EAAE;AACnB,UAAU,IAAI,EAAE,cAAc;AAC9B,UAAU,OAAO,EAAE,KAAK;AACxB,SAAS;AACT,OAAO,CAAC;AACR,MAAM,IAAI,SAAS,EAAE;AACrB;AACA,QAAQ,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC;AAC5B,MAAM;AACN,MAAM,IAAI;AACV,QAAQ,MAAMC,sBAAiB,EAAE;AACjC,MAAM,EAAE,MAAM;AACd;AACA,MAAM;AACN,IAAI;AACJ,EAAE,CAAC;;AAEH,EAAE,OAAO,WAAW;AACpB;;;;"}
+{"version":3,"file":"createSentryHandleError.js","sources":["../../../src/server/createSentryHandleError.ts"],"sourcesContent":["import { captureException, flushIfServerless } from '@sentry/core';\nimport type { HandleErrorFunction } from 'react-router';\n\nexport type SentryHandleErrorOptions = {\n  logErrors?: boolean;\n};\n\n/**\n * A complete Sentry-instrumented handleError implementation that handles error reporting\n *\n * @returns A Sentry-instrumented handleError function\n */\nexport function createSentryHandleError({ logErrors = false }: SentryHandleErrorOptions): HandleErrorFunction {\n  const handleError: HandleErrorFunction = async function handleError(error, args): Promise<void> {\n    // React Router may abort some interrupted requests, don't report those\n    if (!args.request.signal.aborted) {\n      captureException(error, {\n        mechanism: {\n          type: 'react-router',\n          handled: false,\n        },\n      });\n      if (logErrors) {\n        // eslint-disable-next-line no-console\n        console.error(error);\n      }\n      try {\n        await flushIfServerless();\n      } catch {\n        // Ignore flush errors to ensure error handling completes gracefully\n      }\n    }\n  };\n\n  return handleError;\n}\n"],"names":["handleError","captureException","flushIfServerless"],"mappings":";;;;AAYO,SAAS,uBAAA,CAAwB,EAAE,SAAA,GAAY,KAAA,EAAM,EAAkD;AAC5G,EAAA,MAAM,WAAA,GAAmC,eAAeA,YAAAA,CAAY,KAAA,EAAO,IAAA,EAAqB;AAE9F,IAAA,IAAI,CAAC,IAAA,CAAK,OAAA,CAAQ,MAAA,CAAO,OAAA,EAAS;AAChC,MAAAC,qBAAA,CAAiB,KAAA,EAAO;AAAA,QACtB,SAAA,EAAW;AAAA,UACT,IAAA,EAAM,cAAA;AAAA,UACN,OAAA,EAAS;AAAA;AACX,OACD,CAAA;AACD,MAAA,IAAI,SAAA,EAAW;AAEb,QAAA,OAAA,CAAQ,MAAM,KAAK,CAAA;AAAA,MACrB;AACA,MAAA,IAAI;AACF,QAAA,MAAMC,sBAAA,EAAkB;AAAA,MAC1B,CAAA,CAAA,MAAQ;AAAA,MAER;AAAA,IACF;AAAA,EACF,CAAA;AAEA,EAAA,OAAO,WAAA;AACT;;;;"}

package/build/cjs/server/createSentryHandleRequest.js

@@ -5,84 +5,49 @@ const stream = require('stream');
 const getMetaTagTransformer = require('./getMetaTagTransformer.js');
 const wrapSentryHandleRequest = require('./wrapSentryHandleRequest.js');
 
-/**
- * A complete Sentry-instrumented handleRequest implementation that handles both
- * route parametrization and trace meta tag injection.
- *
- * @param options Configuration options
- * @returns A Sentry-instrumented handleRequest function
- */
-function createSentryHandleRequest(
-  options,
-) {
+function createSentryHandleRequest(options) {
   const {
-    streamTimeout = 10000,
+    streamTimeout = 1e4,
     renderToPipeableStream,
     ServerRouter,
     createReadableStreamFromReadable,
-    botRegex = /bot|crawler|spider|googlebot|chrome-lighthouse|baidu|bing|google|yahoo|lighthouse/i,
+    botRegex = /bot|crawler|spider|googlebot|chrome-lighthouse|baidu|bing|google|yahoo|lighthouse/i
   } = options;
-
-  const handleRequest = function handleRequest(
-    request,
-    responseStatusCode,
-    responseHeaders,
-    routerContext,
-    _loadContext,
-  ) {
+  const handleRequest = function handleRequest2(request, responseStatusCode, responseHeaders, routerContext, _loadContext) {
     return new Promise((resolve, reject) => {
       let shellRendered = false;
-      const userAgent = request.headers.get('user-agent');
-
-      // Determine if we should use onAllReady or onShellReady
-      const isBot = typeof userAgent === 'string' && botRegex.test(userAgent);
-      const isSpaMode = !!(routerContext ).isSpaMode;
-
-      const readyOption = isBot || isSpaMode ? 'onAllReady' : 'onShellReady';
-
-      const { pipe, abort } = renderToPipeableStream(React.default.createElement(ServerRouter, { context: routerContext, url: request.url,} ), {
+      const userAgent = request.headers.get("user-agent");
+      const isBot = typeof userAgent === "string" && botRegex.test(userAgent);
+      const isSpaMode = !!routerContext.isSpaMode;
+      const readyOption = isBot || isSpaMode ? "onAllReady" : "onShellReady";
+      const { pipe, abort } = renderToPipeableStream(/* @__PURE__ */ React.default.createElement(ServerRouter, { context: routerContext, url: request.url }), {
         [readyOption]() {
           shellRendered = true;
           const body = new stream.PassThrough();
-
           const stream$1 = createReadableStreamFromReadable(body);
-
-          responseHeaders.set('Content-Type', 'text/html');
-
+          responseHeaders.set("Content-Type", "text/html");
           resolve(
             new Response(stream$1, {
               headers: responseHeaders,
-              status: responseStatusCode,
-            }),
+              status: responseStatusCode
+            })
           );
-
-          // this injects trace data to the HTML head
           pipe(getMetaTagTransformer.getMetaTagTransformer(body));
         },
         onShellError(error) {
           reject(error);
         },
         onError(error) {
-          // eslint-disable-next-line no-param-reassign
           responseStatusCode = 500;
-          // Log streaming rendering errors from inside the shell.  Don't log
-          // errors encountered during initial shell rendering since they'll
-          // reject and get logged in handleDocumentRequest.
           if (shellRendered) {
-            // eslint-disable-next-line no-console
             console.error(error);
           }
-        },
+        }
       });
-
-      // Abort the rendering stream after the `streamTimeout`
       setTimeout(abort, streamTimeout);
     });
   };
-
-  // Wrap the handle request function for request parametrization
-  return wrapSentryHandleRequest.wrapSentryHandleRequest(handleRequest )
-;
+  return wrapSentryHandleRequest.wrapSentryHandleRequest(handleRequest);
 }
 
 exports.createSentryHandleRequest = createSentryHandleRequest;

package/build/cjs/server/createSentryHandleRequest.js.map

@@ -1 +1 @@
-{"version":3,"file":"createSentryHandleRequest.js","sources":["../../../src/server/createSentryHandleRequest.tsx"],"sourcesContent":["import type { createReadableStreamFromReadable } from '@react-router/node';\nimport type { ReactNode } from 'react';\nimport React from 'react';\nimport type { AppLoadContext, EntryContext, RouterContextProvider, ServerRouter } from 'react-router';\nimport { PassThrough } from 'stream';\nimport { getMetaTagTransformer } from './getMetaTagTransformer';\nimport { wrapSentryHandleRequest } from './wrapSentryHandleRequest';\n\ntype RenderToPipeableStreamOptions = {\n  [key: string]: unknown;\n  onShellReady?: () => void;\n  onAllReady?: () => void;\n  onShellError?: (error: unknown) => void;\n  onError?: (error: unknown) => void;\n};\n\ntype RenderToPipeableStreamResult = {\n  pipe: (destination: NodeJS.WritableStream) => void;\n  abort: () => void;\n};\n\ntype RenderToPipeableStreamFunction = (\n  node: ReactNode,\n  options: RenderToPipeableStreamOptions,\n) => RenderToPipeableStreamResult;\n\nexport interface SentryHandleRequestOptions {\n  /**\n   * Timeout in milliseconds after which the rendering stream will be aborted\n   * @default 10000\n   */\n  streamTimeout?: number;\n\n  /**\n   * React's renderToPipeableStream function from 'react-dom/server'\n   */\n  renderToPipeableStream: RenderToPipeableStreamFunction;\n\n  /**\n   * The <ServerRouter /> component from '@react-router/server'\n   */\n  ServerRouter: typeof ServerRouter;\n\n  /**\n   * createReadableStreamFromReadable from '@react-router/node'\n   */\n  createReadableStreamFromReadable: typeof createReadableStreamFromReadable;\n\n  /**\n   * Regular expression to identify bot user agents\n   * @default /bot|crawler|spider|googlebot|chrome-lighthouse|baidu|bing|google|yahoo|lighthouse/i\n   */\n  botRegex?: RegExp;\n}\n\ntype HandleRequestWithoutMiddleware = (\n  request: Request,\n  responseStatusCode: number,\n  responseHeaders: Headers,\n  routerContext: EntryContext,\n  loadContext: AppLoadContext,\n) => Promise<unknown>;\n\ntype HandleRequestWithMiddleware = (\n  request: Request,\n  responseStatusCode: number,\n  responseHeaders: Headers,\n  routerContext: EntryContext,\n  loadContext: RouterContextProvider,\n) => Promise<unknown>;\n\n/**\n * A complete Sentry-instrumented handleRequest implementation that handles both\n * route parametrization and trace meta tag injection.\n *\n * @param options Configuration options\n * @returns A Sentry-instrumented handleRequest function\n */\nexport function createSentryHandleRequest(\n  options: SentryHandleRequestOptions,\n): HandleRequestWithoutMiddleware & HandleRequestWithMiddleware {\n  const {\n    streamTimeout = 10000,\n    renderToPipeableStream,\n    ServerRouter,\n    createReadableStreamFromReadable,\n    botRegex = /bot|crawler|spider|googlebot|chrome-lighthouse|baidu|bing|google|yahoo|lighthouse/i,\n  } = options;\n\n  const handleRequest = function handleRequest(\n    request: Request,\n    responseStatusCode: number,\n    responseHeaders: Headers,\n    routerContext: EntryContext,\n    _loadContext: AppLoadContext | RouterContextProvider,\n  ): Promise<Response> {\n    return new Promise((resolve, reject) => {\n      let shellRendered = false;\n      const userAgent = request.headers.get('user-agent');\n\n      // Determine if we should use onAllReady or onShellReady\n      const isBot = typeof userAgent === 'string' && botRegex.test(userAgent);\n      const isSpaMode = !!(routerContext as { isSpaMode?: boolean }).isSpaMode;\n\n      const readyOption = isBot || isSpaMode ? 'onAllReady' : 'onShellReady';\n\n      const { pipe, abort } = renderToPipeableStream(<ServerRouter context={routerContext} url={request.url} />, {\n        [readyOption]() {\n          shellRendered = true;\n          const body = new PassThrough();\n\n          const stream = createReadableStreamFromReadable(body);\n\n          responseHeaders.set('Content-Type', 'text/html');\n\n          resolve(\n            new Response(stream, {\n              headers: responseHeaders,\n              status: responseStatusCode,\n            }),\n          );\n\n          // this injects trace data to the HTML head\n          pipe(getMetaTagTransformer(body));\n        },\n        onShellError(error: unknown) {\n          reject(error);\n        },\n        onError(error: unknown) {\n          // eslint-disable-next-line no-param-reassign\n          responseStatusCode = 500;\n          // Log streaming rendering errors from inside the shell.  Don't log\n          // errors encountered during initial shell rendering since they'll\n          // reject and get logged in handleDocumentRequest.\n          if (shellRendered) {\n            // eslint-disable-next-line no-console\n            console.error(error);\n          }\n        },\n      });\n\n      // Abort the rendering stream after the `streamTimeout`\n      setTimeout(abort, streamTimeout);\n    });\n  };\n\n  // Wrap the handle request function for request parametrization\n  return wrapSentryHandleRequest(handleRequest as HandleRequestWithoutMiddleware) as HandleRequestWithoutMiddleware &\n    HandleRequestWithMiddleware;\n}\n"],"names":["React","PassThrough","stream","getMetaTagTransformer","wrapSentryHandleRequest"],"mappings":";;;;;;;AAuEA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,yBAAyB;AACzC,EAAE,OAAO;AACT,EAAgE;AAChE,EAAE,MAAM;AACR,IAAI,aAAA,GAAgB,KAAK;AACzB,IAAI,sBAAsB;AAC1B,IAAI,YAAY;AAChB,IAAI,gCAAgC;AACpC,IAAI,QAAA,GAAW,oFAAoF;AACnG,GAAE,GAAI,OAAO;;AAEb,EAAE,MAAM,aAAA,GAAgB,SAAS,aAAa;AAC9C,IAAI,OAAO;AACX,IAAI,kBAAkB;AACtB,IAAI,eAAe;AACnB,IAAI,aAAa;AACjB,IAAI,YAAY;AAChB,IAAuB;AACvB,IAAI,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,KAAK;AAC5C,MAAM,IAAI,aAAA,GAAgB,KAAK;AAC/B,MAAM,MAAM,SAAA,GAAY,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC;;AAEzD;AACA,MAAM,MAAM,KAAA,GAAQ,OAAO,SAAA,KAAc,QAAA,IAAY,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC;AAC7E,MAAM,MAAM,YAAY,CAAC,CAAC,CAAC,aAAA,GAA0C,SAAS;;AAE9E,MAAM,MAAM,cAAc,KAAA,IAAS,SAAA,GAAY,YAAA,GAAe,cAAc;;AAE5E,MAAM,MAAM,EAAE,IAAI,EAAE,OAAM,GAAI,sBAAsB,CAACA,aAAA,CAAA,aAAA,CAAC,YAAA,EAAA,EAAa,OAAO,EAAC,aAAc,EAAE,GAAG,EAAC,OAAQ,CAAC,GAAG,EAAA,EAAI,EAAE;AACjH,QAAQ,CAAC,WAAW,CAAC,GAAG;AACxB,UAAU,aAAA,GAAgB,IAAI;AAC9B,UAAU,MAAM,IAAA,GAAO,IAAIC,kBAAW,EAAE;;AAExC,UAAU,MAAMC,QAAA,GAAS,gCAAgC,CAAC,IAAI,CAAC;;AAE/D,UAAU,eAAe,CAAC,GAAG,CAAC,cAAc,EAAE,WAAW,CAAC;;AAE1D,UAAU,OAAO;AACjB,YAAY,IAAI,QAAQ,CAACA,QAAM,EAAE;AACjC,cAAc,OAAO,EAAE,eAAe;AACtC,cAAc,MAAM,EAAE,kBAAkB;AACxC,aAAa,CAAC;AACd,WAAW;;AAEX;AACA,UAAU,IAAI,CAACC,2CAAqB,CAAC,IAAI,CAAC,CAAC;AAC3C,QAAQ,CAAC;AACT,QAAQ,YAAY,CAAC,KAAK,EAAW;AACrC,UAAU,MAAM,CAAC,KAAK,CAAC;AACvB,QAAQ,CAAC;AACT,QAAQ,OAAO,CAAC,KAAK,EAAW;AAChC;AACA,UAAU,kBAAA,GAAqB,GAAG;AAClC;AACA;AACA;AACA,UAAU,IAAI,aAAa,EAAE;AAC7B;AACA,YAAY,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC;AAChC,UAAU;AACV,QAAQ,CAAC;AACT,OAAO,CAAC;;AAER;AACA,MAAM,UAAU,CAAC,KAAK,EAAE,aAAa,CAAC;AACtC,IAAI,CAAC,CAAC;AACN,EAAE,CAAC;;AAEH;AACA,EAAE,OAAOC,+CAAuB,CAAC,aAAA;AAC7B;AACJ;;;;"}
+{"version":3,"file":"createSentryHandleRequest.js","sources":["../../../src/server/createSentryHandleRequest.tsx"],"sourcesContent":["import type { createReadableStreamFromReadable } from '@react-router/node';\nimport type { ReactNode } from 'react';\nimport React from 'react';\nimport type { AppLoadContext, EntryContext, RouterContextProvider, ServerRouter } from 'react-router';\nimport { PassThrough } from 'stream';\nimport { getMetaTagTransformer } from './getMetaTagTransformer';\nimport { wrapSentryHandleRequest } from './wrapSentryHandleRequest';\n\ntype RenderToPipeableStreamOptions = {\n  [key: string]: unknown;\n  onShellReady?: () => void;\n  onAllReady?: () => void;\n  onShellError?: (error: unknown) => void;\n  onError?: (error: unknown) => void;\n};\n\ntype RenderToPipeableStreamResult = {\n  pipe: (destination: NodeJS.WritableStream) => void;\n  abort: () => void;\n};\n\ntype RenderToPipeableStreamFunction = (\n  node: ReactNode,\n  options: RenderToPipeableStreamOptions,\n) => RenderToPipeableStreamResult;\n\nexport interface SentryHandleRequestOptions {\n  /**\n   * Timeout in milliseconds after which the rendering stream will be aborted\n   * @default 10000\n   */\n  streamTimeout?: number;\n\n  /**\n   * React's renderToPipeableStream function from 'react-dom/server'\n   */\n  renderToPipeableStream: RenderToPipeableStreamFunction;\n\n  /**\n   * The <ServerRouter /> component from '@react-router/server'\n   */\n  ServerRouter: typeof ServerRouter;\n\n  /**\n   * createReadableStreamFromReadable from '@react-router/node'\n   */\n  createReadableStreamFromReadable: typeof createReadableStreamFromReadable;\n\n  /**\n   * Regular expression to identify bot user agents\n   * @default /bot|crawler|spider|googlebot|chrome-lighthouse|baidu|bing|google|yahoo|lighthouse/i\n   */\n  botRegex?: RegExp;\n}\n\ntype HandleRequestWithoutMiddleware = (\n  request: Request,\n  responseStatusCode: number,\n  responseHeaders: Headers,\n  routerContext: EntryContext,\n  loadContext: AppLoadContext,\n) => Promise<unknown>;\n\ntype HandleRequestWithMiddleware = (\n  request: Request,\n  responseStatusCode: number,\n  responseHeaders: Headers,\n  routerContext: EntryContext,\n  loadContext: RouterContextProvider,\n) => Promise<unknown>;\n\n/**\n * A complete Sentry-instrumented handleRequest implementation that handles both\n * route parametrization and trace meta tag injection.\n *\n * @param options Configuration options\n * @returns A Sentry-instrumented handleRequest function\n */\nexport function createSentryHandleRequest(\n  options: SentryHandleRequestOptions,\n): HandleRequestWithoutMiddleware & HandleRequestWithMiddleware {\n  const {\n    streamTimeout = 10000,\n    renderToPipeableStream,\n    ServerRouter,\n    createReadableStreamFromReadable,\n    botRegex = /bot|crawler|spider|googlebot|chrome-lighthouse|baidu|bing|google|yahoo|lighthouse/i,\n  } = options;\n\n  const handleRequest = function handleRequest(\n    request: Request,\n    responseStatusCode: number,\n    responseHeaders: Headers,\n    routerContext: EntryContext,\n    _loadContext: AppLoadContext | RouterContextProvider,\n  ): Promise<Response> {\n    return new Promise((resolve, reject) => {\n      let shellRendered = false;\n      const userAgent = request.headers.get('user-agent');\n\n      // Determine if we should use onAllReady or onShellReady\n      const isBot = typeof userAgent === 'string' && botRegex.test(userAgent);\n      const isSpaMode = !!(routerContext as { isSpaMode?: boolean }).isSpaMode;\n\n      const readyOption = isBot || isSpaMode ? 'onAllReady' : 'onShellReady';\n\n      const { pipe, abort } = renderToPipeableStream(<ServerRouter context={routerContext} url={request.url} />, {\n        [readyOption]() {\n          shellRendered = true;\n          const body = new PassThrough();\n\n          const stream = createReadableStreamFromReadable(body);\n\n          responseHeaders.set('Content-Type', 'text/html');\n\n          resolve(\n            new Response(stream, {\n              headers: responseHeaders,\n              status: responseStatusCode,\n            }),\n          );\n\n          // this injects trace data to the HTML head\n          pipe(getMetaTagTransformer(body));\n        },\n        onShellError(error: unknown) {\n          reject(error);\n        },\n        onError(error: unknown) {\n          // eslint-disable-next-line no-param-reassign\n          responseStatusCode = 500;\n          // Log streaming rendering errors from inside the shell.  Don't log\n          // errors encountered during initial shell rendering since they'll\n          // reject and get logged in handleDocumentRequest.\n          if (shellRendered) {\n            // eslint-disable-next-line no-console\n            console.error(error);\n          }\n        },\n      });\n\n      // Abort the rendering stream after the `streamTimeout`\n      setTimeout(abort, streamTimeout);\n    });\n  };\n\n  // Wrap the handle request function for request parametrization\n  return wrapSentryHandleRequest(handleRequest as HandleRequestWithoutMiddleware) as HandleRequestWithoutMiddleware &\n    HandleRequestWithMiddleware;\n}\n"],"names":["handleRequest","React","PassThrough","stream","getMetaTagTransformer","wrapSentryHandleRequest"],"mappings":";;;;;;;AA8EO,SAAS,0BACd,OAAA,EAC8D;AAC9D,EAAA,MAAM;AAAA,IACJ,aAAA,GAAgB,GAAA;AAAA,IAChB,sBAAA;AAAA,IACA,YAAA;AAAA,IACA,gCAAA;AAAA,IACA,QAAA,GAAW;AAAA,GACb,GAAI,OAAA;AAEJ,EAAA,MAAM,gBAAgB,SAASA,cAAAA,CAC7B,SACA,kBAAA,EACA,eAAA,EACA,eACA,YAAA,EACmB;AACnB,IAAA,OAAO,IAAI,OAAA,CAAQ,CAAC,OAAA,EAAS,MAAA,KAAW;AACtC,MAAA,IAAI,aAAA,GAAgB,KAAA;AACpB,MAAA,MAAM,SAAA,GAAY,OAAA,CAAQ,OAAA,CAAQ,GAAA,CAAI,YAAY,CAAA;AAGlD,MAAA,MAAM,QAAQ,OAAO,SAAA,KAAc,QAAA,IAAY,QAAA,CAAS,KAAK,SAAS,CAAA;AACtE,MAAA,MAAM,SAAA,GAAY,CAAC,CAAE,aAAA,CAA0C,SAAA;AAE/D,MAAA,MAAM,WAAA,GAAc,KAAA,IAAS,SAAA,GAAY,YAAA,GAAe,cAAA;AAExD,MAAA,MAAM,EAAE,IAAA,EAAM,KAAA,EAAM,GAAI,sBAAA,iBAAuBC,aAAA,CAAA,aAAA,CAAC,YAAA,EAAA,EAAa,OAAA,EAAS,aAAA,EAAe,GAAA,EAAK,OAAA,CAAQ,GAAA,EAAK,CAAA,EAAI;AAAA,QACzG,CAAC,WAAW,CAAA,GAAI;AACd,UAAA,aAAA,GAAgB,IAAA;AAChB,UAAA,MAAM,IAAA,GAAO,IAAIC,kBAAA,EAAY;AAE7B,UAAA,MAAMC,QAAA,GAAS,iCAAiC,IAAI,CAAA;AAEpD,UAAA,eAAA,CAAgB,GAAA,CAAI,gBAAgB,WAAW,CAAA;AAE/C,UAAA,OAAA;AAAA,YACE,IAAI,SAASA,QAAA,EAAQ;AAAA,cACnB,OAAA,EAAS,eAAA;AAAA,cACT,MAAA,EAAQ;AAAA,aACT;AAAA,WACH;AAGA,UAAA,IAAA,CAAKC,2CAAA,CAAsB,IAAI,CAAC,CAAA;AAAA,QAClC,CAAA;AAAA,QACA,aAAa,KAAA,EAAgB;AAC3B,UAAA,MAAA,CAAO,KAAK,CAAA;AAAA,QACd,CAAA;AAAA,QACA,QAAQ,KAAA,EAAgB;AAEtB,UAAA,kBAAA,GAAqB,GAAA;AAIrB,UAAA,IAAI,aAAA,EAAe;AAEjB,YAAA,OAAA,CAAQ,MAAM,KAAK,CAAA;AAAA,UACrB;AAAA,QACF;AAAA,OACD,CAAA;AAGD,MAAA,UAAA,CAAW,OAAO,aAAa,CAAA;AAAA,IACjC,CAAC,CAAA;AAAA,EACH,CAAA;AAGA,EAAA,OAAOC,gDAAwB,aAA+C,CAAA;AAEhF;;;;"}

package/build/cjs/server/createServerInstrumentation.js

@@ -9,51 +9,35 @@ const utils = require('../common/utils.js');
 const serverBuild = require('./serverBuild.js');
 const serverGlobals = require('./serverGlobals.js');
 
-const MIDDLEWARE_COUNTER_KEY = api.createContextKey('sentry_react_router_middleware_counter');
-
-/**
- * Options for creating Sentry server instrumentation.
- */
-
-/**
- * Creates a Sentry server instrumentation for React Router's instrumentation API.
- * @experimental
- */
-function createSentryServerInstrumentation(
-  options = {},
-) {
+const MIDDLEWARE_COUNTER_KEY = api.createContextKey("sentry_react_router_middleware_counter");
+function createSentryServerInstrumentation(options = {}) {
   const { captureErrors = true } = options;
-
   serverGlobals.markInstrumentationApiUsed();
-  debugBuild.DEBUG_BUILD && core.debug.log('React Router server instrumentation API enabled.');
-
+  debugBuild.DEBUG_BUILD && core.debug.log("React Router server instrumentation API enabled.");
   return {
     handler(handler) {
       handler.instrument({
         async request(handleRequest, info) {
           const pathname = utils.getPathFromRequest(info.request);
           const activeSpan = core.getActiveSpan();
-          const existingRootSpan = activeSpan ? core.getRootSpan(activeSpan) : undefined;
-
-          const counterStore = { counters: {}  };
+          const existingRootSpan = activeSpan ? core.getRootSpan(activeSpan) : void 0;
+          const counterStore = { counters: {} };
           const ctx = api.context.active().setValue(MIDDLEWARE_COUNTER_KEY, counterStore);
-
           await api.context.with(ctx, async () => {
             if (existingRootSpan) {
               core.updateSpanName(existingRootSpan, `${info.request.method} ${pathname}`);
               existingRootSpan.setAttributes({
-                [core.SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'http.server',
-                [core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.http.react_router.instrumentation_api',
-                [core.SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'url',
+                [core.SEMANTIC_ATTRIBUTE_SENTRY_OP]: "http.server",
+                [core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.http.react_router.instrumentation_api",
+                [core.SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: "url"
               });
-
               try {
                 const result = await handleRequest();
-                if (result.status === 'error' && result.error instanceof Error) {
-                  existingRootSpan.setStatus({ code: core.SPAN_STATUS_ERROR, message: 'internal_error' });
-                  utils.captureInstrumentationError(result, captureErrors, 'react_router.request_handler', {
-                    'http.method': info.request.method,
-                    'http.url': pathname,
+                if (result.status === "error" && result.error instanceof Error) {
+                  existingRootSpan.setStatus({ code: core.SPAN_STATUS_ERROR, message: "internal_error" });
+                  utils.captureInstrumentationError(result, captureErrors, "react_router.request_handler", {
+                    "http.method": info.request.method,
+                    "http.url": pathname
                   });
                 }
               } finally {
@@ -65,188 +49,166 @@ function createSentryServerInstrumentation(
                   name: `${info.request.method} ${pathname}`,
                   forceTransaction: true,
                   attributes: {
-                    [core.SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'http.server',
-                    [core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.http.react_router.instrumentation_api',
-                    [core.SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'url',
-                    'http.request.method': info.request.method,
-                    'url.path': pathname,
-                    'url.full': info.request.url,
-                  },
+                    [core.SEMANTIC_ATTRIBUTE_SENTRY_OP]: "http.server",
+                    [core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.http.react_router.instrumentation_api",
+                    [core.SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: "url",
+                    "http.request.method": info.request.method,
+                    "url.path": pathname,
+                    "url.full": info.request.url
+                  }
                 },
-                async span => {
+                async (span) => {
                   try {
                     const result = await handleRequest();
-                    if (result.status === 'error' && result.error instanceof Error) {
-                      span.setStatus({ code: core.SPAN_STATUS_ERROR, message: 'internal_error' });
-                      utils.captureInstrumentationError(result, captureErrors, 'react_router.request_handler', {
-                        'http.method': info.request.method,
-                        'http.url': pathname,
+                    if (result.status === "error" && result.error instanceof Error) {
+                      span.setStatus({ code: core.SPAN_STATUS_ERROR, message: "internal_error" });
+                      utils.captureInstrumentationError(result, captureErrors, "react_router.request_handler", {
+                        "http.method": info.request.method,
+                        "http.url": pathname
                       });
                     }
                   } finally {
                     await core.flushIfServerless();
                   }
-                },
+                }
               );
             }
           });
-        },
+        }
       });
     },
-
     route(route) {
       const routeId = route.id;
-
       route.instrument({
         async loader(callLoader, info) {
           const urlPath = utils.getPathFromRequest(info.request);
           const pattern = utils.getPattern(info);
           const routePattern = utils.normalizeRoutePath(pattern) || urlPath;
           updateRootSpanWithRoute(info.request.method, pattern, urlPath);
-
           await core.startSpan(
             {
               name: routePattern,
               attributes: {
-                [core.SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'function.react_router.loader',
-                [core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.function.react_router.instrumentation_api',
-              },
+                [core.SEMANTIC_ATTRIBUTE_SENTRY_OP]: "function.react_router.loader",
+                [core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.function.react_router.instrumentation_api"
+              }
             },
-            async span => {
+            async (span) => {
               const result = await callLoader();
-              if (result.status === 'error' && result.error instanceof Error) {
-                span.setStatus({ code: core.SPAN_STATUS_ERROR, message: 'internal_error' });
-                utils.captureInstrumentationError(result, captureErrors, 'react_router.loader', {
-                  'http.method': info.request.method,
-                  'http.url': urlPath,
+              if (result.status === "error" && result.error instanceof Error) {
+                span.setStatus({ code: core.SPAN_STATUS_ERROR, message: "internal_error" });
+                utils.captureInstrumentationError(result, captureErrors, "react_router.loader", {
+                  "http.method": info.request.method,
+                  "http.url": urlPath
                 });
               }
-            },
+            }
           );
         },
-
         async action(callAction, info) {
           const urlPath = utils.getPathFromRequest(info.request);
           const pattern = utils.getPattern(info);
           const routePattern = utils.normalizeRoutePath(pattern) || urlPath;
           updateRootSpanWithRoute(info.request.method, pattern, urlPath);
-
           await core.startSpan(
             {
               name: routePattern,
               attributes: {
-                [core.SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'function.react_router.action',
-                [core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.function.react_router.instrumentation_api',
-              },
+                [core.SEMANTIC_ATTRIBUTE_SENTRY_OP]: "function.react_router.action",
+                [core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.function.react_router.instrumentation_api"
+              }
             },
-            async span => {
+            async (span) => {
               const result = await callAction();
-              if (result.status === 'error' && result.error instanceof Error) {
-                span.setStatus({ code: core.SPAN_STATUS_ERROR, message: 'internal_error' });
-                utils.captureInstrumentationError(result, captureErrors, 'react_router.action', {
-                  'http.method': info.request.method,
-                  'http.url': urlPath,
+              if (result.status === "error" && result.error instanceof Error) {
+                span.setStatus({ code: core.SPAN_STATUS_ERROR, message: "internal_error" });
+                utils.captureInstrumentationError(result, captureErrors, "react_router.action", {
+                  "http.method": info.request.method,
+                  "http.url": urlPath
                 });
               }
-            },
+            }
           );
         },
-
         async middleware(callMiddleware, info) {
           const urlPath = utils.getPathFromRequest(info.request);
           const pattern = utils.getPattern(info);
           const routePattern = utils.normalizeRoutePath(pattern) || urlPath;
-
           updateRootSpanWithRoute(info.request.method, pattern, urlPath);
-
-          const counterStore = api.context.active().getValue(MIDDLEWARE_COUNTER_KEY)
-
-;
+          const counterStore = api.context.active().getValue(MIDDLEWARE_COUNTER_KEY);
           let middlewareIndex = 0;
           if (counterStore) {
             middlewareIndex = counterStore.counters[routeId] ?? 0;
             counterStore.counters[routeId] = middlewareIndex + 1;
           }
-
           const middlewareName = serverBuild.getMiddlewareName(routeId, middlewareIndex);
-
           await core.startSpan(
             {
               name: `middleware ${middlewareName || routeId}`,
               attributes: {
-                [core.SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'function.react_router.middleware',
-                [core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.function.react_router.instrumentation_api',
-                'react_router.route.id': routeId,
+                [core.SEMANTIC_ATTRIBUTE_SENTRY_OP]: "function.react_router.middleware",
+                [core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.function.react_router.instrumentation_api",
+                "react_router.route.id": routeId,
                 [semanticConventions.ATTR_HTTP_ROUTE]: routePattern,
-                ...(middlewareName && { 'react_router.middleware.name': middlewareName }),
-                'react_router.middleware.index': middlewareIndex,
-              },
+                ...middlewareName && { "react_router.middleware.name": middlewareName },
+                "react_router.middleware.index": middlewareIndex
+              }
             },
-            async span => {
+            async (span) => {
               const result = await callMiddleware();
-              if (result.status === 'error' && result.error instanceof Error) {
-                span.setStatus({ code: core.SPAN_STATUS_ERROR, message: 'internal_error' });
-                utils.captureInstrumentationError(result, captureErrors, 'react_router.middleware', {
-                  'http.method': info.request.method,
-                  'http.url': urlPath,
+              if (result.status === "error" && result.error instanceof Error) {
+                span.setStatus({ code: core.SPAN_STATUS_ERROR, message: "internal_error" });
+                utils.captureInstrumentationError(result, captureErrors, "react_router.middleware", {
+                  "http.method": info.request.method,
+                  "http.url": urlPath
                 });
               }
-            },
+            }
           );
         },
-
         async lazy(callLazy) {
           await core.startSpan(
             {
-              name: 'Lazy Route Load',
+              name: "Lazy Route Load",
               attributes: {
-                [core.SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'function.react_router.lazy',
-                [core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.function.react_router.instrumentation_api',
-              },
+                [core.SEMANTIC_ATTRIBUTE_SENTRY_OP]: "function.react_router.lazy",
+                [core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.function.react_router.instrumentation_api"
+              }
             },
-            async span => {
+            async (span) => {
               const result = await callLazy();
-              if (result.status === 'error' && result.error instanceof Error) {
-                span.setStatus({ code: core.SPAN_STATUS_ERROR, message: 'internal_error' });
-                utils.captureInstrumentationError(result, captureErrors, 'react_router.lazy', {});
+              if (result.status === "error" && result.error instanceof Error) {
+                span.setStatus({ code: core.SPAN_STATUS_ERROR, message: "internal_error" });
+                utils.captureInstrumentationError(result, captureErrors, "react_router.lazy", {});
               }
-            },
+            }
           );
-        },
+        }
       });
-    },
+    }
   };
 }
-
 function updateRootSpanWithRoute(method, pattern, urlPath) {
   const activeSpan = core.getActiveSpan();
   if (!activeSpan) return;
   const rootSpan = core.getRootSpan(activeSpan);
   if (!rootSpan) return;
-
-  // Skip update if URL path is invalid (failed to parse)
-  if (!urlPath || urlPath === '<unknown>') {
-    debugBuild.DEBUG_BUILD && core.debug.warn('Cannot update span with invalid URL path:', urlPath);
+  if (!urlPath || urlPath === "<unknown>") {
+    debugBuild.DEBUG_BUILD && core.debug.warn("Cannot update span with invalid URL path:", urlPath);
     return;
   }
-
   const hasPattern = !!pattern;
   const routeName = hasPattern ? utils.normalizeRoutePath(pattern) || urlPath : urlPath;
-
   const rpcMetadata = core$1.getRPCMetadata(api.context.active());
   if (rpcMetadata?.type === core$1.RPCType.HTTP) {
     rpcMetadata.route = routeName;
   }
-
   const transactionName = `${method} ${routeName}`;
   core.updateSpanName(rootSpan, transactionName);
   rootSpan.setAttributes({
     [semanticConventions.ATTR_HTTP_ROUTE]: routeName,
-    [core.SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: hasPattern ? 'route' : 'url',
+    [core.SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: hasPattern ? "route" : "url"
   });
-
-  // Also update the scope's transaction name so errors captured during this request
-  // have the correct transaction name (not the initial placeholder like "GET *")
   core.getCurrentScope().setTransactionName(transactionName);
 }