feat(node): Ensure tracing without performance (TWP) works (#11564)

This fixes the node SDK to make tracing without performance work as
expected.

This has three aspects:

1. Ensure we always have an url to check against
`tracePropagationTargets`, even if the span is not sampled.
2. Ensure we use the correct propagation context always
3. Ensure we actually consistently handle ougoing http.client spans
without an active transaction

The fix for 2. was to have a fallback behavior if we don't have a scope
linked to a context yet (we'll just use the current scope then). This is
needed because we won't necessarily have an assigned scope yet at the
time this is called, because at this point in time this is still a
floating context. This also meant removing the fallback code to look at
the remote span context (because we'll always have a scope now).

The fix for 3. was to move this out of the http integration and do this
in the sampler instead.

The fix for 1. was a bit more elaborate, because we require different
things to solve the http instrumentation and the fetch instrumentation.

For fetch, we leverage our sampler, which can attach trace state that
even unsampled spans will have. We attach the URL as trace state which
we can read in the propagator, ensuring this works even for unsampled
spans.

Sadly, for http this is not sufficient, because our usage of
`onlyIfParentForOutgoingRequest` lead to some spans being created
outside of the sampler. By removing this option (see 3) and doing stuff
in the sampler instead, we can ensure that all spans for http are
handled properly.

This also bumps our node-fetch otel instrumentation to
[1.2.0](https://github.com/gas-buddy/opentelemetry-instrumentation-fetch-node/releases/tag/v1.2.0)
which fixes headers for Node 21 (tests were actually failing without
this!).

Author: mydea

dev-packages/node-integration-tests/suites/express/sentry-trace/trace-header-assign/server.ts

@@ -0,0 +1,35 @@
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+import * as Sentry from '@sentry/node';
+
+export type TestAPIResponse = { test_data: { host: string; 'sentry-trace': string; baggage: string } };
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  environment: 'prod',
+  integrations: [
+    // TODO: This used to use the Express integration
+  ],
+  tracesSampleRate: 1.0,
+  transport: loggingTransport,
+});
+
+import http from 'http';
+import { startExpressServerAndSendPortToRunner } from '@sentry-internal/node-integration-tests';
+import cors from 'cors';
+import express from 'express';
+
+const app = express();
+
+app.use(cors());
+
+app.get('/test/express', (_req, res) => {
+  const headers = http.get('http://somewhere.not.sentry/').getHeaders();
+
+  // Responding with the headers outgoing request headers back to the assertions.
+  res.send({ test_data: headers });
+});
+
+Sentry.setupExpressErrorHandler(app);
+
+startExpressServerAndSendPortToRunner(app);

dev-packages/node-integration-tests/suites/express/sentry-trace/trace-header-assign/test.ts

@@ -7,7 +7,7 @@ afterAll(() => {
 });
 
 test('Should assign `sentry-trace` header which sets parent trace id of an outgoing request.', async () => {
-  const runner = createRunner(__dirname, '..', 'server.ts').start();
+  const runner = createRunner(__dirname, 'server.ts').start();
 
   const response = await runner.makeRequest<TestAPIResponse>('get', '/test/express', {
     'sentry-trace': '12312012123120121231201212312012-1121201211212012-0',

dev-packages/node-integration-tests/suites/tracing/requests/fetch-noSampleRate/scenario.ts

@@ -0,0 +1,24 @@
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+import * as Sentry from '@sentry/node';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracePropagationTargets: [/\/v0/, 'v1'],
+  integrations: [],
+  transport: loggingTransport,
+});
+
+async function run(): Promise<void> {
+  // Since fetch is lazy loaded, we need to wait a bit until it's fully instrumented
+  await new Promise(resolve => setTimeout(resolve, 100));
+  await fetch(`${process.env.SERVER_URL}/api/v0`).then(res => res.text());
+  await fetch(`${process.env.SERVER_URL}/api/v1`).then(res => res.text());
+  await fetch(`${process.env.SERVER_URL}/api/v2`).then(res => res.text());
+  await fetch(`${process.env.SERVER_URL}/api/v3`).then(res => res.text());
+
+  Sentry.captureException(new Error('foo'));
+}
+
+// eslint-disable-next-line @typescript-eslint/no-floating-promises
+run();

dev-packages/node-integration-tests/suites/tracing/requests/fetch-noSampleRate/test.ts

@@ -0,0 +1,53 @@
+import { conditionalTest } from '../../../../utils';
+import { createRunner } from '../../../../utils/runner';
+import { createTestServer } from '../../../../utils/server';
+
+conditionalTest({ min: 18 })('outgoing fetch', () => {
+  test('outgoing fetch requests are correctly instrumented without tracesSampleRate', done => {
+    expect.assertions(15);
+
+    createTestServer(done)
+      .get('/api/v0', headers => {
+        expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})$/));
+        expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000');
+        expect(headers['baggage']).toEqual(expect.any(String));
+        expect(headers['__requestUrl']).toBeUndefined();
+      })
+      .get('/api/v1', headers => {
+        expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})$/));
+        expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000');
+        expect(headers['baggage']).toEqual(expect.any(String));
+        expect(headers['__requestUrl']).toBeUndefined();
+      })
+      .get('/api/v2', headers => {
+        expect(headers['baggage']).toBeUndefined();
+        expect(headers['sentry-trace']).toBeUndefined();
+        expect(headers['__requestUrl']).toBeUndefined();
+      })
+      .get('/api/v3', headers => {
+        expect(headers['baggage']).toBeUndefined();
+        expect(headers['sentry-trace']).toBeUndefined();
+        expect(headers['__requestUrl']).toBeUndefined();
+      })
+      .start()
+      .then(SERVER_URL => {
+        createRunner(__dirname, 'scenario.ts')
+          .withEnv({ SERVER_URL })
+          .ensureNoErrorOutput()
+          .ignore('session', 'sessions')
+          .expect({
+            event: {
+              exception: {
+                values: [
+                  {
+                    type: 'Error',
+                    value: 'foo',
+                  },
+                ],
+              },
+            },
+          })
+          .start(done);
+      });
+  });
+});

