@depup/sentry__server-utils 10.67.0-depup.0

package/build/esm/integrations/tracing-channel/express/instrumentation.js

@@ -0,0 +1,166 @@
+import { HTTP_ROUTE } from '@sentry/conventions/attributes';
+import { debug, getActiveSpan, getIsolationScope, getDefaultIsolationScope, startInactiveSpan, SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, getRootSpan, spanToJSON, stringMatchesSomePattern } from '@sentry/core';
+import { DEBUG_BUILD } from '../../../debug-build.js';
+import { CHANNELS } from '../../../orchestrion/channels.js';
+import { bindTracingChannelToSpan } from '../../../tracing-channel.js';
+import { setLayerRegisteredPath, getLayerPath, getLayerRegisteredPath, pushLayerPath, getConstructedRoute, getActualMatchedRoute, popLayerPath } from './route.js';
+
+const ORIGIN = "auto.http.express";
+const ATTR_EXPRESS_NAME = "express.name";
+const ATTR_EXPRESS_TYPE = "express.type";
+const NOOP = () => {
+};
+let _isInstrumented = false;
+function instrumentExpress(options, tracingChannel) {
+  if (_isInstrumented) {
+    return;
+  }
+  _isInstrumented = true;
+  for (const channelName of [CHANNELS.EXPRESS_REGISTER, CHANNELS.ROUTER_REGISTER]) {
+    tracingChannel(channelName).subscribe({
+      start: NOOP,
+      asyncStart: NOOP,
+      asyncEnd: NOOP,
+      error: NOOP,
+      end: captureRegisteredLayerPath
+    });
+  }
+  for (const channelName of [CHANNELS.EXPRESS_HANDLE, CHANNELS.ROUTER_HANDLE]) {
+    DEBUG_BUILD && debug.log(`[orchestrion:express] subscribing to channel "${channelName}"`);
+    const channel = tracingChannel(channelName);
+    bindTracingChannelToSpan(channel, (data) => getSpanForLayer(data, options), {
+      beforeSpanEnd(_span, data) {
+        data._sentryCleanup?.();
+      }
+    });
+    channel.subscribe({
+      start: NOOP,
+      asyncEnd: NOOP,
+      end: NOOP,
+      error: NOOP,
+      asyncStart: popLayerPathForLayer
+    });
+  }
+}
+function captureRegisteredLayerPath(data) {
+  const stack = data.self?.stack;
+  if (!Array.isArray(stack)) {
+    return;
+  }
+  const layer = stack[stack.length - 1];
+  if (layer) {
+    setLayerRegisteredPath(layer, getLayerPath(data.arguments ?? []));
+  }
+}
+function popLayerPathForLayer(data) {
+  if (!data._sentryStoredLayer) {
+    return;
+  }
+  data._sentryStoredLayer = false;
+  const req = data.arguments?.[0];
+  if (req) {
+    popLayerPath(req);
+  }
+}
+function getSpanForLayer(data, options) {
+  const layer = data.self;
+  const args = data.arguments;
+  if (!layer || !Array.isArray(args)) {
+    return void 0;
+  }
+  if (layer.handle?.length === 4) {
+    return void 0;
+  }
+  if (layer.method && !layer.route) {
+    return void 0;
+  }
+  const req = args[0];
+  const res = args[1];
+  if (!req) {
+    return void 0;
+  }
+  if (!getActiveSpan()) {
+    return void 0;
+  }
+  const type = getLayerType(layer);
+  const registeredPath = getLayerRegisteredPath(layer);
+  if (registeredPath != null) {
+    pushLayerPath(req, registeredPath);
+    data._sentryStoredLayer = true;
+  }
+  const constructedRoute = type === "request_handler" ? getConstructedRoute(req) : void 0;
+  const matchedRoute = type === "request_handler" && constructedRoute != null ? getActualMatchedRoute(req, constructedRoute) : void 0;
+  const name = type === "request_handler" ? constructedRoute || "request handler" : type === "router" ? layer.path ?? "/" : layer.name ?? "<anonymous>";
+  if (matchedRoute) {
+    setHttpServerSpanRoute(matchedRoute);
+  }
+  if (type === "request_handler" && constructedRoute) {
+    const isolationScope = getIsolationScope();
+    if (isolationScope !== getDefaultIsolationScope()) {
+      const method = typeof req.method === "string" ? req.method.toUpperCase() : "GET";
+      isolationScope.setTransactionName(`${method} ${constructedRoute}`);
+    } else {
+      DEBUG_BUILD && debug.warn(
+        "[orchestrion:express] Isolation scope is still default isolation scope - skipping transaction name"
+      );
+    }
+  }
+  if (isLayerIgnored(name, type, options)) {
+    return void 0;
+  }
+  const span = startInactiveSpan({
+    name,
+    attributes: {
+      [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: ORIGIN,
+      [SEMANTIC_ATTRIBUTE_SENTRY_OP]: `${type}.express`,
+      [ATTR_EXPRESS_NAME]: name,
+      [ATTR_EXPRESS_TYPE]: type,
+      ...matchedRoute ? { [HTTP_ROUTE]: matchedRoute } : {}
+    }
+  });
+  if (res && typeof res.once === "function") {
+    const onFinish = () => {
+      span.end();
+    };
+    res.once("finish", onFinish);
+    data._sentryCleanup = () => res.removeListener("finish", onFinish);
+  }
+  return span;
+}
+function getLayerType(layer) {
+  if (layer.name === "router") {
+    return "router";
+  }
+  if (layer.name === "bound dispatch" || layer.name === "handle") {
+    return "request_handler";
+  }
+  return "middleware";
+}
+function setHttpServerSpanRoute(route) {
+  const activeSpan = getActiveSpan();
+  const rootSpan = activeSpan && getRootSpan(activeSpan);
+  if (!rootSpan) {
+    return;
+  }
+  if (spanToJSON(rootSpan).data[SEMANTIC_ATTRIBUTE_SENTRY_OP] !== "http.server") {
+    return;
+  }
+  rootSpan.setAttribute(HTTP_ROUTE, route);
+}
+function isLayerIgnored(name, type, options) {
+  const { ignoreLayers, ignoreLayersType } = options;
+  if (Array.isArray(ignoreLayersType) && ignoreLayersType.includes(type)) {
+    return true;
+  }
+  if (!Array.isArray(ignoreLayers)) {
+    return false;
+  }
+  try {
+    return stringMatchesSomePattern(name, ignoreLayers, true);
+  } catch {
+    return false;
+  }
+}
+
+export { instrumentExpress };
+//# sourceMappingURL=instrumentation.js.map

package/build/esm/integrations/tracing-channel/express/instrumentation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentation.js","sources":["../../../../../src/integrations/tracing-channel/express/instrumentation.ts"],"sourcesContent":["import type * as diagnosticsChannel from 'node:diagnostics_channel';\nimport { HTTP_ROUTE } from '@sentry/conventions/attributes';\nimport type { Span } from '@sentry/core';\nimport {\n  debug,\n  getActiveSpan,\n  getDefaultIsolationScope,\n  getIsolationScope,\n  getRootSpan,\n  SEMANTIC_ATTRIBUTE_SENTRY_OP,\n  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,\n  spanToJSON,\n  startInactiveSpan,\n  stringMatchesSomePattern,\n} from '@sentry/core';\nimport { DEBUG_BUILD } from '../../../debug-build';\nimport { CHANNELS } from '../../../orchestrion/channels';\nimport { bindTracingChannelToSpan } from '../../../tracing-channel';\nimport {\n  getActualMatchedRoute,\n  getConstructedRoute,\n  getLayerPath,\n  getLayerRegisteredPath,\n  popLayerPath,\n  pushLayerPath,\n  setLayerRegisteredPath,\n} from './route';\nimport type {\n  ExpressIntegrationOptions,\n  ExpressLayer,\n  ExpressLayerType,\n  ExpressRequest,\n  ExpressResponse,\n  HandleChannelContext,\n  RegistrationChannelContext,\n} from './types';\n\nconst ORIGIN = 'auto.http.express';\n\n// `express.name`/`express.type` are Sentry-internal Express attributes (not part\n// of `@sentry/conventions`); kept in sync with `@sentry/core`'s OTel-derived\n// Express integration so the emitted spans are identical across both code paths.\nconst ATTR_EXPRESS_NAME = 'express.name';\nconst ATTR_EXPRESS_TYPE = 'express.type';\n\nconst NOOP = (): void => {};\n\nlet _isInstrumented = false;\n\nexport function instrumentExpress(\n  options: ExpressIntegrationOptions,\n  tracingChannel: typeof diagnosticsChannel.tracingChannel,\n): void {\n  if (_isInstrumented) {\n    return;\n  }\n  _isInstrumented = true;\n\n  // Record each layer's registered path *pattern* as it is registered, so the\n  // matched route can be reconstructed with its parameters intact at request\n  // time. Only the `end` event matters (the layer is on the router's stack by\n  // then); the others are required by the subscriber type, so no-op them.\n  for (const channelName of [CHANNELS.EXPRESS_REGISTER, CHANNELS.ROUTER_REGISTER]) {\n    tracingChannel<RegistrationChannelContext>(channelName).subscribe({\n      start: NOOP,\n      asyncStart: NOOP,\n      asyncEnd: NOOP,\n      error: NOOP,\n      end: captureRegisteredLayerPath,\n    });\n  }\n\n  for (const channelName of [CHANNELS.EXPRESS_HANDLE, CHANNELS.ROUTER_HANDLE]) {\n    DEBUG_BUILD && debug.log(`[orchestrion:express] subscribing to channel \"${channelName}\"`);\n\n    const channel = tracingChannel<HandleChannelContext>(channelName);\n\n    bindTracingChannelToSpan(channel, data => getSpanForLayer(data, options), {\n      beforeSpanEnd(_span, data) {\n        data._sentryCleanup?.();\n      },\n    });\n\n    // Pop the layer path when the layer hands off via `next`. `asyncStart` fires\n    // when `next` is called and *before* the downstream layer runs, so the\n    // per-request path chain reflects only the current chain when each layer\n    // reconstructs its route. Only `asyncStart` is relevant here.\n    channel.subscribe({\n      start: NOOP,\n      asyncEnd: NOOP,\n      end: NOOP,\n      error: NOOP,\n      asyncStart: popLayerPathForLayer,\n    });\n  }\n}\n\n/** Record the freshly-registered layer's path pattern from a `route`/`use` call. */\nfunction captureRegisteredLayerPath(data: RegistrationChannelContext): void {\n  const stack = data.self?.stack;\n  if (!Array.isArray(stack)) {\n    return;\n  }\n  const layer = stack[stack.length - 1];\n  if (layer) {\n    setLayerRegisteredPath(layer, getLayerPath(data.arguments ?? []));\n  }\n}\n\n/** Pop the path a layer pushed once it hands control onward via `next`. */\nfunction popLayerPathForLayer(data: HandleChannelContext): void {\n  if (!data._sentryStoredLayer) {\n    return;\n  }\n  // Clear the marker first so a layer that (incorrectly) calls `next` more than\n  // once can't pop again and take a parent's entry off the stack with it.\n  data._sentryStoredLayer = false;\n  const req = data.arguments?.[0] as ExpressRequest | undefined;\n  if (req) {\n    popLayerPath(req);\n  }\n}\n\n/**\n * Open a span for one layer invocation. Returns `undefined` to opt the layer\n * out (error handlers, or a layer with no active parent trace) — the helper\n * then leaves the active context untouched.\n */\nfunction getSpanForLayer(data: HandleChannelContext, options: ExpressIntegrationOptions): Span | undefined {\n  const layer = data.self;\n  const args = data.arguments;\n  if (!layer || !Array.isArray(args)) {\n    return undefined;\n  }\n\n  // Express only treats a 4-arg handler as an error handler and skips it in\n  // the normal request pipeline; match the OTel integration and don't trace it.\n  if (layer.handle?.length === 4) {\n    return undefined;\n  }\n\n  // A Route dispatches to its handlers via the same `handle_request` method,\n  // but those inner layers already run inside the route-dispatch layer's\n  // `request_handler` span. They carry `.method` (and no `.route`); skip them\n  // so we emit one span per route, matching the OTel Express integration.\n  if (layer.method && !layer.route) {\n    return undefined;\n  }\n\n  const req = args[0] as ExpressRequest | undefined;\n  const res = args[1] as ExpressResponse | undefined;\n  if (!req) {\n    return undefined;\n  }\n\n  // No active parent span means this request is being ignored (unsampled /\n  // filtered), so don't open a span\n  if (!getActiveSpan()) {\n    return undefined;\n  }\n\n  const type = getLayerType(layer);\n\n  // Push this layer's registered path onto the request's chain so a\n  // `request_handler` can reconstruct the full route with parameters intact\n  // (`req.baseUrl` only exposes the *resolved* mount prefix). The matching pop\n  // happens on `asyncStart` when the layer hands off via `next`.\n  const registeredPath = getLayerRegisteredPath(layer);\n  if (registeredPath != null) {\n    pushLayerPath(req, registeredPath);\n    data._sentryStoredLayer = true;\n  }\n\n  // `constructedRoute` (the full registered pattern) names the span/transaction;\n  // `matchedRoute` (validated against the request URL) is the `http.route`.\n  const constructedRoute = type === 'request_handler' ? getConstructedRoute(req) : undefined;\n  const matchedRoute =\n    type === 'request_handler' && constructedRoute != null ? getActualMatchedRoute(req, constructedRoute) : undefined;\n\n  const name =\n    type === 'request_handler'\n      ? constructedRoute || 'request handler'\n      : type === 'router'\n        ? (layer.path ?? '/')\n        : (layer.name ?? '<anonymous>');\n\n  // Propagate the route to the root `http.server` span *before* the ignore\n  // check, so the transaction is still named even when the layer's own span is\n  // ignored — matches the OTel Express integration's `onRouteResolved` timing.\n  if (matchedRoute) {\n    setHttpServerSpanRoute(matchedRoute);\n  }\n\n  if (type === 'request_handler' && constructedRoute) {\n    const isolationScope = getIsolationScope();\n    if (isolationScope !== getDefaultIsolationScope()) {\n      const method = typeof req.method === 'string' ? req.method.toUpperCase() : 'GET';\n      isolationScope.setTransactionName(`${method} ${constructedRoute}`);\n    } else {\n      DEBUG_BUILD &&\n        debug.warn(\n          '[orchestrion:express] Isolation scope is still default isolation scope - skipping transaction name',\n        );\n    }\n  }\n\n  // Honor `ignoreLayers`/`ignoreLayersType`: skip the span for matching layers.\n  // We intentionally do NOT pop the pushed path here (unlike OTel Express, which\n  // pops on ignore): the path is still popped on `asyncStart` when the layer\n  // calls `next`, so a following sibling isn't polluted, while an ignored\n  // *router* keeps its mount prefix on the stack for the sub-stack it dispatches\n  // — so routes under an ignored router stay correct. The only entries that\n  // never pop come from layers that end the response without `next()`, and those\n  // sit on a per-request store that is discarded when the request ends.\n  if (isLayerIgnored(name, type, options)) {\n    return undefined;\n  }\n\n  const span = startInactiveSpan({\n    name,\n    attributes: {\n      [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: ORIGIN,\n      [SEMANTIC_ATTRIBUTE_SENTRY_OP]: `${type}.express`,\n      [ATTR_EXPRESS_NAME]: name,\n      [ATTR_EXPRESS_TYPE]: type,\n      ...(matchedRoute ? { [HTTP_ROUTE]: matchedRoute } : {}),\n    },\n  });\n\n  // A layer that sends the response (route handlers, typically) never calls\n  // `next`, so the channel's `asyncEnd` never fires. End on the response's\n  // `finish` in that case. When `next` *is* called, the helper ends the span\n  // (via `asyncEnd`) and `beforeSpanEnd` removes this now-redundant listener.\n  if (res && typeof res.once === 'function') {\n    const onFinish = (): void => {\n      span.end();\n    };\n    res.once('finish', onFinish);\n    data._sentryCleanup = () => res.removeListener('finish', onFinish);\n  }\n\n  return span;\n}\n\nfunction getLayerType(layer: ExpressLayer): ExpressLayerType {\n  if (layer.name === 'router') {\n    return 'router';\n  }\n  // `bound dispatch` (v4) / `handle` — the route-dispatch layer created by `router.route()`.\n  if (layer.name === 'bound dispatch' || layer.name === 'handle') {\n    return 'request_handler';\n  }\n  return 'middleware';\n}\n\n/**\n * Propagate the resolved route to the root `http.server` span so the\n * transaction gets a parameterized `http.route`. Mirrors `@sentry/node`'s\n * `setHttpServerSpanRouteAttribute`; inlined to keep this package free of\n * `@sentry/node` deps. No-op unless the root span is an `http.server` span.\n */\nfunction setHttpServerSpanRoute(route: string): void {\n  const activeSpan = getActiveSpan();\n  const rootSpan = activeSpan && getRootSpan(activeSpan);\n  if (!rootSpan) {\n    return;\n  }\n  if (spanToJSON(rootSpan).data[SEMANTIC_ATTRIBUTE_SENTRY_OP] !== 'http.server') {\n    return;\n  }\n  rootSpan.setAttribute(HTTP_ROUTE, route);\n}\n\n/**\n * Whether a layer should be skipped per the `ignoreLayers`/`ignoreLayersType`\n * options. Matches `@sentry/core`'s Express `isLayerIgnored`: `ignoreLayersType`\n * filters by layer type, `ignoreLayers` matches the layer's name against\n * string/RegExp/predicate patterns (exact string match).\n */\nfunction isLayerIgnored(name: string, type: ExpressLayerType, options: ExpressIntegrationOptions): boolean {\n  const { ignoreLayers, ignoreLayersType } = options;\n\n  if (Array.isArray(ignoreLayersType) && ignoreLayersType.includes(type)) {\n    return true;\n  }\n\n  if (!Array.isArray(ignoreLayers)) {\n    return false;\n  }\n\n  try {\n    return stringMatchesSomePattern(name, ignoreLayers, true);\n  } catch {\n    return false;\n  }\n}\n"],"names":[],"mappings":"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"}

package/build/esm/integrations/tracing-channel/express/route.js

@@ -0,0 +1,68 @@
+const layerRegisteredPaths = /* @__PURE__ */ new WeakMap();
+function setLayerRegisteredPath(layer, path) {
+  layerRegisteredPaths.set(layer, path);
+}
+function getLayerRegisteredPath(layer) {
+  return layerRegisteredPaths.get(layer);
+}
+const requestLayerPaths = /* @__PURE__ */ new WeakMap();
+function getStore(req) {
+  let store = requestLayerPaths.get(req);
+  if (!store) {
+    store = [];
+    requestLayerPaths.set(req, store);
+  }
+  return store;
+}
+function pushLayerPath(req, path) {
+  getStore(req).push(path);
+}
+function popLayerPath(req) {
+  getStore(req).pop();
+}
+function getLayerPath(args) {
+  const firstArg = args[0];
+  if (Array.isArray(firstArg)) {
+    return firstArg.map((segment) => extractLayerPathSegment(segment) ?? "").join(",");
+  }
+  return extractLayerPathSegment(firstArg);
+}
+function extractLayerPathSegment(segment) {
+  return typeof segment === "string" ? segment : segment instanceof RegExp || typeof segment === "number" ? String(segment) : void 0;
+}
+function getConstructedRoute(req) {
+  const layersStore = getStore(req);
+  let constructedRoute = "";
+  for (const path of layersStore) {
+    if (path === "/" || path === "/*") {
+      continue;
+    }
+    constructedRoute += !constructedRoute || constructedRoute.endsWith("/") ? path : `/${path}`;
+  }
+  return constructedRoute.replace(/\/{2,}/g, "/");
+}
+function getActualMatchedRoute(req, constructedRoute) {
+  const layersStore = getStore(req);
+  if (layersStore.length === 0) {
+    return void 0;
+  }
+  const originalUrl = typeof req.originalUrl === "string" ? req.originalUrl : "";
+  if (layersStore.every((path) => path === "/")) {
+    return originalUrl === "/" ? "/" : void 0;
+  }
+  if (constructedRoute === "*") {
+    return constructedRoute;
+  }
+  if (constructedRoute.includes("/") && (constructedRoute.includes(",") || constructedRoute.includes("\\") || constructedRoute.includes("*") || constructedRoute.includes("["))) {
+    return constructedRoute;
+  }
+  const normalizedRoute = constructedRoute.startsWith("/") ? constructedRoute : `/${constructedRoute}`;
+  const isValidRoute = normalizedRoute.length > 0 && (originalUrl === normalizedRoute || originalUrl.startsWith(normalizedRoute) || isRoutePattern(normalizedRoute));
+  return isValidRoute ? normalizedRoute : void 0;
+}
+function isRoutePattern(route) {
+  return route.includes(":") || route.includes("*");
+}
+
+export { getActualMatchedRoute, getConstructedRoute, getLayerPath, getLayerRegisteredPath, popLayerPath, pushLayerPath, setLayerRegisteredPath };
+//# sourceMappingURL=route.js.map

package/build/esm/integrations/tracing-channel/express/route.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.js","sources":["../../../../../src/integrations/tracing-channel/express/route.ts"],"sourcesContent":["import type { ExpressLayer, ExpressRequest } from './types';\n\n/**\n * Registered path *pattern* per routing `Layer`, captured when the layer is\n * registered via `Router.prototype.route`/`.use`. `undefined` means the layer\n * was registered without an explicit path (e.g. `app.use(mw)`), so it does not\n * contribute to the reconstructed route.\n *\n * This is the piece `req.baseUrl` can't provide: at request time `req.baseUrl`\n * holds the *resolved* mount prefix (`/api/v1`), whereas we want the registered\n * pattern (`/api/:version`).\n */\nconst layerRegisteredPaths = new WeakMap<ExpressLayer, string | undefined>();\n\n/** Record the path pattern a layer was registered with. */\nexport function setLayerRegisteredPath(layer: ExpressLayer, path: string | undefined): void {\n  layerRegisteredPaths.set(layer, path);\n}\n\n/** Read the path pattern a layer was registered with, if any. */\nexport function getLayerRegisteredPath(layer: ExpressLayer): string | undefined {\n  return layerRegisteredPaths.get(layer);\n}\n\n/**\n * Per-request ordered stack of the registered path patterns of the layers\n * currently on the matched chain. Layers push on entry and pop when they hand\n * off via `next`, so at any point it reflects the path from the app root down\n * to the currently-executing layer. `WeakMap` so entries are released with the\n * request.\n */\nconst requestLayerPaths = new WeakMap<ExpressRequest, string[]>();\n\nfunction getStore(req: ExpressRequest): string[] {\n  let store = requestLayerPaths.get(req);\n  if (!store) {\n    store = [];\n    requestLayerPaths.set(req, store);\n  }\n  return store;\n}\n\n/** Push a layer's registered path onto the request's chain. */\nexport function pushLayerPath(req: ExpressRequest, path: string): void {\n  getStore(req).push(path);\n}\n\n/** Pop the most recently pushed layer path off the request's chain. */\nexport function popLayerPath(req: ExpressRequest): void {\n  getStore(req).pop();\n}\n\n/**\n * The path pattern a `route`/`use` call registered, derived from its arguments.\n * A leading string/RegExp/number path becomes the pattern (arrays are joined\n * with `,`); a bare handler function yields `undefined`. Kept in sync with\n * `@sentry/core`'s Express `getLayerPath`.\n */\nexport function getLayerPath(args: unknown[]): string | undefined {\n  const firstArg = args[0];\n  if (Array.isArray(firstArg)) {\n    return firstArg.map(segment => extractLayerPathSegment(segment) ?? '').join(',');\n  }\n  return extractLayerPathSegment(firstArg);\n}\n\nfunction extractLayerPathSegment(segment: unknown): string | undefined {\n  return typeof segment === 'string'\n    ? segment\n    : segment instanceof RegExp || typeof segment === 'number'\n      ? String(segment)\n      : undefined;\n}\n\n/**\n * Concatenate the stored layer paths into the full route pattern (parameters\n * preserved), e.g. `/api/:version/user`. Mirrors `@sentry/core`.\n */\nexport function getConstructedRoute(req: ExpressRequest): string {\n  const layersStore = getStore(req);\n\n  let constructedRoute = '';\n  for (const path of layersStore) {\n    if (path === '/' || path === '/*') {\n      continue;\n    }\n    constructedRoute += !constructedRoute || constructedRoute.endsWith('/') ? path : `/${path}`;\n  }\n\n  return constructedRoute.replace(/\\/{2,}/g, '/');\n}\n\n/**\n * Validate the constructed route against the request URL, returning it only\n * when it plausibly corresponds to a real match (otherwise `undefined`). Mirrors\n * `@sentry/core`'s `getActualMatchedRoute` — used for the `http.route` attribute.\n */\nexport function getActualMatchedRoute(req: ExpressRequest, constructedRoute: string): string | undefined {\n  const layersStore = getStore(req);\n\n  if (layersStore.length === 0) {\n    return undefined;\n  }\n\n  const originalUrl = typeof req.originalUrl === 'string' ? req.originalUrl : '';\n\n  // The layer store also includes root paths in case a non-existing url was requested.\n  if (layersStore.every(path => path === '/')) {\n    return originalUrl === '/' ? '/' : undefined;\n  }\n\n  if (constructedRoute === '*') {\n    return constructedRoute;\n  }\n\n  // For RegExp routes or route arrays, return the constructed route as-is.\n  if (\n    constructedRoute.includes('/') &&\n    (constructedRoute.includes(',') ||\n      constructedRoute.includes('\\\\') ||\n      constructedRoute.includes('*') ||\n      constructedRoute.includes('['))\n  ) {\n    return constructedRoute;\n  }\n\n  const normalizedRoute = constructedRoute.startsWith('/') ? constructedRoute : `/${constructedRoute}`;\n\n  const isValidRoute =\n    normalizedRoute.length > 0 &&\n    (originalUrl === normalizedRoute || originalUrl.startsWith(normalizedRoute) || isRoutePattern(normalizedRoute));\n\n  return isValidRoute ? normalizedRoute : undefined;\n}\n\n/** Whether a route contains parameter/wildcard patterns (`:id`, `*`). */\nfunction isRoutePattern(route: string): boolean {\n  return route.includes(':') || route.includes('*');\n}\n"],"names":[],"mappings":"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"}

package/build/esm/integrations/tracing-channel/fastify/errors.js

@@ -0,0 +1,39 @@
+import * as diagnosticsChannel from 'node:diagnostics_channel';
+import { DEBUG_BUILD } from '../../../debug-build.js';
+import { debug, captureException, getClient } from '@sentry/core';
+import { defaultShouldHandleError, INTEGRATION_NAME } from './utils.js';
+
+function getFastifyIntegration() {
+  const client = getClient();
+  return client?.getIntegrationByName(INTEGRATION_NAME);
+}
+function subscribeToFastifyErrorChannel() {
+  diagnosticsChannel.subscribe("tracing:fastify.request.handler:error", (message) => {
+    const { error, request, reply } = message;
+    handleFastifyError.call(handleFastifyError, error, request, reply, "diagnostics-channel");
+  });
+}
+function handleFastifyError(error, request, reply, handlerOrigin) {
+  const shouldHandleError = getFastifyIntegration()?.getShouldHandleError() || defaultShouldHandleError;
+  if (handlerOrigin === "diagnostics-channel") {
+    this.diagnosticsChannelExists = true;
+  }
+  if (this.diagnosticsChannelExists && handlerOrigin === "onError-hook") {
+    DEBUG_BUILD && debug.warn(
+      "Fastify error handler was already registered via diagnostics channel.",
+      "You can safely remove `setupFastifyErrorHandler` call and set `shouldHandleError` on the integration options."
+    );
+    return;
+  }
+  if (shouldHandleError(error, request, reply)) {
+    captureException(error, {
+      mechanism: {
+        handled: false,
+        type: "auto.function.fastify"
+      }
+    });
+  }
+}
+
+export { handleFastifyError, subscribeToFastifyErrorChannel };
+//# sourceMappingURL=errors.js.map

package/build/esm/integrations/tracing-channel/fastify/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sources":["../../../../../src/integrations/tracing-channel/fastify/errors.ts"],"sourcesContent":["import type { FastifyIntegration, FastifyReply, FastifyRequest } from './types';\nimport * as diagnosticsChannel from 'node:diagnostics_channel';\nimport { DEBUG_BUILD } from '../../../debug-build';\nimport { getClient, debug, captureException } from '@sentry/core';\nimport { defaultShouldHandleError, INTEGRATION_NAME } from './utils';\n\nfunction getFastifyIntegration(): FastifyIntegration | undefined {\n  const client = getClient();\n  return client?.getIntegrationByName(INTEGRATION_NAME);\n}\n\n/**\n * Subscribe to the Fastify v5 error diagnostics channel.\n */\nexport function subscribeToFastifyErrorChannel(): void {\n  diagnosticsChannel.subscribe('tracing:fastify.request.handler:error', message => {\n    const { error, request, reply } = message as {\n      error: Error;\n      request: FastifyRequest;\n      reply: FastifyReply;\n    };\n\n    handleFastifyError.call(handleFastifyError, error, request, reply, 'diagnostics-channel');\n  });\n}\n\n/**\n * Handle a Fastify error, and possibly send it to Sentry.\n */\nexport function handleFastifyError(\n  this: {\n    diagnosticsChannelExists?: boolean;\n  },\n  error: Error,\n  request: FastifyRequest,\n  reply: FastifyReply,\n  handlerOrigin: 'diagnostics-channel' | 'onError-hook',\n): void {\n  const shouldHandleError = getFastifyIntegration()?.getShouldHandleError() || defaultShouldHandleError;\n  // Diagnostics channel runs before the onError hook, so we can use it to check if the handler was already registered\n  if (handlerOrigin === 'diagnostics-channel') {\n    this.diagnosticsChannelExists = true;\n  }\n\n  if (this.diagnosticsChannelExists && handlerOrigin === 'onError-hook') {\n    DEBUG_BUILD &&\n      debug.warn(\n        'Fastify error handler was already registered via diagnostics channel.',\n        'You can safely remove `setupFastifyErrorHandler` call and set `shouldHandleError` on the integration options.',\n      );\n\n    // If the diagnostics channel already exists, we don't need to handle the error again\n    return;\n  }\n\n  if (shouldHandleError(error, request, reply)) {\n    captureException(error, {\n      mechanism: {\n        handled: false,\n        type: 'auto.function.fastify',\n      },\n    });\n  }\n}\n"],"names":[],"mappings":";;;;;AAMA,SAAS,qBAAA,GAAwD;AAC/D,EAAA,MAAM,SAAS,SAAA,EAAU;AACzB,EAAA,OAAO,MAAA,EAAQ,qBAAqB,gBAAgB,CAAA;AACtD;AAKO,SAAS,8BAAA,GAAuC;AACrD,EAAA,kBAAA,CAAmB,SAAA,CAAU,yCAAyC,CAAA,OAAA,KAAW;AAC/E,IAAA,MAAM,EAAE,KAAA,EAAO,OAAA,EAAS,KAAA,EAAM,GAAI,OAAA;AAMlC,IAAA,kBAAA,CAAmB,IAAA,CAAK,kBAAA,EAAoB,KAAA,EAAO,OAAA,EAAS,OAAO,qBAAqB,CAAA;AAAA,EAC1F,CAAC,CAAA;AACH;AAKO,SAAS,kBAAA,CAId,KAAA,EACA,OAAA,EACA,KAAA,EACA,aAAA,EACM;AACN,EAAA,MAAM,iBAAA,GAAoB,qBAAA,EAAsB,EAAG,oBAAA,EAAqB,IAAK,wBAAA;AAE7E,EAAA,IAAI,kBAAkB,qBAAA,EAAuB;AAC3C,IAAA,IAAA,CAAK,wBAAA,GAA2B,IAAA;AAAA,EAClC;AAEA,EAAA,IAAI,IAAA,CAAK,wBAAA,IAA4B,aAAA,KAAkB,cAAA,EAAgB;AACrE,IAAA,WAAA,IACE,KAAA,CAAM,IAAA;AAAA,MACJ,uEAAA;AAAA,MACA;AAAA,KACF;AAGF,IAAA;AAAA,EACF;AAEA,EAAA,IAAI,iBAAA,CAAkB,KAAA,EAAO,OAAA,EAAS,KAAK,CAAA,EAAG;AAC5C,IAAA,gBAAA,CAAiB,KAAA,EAAO;AAAA,MACtB,SAAA,EAAW;AAAA,QACT,OAAA,EAAS,KAAA;AAAA,QACT,IAAA,EAAM;AAAA;AACR,KACD,CAAA;AAAA,EACH;AACF;;;;"}

package/build/esm/integrations/tracing-channel/fastify/index.js

@@ -0,0 +1,30 @@
+import { defineIntegration } from '@sentry/core';
+import { instrumentFastify as instrumentFastify$1 } from './instrumentation.js';
+import { INTEGRATION_NAME, defaultShouldHandleError } from './utils.js';
+import { subscribeToFastifyErrorChannel, handleFastifyError as handleFastifyError$1 } from './errors.js';
+
+const _fastifyIntegration = (({ shouldHandleError }) => {
+  let _shouldHandleError;
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      _shouldHandleError = shouldHandleError || defaultShouldHandleError;
+      subscribeToFastifyErrorChannel();
+      instrumentFastify$1();
+    },
+    getShouldHandleError() {
+      return _shouldHandleError;
+    },
+    setShouldHandleError(shouldHandleError2) {
+      _shouldHandleError = shouldHandleError2;
+    }
+  };
+});
+const fastifyIntegration = defineIntegration(
+  (options = {}) => _fastifyIntegration(options)
+);
+const instrumentFastify = instrumentFastify$1;
+const handleFastifyError = handleFastifyError$1;
+
+export { fastifyIntegration, handleFastifyError, instrumentFastify };
+//# sourceMappingURL=index.js.map

package/build/esm/integrations/tracing-channel/fastify/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../src/integrations/tracing-channel/fastify/index.ts"],"sourcesContent":["import type { IntegrationFn } from '@sentry/core';\nimport { defineIntegration } from '@sentry/core';\nimport type { FastifyIntegration, FastifyReply, FastifyRequest } from './types';\n\nimport { instrumentFastify as _instrumentFastify } from './instrumentation';\nimport { defaultShouldHandleError, INTEGRATION_NAME } from './utils';\nimport { subscribeToFastifyErrorChannel, handleFastifyError as _handleFastifyError } from './errors';\n\n/**\n * Options for the Fastify integration.\n *\n * `shouldHandleError` - Callback method deciding whether error should be captured and sent to Sentry\n * This is used on Fastify v5 where Sentry handles errors in the diagnostics channel.\n * Fastify v3 and v4 use `setupFastifyErrorHandler` instead.\n *\n * @example\n *\n * ```javascript\n * Sentry.init({\n *   integrations: [\n *     Sentry.fastifyIntegration({\n *       shouldHandleError(_error, _request, reply) {\n *         return reply.statusCode >= 500;\n *       },\n *     });\n *   },\n * });\n * ```\n *\n */\ninterface FastifyIntegrationOptions {\n  /**\n   * Callback method deciding whether error should be captured and sent to Sentry\n   * This is used on Fastify v5 where Sentry handles errors in the diagnostics channel.\n   * Fastify v3 and v4 use `setupFastifyErrorHandler` instead.\n   *\n   * @param error Captured Fastify error\n   * @param request Fastify request (or any object containing at least method, routeOptions.url, and routerPath)\n   * @param reply Fastify reply (or any object containing at least statusCode)\n   */\n  shouldHandleError: (error: Error, request: FastifyRequest, reply: FastifyReply) => boolean;\n}\n\nconst _fastifyIntegration = (({ shouldHandleError }: Partial<FastifyIntegrationOptions>) => {\n  let _shouldHandleError: (error: Error, request: FastifyRequest, reply: FastifyReply) => boolean;\n\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      _shouldHandleError = shouldHandleError || defaultShouldHandleError;\n\n      subscribeToFastifyErrorChannel();\n      _instrumentFastify();\n    },\n    getShouldHandleError() {\n      return _shouldHandleError;\n    },\n    setShouldHandleError(shouldHandleError: (error: Error, request: FastifyRequest, reply: FastifyReply) => boolean) {\n      _shouldHandleError = shouldHandleError;\n    },\n  } satisfies FastifyIntegration;\n}) satisfies IntegrationFn;\n\n/**\n * Adds Sentry tracing instrumentation for [Fastify](https://fastify.dev/).\n * This integration supports Fastify v5 only.\n *\n * For more information, see the [fastify documentation](https://docs.sentry.io/platforms/javascript/guides/fastify/).\n *\n * @example\n * ```javascript\n * const Sentry = require('@sentry/node');\n *\n * Sentry.init({\n *   integrations: [Sentry.fastifyIntegration()],\n * })\n * ```\n */\nexport const fastifyIntegration = defineIntegration((options: Partial<FastifyIntegrationOptions> = {}) =>\n  _fastifyIntegration(options),\n);\n\n/**\n * @deprecated This export is deprecated and will not longer be exposed in the next major version.\n */\nexport const instrumentFastify = _instrumentFastify;\n\n/**\n * @deprecated This export is deprecated and will not longer be exposed in the next major version.\n */\nexport const handleFastifyError = _handleFastifyError;\n"],"names":["_instrumentFastify","shouldHandleError","_handleFastifyError"],"mappings":";;;;;AA2CA,MAAM,mBAAA,IAAuB,CAAC,EAAE,iBAAA,EAAkB,KAA0C;AAC1F,EAAA,IAAI,kBAAA;AAEJ,EAAA,OAAO;AAAA,IACL,IAAA,EAAM,gBAAA;AAAA,IACN,SAAA,GAAY;AACV,MAAA,kBAAA,GAAqB,iBAAA,IAAqB,wBAAA;AAE1C,MAAA,8BAAA,EAA+B;AAC/B,MAAAA,mBAAA,EAAmB;AAAA,IACrB,CAAA;AAAA,IACA,oBAAA,GAAuB;AACrB,MAAA,OAAO,kBAAA;AAAA,IACT,CAAA;AAAA,IACA,qBAAqBC,kBAAAA,EAA4F;AAC/G,MAAA,kBAAA,GAAqBA,kBAAAA;AAAA,IACvB;AAAA,GACF;AACF,CAAA,CAAA;AAiBO,MAAM,kBAAA,GAAqB,iBAAA;AAAA,EAAkB,CAAC,OAAA,GAA8C,EAAC,KAClG,oBAAoB,OAAO;AAC7B;AAKO,MAAM,iBAAA,GAAoBD;AAK1B,MAAM,kBAAA,GAAqBE;;;;"}

