test(node): Add integration tests for diagnostics channel HTTP spans

This adds integration tests for the new outgoing request span creation
feature using diagnostics channels (Node 22.12+). The tests verify:

- Spans are created for outgoing HTTP requests
- Trace propagation uses the outgoing span's ID, not the parent
- The 'spans' option correctly disables span creation when false
- Span attributes include proper sentry.origin values

The tests are conditionally run only on Node 22.12+, 23.2+, or 24+
where the http.client.request.created diagnostics channel is available.

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: cursoragent

dev-packages/node-integration-tests/suites/tracing/requests/http-diagnostics-channel-spans-disabled/instrument.mjs

@@ -0,0 +1,10 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracesSampleRate: 1.0,
+  integrations: [Sentry.httpIntegration({ spans: false })],
+  transport: loggingTransport,
+});

dev-packages/node-integration-tests/suites/tracing/requests/http-diagnostics-channel-spans-disabled/scenario.mjs

@@ -0,0 +1,23 @@
+import * as Sentry from '@sentry/node';
+import * as http from 'http';
+
+Sentry.startSpan({ name: 'test_span' }, async () => {
+  await makeHttpRequest(`${process.env.SERVER_URL}/api/test`);
+});
+
+function makeHttpRequest(url) {
+  return new Promise((resolve, reject) => {
+    http
+      .request(url, httpRes => {
+        httpRes.on('data', () => {
+          // we don't care about data
+        });
+        httpRes.on('end', () => {
+          resolve();
+        });
+        httpRes.on('error', reject);
+      })
+      .on('error', reject)
+      .end();
+  });
+}

dev-packages/node-integration-tests/suites/tracing/requests/http-diagnostics-channel-spans-disabled/test.ts

@@ -0,0 +1,41 @@
+import { createTestServer } from '@sentry-internal/test-utils';
+import { parseSemver } from '@sentry/core';
+import { describe, expect } from 'vitest';
+import { createEsmAndCjsTests } from '../../../../utils/runner';
+
+const NODE_VERSION = parseSemver(process.versions.node);
+
+const supportsHttpDiagnosticsChannel =
+  (NODE_VERSION.major === 22 && NODE_VERSION.minor >= 12) ||
+  (NODE_VERSION.major === 23 && NODE_VERSION.minor >= 2) ||
+  NODE_VERSION.major >= 24;
+
+const testIfSupported = supportsHttpDiagnosticsChannel ? describe : describe.skip;
+
+testIfSupported('outgoing http with diagnostics channel spans disabled', () => {
+  createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument.mjs', (createRunner, test) => {
+    test('does not create spans when spans option is false', async () => {
+      expect.assertions(3);
+
+      const [SERVER_URL, closeTestServer] = await createTestServer()
+        .get('/api/test', headers => {
+          expect(headers['sentry-trace']).toEqual(expect.any(String));
+        })
+        .start();
+
+      await createRunner()
+        .withEnv({ SERVER_URL })
+        .expect({
+          transaction: event => {
+            expect(event.transaction).toBe('test_span');
+
+            const httpClientSpans = event.spans?.filter(span => span.op === 'http.client');
+            expect(httpClientSpans).toHaveLength(0);
+          },
+        })
+        .start()
+        .completed();
+      closeTestServer();
+    });
+  });
+});

dev-packages/node-integration-tests/suites/tracing/requests/http-diagnostics-channel-spans/instrument.mjs

@@ -0,0 +1,10 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracesSampleRate: 1.0,
+  integrations: [],
+  transport: loggingTransport,
+});

dev-packages/node-integration-tests/suites/tracing/requests/http-diagnostics-channel-spans/scenario.mjs

@@ -0,0 +1,23 @@
+import * as Sentry from '@sentry/node';
+import * as http from 'http';
+
+Sentry.startSpan({ name: 'test_span' }, async () => {
+  await makeHttpRequest(`${process.env.SERVER_URL}/api/test`);
+});
+
+function makeHttpRequest(url) {
+  return new Promise((resolve, reject) => {
+    http
+      .request(url, httpRes => {
+        httpRes.on('data', () => {
+          // we don't care about data
+        });
+        httpRes.on('end', () => {
+          resolve();
+        });
+        httpRes.on('error', reject);
+      })
+      .on('error', reject)
+      .end();
+  });
+}

dev-packages/node-integration-tests/suites/tracing/requests/http-diagnostics-channel-spans/test.ts

@@ -0,0 +1,65 @@
+import { createTestServer } from '@sentry-internal/test-utils';
+import { parseSemver } from '@sentry/core';
+import { describe, expect } from 'vitest';
+import { createEsmAndCjsTests } from '../../../../utils/runner';
+
+const NODE_VERSION = parseSemver(process.versions.node);
+
+// The `http.client.request.created` diagnostics channel was added in Node 22.12.0 and 23.2.0
+const supportsHttpDiagnosticsChannel =
+  (NODE_VERSION.major === 22 && NODE_VERSION.minor >= 12) ||
+  (NODE_VERSION.major === 23 && NODE_VERSION.minor >= 2) ||
+  NODE_VERSION.major >= 24;
+
+const testIfSupported = supportsHttpDiagnosticsChannel ? describe : describe.skip;
+
+testIfSupported('outgoing http with diagnostics channel spans', () => {
+  createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument.mjs', (createRunner, test) => {
+    test('creates spans for outgoing requests and propagates trace context within span', async () => {
+      expect.assertions(8);
+
+      let outgoingSpanId: string | undefined;
+
+      const [SERVER_URL, closeTestServer] = await createTestServer()
+        .get('/api/test', headers => {
+          // Verify trace propagation headers are present
+          expect(headers['baggage']).toEqual(expect.any(String));
+          expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f\d]{32})-([a-f\d]{16})-1$/));
+
+          // Extract the span ID from the sentry-trace header
+          const sentryTrace = headers['sentry-trace'] as string;
+          outgoingSpanId = sentryTrace.split('-')[1];
+
+          // Verify we're not propagating all-zero trace IDs
+          expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000-1');
+        })
+        .start();
+
+      await createRunner()
+        .withEnv({ SERVER_URL })
+        .expect({
+          transaction: event => {
+            expect(event.transaction).toBe('test_span');
+
+            // Verify that an http.client span was created
+            const httpClientSpans = event.spans?.filter(span => span.op === 'http.client');
+            expect(httpClientSpans).toHaveLength(1);
+
+            const httpSpan = httpClientSpans![0];
+            expect(httpSpan?.description).toMatch(/^GET /);
+
+            // Verify the propagated span ID matches the created span
+            if (outgoingSpanId) {
+              expect(httpSpan?.span_id).toBe(outgoingSpanId);
+            }
+
+            // Verify span attributes include sentry.origin
+            expect(httpSpan?.data?.['sentry.origin']).toBe('auto.http.otel.http');
+          },
+        })
+        .start()
+        .completed();
+      closeTestServer();
+    });
+  });
+});