feat(bun): Instrument outgoing fetch requests

Add a `fetchIntegration` to `@sentry/bun` that patches the global `fetch` to
create `http.client` spans, record breadcrumbs, and inject trace-propagation
headers. Bun implements `fetch` natively rather than through undici, so the
Node SDK's `nativeNodeFetchIntegration` (which subscribes to undici's
`diagnostics_channel` events) never fires. The new integration mirrors the
Cloudflare approach and replaces `nativeNodeFetchIntegration` in the Bun
default integrations.

Also fix an inverted guard in core's `instrumentFetch`: `skipNativeFetchCheck`
did the opposite of its name — passing `true` performed the browser-only native
check, while the default skipped it. Only Cloudflare/Bun passed `true`, so they
were the only callers that ran the check. The guard now reads
`!skipNativeFetchCheck && !supportsNativeFetch()` so the parameter matches its
name.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: mydea

dev-packages/bun-integration-tests/suites/fetch/index.ts

@@ -0,0 +1,46 @@
+import * as Sentry from '@sentry/bun';
+
+// The target server the instrumented app makes outgoing fetch requests to. It
+// echoes back the headers it received so the test can assert on trace propagation.
+const targetServer = Bun.serve({
+  port: 0,
+  fetch(request) {
+    const headers = Object.fromEntries(request.headers.entries());
+    return Response.json({ headers });
+  },
+});
+
+const targetUrl = `http://localhost:${targetServer.port}`;
+
+Sentry.init({
+  traceLifecycle: 'static',
+  environment: 'production',
+  dsn: process.env.SENTRY_DSN,
+  tracesSampleRate: 1.0,
+  // Only the `/allowed` path is a propagation target (matching is substring-based),
+  // so requests to `/disallowed` below must NOT receive sentry-trace/baggage headers.
+  tracePropagationTargets: [`${targetUrl}/allowed`],
+});
+
+const server = Bun.serve({
+  port: 0,
+  async fetch(request) {
+    const url = new URL(request.url);
+
+    if (url.pathname === '/outgoing-fetch') {
+      const response = await fetch(`${targetUrl}/allowed`);
+      const data = await response.json();
+      return Response.json(data);
+    }
+
+    if (url.pathname === '/outgoing-fetch-disallowed') {
+      const response = await fetch(`${targetUrl}/disallowed`);
+      const data = await response.json();
+      return Response.json(data);
+    }
+
+    return new Response('Hello from Bun!');
+  },
+});
+
+process.send?.(JSON.stringify({ event: 'READY', port: server.port }));

dev-packages/bun-integration-tests/suites/fetch/test.ts

@@ -0,0 +1,78 @@
+import type { Envelope, TransactionEvent } from '@sentry/core';
+import { expect, it } from 'vitest';
+import { createRunner } from '../../runner';
+
+function getTransaction(envelope: Envelope): TransactionEvent {
+  return envelope[1][0][1] as TransactionEvent;
+}
+
+it('creates an http.client span for outgoing fetch requests', async ({ signal }) => {
+  const runner = createRunner(__dirname)
+    .expect(envelope => {
+      const transaction = getTransaction(envelope);
+
+      expect(transaction.transaction).toBe('GET /outgoing-fetch');
+
+      const httpClientSpan = transaction.spans?.find(span => span.op === 'http.client');
+
+      expect(httpClientSpan).toBeDefined();
+      expect(httpClientSpan).toMatchObject({
+        op: 'http.client',
+        origin: 'auto.http.fetch',
+        description: expect.stringMatching(/^GET http:\/\/localhost:\d+\/allowed$/),
+        data: expect.objectContaining({
+          'http.method': 'GET',
+          type: 'fetch',
+        }),
+      });
+    })
+    .start(signal);
+
+  await runner.makeRequest('get', '/outgoing-fetch');
+  await runner.completed();
+});
+
+it('propagates sentry-trace and baggage headers to allowed outgoing fetch requests', async ({ signal }) => {
+  const runner = createRunner(__dirname).start(signal);
+
+  const response = await runner.makeRequest<{ headers: Record<string, string> }>('get', '/outgoing-fetch');
+
+  const traceId = response?.headers['sentry-trace']?.split('-')[0];
+
+  expect(response?.headers['sentry-trace']).toMatch(/^[\da-f]{32}-[\da-f]{16}-1$/);
+  expect(response?.headers.baggage).toContain('sentry-environment=production');
+  expect(response?.headers.baggage).toContain(`sentry-trace_id=${traceId}`);
+});
+
+it('does not propagate headers to outgoing fetch requests outside tracePropagationTargets', async ({ signal }) => {
+  const runner = createRunner(__dirname).start(signal);
+
+  const response = await runner.makeRequest<{ headers: Record<string, string> }>('get', '/outgoing-fetch-disallowed');
+
+  expect(response?.headers['sentry-trace']).toBeUndefined();
+  expect(response?.headers.baggage).toBeUndefined();
+});
+
+it('records a breadcrumb for outgoing fetch requests', async ({ signal }) => {
+  const runner = createRunner(__dirname)
+    .expect(envelope => {
+      const transaction = getTransaction(envelope);
+
+      const fetchBreadcrumb = transaction.breadcrumbs?.find(
+        breadcrumb => breadcrumb.category === 'fetch' && (breadcrumb.data?.url as string)?.includes('/allowed'),
+      );
+
+      expect(fetchBreadcrumb).toMatchObject({
+        category: 'fetch',
+        type: 'http',
+        data: expect.objectContaining({
+          method: 'GET',
+          status_code: 200,
+        }),
+      });
+    })
+    .start(signal);
+
+  await runner.makeRequest('get', '/outgoing-fetch');
+  await runner.completed();
+});

