feat(bun): Support new Bun.serve APIs (#16035)

Supercedes #15978

resolves #15941
resolves #15827
resolves #15816

Bun recently updated their `Bun.serve` API with new functionality, which
unfortunately broke our existing instrumentation. This is detailed with
https://bun.sh/docs/api/http#bun-serve. Specifically, they added a new
routing API that looks like so:

```ts
Bun.serve({
  // `routes` requires Bun v1.2.3+
  routes: {
    // Dynamic routes
    "/users/:id": req => {
      return new Response(`Hello User ${req.params.id}!`);
    },

    // Per-HTTP method handlers
    "/api/posts": {
      GET: () => new Response("List posts"),
      POST: async req => {
        const body = await req.json();
        return Response.json({ created: true, ...body });
      },
    },

    // Wildcard route for all routes that start with "/api/" and aren't otherwise matched
    "/api/*": Response.json({ message: "Not found" }, { status: 404 }),

    // Redirect from /blog/hello to /blog/hello/world
    "/blog/hello": Response.redirect("/blog/hello/world"),

    // Serve a file by buffering it in memory
    "/favicon.ico": new Response(await Bun.file("./favicon.ico").bytes(), {
      headers: {
        "Content-Type": "image/x-icon",
      },
    }),
  },

  // (optional) fallback for unmatched routes:
  // Required if Bun's version < 1.2.3
  fetch(req) {
    return new Response("Not Found", { status: 404 });
  },
});
``` 

Because there are now dynamic routes and wildcard routes, we can
actually generate `route` transaction source and send parameterized
routes to Sentry. The `fetch` API is still supported.

The only API we don't support is [static
routes/responses](https://bun.sh/docs/api/http#static-responses). This
is because these are optimized by Bun itself, and if we turn it into a
function (which we need to do to time it), we'll lose out on the
optimization. For now they aren't instrumented.

Author: AbhiPrasad

packages/bun/package.json

@@ -44,7 +44,7 @@
     "@sentry/opentelemetry": "9.12.0"
   },
   "devDependencies": {
-    "bun-types": "latest"
+    "bun-types": "^1.2.9"
   },
   "scripts": {
     "build": "run-p build:transpile build:types",

packages/bun/src/integrations/bunserver.ts

@@ -1,17 +1,17 @@
+import type { ServeOptions } from 'bun';
 import type { IntegrationFn, RequestEventData, SpanAttributes } from '@sentry/core';
 import {
   SEMANTIC_ATTRIBUTE_HTTP_REQUEST_METHOD,
   SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
   SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
   captureException,
-  continueTrace,
-  defineIntegration,
-  extractQueryParamsFromUrl,
-  getSanitizedUrlString,
-  parseUrl,
+  isURLObjectRelative,
   setHttpStatus,
+  defineIntegration,
+  continueTrace,
   startSpan,
   withIsolationScope,
+  parseStringToURLObject,
 } from '@sentry/core';
 
 const INTEGRATION_NAME = 'BunServer';
@@ -28,6 +28,8 @@ const _bunServerIntegration = (() => {
 /**
  * Instruments `Bun.serve` to automatically create transactions and capture errors.
  *
+ * Does not support instrumenting static routes.
+ *
  * Enabled by default in the Bun SDK.
  *
  * ```js
@@ -40,10 +42,18 @@ const _bunServerIntegration = (() => {
  */
 export const bunServerIntegration = defineIntegration(_bunServerIntegration);
 
+let hasPatchedBunServe = false;
+
 /**
  * Instruments Bun.serve by patching it's options.
+ *
+ * Only exported for tests.
  */
 export function instrumentBunServe(): void {
+  if (hasPatchedBunServe) {
+    return;
+  }
+
   Bun.serve = new Proxy(Bun.serve, {
     apply(serveTarget, serveThisArg, serveArgs: Parameters<typeof Bun.serve>) {
       instrumentBunServeOptions(serveArgs[0]);
@@ -53,89 +63,231 @@ export function instrumentBunServe(): void {
       // We can't use a Proxy for this as Bun does `instanceof` checks internally that fail if we
       // wrap the Server instance.
       const originalReload: typeof server.reload = server.reload.bind(server);
-      server.reload = (serveOptions: Parameters<typeof Bun.serve>[0]) => {
+      server.reload = (serveOptions: ServeOptions) => {
         instrumentBunServeOptions(serveOptions);
         return originalReload(serveOptions);
       };
 
       return server;
     },
   });
+
+  hasPatchedBunServe = true;
 }
 
 /**
- * Instruments Bun.serve `fetch` option to automatically create spans and capture errors.
+ * Instruments Bun.serve options.
+ *
+ * @param serveOptions - The options for the Bun.serve function.
  */
 function instrumentBunServeOptions(serveOptions: Parameters<typeof Bun.serve>[0]): void {
+  // First handle fetch
+  instrumentBunServeOptionFetch(serveOptions);
+  // then handle routes
+  instrumentBunServeOptionRoutes(serveOptions);
+}
+
+/**
+ * Instruments the `fetch` option of Bun.serve.
+ *
+ * @param serveOptions - The options for the Bun.serve function.
+ */
+function instrumentBunServeOptionFetch(serveOptions: Parameters<typeof Bun.serve>[0]): void {
+  if (typeof serveOptions.fetch !== 'function') {
+    return;
+  }
+
   serveOptions.fetch = new Proxy(serveOptions.fetch, {
     apply(fetchTarget, fetchThisArg, fetchArgs: Parameters<typeof serveOptions.fetch>) {
-      return withIsolationScope(isolationScope => {
-        const request = fetchArgs[0];
-        const upperCaseMethod = request.method.toUpperCase();
-        if (upperCaseMethod === 'OPTIONS' || upperCaseMethod === 'HEAD') {
-          return fetchTarget.apply(fetchThisArg, fetchArgs);
-        }
+      return wrapRequestHandler(fetchTarget, fetchThisArg, fetchArgs);
+    },
+  });
+}
 
-        const parsedUrl = parseUrl(request.url);
-        const attributes: SpanAttributes = {
-          [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.http.bun.serve',
-          [SEMANTIC_ATTRIBUTE_HTTP_REQUEST_METHOD]: request.method || 'GET',
-          [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'url',
-        };
-        if (parsedUrl.search) {
-          attributes['http.query'] = parsedUrl.search;
-        }
+/**
+ * Instruments the `routes` option of Bun.serve.
+ *
+ * @param serveOptions - The options for the Bun.serve function.
+ */
+function instrumentBunServeOptionRoutes(serveOptions: Parameters<typeof Bun.serve>[0]): void {
+  if (!serveOptions.routes) {
+    return;
+  }
 
-        const url = getSanitizedUrlString(parsedUrl);
-
-        isolationScope.setSDKProcessingMetadata({
-          normalizedRequest: {
-            url,
-            method: request.method,
-            headers: request.headers.toJSON(),
-            query_string: extractQueryParamsFromUrl(url),
-          } satisfies RequestEventData,
-        });
-
-        return continueTrace(
-          { sentryTrace: request.headers.get('sentry-trace') || '', baggage: request.headers.get('baggage') },
-          () => {
-            return startSpan(
-              {
-                attributes,
-                op: 'http.server',
-                name: `${request.method} ${parsedUrl.path || '/'}`,
-              },
-              async span => {
-                try {
-                  const response = await (fetchTarget.apply(fetchThisArg, fetchArgs) as ReturnType<
-                    typeof serveOptions.fetch
-                  >);
-                  if (response?.status) {
-                    setHttpStatus(span, response.status);
-                    isolationScope.setContext('response', {
-                      headers: response.headers.toJSON(),
-                      status_code: response.status,
-                    });
-                  }
-                  return response;
-                } catch (e) {
-                  captureException(e, {
-                    mechanism: {
-                      type: 'bun',
-                      handled: false,
-                      data: {
-                        function: 'serve',
-                      },
-                    },
-                  });
-                  throw e;
-                }
+  if (typeof serveOptions.routes !== 'object') {
+    return;
+  }
+
+  Object.keys(serveOptions.routes).forEach(route => {
+    const routeHandler = serveOptions.routes[route];
+
+    // Handle route handlers that are an object
+    if (typeof routeHandler === 'function') {
+      serveOptions.routes[route] = new Proxy(routeHandler, {
+        apply: (routeHandlerTarget, routeHandlerThisArg, routeHandlerArgs: Parameters<typeof routeHandler>) => {
+          return wrapRequestHandler(routeHandlerTarget, routeHandlerThisArg, routeHandlerArgs, route);
+        },
+      });
+    }
+
+    // Static routes are not instrumented
+    if (routeHandler instanceof Response) {
+      return;
+    }
+
+    // Handle the route handlers that are an object. This means they define a route handler for each method.
+    if (typeof routeHandler === 'object') {
+      Object.entries(routeHandler).forEach(([routeHandlerObjectHandlerKey, routeHandlerObjectHandler]) => {
+        if (typeof routeHandlerObjectHandler === 'function') {
+          (serveOptions.routes[route] as Record<string, RouteHandler>)[routeHandlerObjectHandlerKey] = new Proxy(
+            routeHandlerObjectHandler,
+            {
+              apply: (
+                routeHandlerObjectHandlerTarget,
+                routeHandlerObjectHandlerThisArg,
+                routeHandlerObjectHandlerArgs: Parameters<typeof routeHandlerObjectHandler>,
+              ) => {
+                return wrapRequestHandler(
+                  routeHandlerObjectHandlerTarget,
+                  routeHandlerObjectHandlerThisArg,
+                  routeHandlerObjectHandlerArgs,
+                  route,
+                );
               },
-            );
-          },
-        );
+            },
+          );
+        }
       });
-    },
+    }
   });
 }
+
+type RouteHandler = Extract<
+  NonNullable<Parameters<typeof Bun.serve>[0]['routes']>[string],
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  Function
+>;
+
+function wrapRequestHandler<T extends RouteHandler = RouteHandler>(
+  target: T,
+  thisArg: unknown,
+  args: Parameters<T>,
+  route?: string,
+): ReturnType<T> {
+  return withIsolationScope(isolationScope => {
+    const request = args[0];
+    const upperCaseMethod = request.method.toUpperCase();
+    if (upperCaseMethod === 'OPTIONS' || upperCaseMethod === 'HEAD') {
+      return target.apply(thisArg, args);
+    }
+
+    const parsedUrl = parseStringToURLObject(request.url);
+    const attributes = getSpanAttributesFromParsedUrl(parsedUrl, request);
+
+    let routeName = parsedUrl?.pathname || '/';
+    if (request.params) {
+      Object.keys(request.params).forEach(key => {
+        attributes[`url.path.parameter.${key}`] = (request.params as Record<string, string>)[key];
+      });
+
+      // If a route has parameters, it's a parameterized route
+      if (route) {
+        attributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE] = 'route';
+        attributes['url.template'] = route;
+        routeName = route;
+      }
+    }
+
+    // Handle wildcard routes
+    if (route?.endsWith('/*')) {
+      attributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE] = 'route';
+      attributes['url.template'] = route;
+      routeName = route;
+    }
+
+    isolationScope.setSDKProcessingMetadata({
+      normalizedRequest: {
+        url: request.url,
+        method: request.method,
+        headers: request.headers.toJSON(),
+        query_string: parsedUrl?.search,
+      } satisfies RequestEventData,
+    });
+
+    return continueTrace(
+      {
+        sentryTrace: request.headers.get('sentry-trace') ?? '',
+        baggage: request.headers.get('baggage'),
+      },
+      () =>
+        startSpan(
+          {
+            attributes,
+            op: 'http.server',
+            name: `${request.method} ${routeName}`,
+          },
+          async span => {
+            try {
+              const response = (await target.apply(thisArg, args)) as Response | undefined;
+              if (response?.status) {
+                setHttpStatus(span, response.status);
+                isolationScope.setContext('response', {
+                  headers: response.headers.toJSON(),
+                  status_code: response.status,
+                });
+              }
+              return response;
+            } catch (e) {
+              captureException(e, {
+                mechanism: {
+                  type: 'bun',
+                  handled: false,
+                  data: {
+                    function: 'serve',
+                  },
+                },
+              });
+              throw e;
+            }
+          },
+        ),
+    );
+  });
+}
+
+function getSpanAttributesFromParsedUrl(
+  parsedUrl: ReturnType<typeof parseStringToURLObject>,
+  request: Request,
+): SpanAttributes {
+  const attributes: SpanAttributes = {
+    [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.http.bun.serve',
+    [SEMANTIC_ATTRIBUTE_HTTP_REQUEST_METHOD]: request.method || 'GET',
+    [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'url',
+  };
+
+  if (parsedUrl) {
+    if (parsedUrl.search) {
+      attributes['url.query'] = parsedUrl.search;
+    }
+    if (parsedUrl.hash) {
+      attributes['url.fragment'] = parsedUrl.hash;
+    }
+    if (parsedUrl.pathname) {
+      attributes['url.path'] = parsedUrl.pathname;
+    }
+    if (!isURLObjectRelative(parsedUrl)) {
+      attributes['url.full'] = parsedUrl.href;
+      if (parsedUrl.port) {
+        attributes['url.port'] = parsedUrl.port;
+      }
+      if (parsedUrl.protocol) {
+        attributes['url.scheme'] = parsedUrl.protocol;
+      }
+      if (parsedUrl.hostname) {
+        attributes['url.domain'] = parsedUrl.hostname;
+      }
+    }
+  }
+
+  return attributes;
+}