dev-packages/node-integration-tests/suites/tracing/requests/fetch-sampled-no-active-span/scenario.ts

@@ -0,0 +1,25 @@
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+import * as Sentry from '@sentry/node';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracePropagationTargets: [/\/v0/, 'v1'],
+  tracesSampleRate: 1.0,
+  integrations: [],
+  transport: loggingTransport,
+});
+
+async function run(): Promise<void> {
+  // Since fetch is lazy loaded, we need to wait a bit until it's fully instrumented
+  await new Promise(resolve => setTimeout(resolve, 100));
+  await fetch(`${process.env.SERVER_URL}/api/v0`).then(res => res.text());
+  await fetch(`${process.env.SERVER_URL}/api/v1`).then(res => res.text());
+  await fetch(`${process.env.SERVER_URL}/api/v2`).then(res => res.text());
+  await fetch(`${process.env.SERVER_URL}/api/v3`).then(res => res.text());
+
+  Sentry.captureException(new Error('foo'));
+}
+
+// eslint-disable-next-line @typescript-eslint/no-floating-promises
+run();

dev-packages/node-integration-tests/suites/tracing/requests/fetch-sampled-no-active-span/test.ts

@@ -0,0 +1,48 @@
+import { conditionalTest } from '../../../../utils';
+import { createRunner } from '../../../../utils/runner';
+import { createTestServer } from '../../../../utils/server';
+
+conditionalTest({ min: 18 })('outgoing fetch', () => {
+  test('outgoing sampled fetch requests without active span are correctly instrumented', done => {
+    expect.assertions(11);
+
+    createTestServer(done)
+      .get('/api/v0', headers => {
+        expect(headers['baggage']).toEqual(expect.any(String));
+        expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})$/));
+        expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000');
+      })
+      .get('/api/v1', headers => {
+        expect(headers['baggage']).toEqual(expect.any(String));
+        expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})$/));
+        expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000');
+      })
+      .get('/api/v2', headers => {
+        expect(headers['baggage']).toBeUndefined();
+        expect(headers['sentry-trace']).toBeUndefined();
+      })
+      .get('/api/v3', headers => {
+        expect(headers['baggage']).toBeUndefined();
+        expect(headers['sentry-trace']).toBeUndefined();
+      })
+      .start()
+      .then(SERVER_URL => {
+        createRunner(__dirname, 'scenario.ts')
+          .withEnv({ SERVER_URL })
+          .ignore('session', 'sessions')
+          .expect({
+            event: {
+              exception: {
+                values: [
+                  {
+                    type: 'Error',
+                    value: 'foo',
+                  },
+                ],
+              },
+            },
+          })
+          .start(done);
+      });
+  });
+});

dev-packages/node-integration-tests/suites/tracing/requests/fetch-sampled/scenario.ts

@@ -0,0 +1,25 @@
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+import * as Sentry from '@sentry/node';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracesSampleRate: 1.0,
+  tracePropagationTargets: [/\/v0/, 'v1'],
+  integrations: [],
+  transport: loggingTransport,
+});
+
+async function run(): Promise<void> {
+  await Sentry.startSpan({ name: 'test_span' }, async () => {
+    // Since fetch is lazy loaded, we need to wait a bit until it's fully instrumented
+    await new Promise(resolve => setTimeout(resolve, 100));
+    await fetch(`${process.env.SERVER_URL}/api/v0`).then(res => res.text());
+    await fetch(`${process.env.SERVER_URL}/api/v1`).then(res => res.text());
+    await fetch(`${process.env.SERVER_URL}/api/v2`).then(res => res.text());
+    await fetch(`${process.env.SERVER_URL}/api/v3`).then(res => res.text());
+  });
+}
+
+// eslint-disable-next-line @typescript-eslint/no-floating-promises
+run();