dev-packages/e2e-tests/test-applications/elysia-bun/tests/propagation.test.ts

@@ -13,12 +13,12 @@ test('Includes sentry-trace and baggage in response headers', async ({ baseURL }
   expect(baggage).toContain('sentry-trace_id=');
 });
 
-// Bun's native fetch does not emit undici diagnostics channels,
-// so the nativeNodeFetchIntegration cannot inject sentry-trace/baggage headers.
-// These tests document the desired behavior and will pass once Bun adds support
-// for undici diagnostics channels or an alternative propagation mechanism is added.
+// Bun's native fetch does not emit undici diagnostics channels, so the
+// nativeNodeFetchIntegration cannot see these requests. `@sentry/bun`'s
+// `fetchIntegration` instead patches the global `fetch` (like Cloudflare), which
+// is what creates the spans and injects sentry-trace/baggage headers below.
 
-test.fixme('Propagates trace for outgoing fetch requests', async ({ baseURL }) => {
+test('Propagates trace for outgoing fetch requests', async ({ baseURL }) => {
   const id = randomUUID();
 
   const inboundTransactionPromise = waitForTransaction('elysia-bun', transactionEvent => {
@@ -64,7 +64,7 @@ test.fixme('Propagates trace for outgoing fetch requests', async ({ baseURL }) =
   expect(inboundTransaction.contexts?.trace?.trace_id).toBe(traceId);
 });
 
-test.fixme('Propagates trace for outgoing fetch to external allowed URL', async ({ baseURL }) => {
+test('Propagates trace for outgoing fetch to external allowed URL', async ({ baseURL }) => {
   const inboundTransactionPromise = waitForTransaction('elysia-bun', transactionEvent => {
     return (
       transactionEvent.contexts?.trace?.op === 'http.server' &&

dev-packages/e2e-tests/test-applications/nextjs-16-bun/package.json

@@ -13,6 +13,7 @@
   },
   "dependencies": {
     "@sentry/nextjs": "file:../../packed/sentry-nextjs-packed.tgz",
+    "@sentry/bun": "file:../../packed/sentry-bun-packed.tgz",
     "@sentry/core": "file:../../packed/sentry-core-packed.tgz",
     "import-in-the-middle": "^2",
     "next": "16.2.3",

dev-packages/e2e-tests/test-applications/nextjs-16-bun/sentry.server.config.ts

@@ -1,4 +1,5 @@
 import * as Sentry from '@sentry/nextjs';
+import { bunServerIntegration, fetchIntegration } from '@sentry/bun';
 
 Sentry.init({
   traceLifecycle: 'static',
@@ -8,4 +9,8 @@ Sentry.init({
   tracesSampleRate: 1.0,
   dataCollection: { userInfo: true },
   tracePropagationTargets: ['http://localhost:3030/propagation/test-outgoing-fetch/check'],
+  integrations: [
+    // Adding bun-specific integration here
+    fetchIntegration(),
+  ],
 });

dev-packages/e2e-tests/test-applications/nextjs-16-bun/tests/propagation.test.ts

@@ -1,11 +1,7 @@
 import { expect, test } from '@playwright/test';
 import { waitForTransaction } from '@sentry-internal/test-utils';
 
-// Bun runtime does not propagate trace headers for outgoing fetch requests.
-// The OTel node_fetch instrumentation does not intercept Bun's native fetch,
-// so sentry-trace and baggage headers are not attached to outgoing requests.
-// This test documents the current limitation - un-skip when Bun fetch instrumentation is supported.
-test.skip('Propagates trace for outgoing fetch requests', async ({ baseURL, request }) => {
+test('Propagates trace for outgoing fetch requests', async ({ baseURL, request }) => {
   const inboundTransactionPromise = waitForTransaction('nextjs-16-bun', transactionEvent => {
     return transactionEvent.transaction === 'GET /propagation/test-outgoing-fetch/check';
   });
@@ -22,8 +18,12 @@ test.skip('Propagates trace for outgoing fetch requests', async ({ baseURL, requ
   expect(inboundTransaction.contexts?.trace?.trace_id).toStrictEqual(expect.any(String));
   expect(inboundTransaction.contexts?.trace?.trace_id).toBe(outboundTransaction.contexts?.trace?.trace_id);
 
+  // Although we have a fetch http.client span, we propagate through Next.js and AppRouteRouteHandlers.runHandler
+  // as that is the active span at that time - not ideal, but it's the best we can do.
   const httpClientSpan = outboundTransaction.spans?.find(
-    span => span.op === 'http.client' && span.data?.['sentry.origin'] === 'auto.http.otel.node_fetch',
+    span =>
+      span.data?.['next.span_type'] === 'AppRouteRouteHandlers.runHandler' &&
+      span.data?.['next.route'] === '/propagation/test-outgoing-fetch',
   );
 
   expect(httpClientSpan).toBeDefined();

packages/bun/src/index.ts

@@ -199,5 +199,6 @@ export {
   initWithoutDefaultIntegrations,
 } from './sdk';
 export { bunServerIntegration } from './integrations/bunserver';
+export { fetchIntegration } from './integrations/fetch';
 export { bunRuntimeMetricsIntegration, type BunRuntimeMetricsOptions } from './integrations/bunRuntimeMetrics';
 export { makeFetchTransport } from './transports';

packages/bun/src/integrations/fetch.ts

@@ -0,0 +1,186 @@
+import type {
+  Client,
+  FetchBreadcrumbData,
+  FetchBreadcrumbHint,
+  HandlerDataFetch,
+  IntegrationFn,
+  Span,
+} from '@sentry/core';
+import {
+  addBreadcrumb,
+  addFetchInstrumentationHandler,
+  defineIntegration,
+  getBreadcrumbLogLevelFromHttpStatusCode,
+  getClient,
+  instrumentFetchRequest,
+  isSentryRequestUrl,
+  LRUMap,
+  stringMatchesSomePattern,
+} from '@sentry/core';
+
+const INTEGRATION_NAME = 'Fetch' as const;
+
+const HAS_CLIENT_MAP = new WeakMap<Client, boolean>();
+
+interface FetchOptions {
+  /**
+   * Whether breadcrumbs should be recorded for requests.
+   * Defaults to true.
+   */
+  breadcrumbs?: boolean;
+
+  /**
+   * Function determining whether or not to create spans to track outgoing requests to the given URL.
+   * By default, spans will be created for all outgoing requests.
+   */
+  shouldCreateSpanForRequest?: (url: string) => boolean;
+}
+
+const _fetchIntegration = ((options: FetchOptions = {}) => {
+  const breadcrumbs = options.breadcrumbs === undefined ? true : options.breadcrumbs;
+  const shouldCreateSpanForRequest = options.shouldCreateSpanForRequest;
+
+  const _createSpanUrlMap = new LRUMap<string, boolean>(100);
+  const _headersUrlMap = new LRUMap<string, boolean>(100);
+
+  const spans: Record<string, Span> = {};
+
+  /** Decides whether to attach trace data to the outgoing fetch request */
+  function _shouldAttachTraceData(url: string): boolean {
+    const client = getClient();
+
+    if (!client) {
+      return false;
+    }
+
+    const clientOptions = client.getOptions();
+
+    if (clientOptions.tracePropagationTargets === undefined) {
+      return true;
+    }
+
+    const cachedDecision = _headersUrlMap.get(url);
+    if (cachedDecision !== undefined) {
+      return cachedDecision;
+    }
+
+    const decision = stringMatchesSomePattern(url, clientOptions.tracePropagationTargets);
+    _headersUrlMap.set(url, decision);
+    return decision;
+  }
+
+  /** Helper that wraps shouldCreateSpanForRequest option */
+  function _shouldCreateSpan(url: string): boolean {
+    if (shouldCreateSpanForRequest === undefined) {
+      return true;
+    }
+
+    const cachedDecision = _createSpanUrlMap.get(url);
+    if (cachedDecision !== undefined) {
+      return cachedDecision;
+    }
+
+    const decision = shouldCreateSpanForRequest(url);
+    _createSpanUrlMap.set(url, decision);
+    return decision;
+  }
+
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      addFetchInstrumentationHandler(handlerData => {
+        const client = getClient();
+        const { propagateTraceparent } = client?.getOptions() || {};
+        if (!client || !HAS_CLIENT_MAP.get(client)) {
+          return;
+        }
+
+        if (isSentryRequestUrl(handlerData.fetchData.url, client)) {
+          return;
+        }
+
+        instrumentFetchRequest(handlerData, _shouldCreateSpan, _shouldAttachTraceData, spans, {
+          spanOrigin: 'auto.http.fetch',
+          propagateTraceparent,
+        });
+
+        if (breadcrumbs) {
+          createBreadcrumb(handlerData);
+        }
+        // `skipNativeFetchCheck: true` — the native-fetch check is browser-only (it probes for
+        // `[native code]` and falls back to an iframe DOM check). On Bun `fetch` may already be
+        // wrapped by the host (e.g. Next.js) and there is no DOM, so we always patch the global.
+      }, true);
+    },
+    setup(client) {
+      HAS_CLIENT_MAP.set(client, true);
+    },
+  };
+}) satisfies IntegrationFn;
+
+/**
+ * Instruments outgoing `fetch` requests in Bun: creates spans, records breadcrumbs and
+ * attaches trace propagation headers.
+ *
+ * Bun does not route `fetch` through undici's `diagnostics_channel`, so unlike Node the
+ * `nativeNodeFetchIntegration` cannot observe these requests. This integration instead patches
+ * the global `fetch`, mirroring the Cloudflare SDK.
+ */
+export const fetchIntegration = defineIntegration(_fetchIntegration);
+
+function createBreadcrumb(handlerData: HandlerDataFetch): void {
+  const { startTimestamp, endTimestamp } = handlerData;
+
+  // We only capture complete fetch requests
+  if (!endTimestamp) {
+    return;
+  }
+
+  const breadcrumbData: FetchBreadcrumbData = {
+    method: handlerData.fetchData.method,
+    url: handlerData.fetchData.url,
+  };
+
+  if (handlerData.error) {
+    const hint: FetchBreadcrumbHint = {
+      data: handlerData.error,
+      input: handlerData.args,
+      startTimestamp,
+      endTimestamp,
+    };
+
+    addBreadcrumb(
+      {
+        category: 'fetch',
+        data: breadcrumbData,
+        level: 'error',
+        type: 'http',
+      },
+      hint,
+    );
+  } else {
+    const response = handlerData.response as Response | undefined;
+
+    breadcrumbData.request_body_size = handlerData.fetchData.request_body_size;
+    breadcrumbData.response_body_size = handlerData.fetchData.response_body_size;
+    breadcrumbData.status_code = response?.status;
+
+    const hint: FetchBreadcrumbHint = {
+      input: handlerData.args,
+      response,
+      startTimestamp,
+      endTimestamp,
+    };
+    const level = getBreadcrumbLogLevelFromHttpStatusCode(breadcrumbData.status_code);
+
+    addBreadcrumb(
+      {
+        category: 'fetch',
+        data: breadcrumbData,
+        type: 'http',
+        level,
+      },
+      hint,
+    );
+  }
+}