feat(cloudflare): Support propagateTraceparent

Author: timfish

dev-packages/cloudflare-integration-tests/runner.ts

@@ -64,8 +64,13 @@ export function createRunner(...paths: string[]) {
   const expectedEnvelopes: Expected[] = [];
   // By default, we ignore session & sessions
   const ignored: Set<EnvelopeItemType> = new Set(['session', 'sessions', 'client_report']);
+  let serverUrl: string | undefined;
 
   return {
+    withServerUrl: function (url: string) {
+      serverUrl = url;
+      return this;
+    },
     expect: function (expected: Expected) {
       expectedEnvelopes.push(expected);
       return this;
@@ -154,6 +159,8 @@ export function createRunner(...paths: string[]) {
               'false',
               '--var',
               `SENTRY_DSN:http://public@localhost:${mockServerPort}/1337`,
+              '--var',
+              `SERVER_URL:${serverUrl}`,
             ],
             { stdio, signal },
           );

dev-packages/cloudflare-integration-tests/suites/tracing/headers/index.ts

@@ -0,0 +1,19 @@
+import * as Sentry from '@sentry/cloudflare';
+
+interface Env {
+  SENTRY_DSN: string;
+  SERVER_URL: string;
+}
+
+export default Sentry.withSentry(
+  (env: Env) => ({
+    dsn: env.SENTRY_DSN,
+    propagateTraceparent: true,
+  }),
+  {
+    async fetch(_request, env, _ctx) {
+      await fetch(env.SERVER_URL);
+      throw new Error('Test error to capture trace headers');
+    },
+  },
+);

dev-packages/cloudflare-integration-tests/suites/tracing/headers/test.ts

@@ -0,0 +1,59 @@
+import { createTestServer } from '@sentry-internal/test-utils';
+import { expect, it } from 'vitest';
+import { eventEnvelope } from '../../../expect';
+import { createRunner } from '../../../runner';
+
+it('Tracing headers', async ({ signal }) => {
+  expect.assertions(5);
+
+  const [SERVER_URL, closeTestServer] = await createTestServer()
+    .get('/', headers => {
+      expect(headers['baggage']).toEqual(expect.any(String));
+      expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f\d]{32})-([a-f\d]{16})-0$/));
+      expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000-0');
+      expect(headers['traceparent']).toEqual(expect.stringMatching(/^00-([a-f\d]{32})-([a-f\d]{16})-00$/));
+    })
+    .start();
+
+  const runner = createRunner(__dirname)
+    .withServerUrl(SERVER_URL)
+    .expect(
+      eventEnvelope({
+        level: 'error',
+        exception: {
+          values: [
+            {
+              type: 'Error',
+              value: 'Test error to capture trace headers',
+              stacktrace: {
+                frames: expect.any(Array),
+              },
+              mechanism: { type: 'auto.http.cloudflare', handled: false },
+            },
+          ],
+        },
+        breadcrumbs: [
+          {
+            category: 'fetch',
+            data: {
+              method: 'GET',
+              status_code: 200,
+              url: expect.stringContaining('http://localhost:'),
+            },
+            timestamp: expect.any(Number),
+            type: 'http',
+          },
+        ],
+        request: {
+          headers: expect.any(Object),
+          method: 'GET',
+          url: expect.any(String),
+        },
+      }),
+    )
+    .start(signal);
+
+  await runner.makeRequest('get', '/');
+  await runner.completed();
+  closeTestServer();
+});

dev-packages/cloudflare-integration-tests/suites/tracing/headers/wrangler.jsonc

@@ -0,0 +1,6 @@
+{
+  "name": "worker-name",
+  "compatibility_date": "2025-06-17",
+  "main": "index.ts",
+  "compatibility_flags": ["nodejs_compat"]
+}

dev-packages/node-core-integration-tests/suites/tracing/dsc-txn-name-update/test.ts

@@ -1,7 +1,7 @@
+import { createTestServer } from '@sentry-internal/test-utils';
 import { expect, test } from 'vitest';
 import { conditionalTest } from '../../../utils';
 import { createRunner } from '../../../utils/runner';
-import { createTestServer } from '../../../utils/server';
 
 // This test requires Node.js 22+ because it depends on the 'http.client.request.created'
 // diagnostic channel for baggage header propagation, which only exists since Node 22.12.0+ and 23.2.0+

dev-packages/node-core-integration-tests/suites/tracing/requests/traceparent/test.ts

@@ -1,6 +1,6 @@
+import { createTestServer } from '@sentry-internal/test-utils';
 import { describe, expect } from 'vitest';
 import { createEsmAndCjsTests } from '../../../../utils/runner';
-import { createTestServer } from '../../../../utils/server';
 
 describe('outgoing traceparent', () => {
   createEsmAndCjsTests(__dirname, 'scenario-fetch.mjs', 'instrument.mjs', (createRunner, test) => {

dev-packages/node-core-integration-tests/suites/tracing/tracePropagationTargets/test.ts

@@ -1,7 +1,7 @@
+import { createTestServer } from '@sentry-internal/test-utils';
 import { expect, test } from 'vitest';
 import { conditionalTest } from '../../../utils';
 import { createRunner } from '../../../utils/runner';
-import { createTestServer } from '../../../utils/server';
 
 // This test requires Node.js 22+ because it depends on the 'http.client.request.created'
 // diagnostic channel for baggage header propagation, which only exists since Node 22.12.0+ and 23.2.0+

dev-packages/node-core-integration-tests/utils/server.ts

@@ -38,48 +38,3 @@ export function createBasicSentryServer(onEnvelope: (env: Envelope) => void): Pr
   });
 }
 
-type HeaderAssertCallback = (headers: Record<string, string | string[] | undefined>) => void;
-
-/** Creates a test server that can be used to check headers */
-// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-export function createTestServer() {
-  const gets: Array<[string, HeaderAssertCallback, number]> = [];
-  let error: unknown | undefined;
-
-  return {
-    get: function (path: string, callback: HeaderAssertCallback, result = 200) {
-      gets.push([path, callback, result]);
-      return this;
-    },
-    start: async (): Promise<[string, () => void]> => {
-      const app = express();
-
-      for (const [path, callback, result] of gets) {
-        app.get(path, (req, res) => {
-          try {
-            callback(req.headers);
-          } catch (e) {
-            error = e;
-          }
-
-          res.status(result).send();
-        });
-      }
-
-      return new Promise(resolve => {
-        const server = app.listen(0, () => {
-          const address = server.address() as AddressInfo;
-          resolve([
-            `http://localhost:${address.port}`,
-            () => {
-              server.close();
-              if (error) {
-                throw error;
-              }
-            },
-          ]);
-        });
-      });
-    },
-  };
-}

dev-packages/node-integration-tests/suites/tracing/dsc-txn-name-update/test.ts

@@ -1,6 +1,6 @@
+import { createTestServer } from '@sentry-internal/test-utils';
 import { expect, test } from 'vitest';
 import { createRunner } from '../../../utils/runner';
-import { createTestServer } from '../../../utils/server';
 
 test('adds current transaction name to baggage when the txn name is high-quality', async () => {
   expect.assertions(5);

dev-packages/node-integration-tests/suites/tracing/http-client-spans/fetch-basic/test.ts

@@ -1,6 +1,6 @@
+import { createTestServer } from '@sentry-internal/test-utils';
 import { expect, test } from 'vitest';
 import { createRunner } from '../../../../utils/runner';
-import { createTestServer } from '../../../../utils/server';
 
 test('captures spans for outgoing fetch requests', async () => {
   expect.assertions(3);