dev-packages/node-integration-tests/suites/tracing/requests/fetch-sampled/test.ts

@@ -0,0 +1,40 @@
+import { conditionalTest } from '../../../../utils';
+import { createRunner } from '../../../../utils/runner';
+import { createTestServer } from '../../../../utils/server';
+
+conditionalTest({ min: 18 })('outgoing fetch', () => {
+  test('outgoing sampled fetch requests are correctly instrumented', done => {
+    expect.assertions(11);
+
+    createTestServer(done)
+      .get('/api/v0', headers => {
+        expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})-1$/));
+        expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000-1');
+        expect(headers['baggage']).toEqual(expect.any(String));
+      })
+      .get('/api/v1', headers => {
+        expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})-1$/));
+        expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000-1');
+        expect(headers['baggage']).toEqual(expect.any(String));
+      })
+      .get('/api/v2', headers => {
+        expect(headers['baggage']).toBeUndefined();
+        expect(headers['sentry-trace']).toBeUndefined();
+      })
+      .get('/api/v3', headers => {
+        expect(headers['baggage']).toBeUndefined();
+        expect(headers['sentry-trace']).toBeUndefined();
+      })
+      .start()
+      .then(SERVER_URL => {
+        createRunner(__dirname, 'scenario.ts')
+          .withEnv({ SERVER_URL })
+          .expect({
+            transaction: {
+              // we're not too concerned with the actual transaction here since this is tested elsewhere
+            },
+          })
+          .start(done);
+      });
+  });
+});

dev-packages/node-integration-tests/suites/tracing/requests/fetch-unsampled/scenario.ts

@@ -0,0 +1,28 @@
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+import * as Sentry from '@sentry/node';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracePropagationTargets: [/\/v0/, 'v1'],
+  tracesSampleRate: 0,
+  integrations: [],
+  transport: loggingTransport,
+});
+
+async function run(): Promise<void> {
+  // Wrap in span that is not sampled
+  await Sentry.startSpan({ name: 'outer' }, async () => {
+    // Since fetch is lazy loaded, we need to wait a bit until it's fully instrumented
+    await new Promise(resolve => setTimeout(resolve, 100));
+    await fetch(`${process.env.SERVER_URL}/api/v0`).then(res => res.text());
+    await fetch(`${process.env.SERVER_URL}/api/v1`).then(res => res.text());
+    await fetch(`${process.env.SERVER_URL}/api/v2`).then(res => res.text());
+    await fetch(`${process.env.SERVER_URL}/api/v3`).then(res => res.text());
+  });
+
+  Sentry.captureException(new Error('foo'));
+}
+
+// eslint-disable-next-line @typescript-eslint/no-floating-promises
+run();

dev-packages/node-integration-tests/suites/tracing/requests/fetch-unsampled/test.ts

@@ -0,0 +1,48 @@
+import { conditionalTest } from '../../../../utils';
+import { createRunner } from '../../../../utils/runner';
+import { createTestServer } from '../../../../utils/server';
+
+conditionalTest({ min: 18 })('outgoing fetch', () => {
+  test('outgoing fetch requests are correctly instrumented when not sampled', done => {
+    expect.assertions(11);
+
+    createTestServer(done)
+      .get('/api/v0', headers => {
+        expect(headers['baggage']).toEqual(expect.any(String));
+        expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})-0$/));
+        expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000-0');
+      })
+      .get('/api/v1', headers => {
+        expect(headers['baggage']).toEqual(expect.any(String));
+        expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f0-9]{32})-([a-f0-9]{16})-0$/));
+        expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000-0');
+      })
+      .get('/api/v2', headers => {
+        expect(headers['baggage']).toBeUndefined();
+        expect(headers['sentry-trace']).toBeUndefined();
+      })
+      .get('/api/v3', headers => {
+        expect(headers['baggage']).toBeUndefined();
+        expect(headers['sentry-trace']).toBeUndefined();
+      })
+      .start()
+      .then(SERVER_URL => {
+        createRunner(__dirname, 'scenario.ts')
+          .withEnv({ SERVER_URL })
+          .ignore('session', 'sessions')
+          .expect({
+            event: {
+              exception: {
+                values: [
+                  {
+                    type: 'Error',
+                    value: 'foo',
+                  },
+                ],
+              },
+            },
+          })
+          .start(done);
+      });
+  });
+});