@@ -0,0 +1,10 @@
+import * as Sentry from '@sentry/node';
+
+Sentry.init({
+  dsn: process.env.SENTRY_DSN,
+  // A release makes the process session sendable, so the session is sent on `beforeExit`.
+  release: '1.0.0',
+  // Without the SDK's own OpenTelemetry setup there is no context manager, so the `suppressTracing()`
+  // wrapper around transport requests has nowhere to store the suppression.
+  skipOpenTelemetrySetup: true,
+});
@@ -0,0 +1,24 @@
+import { afterAll, expect, test } from 'vitest';
+import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
+
+afterAll(() => {
+  cleanupChildProcesses();
+});
+
+test('exits when client reports are flushed on `beforeExit` without the SDK owning the OpenTelemetry setup', async () => {
+  // `ensureNoErrorOutput` is what separates a clean exit from a scenario that died on startup: both
+  // leave the child exited, but only the latter writes to stderr.
+  const runner = createRunner(__dirname, 'scenario.ts').withMockSentryServer().ensureNoErrorOutput().start();
+
+  // The scenario exits as soon as its `beforeExit` flush settles, so polling for the child's own
+  // exit keeps the passing run short. A flush loop that keeps re-arming `beforeExit` never exits
+  // and runs into the deadline.
+  const deadline = Date.now() + 10_000;
+  while (!runner.childHasExited() && Date.now() < deadline) {
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+
+  expect(runner.childHasExited()).toBe(true);
+
+  await runner.completed();
+});
@@ -35,6 +35,7 @@ import { LOG_PREFIX, HTTP_ON_CLIENT_REQUEST } from './constants';
 import type { ClientSubscriptionName } from './constants';
 import { getClient, getCurrentScope } from '../../currentScopes';
 import { hasSpansEnabled } from '../../utils/hasSpansEnabled';
+import { isSentryRequestUrl } from '../../utils/isSentryRequestUrl';
 import { doubleWrapWarning } from './double-wrap-warning';
 
 type ChannelListener = (message: unknown, name: string | symbol) => void;
@@ -64,9 +65,20 @@ export function getHttpClientSubscriptions(options: HttpInstrumentationOptions):
     } = options;
 
     const { request } = data as { request: HttpClientRequest };
+    const requestUrl = getRequestUrlFromClientRequest(request);
+
+    // The suppression check above only works while the suppression is readable, which it is not when
+    // the SDK does not own the OpenTelemetry setup: `suppressTracing()` writes to an OpenTelemetry
+    // context that no registered context manager propagates. Recognizing the SDK's own requests by
+    // their URL holds either way, and it has to: instrumenting them makes each envelope send record
+    // a dropped-span outcome, which the `beforeExit` client report flush then sends as another
+    // envelope, keeping the process alive forever.
+    if (isSentryRequestUrl(requestUrl, getClient())) {
+      return;
+    }
 
     // check if request is ignored. if so, we do nothing at all.
-    if (options.ignoreOutgoingRequests?.(getRequestUrlFromClientRequest(request), request)) {
+    if (options.ignoreOutgoingRequests?.(requestUrl, request)) {
       return;
     }
 
 
@@ -5,6 +5,9 @@ import { getHttpClientSubscriptions } from '../../../../src/integrations/http/cl
 import type { HttpClientRequest, HttpIncomingMessage } from '../../../../src/integrations/http/types';
 import { SUPPRESS_TRACING_KEY } from '../../../../src/tracing';
 import { getCurrentScope, withScope } from '../../../../src/currentScopes';
+import type { Client } from '../../../../src/client';
+import { setCurrentClient } from '../../../../src/sdk';
+import { getDefaultTestClientOptions, TestClient } from '../../../mocks/client';
 
 function makeMockRequest(): HttpClientRequest & {
   _responseListeners: ((res: HttpIncomingMessage) => void)[];
@@ -109,4 +112,50 @@ describe('getHttpClientSubscriptions', () => {
       expect(spy).toHaveBeenCalledOnce();
     });
   });
+
+  describe("the SDK's own requests", () => {
+    afterEach(() => {
+      setCurrentClient(undefined as unknown as Client);
+    });
+
+    function setUpClientWithDsn(): void {
+      const client = new TestClient(getDefaultTestClientOptions({ dsn: 'https://public@dsn.ingest.sentry.io/1337' }));
+      setCurrentClient(client);
+    }
+
+    it('does not instrument requests to the ingest endpoint', () => {
+      setUpClientWithDsn();
+      const spy = vi.spyOn(breadcrumbModule, 'addOutgoingRequestBreadcrumb');
+      const subscriptions = getHttpClientSubscriptions({ breadcrumbs: true, spans: false, propagateTrace: true });
+      const handler = subscriptions[HTTP_ON_CLIENT_REQUEST];
+
+      const request = makeMockRequest();
+      (request as { host: string }).host = 'dsn.ingest.sentry.io';
+      (request as { path: string }).path = '/api/1337/envelope/?sentry_version=7&sentry_key=public';
+
+      handler({ request }, HTTP_ON_CLIENT_REQUEST);
+
+      expect(request._responseListeners).toHaveLength(0);
+      expect(request.setHeader).not.toHaveBeenCalled();
+      expect(spy).not.toHaveBeenCalled();
+    });
+
+    it('still instruments requests to the same host that are not envelope sends', () => {
+      setUpClientWithDsn();
+      const spy = vi.spyOn(breadcrumbModule, 'addOutgoingRequestBreadcrumb');
+      const subscriptions = getHttpClientSubscriptions({ breadcrumbs: true, spans: false });
+      const handler = subscriptions[HTTP_ON_CLIENT_REQUEST];
+
+      const request = makeMockRequest();
+      (request as { host: string }).host = 'dsn.ingest.sentry.io';
+
+      handler({ request }, HTTP_ON_CLIENT_REQUEST);
+
+      const response = makeMockResponse();
+      request._responseListeners.forEach(fn => fn(response));
+      response._endListeners.forEach(fn => fn());
+
+      expect(spy).toHaveBeenCalledOnce();
+    });
+  });
 });