package/build/esm/integrations/tracing-channel/fastify/instrumentation.js

@@ -0,0 +1,277 @@
+import * as diagnosticsChannel from 'node:diagnostics_channel';
+import { HTTP_ROUTE, URL_PATH, HTTP_REQUEST_METHOD, HTTP_RESPONSE_STATUS_CODE } from '@sentry/conventions/attributes';
+import { debug, getIsolationScope, getActiveSpan, getRootSpan, spanToJSON, SEMANTIC_ATTRIBUTE_SENTRY_OP, startInactiveSpan, withActiveSpan, startSpan, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, isObjectLike, SPAN_STATUS_ERROR } from '@sentry/core';
+import { DEBUG_BUILD } from '../../../debug-build.js';
+
+const PACKAGE_NAME = "@sentry/instrumentation-fastify";
+const SUPPORTED_VERSIONS = ">=3.21.0 <6";
+const ORIGIN = "auto.http.otel.fastify";
+const HOOK_OP = "hook.fastify";
+const REQUEST_HANDLER_OP = "request_handler.fastify";
+const FASTIFY_HOOKS = [
+  "onRequest",
+  "preParsing",
+  "preValidation",
+  "preHandler",
+  "preSerialization",
+  "onSend",
+  "onResponse",
+  "onError"
+];
+const ATTRIBUTE_HOOK_NAME = "hook.name";
+const ATTRIBUTE_FASTIFY_TYPE = "fastify.type";
+const ATTRIBUTE_HOOK_CALLBACK_NAME = "hook.callback.name";
+const ATTRIBUTE_FASTIFY_ROOT = "fastify.root";
+const HOOK_TYPE_ROUTE = "route-hook";
+const HOOK_TYPE_INSTANCE = "hook";
+const HOOK_TYPE_HANDLER = "request-handler";
+const ANONYMOUS_FUNCTION_NAME = "anonymous";
+const kRequestSpan = /* @__PURE__ */ Symbol("sentry fastify request span");
+const kAddHookOriginal = /* @__PURE__ */ Symbol("sentry fastify addHook original");
+const kSetNotFoundOriginal = /* @__PURE__ */ Symbol("sentry fastify setNotFoundHandler original");
+function getRequestRouteUrl(request) {
+  return request.routeOptions?.url ?? request.routerPath;
+}
+function getRequestRouteConfig(request) {
+  return request.routeOptions?.config ?? request.routeConfig;
+}
+function isFastifyRequest(arg) {
+  return isObjectLike(arg) && !!arg.method && !!arg.url && (!!arg.routeOptions || "routerPath" in arg);
+}
+function fastifyOtelPlugin(instance, _opts, done) {
+  instance.decorate(kAddHookOriginal, instance.addHook);
+  instance.decorate(kSetNotFoundOriginal, instance.setNotFoundHandler);
+  instance.decorateRequest("opentelemetry", function opentelemetry() {
+    return { span: this[kRequestSpan] };
+  });
+  instance.decorateRequest(kRequestSpan, null);
+  instance.addHook("onRoute", otelWireRoute);
+  instance.addHook("onRequest", startRequestSpanHook);
+  instance.addHook("onResponse", finalizeNotFoundSpanHook);
+  instance.addHook = addHookPatched;
+  instance.setNotFoundHandler = setNotFoundHandlerPatched;
+  done();
+}
+const pluginSymbols = fastifyOtelPlugin;
+pluginSymbols[/* @__PURE__ */ Symbol.for("skip-override")] = true;
+pluginSymbols[/* @__PURE__ */ Symbol.for("fastify.display-name")] = PACKAGE_NAME;
+pluginSymbols[/* @__PURE__ */ Symbol.for("plugin-meta")] = {
+  fastify: SUPPORTED_VERSIONS,
+  name: PACKAGE_NAME
+};
+function otelWireRoute(routeOptions) {
+  if (routeOptions.config?.otel === false) {
+    return;
+  }
+  for (const hook of FASTIFY_HOOKS) {
+    const handlerLike = routeOptions[hook];
+    if (typeof handlerLike === "function") {
+      routeOptions[hook] = handlerWrapper(
+        handlerLike,
+        hook,
+        routeHookAttributes(this.pluginName, hook, handlerLike, routeOptions.url)
+      );
+    } else if (Array.isArray(handlerLike)) {
+      routeOptions[hook] = handlerLike.map(
+        (handler) => handlerWrapper(handler, hook, routeHookAttributes(this.pluginName, hook, handler, routeOptions.url))
+      );
+    }
+  }
+  routeOptions.onSend = appendRouteHook(routeOptions.onSend, finalizeResponseSpanHook);
+  routeOptions.onError = appendRouteHook(routeOptions.onError, recordErrorInSpanHook);
+  routeOptions.handler = handlerWrapper(routeOptions.handler, "handler", {
+    [ATTRIBUTE_HOOK_NAME]: `${this.pluginName} - route-handler`,
+    [ATTRIBUTE_FASTIFY_TYPE]: HOOK_TYPE_HANDLER,
+    [HTTP_ROUTE]: routeOptions.url,
+    [ATTRIBUTE_HOOK_CALLBACK_NAME]: routeOptions.handler.name.length > 0 ? routeOptions.handler.name : ANONYMOUS_FUNCTION_NAME
+  });
+}
+function routeHookAttributes(pluginName, hook, handler, url) {
+  return {
+    [ATTRIBUTE_HOOK_NAME]: `${pluginName} - route -> ${hook}`,
+    [ATTRIBUTE_FASTIFY_TYPE]: HOOK_TYPE_ROUTE,
+    [HTTP_ROUTE]: url,
+    [ATTRIBUTE_HOOK_CALLBACK_NAME]: handler.name?.length > 0 ? handler.name : ANONYMOUS_FUNCTION_NAME
+  };
+}
+function appendRouteHook(existing, hook) {
+  if (existing == null) {
+    return hook;
+  }
+  return Array.isArray(existing) ? [...existing, hook] : [existing, hook];
+}
+function startRequestSpanHook(request, _reply, hookDone) {
+  if (getRequestRouteConfig(request)?.otel === false) {
+    return hookDone();
+  }
+  const attributes = {
+    [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: ORIGIN,
+    [ATTRIBUTE_FASTIFY_ROOT]: PACKAGE_NAME,
+    [HTTP_REQUEST_METHOD]: request.method,
+    [URL_PATH]: request.url
+  };
+  const route = getRequestRouteUrl(request);
+  if (route != null) {
+    attributes[HTTP_ROUTE] = route;
+    const activeSpan = getActiveSpan();
+    const rootSpan = activeSpan && getRootSpan(activeSpan);
+    if (rootSpan && spanToJSON(rootSpan).data[SEMANTIC_ATTRIBUTE_SENTRY_OP] === "http.server") {
+      rootSpan.setAttribute(HTTP_ROUTE, route);
+    }
+  }
+  const requestSpan = startInactiveSpan({ name: "request", op: REQUEST_HANDLER_OP, attributes });
+  request[kRequestSpan] = requestSpan;
+  withActiveSpan(requestSpan, () => {
+    hookDone();
+  });
+}
+function finalizeNotFoundSpanHook(request, reply, hookDone) {
+  const span = request[kRequestSpan];
+  if (span != null) {
+    span.setAttributes({ [HTTP_RESPONSE_STATUS_CODE]: reply.statusCode });
+    span.end();
+  }
+  request[kRequestSpan] = null;
+  hookDone();
+}
+function finalizeResponseSpanHook(request, reply, payload, hookDone) {
+  const span = request[kRequestSpan];
+  if (span != null) {
+    if (reply.statusCode >= 500) {
+      span.setStatus({ code: SPAN_STATUS_ERROR });
+    }
+    span.setAttributes({ [HTTP_RESPONSE_STATUS_CODE]: reply.statusCode });
+    span.end();
+  }
+  request[kRequestSpan] = null;
+  hookDone(null, payload);
+}
+function recordErrorInSpanHook(request, _reply, error, hookDone) {
+  const span = request[kRequestSpan];
+  if (span != null) {
+    span.setStatus({ code: SPAN_STATUS_ERROR, message: error.message });
+  }
+  hookDone();
+}
+function addHookPatched(name, hook) {
+  const addHookOriginal = this[kAddHookOriginal];
+  if (FASTIFY_HOOKS.includes(name)) {
+    return addHookOriginal.call(
+      this,
+      name,
+      handlerWrapper(hook, name, {
+        [ATTRIBUTE_HOOK_NAME]: `${this.pluginName} - ${name}`,
+        [ATTRIBUTE_FASTIFY_TYPE]: HOOK_TYPE_INSTANCE,
+        [ATTRIBUTE_HOOK_CALLBACK_NAME]: hook.name?.length > 0 ? hook.name : ANONYMOUS_FUNCTION_NAME
+      })
+    );
+  }
+  return addHookOriginal.call(this, name, hook);
+}
+function setNotFoundHandlerPatched(hooks, handler) {
+  const setNotFoundHandlerOriginal = this[kSetNotFoundOriginal];
+  if (typeof hooks === "function") {
+    setNotFoundHandlerOriginal.call(
+      this,
+      handlerWrapper(hooks, "notFoundHandler", {
+        [ATTRIBUTE_HOOK_NAME]: `${this.pluginName} - not-found-handler`,
+        [ATTRIBUTE_FASTIFY_TYPE]: HOOK_TYPE_INSTANCE,
+        [ATTRIBUTE_HOOK_CALLBACK_NAME]: hooks.name?.length > 0 ? hooks.name : ANONYMOUS_FUNCTION_NAME
+      })
+    );
+    return;
+  }
+  if (hooks.preValidation != null) {
+    hooks.preValidation = handlerWrapper(hooks.preValidation, "notFoundHandler - preValidation", {
+      [ATTRIBUTE_HOOK_NAME]: `${this.pluginName} - not-found-handler - preValidation`,
+      [ATTRIBUTE_FASTIFY_TYPE]: HOOK_TYPE_INSTANCE,
+      [ATTRIBUTE_HOOK_CALLBACK_NAME]: hooks.preValidation.name?.length > 0 ? hooks.preValidation.name : ANONYMOUS_FUNCTION_NAME
+    });
+  }
+  if (hooks.preHandler != null) {
+    hooks.preHandler = handlerWrapper(hooks.preHandler, "notFoundHandler - preHandler", {
+      [ATTRIBUTE_HOOK_NAME]: `${this.pluginName} - not-found-handler - preHandler`,
+      [ATTRIBUTE_FASTIFY_TYPE]: HOOK_TYPE_INSTANCE,
+      [ATTRIBUTE_HOOK_CALLBACK_NAME]: hooks.preHandler.name?.length > 0 ? hooks.preHandler.name : ANONYMOUS_FUNCTION_NAME
+    });
+  }
+  if (handler == null) {
+    setNotFoundHandlerOriginal.call(this, hooks);
+    return;
+  }
+  setNotFoundHandlerOriginal.call(
+    this,
+    hooks,
+    handlerWrapper(handler, "notFoundHandler", {
+      [ATTRIBUTE_HOOK_NAME]: `${this.pluginName} - not-found-handler`,
+      [ATTRIBUTE_FASTIFY_TYPE]: HOOK_TYPE_INSTANCE,
+      [ATTRIBUTE_HOOK_CALLBACK_NAME]: handler.name?.length > 0 ? handler.name : ANONYMOUS_FUNCTION_NAME
+    })
+  );
+}
+function getRequestFromArgs(args) {
+  for (const arg of args) {
+    if (isFastifyRequest(arg)) {
+      return arg;
+    }
+  }
+  return null;
+}
+function handlerWrapper(handler, hookName, spanAttributes = {}) {
+  return function handlerWrapped(...args) {
+    const request = getRequestFromArgs(args);
+    if (request === null || getRequestRouteConfig(request)?.otel === false) {
+      return handler.call(this, ...args);
+    }
+    const parentSpan = request[kRequestSpan] ?? void 0;
+    const handlerName = handler.name?.length > 0 ? handler.name : this.pluginName ?? ANONYMOUS_FUNCTION_NAME;
+    const hookType = spanAttributes[ATTRIBUTE_FASTIFY_TYPE];
+    const op = hookType === HOOK_TYPE_INSTANCE ? HOOK_OP : hookType === HOOK_TYPE_HANDLER ? REQUEST_HANDLER_OP : void 0;
+    const name = op ? stripFastifyPrefix(spanAttributes[ATTRIBUTE_HOOK_NAME]) : `${hookName} - ${handlerName}`;
+    return startSpan(
+      {
+        name,
+        op,
+        attributes: {
+          ...spanAttributes,
+          [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: ORIGIN
+        },
+        parentSpan
+      },
+      () => handler.call(this, ...args)
+    );
+  };
+}
+function stripFastifyPrefix(hookName = "") {
+  return hookName.replace(/^fastify -> /, "").replace(/^@fastify\/otel -> /, "").replace(/^@sentry\/instrumentation-fastify -> /, "");
+}
+function instrumentOnRequest(fastify) {
+  fastify.addHook("onRequest", async (request, _reply) => {
+    const routeName = getRequestRouteUrl(request);
+    const method = request.method || "GET";
+    getIsolationScope().setTransactionName(`${method} ${routeName}`);
+  });
+}
+let _isInstrumented = false;
+const instrumentFastify = Object.assign(
+  function instrumentFastify2() {
+    if (_isInstrumented) {
+      return;
+    }
+    _isInstrumented = true;
+    diagnosticsChannel.subscribe("fastify.initialization", (message) => {
+      const fastifyInstance = message.fastify;
+      fastifyInstance?.register(fastifyOtelPlugin).after((err) => {
+        if (err) {
+          DEBUG_BUILD && debug.error("Failed to setup Fastify instrumentation", err);
+        } else if (fastifyInstance) {
+          instrumentOnRequest(fastifyInstance);
+        }
+      });
+    });
+  },
+  { id: "Fastify.v5" }
+);
+
+export { instrumentFastify };
+//# sourceMappingURL=instrumentation.js.map