feat(node-core): Add outgoing trace propagation to light mode

dev-packages/node-core-integration-tests/suites/light-mode/outgoing-fetch/server.js

@@ -0,0 +1,70 @@
+const http = require('http');
+const Sentry = require('@sentry/node-core/light');
+const { loggingTransport, sendPortToRunner } = require('@sentry-internal/node-core-integration-tests');
+
+Sentry.init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ release: '1.0',
+ transport: loggingTransport,
+ tracePropagationTargets: [/\/api\/v0/, 'v1'],
+});
+
+let capturedV0 = {};
+let capturedV1 = {};
+let capturedV2 = {};
+
+const targetServer = http.createServer((req, res) => {
+ const headers = {
+ 'sentry-trace': req.headers['sentry-trace'],
+ baggage: req.headers['baggage'],
+ };
+
+ if (req.url === '/api/v0') {
+ capturedV0 = headers;
+ } else if (req.url === '/api/v1') {
+ capturedV1 = headers;
+ } else if (req.url === '/api/v2') {
+ capturedV2 = headers;
+ }
+
+ res.writeHead(200);
+ res.end('ok');
+});
+
+targetServer.listen(0, () => {
+ const targetPort = targetServer.address().port;
+ const targetUrl = `http://localhost:${targetPort}`;
+
+ const server = http.createServer(async (req, res) => {
+ switch (req.url) {
+ case '/test-auto-propagation': {
+ capturedV0 = {};
+ capturedV1 = {};
+ capturedV2 = {};
+ await fetch(`${targetUrl}/api/v0`);
+ await fetch(`${targetUrl}/api/v1`);
+ await fetch(`${targetUrl}/api/v2`);
+ res.writeHead(200, { 'Content-Type': 'application/json' });
+ res.end(JSON.stringify({ '/api/v0': capturedV0, '/api/v1': capturedV1, '/api/v2': capturedV2 }));
+ break;
+ }
+ case '/test-breadcrumbs': {
+ Sentry.addBreadcrumb({ message: 'manual breadcrumb' });
+ await fetch(`${targetUrl}/api/v0`);
+ await fetch(`${targetUrl}/api/v1`);
+ Sentry.captureException(new Error('foo'));
+ res.writeHead(200);
+ res.end('ok');
+ break;
+ }
+ default: {
+ res.writeHead(404);
+ res.end();
+ }
+ }
+ });
+
+ server.listen(0, () => {
+ sendPortToRunner(server.address().port);
+ });
+});

dev-packages/node-core-integration-tests/suites/light-mode/outgoing-fetch/test.ts

@@ -0,0 +1,79 @@
+import crypto from 'crypto';
+import { afterAll, expect, test } from 'vitest';
+import { conditionalTest } from '../../../utils';
+import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
+
+afterAll(() => {
+ cleanupChildProcesses();
+});
+
+conditionalTest({ min: 22 })('light mode outgoing fetch', () => {
+ test('automatically propagates trace headers to outgoing fetch requests matching tracePropagationTargets', async () => {
+ const traceId = crypto.randomUUID().replace(/-/g, '');
+ const parentSpanId = traceId.substring(0, 16);
+
+ const runner = createRunner(__dirname, 'server.js').start();
+
+ const response = await runner.makeRequest<Record<string, { 'sentry-trace'?: string; baggage?: string }>>(
+ 'get',
+ '/test-auto-propagation',
+ {
+ headers: {
+ 'sentry-trace': `${traceId}-${parentSpanId}-1`,
+ baggage: `sentry-trace_id=${traceId},sentry-environment=test,sentry-public_key=public`,
+ },
+ },
+ );
+
+ // /api/v0 matches tracePropagationTargets - should have headers
+ expect(response?.['/api/v0']?.['sentry-trace']).toMatch(new RegExp(`^${traceId}-[a-f\\d]{16}-1$`));
+ expect(response?.['/api/v0']?.baggage).toContain(`sentry-trace_id=${traceId}`);
+
+ // /api/v1 matches tracePropagationTargets - should have headers
+ expect(response?.['/api/v1']?.['sentry-trace']).toMatch(new RegExp(`^${traceId}-[a-f\\d]{16}-1$`));
+ expect(response?.['/api/v1']?.baggage).toContain(`sentry-trace_id=${traceId}`);
+
+ // /api/v2 does NOT match tracePropagationTargets - should NOT have headers
+ expect(response?.['/api/v2']?.['sentry-trace']).toBeUndefined();
+ expect(response?.['/api/v2']?.baggage).toBeUndefined();
+ });
+
+ test('creates breadcrumbs for outgoing fetch requests', async () => {
+ const runner = createRunner(__dirname, 'server.js')
+ .expect({
+ event: event => {
+ const breadcrumbs = event.breadcrumbs || [];
+ const httpBreadcrumbs = breadcrumbs.filter(b => b.category === 'http');
+
+ expect(httpBreadcrumbs.length).toBe(2);
+
+ expect(httpBreadcrumbs[0]).toEqual(
+ expect.objectContaining({
+ category: 'http',
+ type: 'http',
+ data: expect.objectContaining({
+ 'http.method': 'GET',
+ status_code: 200,
+ }),
+ }),
+ );
+
+ expect(httpBreadcrumbs[1]).toEqual(
+ expect.objectContaining({
+ category: 'http',
+ type: 'http',
+ data: expect.objectContaining({
+ 'http.method': 'GET',
+ status_code: 200,
+ }),
+ }),
+ );
+ },
+ })
+ .start();
+
+ await runner.makeRequest('get', '/test-breadcrumbs');
+
+ await runner.completed();
+ });
+});

dev-packages/node-core-integration-tests/suites/light-mode/outgoing-http/server.js

@@ -0,0 +1,98 @@
+const http = require('http');
+const Sentry = require('@sentry/node-core/light');
+const { loggingTransport, sendPortToRunner } = require('@sentry-internal/node-core-integration-tests');
+
+Sentry.init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ release: '1.0',
+ transport: loggingTransport,
+ tracePropagationTargets: [/\/api\/v0/, 'v1'],
+ beforeBreadcrumb(breadcrumb, hint) {
+ breadcrumb.data = breadcrumb.data || {};
+ const req = hint?.request;
+ if (req?.path) {
+ breadcrumb.data.ADDED_PATH = req.path;
+ }
+ return breadcrumb;
+ },
+});
+
+function makeHttpRequest(url) {
+ return new Promise((resolve, reject) => {
+ const urlObj = new URL(url);
+ const req = http.request(
+ {
+ hostname: urlObj.hostname,
+ port: urlObj.port,
+ path: urlObj.pathname,
+ method: 'GET',
+ },
+ res => {
+ res.on('data', () => {});
+ res.on('end', () => resolve());
+ },
+ );
+ req.on('error', reject);
+ req.end();
+ });
+}
+
+let capturedV0 = {};
+let capturedV1 = {};
+let capturedV2 = {};
+
+const targetServer = http.createServer((req, res) => {
+ const headers = {
+ 'sentry-trace': req.headers['sentry-trace'],
+ baggage: req.headers['baggage'],
+ };
+
+ if (req.url === '/api/v0') {
+ capturedV0 = headers;
+ } else if (req.url === '/api/v1') {
+ capturedV1 = headers;
+ } else if (req.url === '/api/v2') {
+ capturedV2 = headers;
+ }
+
+ res.writeHead(200);
+ res.end('ok');
+});
+
+targetServer.listen(0, () => {
+ const targetPort = targetServer.address().port;
+ const targetUrl = `http://localhost:${targetPort}`;
+
+ const server = http.createServer(async (req, res) => {
+ switch (req.url) {
+ case '/test-auto-propagation': {
+ capturedV0 = {};
+ capturedV1 = {};
+ capturedV2 = {};
+ await makeHttpRequest(`${targetUrl}/api/v0`);
+ await makeHttpRequest(`${targetUrl}/api/v1`);
+ await makeHttpRequest(`${targetUrl}/api/v2`);
+ res.writeHead(200, { 'Content-Type': 'application/json' });
+ res.end(JSON.stringify({ '/api/v0': capturedV0, '/api/v1': capturedV1, '/api/v2': capturedV2 }));
+ break;
+ }
+ case '/test-breadcrumbs': {
+ Sentry.addBreadcrumb({ message: 'manual breadcrumb' });
+ await makeHttpRequest(`${targetUrl}/api/v0`);
+ await makeHttpRequest(`${targetUrl}/api/v1`);
+ Sentry.captureException(new Error('foo'));
+ res.writeHead(200);
+ res.end('ok');
+ break;
+ }
+ default: {
+ res.writeHead(404);
+ res.end();
+ }
+ }
+ });
+
+ server.listen(0, () => {
+ sendPortToRunner(server.address().port);
+ });
+});

dev-packages/node-core-integration-tests/suites/light-mode/outgoing-http/test.ts

@@ -0,0 +1,79 @@
+import crypto from 'crypto';
+import { afterAll, expect, test } from 'vitest';
+import { conditionalTest } from '../../../utils';
+import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
+
+afterAll(() => {
+ cleanupChildProcesses();
+});
+
+conditionalTest({ min: 22 })('light mode outgoing http', () => {
+ test('automatically propagates trace headers to outgoing http requests matching tracePropagationTargets', async () => {
+ const traceId = crypto.randomUUID().replace(/-/g, '');
+ const parentSpanId = traceId.substring(0, 16);
+
+ const runner = createRunner(__dirname, 'server.js').start();
+
+ const response = await runner.makeRequest<Record<string, { 'sentry-trace'?: string; baggage?: string }>>(
+ 'get',
+ '/test-auto-propagation',
+ {
+ headers: {
+ 'sentry-trace': `${traceId}-${parentSpanId}-1`,
+ baggage: `sentry-trace_id=${traceId},sentry-environment=test,sentry-public_key=public`,
+ },
+ },
+ );
+
+ // /api/v0 matches tracePropagationTargets - should have headers
+ expect(response?.['/api/v0']?.['sentry-trace']).toMatch(new RegExp(`^${traceId}-[a-f\\d]{16}-1$`));
+ expect(response?.['/api/v0']?.baggage).toContain(`sentry-trace_id=${traceId}`);
+
+ // /api/v1 matches tracePropagationTargets - should have headers
+ expect(response?.['/api/v1']?.['sentry-trace']).toMatch(new RegExp(`^${traceId}-[a-f\\d]{16}-1$`));
+ expect(response?.['/api/v1']?.baggage).toContain(`sentry-trace_id=${traceId}`);
+
+ // /api/v2 does NOT match tracePropagationTargets - should NOT have headers
+ expect(response?.['/api/v2']?.['sentry-trace']).toBeUndefined();
+ expect(response?.['/api/v2']?.baggage).toBeUndefined();
+ });
+
+ test('creates breadcrumbs for outgoing http requests', async () => {
+ const runner = createRunner(__dirname, 'server.js')
+ .expect({
+ event: event => {
+ const breadcrumbs = event.breadcrumbs || [];
+ const httpBreadcrumbs = breadcrumbs.filter(b => b.category === 'http');
+
+ expect(httpBreadcrumbs.length).toBe(2);
+
+ expect(httpBreadcrumbs[0]).toEqual(
+ expect.objectContaining({
+ category: 'http',
+ type: 'http',
+ data: expect.objectContaining({
+ 'http.method': 'GET',
+ status_code: 200,
+ }),
+ }),
+ );
+
+ expect(httpBreadcrumbs[1]).toEqual(
+ expect.objectContaining({
+ category: 'http',
+ type: 'http',
+ data: expect.objectContaining({
+ 'http.method': 'GET',
+ status_code: 200,
+ }),
+ }),
+ );
+ },
+ })
+ .start();
+
+ await runner.makeRequest('get', '/test-breadcrumbs');
+
+ await runner.completed();
+ });
+});

packages/core/src/index.ts

@@ -92,6 +92,7 @@ export { _setSpanForScope as _INTERNAL_setSpanForScope } from './utils/spanOnSco
 export { parseSampleRate } from './utils/parseSampleRate';
 export { applySdkMetadata } from './utils/sdkMetadata';
 export { getTraceData } from './utils/traceData';
+export { shouldPropagateTraceForUrl } from './utils/tracePropagationTargets';
 export { getTraceMetaTags } from './utils/meta';
 export { debounce } from './utils/debounce';
 export {

packages/core/src/utils/tracePropagationTargets.ts

@@ -0,0 +1,34 @@
+import type { CoreOptions as Options } from '../types-hoist/options';
+import { debug } from './debug-logger';
+import type { LRUMap } from './lru';
+import { stringMatchesSomePattern } from './string';
+
+const NOT_PROPAGATED_MESSAGE =
+ '[Tracing] Not injecting trace data for url because it does not match tracePropagationTargets:';
+
+/**
+ * Check if a given URL should be propagated to or not.
+ * If no url is defined, or no trace propagation targets are defined, this will always return `true`.
+ * You can also optionally provide a decision map, to cache decisions and avoid repeated regex lookups.
+ */
+export function shouldPropagateTraceForUrl(
+ url: string | undefined,
+ tracePropagationTargets: Options['tracePropagationTargets'],
+ decisionMap?: LRUMap<string, boolean>,
+): boolean {
+ if (typeof url !== 'string' || !tracePropagationTargets) {
+ return true;
+ }
+
+ const cachedDecision = decisionMap?.get(url);
+ if (cachedDecision !== undefined) {
+ !cachedDecision && debug.log(NOT_PROPAGATED_MESSAGE, url);
+ return cachedDecision;
+ }
+
+ const decision = stringMatchesSomePattern(url, tracePropagationTargets);
+ decisionMap?.set(url, decision);
+
+ !decision && debug.log(NOT_PROPAGATED_MESSAGE, url);
+ return decision;
+}

dev-packages/node-core-integration-tests/suites/light-mode/outgoing-fetch/server.js

@@ -0,0 +1,70 @@
+const http = require('http');
+const Sentry = require('@sentry/node-core/light');
+const { loggingTransport, sendPortToRunner } = require('@sentry-internal/node-core-integration-tests');
+
+Sentry.init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ release: '1.0',
+ transport: loggingTransport,
+ tracePropagationTargets: [/\/api\/v0/, 'v1'],
+});
+
+let capturedV0 = {};
+let capturedV1 = {};
+let capturedV2 = {};
+
+const targetServer = http.createServer((req, res) => {
+ const headers = {
+ 'sentry-trace': req.headers['sentry-trace'],
+ baggage: req.headers['baggage'],
+ };
+
+ if (req.url === '/api/v0') {
+ capturedV0 = headers;
+ } else if (req.url === '/api/v1') {
+ capturedV1 = headers;
+ } else if (req.url === '/api/v2') {
+ capturedV2 = headers;
+ }
+
+ res.writeHead(200);
+ res.end('ok');
+});
+
+targetServer.listen(0, () => {
+ const targetPort = targetServer.address().port;
+ const targetUrl = `http://localhost:${targetPort}`;
+
+ const server = http.createServer(async (req, res) => {
+ switch (req.url) {
+ case '/test-auto-propagation': {
+ capturedV0 = {};
+ capturedV1 = {};
+ capturedV2 = {};
+ await fetch(`${targetUrl}/api/v0`);
+ await fetch(`${targetUrl}/api/v1`);
+ await fetch(`${targetUrl}/api/v2`);
+ res.writeHead(200, { 'Content-Type': 'application/json' });
+ res.end(JSON.stringify({ '/api/v0': capturedV0, '/api/v1': capturedV1, '/api/v2': capturedV2 }));
+ break;
+ }
+ case '/test-breadcrumbs': {
+ Sentry.addBreadcrumb({ message: 'manual breadcrumb' });
+ await fetch(`${targetUrl}/api/v0`);
+ await fetch(`${targetUrl}/api/v1`);
+ Sentry.captureException(new Error('foo'));
+ res.writeHead(200);
+ res.end('ok');
+ break;
+ }
+ default: {
+ res.writeHead(404);
+ res.end();
+ }
+ }
+ });
+
+ server.listen(0, () => {
+ sendPortToRunner(server.address().port);
+ });
+});

dev-packages/node-core-integration-tests/suites/light-mode/outgoing-fetch/test.ts

@@ -0,0 +1,79 @@
+import crypto from 'crypto';
+import { afterAll, expect, test } from 'vitest';
+import { conditionalTest } from '../../../utils';
+import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
+
+afterAll(() => {
+ cleanupChildProcesses();
+});
+
+conditionalTest({ min: 22 })('light mode outgoing fetch', () => {
+ test('automatically propagates trace headers to outgoing fetch requests matching tracePropagationTargets', async () => {
+ const traceId = crypto.randomUUID().replace(/-/g, '');
+ const parentSpanId = traceId.substring(0, 16);
+
+ const runner = createRunner(__dirname, 'server.js').start();
+
+ const response = await runner.makeRequest<Record<string, { 'sentry-trace'?: string; baggage?: string }>>(
+ 'get',
+ '/test-auto-propagation',
+ {
+ headers: {
+ 'sentry-trace': `${traceId}-${parentSpanId}-1`,
+ baggage: `sentry-trace_id=${traceId},sentry-environment=test,sentry-public_key=public`,
+ },
+ },
+ );
+
+ // /api/v0 matches tracePropagationTargets - should have headers
+ expect(response?.['/api/v0']?.['sentry-trace']).toMatch(new RegExp(`^${traceId}-[a-f\\d]{16}-1$`));
+ expect(response?.['/api/v0']?.baggage).toContain(`sentry-trace_id=${traceId}`);
+
+ // /api/v1 matches tracePropagationTargets - should have headers
+ expect(response?.['/api/v1']?.['sentry-trace']).toMatch(new RegExp(`^${traceId}-[a-f\\d]{16}-1$`));
+ expect(response?.['/api/v1']?.baggage).toContain(`sentry-trace_id=${traceId}`);
+
+ // /api/v2 does NOT match tracePropagationTargets - should NOT have headers
+ expect(response?.['/api/v2']?.['sentry-trace']).toBeUndefined();
+ expect(response?.['/api/v2']?.baggage).toBeUndefined();
+ });
+
+ test('creates breadcrumbs for outgoing fetch requests', async () => {
+ const runner = createRunner(__dirname, 'server.js')
+ .expect({
+ event: event => {
+ const breadcrumbs = event.breadcrumbs || [];
+ const httpBreadcrumbs = breadcrumbs.filter(b => b.category === 'http');
+
+ expect(httpBreadcrumbs.length).toBe(2);
+
+ expect(httpBreadcrumbs[0]).toEqual(
+ expect.objectContaining({
+ category: 'http',
+ type: 'http',
+ data: expect.objectContaining({
+ 'http.method': 'GET',
+ status_code: 200,
+ }),
+ }),
+ );
+
+ expect(httpBreadcrumbs[1]).toEqual(
+ expect.objectContaining({
+ category: 'http',
+ type: 'http',
+ data: expect.objectContaining({
+ 'http.method': 'GET',
+ status_code: 200,
+ }),
+ }),
+ );
+ },
+ })
+ .start();
+
+ await runner.makeRequest('get', '/test-breadcrumbs');
+
+ await runner.completed();
+ });
+});

dev-packages/node-core-integration-tests/suites/light-mode/outgoing-http/server.js

@@ -0,0 +1,98 @@
+const http = require('http');
+const Sentry = require('@sentry/node-core/light');
+const { loggingTransport, sendPortToRunner } = require('@sentry-internal/node-core-integration-tests');
+
+Sentry.init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ release: '1.0',
+ transport: loggingTransport,
+ tracePropagationTargets: [/\/api\/v0/, 'v1'],
+ beforeBreadcrumb(breadcrumb, hint) {
+ breadcrumb.data = breadcrumb.data || {};
+ const req = hint?.request;
+ if (req?.path) {
+ breadcrumb.data.ADDED_PATH = req.path;
+ }
+ return breadcrumb;
+ },
+});
+
+function makeHttpRequest(url) {
+ return new Promise((resolve, reject) => {
+ const urlObj = new URL(url);
+ const req = http.request(
+ {
+ hostname: urlObj.hostname,
+ port: urlObj.port,
+ path: urlObj.pathname,
+ method: 'GET',
+ },
+ res => {
+ res.on('data', () => {});
+ res.on('end', () => resolve());
+ },
+ );
+ req.on('error', reject);
+ req.end();
+ });
+}
+
+let capturedV0 = {};
+let capturedV1 = {};
+let capturedV2 = {};
+
+const targetServer = http.createServer((req, res) => {
+ const headers = {
+ 'sentry-trace': req.headers['sentry-trace'],
+ baggage: req.headers['baggage'],
+ };
+
+ if (req.url === '/api/v0') {
+ capturedV0 = headers;
+ } else if (req.url === '/api/v1') {
+ capturedV1 = headers;
+ } else if (req.url === '/api/v2') {
+ capturedV2 = headers;
+ }
+
+ res.writeHead(200);
+ res.end('ok');
+});
+
+targetServer.listen(0, () => {
+ const targetPort = targetServer.address().port;
+ const targetUrl = `http://localhost:${targetPort}`;
+
+ const server = http.createServer(async (req, res) => {
+ switch (req.url) {
+ case '/test-auto-propagation': {
+ capturedV0 = {};
+ capturedV1 = {};
+ capturedV2 = {};
+ await makeHttpRequest(`${targetUrl}/api/v0`);
+ await makeHttpRequest(`${targetUrl}/api/v1`);
+ await makeHttpRequest(`${targetUrl}/api/v2`);
+ res.writeHead(200, { 'Content-Type': 'application/json' });
+ res.end(JSON.stringify({ '/api/v0': capturedV0, '/api/v1': capturedV1, '/api/v2': capturedV2 }));
+ break;
+ }
+ case '/test-breadcrumbs': {
+ Sentry.addBreadcrumb({ message: 'manual breadcrumb' });
+ await makeHttpRequest(`${targetUrl}/api/v0`);
+ await makeHttpRequest(`${targetUrl}/api/v1`);
+ Sentry.captureException(new Error('foo'));
+ res.writeHead(200);
+ res.end('ok');
+ break;
+ }
+ default: {
+ res.writeHead(404);
+ res.end();
+ }
+ }
+ });
+
+ server.listen(0, () => {
+ sendPortToRunner(server.address().port);
+ });
+});

dev-packages/node-core-integration-tests/suites/light-mode/outgoing-http/test.ts

@@ -0,0 +1,79 @@
+import crypto from 'crypto';
+import { afterAll, expect, test } from 'vitest';
+import { conditionalTest } from '../../../utils';
+import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
+
+afterAll(() => {
+ cleanupChildProcesses();
+});
+
+conditionalTest({ min: 22 })('light mode outgoing http', () => {
+ test('automatically propagates trace headers to outgoing http requests matching tracePropagationTargets', async () => {
+ const traceId = crypto.randomUUID().replace(/-/g, '');
+ const parentSpanId = traceId.substring(0, 16);
+
+ const runner = createRunner(__dirname, 'server.js').start();
+
+ const response = await runner.makeRequest<Record<string, { 'sentry-trace'?: string; baggage?: string }>>(
+ 'get',
+ '/test-auto-propagation',
+ {
+ headers: {
+ 'sentry-trace': `${traceId}-${parentSpanId}-1`,
+ baggage: `sentry-trace_id=${traceId},sentry-environment=test,sentry-public_key=public`,
+ },
+ },
+ );
+
+ // /api/v0 matches tracePropagationTargets - should have headers
+ expect(response?.['/api/v0']?.['sentry-trace']).toMatch(new RegExp(`^${traceId}-[a-f\\d]{16}-1$`));
+ expect(response?.['/api/v0']?.baggage).toContain(`sentry-trace_id=${traceId}`);
+
+ // /api/v1 matches tracePropagationTargets - should have headers
+ expect(response?.['/api/v1']?.['sentry-trace']).toMatch(new RegExp(`^${traceId}-[a-f\\d]{16}-1$`));
+ expect(response?.['/api/v1']?.baggage).toContain(`sentry-trace_id=${traceId}`);
+
+ // /api/v2 does NOT match tracePropagationTargets - should NOT have headers
+ expect(response?.['/api/v2']?.['sentry-trace']).toBeUndefined();
+ expect(response?.['/api/v2']?.baggage).toBeUndefined();
+ });
+
+ test('creates breadcrumbs for outgoing http requests', async () => {
+ const runner = createRunner(__dirname, 'server.js')
+ .expect({
+ event: event => {
+ const breadcrumbs = event.breadcrumbs || [];
+ const httpBreadcrumbs = breadcrumbs.filter(b => b.category === 'http');
+
+ expect(httpBreadcrumbs.length).toBe(2);
+
+ expect(httpBreadcrumbs[0]).toEqual(
+ expect.objectContaining({
+ category: 'http',
+ type: 'http',
+ data: expect.objectContaining({
+ 'http.method': 'GET',
+ status_code: 200,
+ }),
+ }),
+ );
+
+ expect(httpBreadcrumbs[1]).toEqual(
+ expect.objectContaining({
+ category: 'http',
+ type: 'http',
+ data: expect.objectContaining({
+ 'http.method': 'GET',
+ status_code: 200,
+ }),
+ }),
+ );
+ },
+ })
+ .start();
+
+ await runner.makeRequest('get', '/test-breadcrumbs');
+
+ await runner.completed();
+ });
+});

packages/core/src/index.ts

@@ -92,6 +92,7 @@ export { _setSpanForScope as _INTERNAL_setSpanForScope } from './utils/spanOnSco
 export { parseSampleRate } from './utils/parseSampleRate';
 export { applySdkMetadata } from './utils/sdkMetadata';
 export { getTraceData } from './utils/traceData';
+export { shouldPropagateTraceForUrl } from './utils/tracePropagationTargets';
 export { getTraceMetaTags } from './utils/meta';
 export { debounce } from './utils/debounce';
 export {

packages/core/src/utils/tracePropagationTargets.ts

@@ -0,0 +1,34 @@
+import type { CoreOptions as Options } from '../types-hoist/options';
+import { debug } from './debug-logger';
+import type { LRUMap } from './lru';
+import { stringMatchesSomePattern } from './string';
+
+const NOT_PROPAGATED_MESSAGE =
+ '[Tracing] Not injecting trace data for url because it does not match tracePropagationTargets:';
+
+/**
+ * Check if a given URL should be propagated to or not.
+ * If no url is defined, or no trace propagation targets are defined, this will always return `true`.
+ * You can also optionally provide a decision map, to cache decisions and avoid repeated regex lookups.
+ */
+export function shouldPropagateTraceForUrl(
+ url: string | undefined,
+ tracePropagationTargets: Options['tracePropagationTargets'],
+ decisionMap?: LRUMap<string, boolean>,
+): boolean {
+ if (typeof url !== 'string' || !tracePropagationTargets) {
+ return true;
+ }
+
+ const cachedDecision = decisionMap?.get(url);
+ if (cachedDecision !== undefined) {
+ !cachedDecision && debug.log(NOT_PROPAGATED_MESSAGE, url);
+ return cachedDecision;
+ }
+
+ const decision = stringMatchesSomePattern(url, tracePropagationTargets);
+ decisionMap?.set(url, decision);
+
+ !decision && debug.log(NOT_PROPAGATED_MESSAGE, url);
+ return decision;
+}

dev-packages/node-core-integration-tests/suites/light-mode/outgoing-fetch/server.js

@@ -0,0 +1,70 @@
+const http = require('http');
+const Sentry = require('@sentry/node-core/light');
+const { loggingTransport, sendPortToRunner } = require('@sentry-internal/node-core-integration-tests');
+
+Sentry.init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ release: '1.0',
+ transport: loggingTransport,
+ tracePropagationTargets: [/\/api\/v0/, 'v1'],
+});
+
+let capturedV0 = {};
+let capturedV1 = {};
+let capturedV2 = {};
+
+const targetServer = http.createServer((req, res) => {
+ const headers = {
+ 'sentry-trace': req.headers['sentry-trace'],
+ baggage: req.headers['baggage'],
+ };
+
+ if (req.url === '/api/v0') {
+ capturedV0 = headers;
+ } else if (req.url === '/api/v1') {
+ capturedV1 = headers;
+ } else if (req.url === '/api/v2') {
+ capturedV2 = headers;
+ }
+
+ res.writeHead(200);
+ res.end('ok');
+});
+
+targetServer.listen(0, () => {
+ const targetPort = targetServer.address().port;
+ const targetUrl = `http://localhost:${targetPort}`;
+
+ const server = http.createServer(async (req, res) => {
+ switch (req.url) {
+ case '/test-auto-propagation': {
+ capturedV0 = {};
+ capturedV1 = {};
+ capturedV2 = {};
+ await fetch(`${targetUrl}/api/v0`);
+ await fetch(`${targetUrl}/api/v1`);
+ await fetch(`${targetUrl}/api/v2`);
+ res.writeHead(200, { 'Content-Type': 'application/json' });
+ res.end(JSON.stringify({ '/api/v0': capturedV0, '/api/v1': capturedV1, '/api/v2': capturedV2 }));
+ break;
+ }
+ case '/test-breadcrumbs': {
+ Sentry.addBreadcrumb({ message: 'manual breadcrumb' });
+ await fetch(`${targetUrl}/api/v0`);
+ await fetch(`${targetUrl}/api/v1`);
+ Sentry.captureException(new Error('foo'));
+ res.writeHead(200);
+ res.end('ok');
+ break;
+ }
+ default: {
+ res.writeHead(404);
+ res.end();
+ }
+ }
+ });
+
+ server.listen(0, () => {
+ sendPortToRunner(server.address().port);
+ });
+});

dev-packages/node-core-integration-tests/suites/light-mode/outgoing-fetch/test.ts

@@ -0,0 +1,79 @@
+import crypto from 'crypto';
+import { afterAll, expect, test } from 'vitest';
+import { conditionalTest } from '../../../utils';
+import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
+
+afterAll(() => {
+ cleanupChildProcesses();
+});
+
+conditionalTest({ min: 22 })('light mode outgoing fetch', () => {
+ test('automatically propagates trace headers to outgoing fetch requests matching tracePropagationTargets', async () => {
+ const traceId = crypto.randomUUID().replace(/-/g, '');
+ const parentSpanId = traceId.substring(0, 16);
+
+ const runner = createRunner(__dirname, 'server.js').start();
+
+ const response = await runner.makeRequest<Record<string, { 'sentry-trace'?: string; baggage?: string }>>(
+ 'get',
+ '/test-auto-propagation',
+ {
+ headers: {
+ 'sentry-trace': `${traceId}-${parentSpanId}-1`,
+ baggage: `sentry-trace_id=${traceId},sentry-environment=test,sentry-public_key=public`,
+ },
+ },
+ );
+
+ // /api/v0 matches tracePropagationTargets - should have headers
+ expect(response?.['/api/v0']?.['sentry-trace']).toMatch(new RegExp(`^${traceId}-[a-f\\d]{16}-1$`));
+ expect(response?.['/api/v0']?.baggage).toContain(`sentry-trace_id=${traceId}`);
+
+ // /api/v1 matches tracePropagationTargets - should have headers
+ expect(response?.['/api/v1']?.['sentry-trace']).toMatch(new RegExp(`^${traceId}-[a-f\\d]{16}-1$`));
+ expect(response?.['/api/v1']?.baggage).toContain(`sentry-trace_id=${traceId}`);
+
+ // /api/v2 does NOT match tracePropagationTargets - should NOT have headers
+ expect(response?.['/api/v2']?.['sentry-trace']).toBeUndefined();
+ expect(response?.['/api/v2']?.baggage).toBeUndefined();
+ });
+
+ test('creates breadcrumbs for outgoing fetch requests', async () => {
+ const runner = createRunner(__dirname, 'server.js')
+ .expect({
+ event: event => {
+ const breadcrumbs = event.breadcrumbs || [];
+ const httpBreadcrumbs = breadcrumbs.filter(b => b.category === 'http');
+
+ expect(httpBreadcrumbs.length).toBe(2);
+
+ expect(httpBreadcrumbs[0]).toEqual(
+ expect.objectContaining({
+ category: 'http',
+ type: 'http',
+ data: expect.objectContaining({
+ 'http.method': 'GET',
+ status_code: 200,
+ }),
+ }),
+ );
+
+ expect(httpBreadcrumbs[1]).toEqual(
+ expect.objectContaining({
+ category: 'http',
+ type: 'http',
+ data: expect.objectContaining({
+ 'http.method': 'GET',
+ status_code: 200,
+ }),
+ }),
+ );
+ },
+ })
+ .start();
+
+ await runner.makeRequest('get', '/test-breadcrumbs');
+
+ await runner.completed();
+ });
+});

dev-packages/node-core-integration-tests/suites/light-mode/outgoing-http/server.js

@@ -0,0 +1,98 @@
+const http = require('http');
+const Sentry = require('@sentry/node-core/light');
+const { loggingTransport, sendPortToRunner } = require('@sentry-internal/node-core-integration-tests');
+
+Sentry.init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ release: '1.0',
+ transport: loggingTransport,
+ tracePropagationTargets: [/\/api\/v0/, 'v1'],
+ beforeBreadcrumb(breadcrumb, hint) {
+ breadcrumb.data = breadcrumb.data || {};
+ const req = hint?.request;
+ if (req?.path) {
+ breadcrumb.data.ADDED_PATH = req.path;
+ }
+ return breadcrumb;
+ },
+});
+
+function makeHttpRequest(url) {
+ return new Promise((resolve, reject) => {
+ const urlObj = new URL(url);
+ const req = http.request(
+ {
+ hostname: urlObj.hostname,
+ port: urlObj.port,
+ path: urlObj.pathname,
+ method: 'GET',
+ },
+ res => {
+ res.on('data', () => {});
+ res.on('end', () => resolve());
+ },
+ );
+ req.on('error', reject);
+ req.end();
+ });
+}
+
+let capturedV0 = {};
+let capturedV1 = {};
+let capturedV2 = {};
+
+const targetServer = http.createServer((req, res) => {
+ const headers = {
+ 'sentry-trace': req.headers['sentry-trace'],
+ baggage: req.headers['baggage'],
+ };
+
+ if (req.url === '/api/v0') {
+ capturedV0 = headers;
+ } else if (req.url === '/api/v1') {
+ capturedV1 = headers;
+ } else if (req.url === '/api/v2') {
+ capturedV2 = headers;
+ }
+
+ res.writeHead(200);
+ res.end('ok');
+});
+
+targetServer.listen(0, () => {
+ const targetPort = targetServer.address().port;
+ const targetUrl = `http://localhost:${targetPort}`;
+
+ const server = http.createServer(async (req, res) => {
+ switch (req.url) {
+ case '/test-auto-propagation': {
+ capturedV0 = {};
+ capturedV1 = {};
+ capturedV2 = {};
+ await makeHttpRequest(`${targetUrl}/api/v0`);
+ await makeHttpRequest(`${targetUrl}/api/v1`);
+ await makeHttpRequest(`${targetUrl}/api/v2`);
+ res.writeHead(200, { 'Content-Type': 'application/json' });
+ res.end(JSON.stringify({ '/api/v0': capturedV0, '/api/v1': capturedV1, '/api/v2': capturedV2 }));
+ break;
+ }
+ case '/test-breadcrumbs': {
+ Sentry.addBreadcrumb({ message: 'manual breadcrumb' });
+ await makeHttpRequest(`${targetUrl}/api/v0`);
+ await makeHttpRequest(`${targetUrl}/api/v1`);
+ Sentry.captureException(new Error('foo'));
+ res.writeHead(200);
+ res.end('ok');
+ break;
+ }
+ default: {
+ res.writeHead(404);
+ res.end();
+ }
+ }
+ });
+
+ server.listen(0, () => {
+ sendPortToRunner(server.address().port);
+ });
+});

dev-packages/node-core-integration-tests/suites/light-mode/outgoing-http/test.ts

@@ -0,0 +1,79 @@
+import crypto from 'crypto';
+import { afterAll, expect, test } from 'vitest';
+import { conditionalTest } from '../../../utils';
+import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
+
+afterAll(() => {
+ cleanupChildProcesses();
+});
+
+conditionalTest({ min: 22 })('light mode outgoing http', () => {
+ test('automatically propagates trace headers to outgoing http requests matching tracePropagationTargets', async () => {
+ const traceId = crypto.randomUUID().replace(/-/g, '');
+ const parentSpanId = traceId.substring(0, 16);
+
+ const runner = createRunner(__dirname, 'server.js').start();
+
+ const response = await runner.makeRequest<Record<string, { 'sentry-trace'?: string; baggage?: string }>>(
+ 'get',
+ '/test-auto-propagation',
+ {
+ headers: {
+ 'sentry-trace': `${traceId}-${parentSpanId}-1`,
+ baggage: `sentry-trace_id=${traceId},sentry-environment=test,sentry-public_key=public`,
+ },
+ },
+ );
+
+ // /api/v0 matches tracePropagationTargets - should have headers
+ expect(response?.['/api/v0']?.['sentry-trace']).toMatch(new RegExp(`^${traceId}-[a-f\\d]{16}-1$`));
+ expect(response?.['/api/v0']?.baggage).toContain(`sentry-trace_id=${traceId}`);
+
+ // /api/v1 matches tracePropagationTargets - should have headers
+ expect(response?.['/api/v1']?.['sentry-trace']).toMatch(new RegExp(`^${traceId}-[a-f\\d]{16}-1$`));
+ expect(response?.['/api/v1']?.baggage).toContain(`sentry-trace_id=${traceId}`);
+
+ // /api/v2 does NOT match tracePropagationTargets - should NOT have headers
+ expect(response?.['/api/v2']?.['sentry-trace']).toBeUndefined();
+ expect(response?.['/api/v2']?.baggage).toBeUndefined();
+ });
+
+ test('creates breadcrumbs for outgoing http requests', async () => {
+ const runner = createRunner(__dirname, 'server.js')
+ .expect({
+ event: event => {
+ const breadcrumbs = event.breadcrumbs || [];
+ const httpBreadcrumbs = breadcrumbs.filter(b => b.category === 'http');
+
+ expect(httpBreadcrumbs.length).toBe(2);
+
+ expect(httpBreadcrumbs[0]).toEqual(
+ expect.objectContaining({
+ category: 'http',
+ type: 'http',
+ data: expect.objectContaining({
+ 'http.method': 'GET',
+ status_code: 200,
+ }),
+ }),
+ );
+
+ expect(httpBreadcrumbs[1]).toEqual(
+ expect.objectContaining({
+ category: 'http',
+ type: 'http',
+ data: expect.objectContaining({
+ 'http.method': 'GET',
+ status_code: 200,
+ }),
+ }),
+ );
+ },
+ })
+ .start();
+
+ await runner.makeRequest('get', '/test-breadcrumbs');
+
+ await runner.completed();
+ });
+});

packages/core/src/index.ts

@@ -92,6 +92,7 @@ export { _setSpanForScope as _INTERNAL_setSpanForScope } from './utils/spanOnSco
 export { parseSampleRate } from './utils/parseSampleRate';
 export { applySdkMetadata } from './utils/sdkMetadata';
 export { getTraceData } from './utils/traceData';
+export { shouldPropagateTraceForUrl } from './utils/tracePropagationTargets';
 export { getTraceMetaTags } from './utils/meta';
 export { debounce } from './utils/debounce';
 export {

packages/core/src/utils/tracePropagationTargets.ts

@@ -0,0 +1,34 @@
+import type { CoreOptions as Options } from '../types-hoist/options';
+import { debug } from './debug-logger';
+import type { LRUMap } from './lru';
+import { stringMatchesSomePattern } from './string';
+
+const NOT_PROPAGATED_MESSAGE =
+ '[Tracing] Not injecting trace data for url because it does not match tracePropagationTargets:';
+
+/**
+ * Check if a given URL should be propagated to or not.
+ * If no url is defined, or no trace propagation targets are defined, this will always return `true`.
+ * You can also optionally provide a decision map, to cache decisions and avoid repeated regex lookups.
+ */
+export function shouldPropagateTraceForUrl(
+ url: string | undefined,
+ tracePropagationTargets: Options['tracePropagationTargets'],
+ decisionMap?: LRUMap<string, boolean>,
+): boolean {
+ if (typeof url !== 'string' || !tracePropagationTargets) {
+ return true;
+ }
+
+ const cachedDecision = decisionMap?.get(url);
+ if (cachedDecision !== undefined) {
+ !cachedDecision && debug.log(NOT_PROPAGATED_MESSAGE, url);
+ return cachedDecision;
+ }
+
+ const decision = stringMatchesSomePattern(url, tracePropagationTargets);
+ decisionMap?.set(url, decision);
+
+ !decision && debug.log(NOT_PROPAGATED_MESSAGE, url);
+ return decision;
+}

dev-packages/node-core-integration-tests/suites/light-mode/outgoing-fetch/server.js

@@ -0,0 +1,70 @@
+const http = require('http');
+const Sentry = require('@sentry/node-core/light');
+const { loggingTransport, sendPortToRunner } = require('@sentry-internal/node-core-integration-tests');
+
+Sentry.init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ release: '1.0',
+ transport: loggingTransport,
+ tracePropagationTargets: [/\/api\/v0/, 'v1'],
+});
+
+let capturedV0 = {};
+let capturedV1 = {};
+let capturedV2 = {};
+
+const targetServer = http.createServer((req, res) => {
+ const headers = {
+ 'sentry-trace': req.headers['sentry-trace'],
+ baggage: req.headers['baggage'],
+ };
+
+ if (req.url === '/api/v0') {
+ capturedV0 = headers;
+ } else if (req.url === '/api/v1') {
+ capturedV1 = headers;
+ } else if (req.url === '/api/v2') {
+ capturedV2 = headers;
+ }
+
+ res.writeHead(200);
+ res.end('ok');
+});
+
+targetServer.listen(0, () => {
+ const targetPort = targetServer.address().port;
+ const targetUrl = `http://localhost:${targetPort}`;
+
+ const server = http.createServer(async (req, res) => {
+ switch (req.url) {
+ case '/test-auto-propagation': {
+ capturedV0 = {};
+ capturedV1 = {};
+ capturedV2 = {};
+ await fetch(`${targetUrl}/api/v0`);
+ await fetch(`${targetUrl}/api/v1`);
+ await fetch(`${targetUrl}/api/v2`);
+ res.writeHead(200, { 'Content-Type': 'application/json' });
+ res.end(JSON.stringify({ '/api/v0': capturedV0, '/api/v1': capturedV1, '/api/v2': capturedV2 }));
+ break;
+ }
+ case '/test-breadcrumbs': {
+ Sentry.addBreadcrumb({ message: 'manual breadcrumb' });
+ await fetch(`${targetUrl}/api/v0`);
+ await fetch(`${targetUrl}/api/v1`);
+ Sentry.captureException(new Error('foo'));
+ res.writeHead(200);
+ res.end('ok');
+ break;
+ }
+ default: {
+ res.writeHead(404);
+ res.end();
+ }
+ }
+ });
+
+ server.listen(0, () => {
+ sendPortToRunner(server.address().port);
+ });
+});

dev-packages/node-core-integration-tests/suites/light-mode/outgoing-fetch/test.ts

@@ -0,0 +1,79 @@
+import crypto from 'crypto';
+import { afterAll, expect, test } from 'vitest';
+import { conditionalTest } from '../../../utils';
+import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
+
+afterAll(() => {
+ cleanupChildProcesses();
+});
+
+conditionalTest({ min: 22 })('light mode outgoing fetch', () => {
+ test('automatically propagates trace headers to outgoing fetch requests matching tracePropagationTargets', async () => {
+ const traceId = crypto.randomUUID().replace(/-/g, '');
+ const parentSpanId = traceId.substring(0, 16);
+
+ const runner = createRunner(__dirname, 'server.js').start();
+
+ const response = await runner.makeRequest<Record<string, { 'sentry-trace'?: string; baggage?: string }>>(
+ 'get',
+ '/test-auto-propagation',
+ {
+ headers: {
+ 'sentry-trace': `${traceId}-${parentSpanId}-1`,
+ baggage: `sentry-trace_id=${traceId},sentry-environment=test,sentry-public_key=public`,
+ },
+ },
+ );
+
+ // /api/v0 matches tracePropagationTargets - should have headers
+ expect(response?.['/api/v0']?.['sentry-trace']).toMatch(new RegExp(`^${traceId}-[a-f\\d]{16}-1$`));
+ expect(response?.['/api/v0']?.baggage).toContain(`sentry-trace_id=${traceId}`);
+
+ // /api/v1 matches tracePropagationTargets - should have headers
+ expect(response?.['/api/v1']?.['sentry-trace']).toMatch(new RegExp(`^${traceId}-[a-f\\d]{16}-1$`));
+ expect(response?.['/api/v1']?.baggage).toContain(`sentry-trace_id=${traceId}`);
+
+ // /api/v2 does NOT match tracePropagationTargets - should NOT have headers
+ expect(response?.['/api/v2']?.['sentry-trace']).toBeUndefined();
+ expect(response?.['/api/v2']?.baggage).toBeUndefined();
+ });
+
+ test('creates breadcrumbs for outgoing fetch requests', async () => {
+ const runner = createRunner(__dirname, 'server.js')
+ .expect({
+ event: event => {
+ const breadcrumbs = event.breadcrumbs || [];
+ const httpBreadcrumbs = breadcrumbs.filter(b => b.category === 'http');
+
+ expect(httpBreadcrumbs.length).toBe(2);
+
+ expect(httpBreadcrumbs[0]).toEqual(
+ expect.objectContaining({
+ category: 'http',
+ type: 'http',
+ data: expect.objectContaining({
+ 'http.method': 'GET',
+ status_code: 200,
+ }),
+ }),
+ );
+
+ expect(httpBreadcrumbs[1]).toEqual(
+ expect.objectContaining({
+ category: 'http',
+ type: 'http',
+ data: expect.objectContaining({
+ 'http.method': 'GET',
+ status_code: 200,
+ }),
+ }),
+ );
+ },
+ })
+ .start();
+
+ await runner.makeRequest('get', '/test-breadcrumbs');
+
+ await runner.completed();
+ });
+});

dev-packages/node-core-integration-tests/suites/light-mode/outgoing-http/server.js

@@ -0,0 +1,98 @@
+const http = require('http');
+const Sentry = require('@sentry/node-core/light');
+const { loggingTransport, sendPortToRunner } = require('@sentry-internal/node-core-integration-tests');
+
+Sentry.init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ release: '1.0',
+ transport: loggingTransport,
+ tracePropagationTargets: [/\/api\/v0/, 'v1'],
+ beforeBreadcrumb(breadcrumb, hint) {
+ breadcrumb.data = breadcrumb.data || {};
+ const req = hint?.request;
+ if (req?.path) {
+ breadcrumb.data.ADDED_PATH = req.path;
+ }
+ return breadcrumb;
+ },
+});
+
+function makeHttpRequest(url) {
+ return new Promise((resolve, reject) => {
+ const urlObj = new URL(url);
+ const req = http.request(
+ {
+ hostname: urlObj.hostname,
+ port: urlObj.port,
+ path: urlObj.pathname,
+ method: 'GET',
+ },
+ res => {
+ res.on('data', () => {});
+ res.on('end', () => resolve());
+ },
+ );
+ req.on('error', reject);
+ req.end();
+ });
+}
+
+let capturedV0 = {};
+let capturedV1 = {};
+let capturedV2 = {};
+
+const targetServer = http.createServer((req, res) => {
+ const headers = {
+ 'sentry-trace': req.headers['sentry-trace'],
+ baggage: req.headers['baggage'],
+ };
+
+ if (req.url === '/api/v0') {
+ capturedV0 = headers;
+ } else if (req.url === '/api/v1') {
+ capturedV1 = headers;
+ } else if (req.url === '/api/v2') {
+ capturedV2 = headers;
+ }
+
+ res.writeHead(200);
+ res.end('ok');
+});
+
+targetServer.listen(0, () => {
+ const targetPort = targetServer.address().port;
+ const targetUrl = `http://localhost:${targetPort}`;
+
+ const server = http.createServer(async (req, res) => {
+ switch (req.url) {
+ case '/test-auto-propagation': {
+ capturedV0 = {};
+ capturedV1 = {};
+ capturedV2 = {};
+ await makeHttpRequest(`${targetUrl}/api/v0`);
+ await makeHttpRequest(`${targetUrl}/api/v1`);
+ await makeHttpRequest(`${targetUrl}/api/v2`);
+ res.writeHead(200, { 'Content-Type': 'application/json' });
+ res.end(JSON.stringify({ '/api/v0': capturedV0, '/api/v1': capturedV1, '/api/v2': capturedV2 }));
+ break;
+ }
+ case '/test-breadcrumbs': {
+ Sentry.addBreadcrumb({ message: 'manual breadcrumb' });
+ await makeHttpRequest(`${targetUrl}/api/v0`);
+ await makeHttpRequest(`${targetUrl}/api/v1`);
+ Sentry.captureException(new Error('foo'));
+ res.writeHead(200);
+ res.end('ok');
+ break;
+ }
+ default: {
+ res.writeHead(404);
+ res.end();
+ }
+ }
+ });
+
+ server.listen(0, () => {
+ sendPortToRunner(server.address().port);
+ });
+});

dev-packages/node-core-integration-tests/suites/light-mode/outgoing-http/test.ts

@@ -0,0 +1,79 @@
+import crypto from 'crypto';
+import { afterAll, expect, test } from 'vitest';
+import { conditionalTest } from '../../../utils';
+import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
+
+afterAll(() => {
+ cleanupChildProcesses();
+});
+
+conditionalTest({ min: 22 })('light mode outgoing http', () => {
+ test('automatically propagates trace headers to outgoing http requests matching tracePropagationTargets', async () => {
+ const traceId = crypto.randomUUID().replace(/-/g, '');
+ const parentSpanId = traceId.substring(0, 16);
+
+ const runner = createRunner(__dirname, 'server.js').start();
+
+ const response = await runner.makeRequest<Record<string, { 'sentry-trace'?: string; baggage?: string }>>(
+ 'get',
+ '/test-auto-propagation',
+ {
+ headers: {
+ 'sentry-trace': `${traceId}-${parentSpanId}-1`,
+ baggage: `sentry-trace_id=${traceId},sentry-environment=test,sentry-public_key=public`,
+ },
+ },
+ );
+
+ // /api/v0 matches tracePropagationTargets - should have headers
+ expect(response?.['/api/v0']?.['sentry-trace']).toMatch(new RegExp(`^${traceId}-[a-f\\d]{16}-1$`));
+ expect(response?.['/api/v0']?.baggage).toContain(`sentry-trace_id=${traceId}`);
+
+ // /api/v1 matches tracePropagationTargets - should have headers
+ expect(response?.['/api/v1']?.['sentry-trace']).toMatch(new RegExp(`^${traceId}-[a-f\\d]{16}-1$`));
+ expect(response?.['/api/v1']?.baggage).toContain(`sentry-trace_id=${traceId}`);
+
+ // /api/v2 does NOT match tracePropagationTargets - should NOT have headers
+ expect(response?.['/api/v2']?.['sentry-trace']).toBeUndefined();
+ expect(response?.['/api/v2']?.baggage).toBeUndefined();
+ });
+
+ test('creates breadcrumbs for outgoing http requests', async () => {
+ const runner = createRunner(__dirname, 'server.js')
+ .expect({
+ event: event => {
+ const breadcrumbs = event.breadcrumbs || [];
+ const httpBreadcrumbs = breadcrumbs.filter(b => b.category === 'http');
+
+ expect(httpBreadcrumbs.length).toBe(2);
+
+ expect(httpBreadcrumbs[0]).toEqual(
+ expect.objectContaining({
+ category: 'http',
+ type: 'http',
+ data: expect.objectContaining({
+ 'http.method': 'GET',
+ status_code: 200,
+ }),
+ }),
+ );
+
+ expect(httpBreadcrumbs[1]).toEqual(
+ expect.objectContaining({
+ category: 'http',
+ type: 'http',
+ data: expect.objectContaining({
+ 'http.method': 'GET',
+ status_code: 200,
+ }),
+ }),
+ );
+ },
+ })
+ .start();
+
+ await runner.makeRequest('get', '/test-breadcrumbs');
+
+ await runner.completed();
+ });
+});

packages/core/src/index.ts

@@ -92,6 +92,7 @@ export { _setSpanForScope as _INTERNAL_setSpanForScope } from './utils/spanOnSco
 export { parseSampleRate } from './utils/parseSampleRate';
 export { applySdkMetadata } from './utils/sdkMetadata';
 export { getTraceData } from './utils/traceData';
+export { shouldPropagateTraceForUrl } from './utils/tracePropagationTargets';
 export { getTraceMetaTags } from './utils/meta';
 export { debounce } from './utils/debounce';
 export {

packages/core/src/utils/tracePropagationTargets.ts

@@ -0,0 +1,34 @@
+import type { CoreOptions as Options } from '../types-hoist/options';
+import { debug } from './debug-logger';
+import type { LRUMap } from './lru';
+import { stringMatchesSomePattern } from './string';
+
+const NOT_PROPAGATED_MESSAGE =
+ '[Tracing] Not injecting trace data for url because it does not match tracePropagationTargets:';
+
+/**
+ * Check if a given URL should be propagated to or not.
+ * If no url is defined, or no trace propagation targets are defined, this will always return `true`.
+ * You can also optionally provide a decision map, to cache decisions and avoid repeated regex lookups.
+ */
+export function shouldPropagateTraceForUrl(
+ url: string | undefined,
+ tracePropagationTargets: Options['tracePropagationTargets'],
+ decisionMap?: LRUMap<string, boolean>,
+): boolean {
+ if (typeof url !== 'string' || !tracePropagationTargets) {
+ return true;
+ }
+
+ const cachedDecision = decisionMap?.get(url);
+ if (cachedDecision !== undefined) {
+ !cachedDecision && debug.log(NOT_PROPAGATED_MESSAGE, url);
+ return cachedDecision;
+ }
+
+ const decision = stringMatchesSomePattern(url, tracePropagationTargets);
+ decisionMap?.set(url, decision);
+
+ !decision && debug.log(NOT_PROPAGATED_MESSAGE, url);
+ return decision;
+}

dev-packages/node-core-integration-tests/suites/light-mode/outgoing-fetch/server.js

@@ -0,0 +1,70 @@
+const http = require('http');
+const Sentry = require('@sentry/node-core/light');
+const { loggingTransport, sendPortToRunner } = require('@sentry-internal/node-core-integration-tests');
+
+Sentry.init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ release: '1.0',
+ transport: loggingTransport,
+ tracePropagationTargets: [/\/api\/v0/, 'v1'],
+});
+
+let capturedV0 = {};
+let capturedV1 = {};
+let capturedV2 = {};
+
+const targetServer = http.createServer((req, res) => {
+ const headers = {
+ 'sentry-trace': req.headers['sentry-trace'],
+ baggage: req.headers['baggage'],
+ };
+
+ if (req.url === '/api/v0') {
+ capturedV0 = headers;
+ } else if (req.url === '/api/v1') {
+ capturedV1 = headers;
+ } else if (req.url === '/api/v2') {
+ capturedV2 = headers;
+ }
+
+ res.writeHead(200);
+ res.end('ok');
+});
+
+targetServer.listen(0, () => {
+ const targetPort = targetServer.address().port;
+ const targetUrl = `http://localhost:${targetPort}`;
+
+ const server = http.createServer(async (req, res) => {
+ switch (req.url) {
+ case '/test-auto-propagation': {
+ capturedV0 = {};
+ capturedV1 = {};
+ capturedV2 = {};
+ await fetch(`${targetUrl}/api/v0`);
+ await fetch(`${targetUrl}/api/v1`);
+ await fetch(`${targetUrl}/api/v2`);
+ res.writeHead(200, { 'Content-Type': 'application/json' });
+ res.end(JSON.stringify({ '/api/v0': capturedV0, '/api/v1': capturedV1, '/api/v2': capturedV2 }));
+ break;
+ }
+ case '/test-breadcrumbs': {
+ Sentry.addBreadcrumb({ message: 'manual breadcrumb' });
+ await fetch(`${targetUrl}/api/v0`);
+ await fetch(`${targetUrl}/api/v1`);
+ Sentry.captureException(new Error('foo'));
+ res.writeHead(200);
+ res.end('ok');
+ break;
+ }
+ default: {
+ res.writeHead(404);
+ res.end();
+ }
+ }
+ });
+
+ server.listen(0, () => {
+ sendPortToRunner(server.address().port);
+ });
+});

dev-packages/node-core-integration-tests/suites/light-mode/outgoing-fetch/test.ts

@@ -0,0 +1,79 @@
+import crypto from 'crypto';
+import { afterAll, expect, test } from 'vitest';
+import { conditionalTest } from '../../../utils';
+import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
+
+afterAll(() => {
+ cleanupChildProcesses();
+});
+
+conditionalTest({ min: 22 })('light mode outgoing fetch', () => {
+ test('automatically propagates trace headers to outgoing fetch requests matching tracePropagationTargets', async () => {
+ const traceId = crypto.randomUUID().replace(/-/g, '');
+ const parentSpanId = traceId.substring(0, 16);
+
+ const runner = createRunner(__dirname, 'server.js').start();
+
+ const response = await runner.makeRequest<Record<string, { 'sentry-trace'?: string; baggage?: string }>>(
+ 'get',
+ '/test-auto-propagation',
+ {
+ headers: {
+ 'sentry-trace': `${traceId}-${parentSpanId}-1`,
+ baggage: `sentry-trace_id=${traceId},sentry-environment=test,sentry-public_key=public`,
+ },
+ },
+ );
+
+ // /api/v0 matches tracePropagationTargets - should have headers
+ expect(response?.['/api/v0']?.['sentry-trace']).toMatch(new RegExp(`^${traceId}-[a-f\\d]{16}-1$`));
+ expect(response?.['/api/v0']?.baggage).toContain(`sentry-trace_id=${traceId}`);
+
+ // /api/v1 matches tracePropagationTargets - should have headers
+ expect(response?.['/api/v1']?.['sentry-trace']).toMatch(new RegExp(`^${traceId}-[a-f\\d]{16}-1$`));
+ expect(response?.['/api/v1']?.baggage).toContain(`sentry-trace_id=${traceId}`);
+
+ // /api/v2 does NOT match tracePropagationTargets - should NOT have headers
+ expect(response?.['/api/v2']?.['sentry-trace']).toBeUndefined();
+ expect(response?.['/api/v2']?.baggage).toBeUndefined();
+ });
+
+ test('creates breadcrumbs for outgoing fetch requests', async () => {
+ const runner = createRunner(__dirname, 'server.js')
+ .expect({
+ event: event => {
+ const breadcrumbs = event.breadcrumbs || [];
+ const httpBreadcrumbs = breadcrumbs.filter(b => b.category === 'http');
+
+ expect(httpBreadcrumbs.length).toBe(2);
+
+ expect(httpBreadcrumbs[0]).toEqual(
+ expect.objectContaining({
+ category: 'http',
+ type: 'http',
+ data: expect.objectContaining({
+ 'http.method': 'GET',
+ status_code: 200,
+ }),
+ }),
+ );
+
+ expect(httpBreadcrumbs[1]).toEqual(
+ expect.objectContaining({
+ category: 'http',
+ type: 'http',
+ data: expect.objectContaining({
+ 'http.method': 'GET',
+ status_code: 200,
+ }),
+ }),
+ );
+ },
+ })
+ .start();
+
+ await runner.makeRequest('get', '/test-breadcrumbs');
+
+ await runner.completed();
+ });
+});

dev-packages/node-core-integration-tests/suites/light-mode/outgoing-http/server.js

@@ -0,0 +1,98 @@
+const http = require('http');
+const Sentry = require('@sentry/node-core/light');
+const { loggingTransport, sendPortToRunner } = require('@sentry-internal/node-core-integration-tests');
+
+Sentry.init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ release: '1.0',
+ transport: loggingTransport,
+ tracePropagationTargets: [/\/api\/v0/, 'v1'],
+ beforeBreadcrumb(breadcrumb, hint) {
+ breadcrumb.data = breadcrumb.data || {};
+ const req = hint?.request;
+ if (req?.path) {
+ breadcrumb.data.ADDED_PATH = req.path;
+ }
+ return breadcrumb;
+ },
+});
+
+function makeHttpRequest(url) {
+ return new Promise((resolve, reject) => {
+ const urlObj = new URL(url);
+ const req = http.request(
+ {
+ hostname: urlObj.hostname,
+ port: urlObj.port,
+ path: urlObj.pathname,
+ method: 'GET',
+ },
+ res => {
+ res.on('data', () => {});
+ res.on('end', () => resolve());
+ },
+ );
+ req.on('error', reject);
+ req.end();
+ });
+}
+
+let capturedV0 = {};
+let capturedV1 = {};
+let capturedV2 = {};
+
+const targetServer = http.createServer((req, res) => {
+ const headers = {
+ 'sentry-trace': req.headers['sentry-trace'],
+ baggage: req.headers['baggage'],
+ };
+
+ if (req.url === '/api/v0') {
+ capturedV0 = headers;
+ } else if (req.url === '/api/v1') {
+ capturedV1 = headers;
+ } else if (req.url === '/api/v2') {
+ capturedV2 = headers;
+ }
+
+ res.writeHead(200);
+ res.end('ok');
+});
+
+targetServer.listen(0, () => {
+ const targetPort = targetServer.address().port;
+ const targetUrl = `http://localhost:${targetPort}`;
+
+ const server = http.createServer(async (req, res) => {
+ switch (req.url) {
+ case '/test-auto-propagation': {
+ capturedV0 = {};
+ capturedV1 = {};
+ capturedV2 = {};
+ await makeHttpRequest(`${targetUrl}/api/v0`);
+ await makeHttpRequest(`${targetUrl}/api/v1`);
+ await makeHttpRequest(`${targetUrl}/api/v2`);
+ res.writeHead(200, { 'Content-Type': 'application/json' });
+ res.end(JSON.stringify({ '/api/v0': capturedV0, '/api/v1': capturedV1, '/api/v2': capturedV2 }));
+ break;
+ }
+ case '/test-breadcrumbs': {
+ Sentry.addBreadcrumb({ message: 'manual breadcrumb' });
+ await makeHttpRequest(`${targetUrl}/api/v0`);
+ await makeHttpRequest(`${targetUrl}/api/v1`);
+ Sentry.captureException(new Error('foo'));
+ res.writeHead(200);
+ res.end('ok');
+ break;
+ }
+ default: {
+ res.writeHead(404);
+ res.end();
+ }
+ }
+ });
+
+ server.listen(0, () => {
+ sendPortToRunner(server.address().port);
+ });
+});

dev-packages/node-core-integration-tests/suites/light-mode/outgoing-http/test.ts

@@ -0,0 +1,79 @@
+import crypto from 'crypto';
+import { afterAll, expect, test } from 'vitest';
+import { conditionalTest } from '../../../utils';
+import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
+
+afterAll(() => {
+ cleanupChildProcesses();
+});
+
+conditionalTest({ min: 22 })('light mode outgoing http', () => {
+ test('automatically propagates trace headers to outgoing http requests matching tracePropagationTargets', async () => {
+ const traceId = crypto.randomUUID().replace(/-/g, '');
+ const parentSpanId = traceId.substring(0, 16);
+
+ const runner = createRunner(__dirname, 'server.js').start();
+
+ const response = await runner.makeRequest<Record<string, { 'sentry-trace'?: string; baggage?: string }>>(
+ 'get',
+ '/test-auto-propagation',
+ {
+ headers: {
+ 'sentry-trace': `${traceId}-${parentSpanId}-1`,
+ baggage: `sentry-trace_id=${traceId},sentry-environment=test,sentry-public_key=public`,
+ },
+ },
+ );
+
+ // /api/v0 matches tracePropagationTargets - should have headers
+ expect(response?.['/api/v0']?.['sentry-trace']).toMatch(new RegExp(`^${traceId}-[a-f\\d]{16}-1$`));
+ expect(response?.['/api/v0']?.baggage).toContain(`sentry-trace_id=${traceId}`);
+
+ // /api/v1 matches tracePropagationTargets - should have headers
+ expect(response?.['/api/v1']?.['sentry-trace']).toMatch(new RegExp(`^${traceId}-[a-f\\d]{16}-1$`));
+ expect(response?.['/api/v1']?.baggage).toContain(`sentry-trace_id=${traceId}`);
+
+ // /api/v2 does NOT match tracePropagationTargets - should NOT have headers
+ expect(response?.['/api/v2']?.['sentry-trace']).toBeUndefined();
+ expect(response?.['/api/v2']?.baggage).toBeUndefined();
+ });
+
+ test('creates breadcrumbs for outgoing http requests', async () => {
+ const runner = createRunner(__dirname, 'server.js')
+ .expect({
+ event: event => {
+ const breadcrumbs = event.breadcrumbs || [];
+ const httpBreadcrumbs = breadcrumbs.filter(b => b.category === 'http');
+
+ expect(httpBreadcrumbs.length).toBe(2);
+
+ expect(httpBreadcrumbs[0]).toEqual(
+ expect.objectContaining({
+ category: 'http',
+ type: 'http',
+ data: expect.objectContaining({
+ 'http.method': 'GET',
+ status_code: 200,
+ }),
+ }),
+ );
+
+ expect(httpBreadcrumbs[1]).toEqual(
+ expect.objectContaining({
+ category: 'http',
+ type: 'http',
+ data: expect.objectContaining({
+ 'http.method': 'GET',
+ status_code: 200,
+ }),
+ }),
+ );
+ },
+ })
+ .start();
+
+ await runner.makeRequest('get', '/test-breadcrumbs');
+
+ await runner.completed();
+ });
+});

packages/core/src/index.ts

@@ -92,6 +92,7 @@ export { _setSpanForScope as _INTERNAL_setSpanForScope } from './utils/spanOnSco
 export { parseSampleRate } from './utils/parseSampleRate';
 export { applySdkMetadata } from './utils/sdkMetadata';
 export { getTraceData } from './utils/traceData';
+export { shouldPropagateTraceForUrl } from './utils/tracePropagationTargets';
 export { getTraceMetaTags } from './utils/meta';
 export { debounce } from './utils/debounce';
 export {

packages/core/src/utils/tracePropagationTargets.ts

@@ -0,0 +1,34 @@
+import type { CoreOptions as Options } from '../types-hoist/options';
+import { debug } from './debug-logger';
+import type { LRUMap } from './lru';
+import { stringMatchesSomePattern } from './string';
+
+const NOT_PROPAGATED_MESSAGE =
+ '[Tracing] Not injecting trace data for url because it does not match tracePropagationTargets:';
+
+/**
+ * Check if a given URL should be propagated to or not.
+ * If no url is defined, or no trace propagation targets are defined, this will always return `true`.
+ * You can also optionally provide a decision map, to cache decisions and avoid repeated regex lookups.
+ */
+export function shouldPropagateTraceForUrl(
+ url: string | undefined,
+ tracePropagationTargets: Options['tracePropagationTargets'],
+ decisionMap?: LRUMap<string, boolean>,
+): boolean {
+ if (typeof url !== 'string' || !tracePropagationTargets) {
+ return true;
+ }
+
+ const cachedDecision = decisionMap?.get(url);
+ if (cachedDecision !== undefined) {
+ !cachedDecision && debug.log(NOT_PROPAGATED_MESSAGE, url);
+ return cachedDecision;
+ }
+
+ const decision = stringMatchesSomePattern(url, tracePropagationTargets);
+ decisionMap?.set(url, decision);
+
+ !decision && debug.log(NOT_PROPAGATED_MESSAGE, url);
+ return decision;
+}

dev-packages/node-core-integration-tests/suites/light-mode/outgoing-fetch/server.js

@@ -0,0 +1,70 @@
+const http = require('http');
+const Sentry = require('@sentry/node-core/light');
+const { loggingTransport, sendPortToRunner } = require('@sentry-internal/node-core-integration-tests');
+
+Sentry.init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ release: '1.0',
+ transport: loggingTransport,
+ tracePropagationTargets: [/\/api\/v0/, 'v1'],
+});
+
+let capturedV0 = {};
+let capturedV1 = {};
+let capturedV2 = {};
+
+const targetServer = http.createServer((req, res) => {
+ const headers = {
+ 'sentry-trace': req.headers['sentry-trace'],
+ baggage: req.headers['baggage'],
+ };
+
+ if (req.url === '/api/v0') {
+ capturedV0 = headers;
+ } else if (req.url === '/api/v1') {
+ capturedV1 = headers;
+ } else if (req.url === '/api/v2') {
+ capturedV2 = headers;
+ }
+
+ res.writeHead(200);
+ res.end('ok');
+});
+
+targetServer.listen(0, () => {
+ const targetPort = targetServer.address().port;
+ const targetUrl = `http://localhost:${targetPort}`;
+
+ const server = http.createServer(async (req, res) => {
+ switch (req.url) {
+ case '/test-auto-propagation': {
+ capturedV0 = {};
+ capturedV1 = {};
+ capturedV2 = {};
+ await fetch(`${targetUrl}/api/v0`);
+ await fetch(`${targetUrl}/api/v1`);
+ await fetch(`${targetUrl}/api/v2`);
+ res.writeHead(200, { 'Content-Type': 'application/json' });
+ res.end(JSON.stringify({ '/api/v0': capturedV0, '/api/v1': capturedV1, '/api/v2': capturedV2 }));
+ break;
+ }
+ case '/test-breadcrumbs': {
+ Sentry.addBreadcrumb({ message: 'manual breadcrumb' });
+ await fetch(`${targetUrl}/api/v0`);
+ await fetch(`${targetUrl}/api/v1`);
+ Sentry.captureException(new Error('foo'));
+ res.writeHead(200);
+ res.end('ok');
+ break;
+ }
+ default: {
+ res.writeHead(404);
+ res.end();
+ }
+ }
+ });
+
+ server.listen(0, () => {
+ sendPortToRunner(server.address().port);
+ });
+});

dev-packages/node-core-integration-tests/suites/light-mode/outgoing-fetch/test.ts

@@ -0,0 +1,79 @@
+import crypto from 'crypto';
+import { afterAll, expect, test } from 'vitest';
+import { conditionalTest } from '../../../utils';
+import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
+
+afterAll(() => {
+ cleanupChildProcesses();
+});
+
+conditionalTest({ min: 22 })('light mode outgoing fetch', () => {
+ test('automatically propagates trace headers to outgoing fetch requests matching tracePropagationTargets', async () => {
+ const traceId = crypto.randomUUID().replace(/-/g, '');
+ const parentSpanId = traceId.substring(0, 16);
+
+ const runner = createRunner(__dirname, 'server.js').start();
+
+ const response = await runner.makeRequest<Record<string, { 'sentry-trace'?: string; baggage?: string }>>(
+ 'get',
+ '/test-auto-propagation',
+ {
+ headers: {
+ 'sentry-trace': `${traceId}-${parentSpanId}-1`,
+ baggage: `sentry-trace_id=${traceId},sentry-environment=test,sentry-public_key=public`,
+ },
+ },
+ );
+
+ // /api/v0 matches tracePropagationTargets - should have headers
+ expect(response?.['/api/v0']?.['sentry-trace']).toMatch(new RegExp(`^${traceId}-[a-f\\d]{16}-1$`));
+ expect(response?.['/api/v0']?.baggage).toContain(`sentry-trace_id=${traceId}`);
+
+ // /api/v1 matches tracePropagationTargets - should have headers
+ expect(response?.['/api/v1']?.['sentry-trace']).toMatch(new RegExp(`^${traceId}-[a-f\\d]{16}-1$`));
+ expect(response?.['/api/v1']?.baggage).toContain(`sentry-trace_id=${traceId}`);
+
+ // /api/v2 does NOT match tracePropagationTargets - should NOT have headers
+ expect(response?.['/api/v2']?.['sentry-trace']).toBeUndefined();
+ expect(response?.['/api/v2']?.baggage).toBeUndefined();
+ });
+
+ test('creates breadcrumbs for outgoing fetch requests', async () => {
+ const runner = createRunner(__dirname, 'server.js')
+ .expect({
+ event: event => {
+ const breadcrumbs = event.breadcrumbs || [];
+ const httpBreadcrumbs = breadcrumbs.filter(b => b.category === 'http');
+
+ expect(httpBreadcrumbs.length).toBe(2);
+
+ expect(httpBreadcrumbs[0]).toEqual(
+ expect.objectContaining({
+ category: 'http',
+ type: 'http',
+ data: expect.objectContaining({
+ 'http.method': 'GET',
+ status_code: 200,
+ }),
+ }),
+ );
+
+ expect(httpBreadcrumbs[1]).toEqual(
+ expect.objectContaining({
+ category: 'http',
+ type: 'http',
+ data: expect.objectContaining({
+ 'http.method': 'GET',
+ status_code: 200,
+ }),
+ }),
+ );
+ },
+ })
+ .start();
+
+ await runner.makeRequest('get', '/test-breadcrumbs');
+
+ await runner.completed();
+ });
+});

dev-packages/node-core-integration-tests/suites/light-mode/outgoing-http/server.js

@@ -0,0 +1,98 @@
+const http = require('http');
+const Sentry = require('@sentry/node-core/light');
+const { loggingTransport, sendPortToRunner } = require('@sentry-internal/node-core-integration-tests');
+
+Sentry.init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ release: '1.0',
+ transport: loggingTransport,
+ tracePropagationTargets: [/\/api\/v0/, 'v1'],
+ beforeBreadcrumb(breadcrumb, hint) {
+ breadcrumb.data = breadcrumb.data || {};
+ const req = hint?.request;
+ if (req?.path) {
+ breadcrumb.data.ADDED_PATH = req.path;
+ }
+ return breadcrumb;
+ },
+});
+
+function makeHttpRequest(url) {
+ return new Promise((resolve, reject) => {
+ const urlObj = new URL(url);
+ const req = http.request(
+ {
+ hostname: urlObj.hostname,
+ port: urlObj.port,
+ path: urlObj.pathname,
+ method: 'GET',
+ },
+ res => {
+ res.on('data', () => {});
+ res.on('end', () => resolve());
+ },
+ );
+ req.on('error', reject);
+ req.end();
+ });
+}
+
+let capturedV0 = {};
+let capturedV1 = {};
+let capturedV2 = {};
+
+const targetServer = http.createServer((req, res) => {
+ const headers = {
+ 'sentry-trace': req.headers['sentry-trace'],
+ baggage: req.headers['baggage'],
+ };
+
+ if (req.url === '/api/v0') {
+ capturedV0 = headers;
+ } else if (req.url === '/api/v1') {
+ capturedV1 = headers;
+ } else if (req.url === '/api/v2') {
+ capturedV2 = headers;
+ }
+
+ res.writeHead(200);
+ res.end('ok');
+});
+
+targetServer.listen(0, () => {
+ const targetPort = targetServer.address().port;
+ const targetUrl = `http://localhost:${targetPort}`;
+
+ const server = http.createServer(async (req, res) => {
+ switch (req.url) {
+ case '/test-auto-propagation': {
+ capturedV0 = {};
+ capturedV1 = {};
+ capturedV2 = {};
+ await makeHttpRequest(`${targetUrl}/api/v0`);
+ await makeHttpRequest(`${targetUrl}/api/v1`);
+ await makeHttpRequest(`${targetUrl}/api/v2`);
+ res.writeHead(200, { 'Content-Type': 'application/json' });
+ res.end(JSON.stringify({ '/api/v0': capturedV0, '/api/v1': capturedV1, '/api/v2': capturedV2 }));
+ break;
+ }
+ case '/test-breadcrumbs': {
+ Sentry.addBreadcrumb({ message: 'manual breadcrumb' });
+ await makeHttpRequest(`${targetUrl}/api/v0`);
+ await makeHttpRequest(`${targetUrl}/api/v1`);
+ Sentry.captureException(new Error('foo'));
+ res.writeHead(200);
+ res.end('ok');
+ break;
+ }
+ default: {
+ res.writeHead(404);
+ res.end();
+ }
+ }
+ });
+
+ server.listen(0, () => {
+ sendPortToRunner(server.address().port);
+ });
+});

dev-packages/node-core-integration-tests/suites/light-mode/outgoing-http/test.ts

@@ -0,0 +1,79 @@
+import crypto from 'crypto';
+import { afterAll, expect, test } from 'vitest';
+import { conditionalTest } from '../../../utils';
+import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
+
+afterAll(() => {
+ cleanupChildProcesses();
+});
+
+conditionalTest({ min: 22 })('light mode outgoing http', () => {
+ test('automatically propagates trace headers to outgoing http requests matching tracePropagationTargets', async () => {
+ const traceId = crypto.randomUUID().replace(/-/g, '');
+ const parentSpanId = traceId.substring(0, 16);
+
+ const runner = createRunner(__dirname, 'server.js').start();
+
+ const response = await runner.makeRequest<Record<string, { 'sentry-trace'?: string; baggage?: string }>>(
+ 'get',
+ '/test-auto-propagation',
+ {
+ headers: {
+ 'sentry-trace': `${traceId}-${parentSpanId}-1`,
+ baggage: `sentry-trace_id=${traceId},sentry-environment=test,sentry-public_key=public`,
+ },
+ },
+ );
+
+ // /api/v0 matches tracePropagationTargets - should have headers
+ expect(response?.['/api/v0']?.['sentry-trace']).toMatch(new RegExp(`^${traceId}-[a-f\\d]{16}-1$`));
+ expect(response?.['/api/v0']?.baggage).toContain(`sentry-trace_id=${traceId}`);
+
+ // /api/v1 matches tracePropagationTargets - should have headers
+ expect(response?.['/api/v1']?.['sentry-trace']).toMatch(new RegExp(`^${traceId}-[a-f\\d]{16}-1$`));
+ expect(response?.['/api/v1']?.baggage).toContain(`sentry-trace_id=${traceId}`);
+
+ // /api/v2 does NOT match tracePropagationTargets - should NOT have headers
+ expect(response?.['/api/v2']?.['sentry-trace']).toBeUndefined();
+ expect(response?.['/api/v2']?.baggage).toBeUndefined();
+ });
+
+ test('creates breadcrumbs for outgoing http requests', async () => {
+ const runner = createRunner(__dirname, 'server.js')
+ .expect({
+ event: event => {
+ const breadcrumbs = event.breadcrumbs || [];
+ const httpBreadcrumbs = breadcrumbs.filter(b => b.category === 'http');
+
+ expect(httpBreadcrumbs.length).toBe(2);
+
+ expect(httpBreadcrumbs[0]).toEqual(
+ expect.objectContaining({
+ category: 'http',
+ type: 'http',
+ data: expect.objectContaining({
+ 'http.method': 'GET',
+ status_code: 200,
+ }),
+ }),
+ );
+
+ expect(httpBreadcrumbs[1]).toEqual(
+ expect.objectContaining({
+ category: 'http',
+ type: 'http',
+ data: expect.objectContaining({
+ 'http.method': 'GET',
+ status_code: 200,
+ }),
+ }),
+ );
+ },
+ })
+ .start();
+
+ await runner.makeRequest('get', '/test-breadcrumbs');
+
+ await runner.completed();
+ });
+});

packages/core/src/index.ts

@@ -92,6 +92,7 @@ export { _setSpanForScope as _INTERNAL_setSpanForScope } from './utils/spanOnSco
 export { parseSampleRate } from './utils/parseSampleRate';
 export { applySdkMetadata } from './utils/sdkMetadata';
 export { getTraceData } from './utils/traceData';
+export { shouldPropagateTraceForUrl } from './utils/tracePropagationTargets';
 export { getTraceMetaTags } from './utils/meta';
 export { debounce } from './utils/debounce';
 export {

packages/core/src/utils/tracePropagationTargets.ts

@@ -0,0 +1,34 @@
+import type { CoreOptions as Options } from '../types-hoist/options';
+import { debug } from './debug-logger';
+import type { LRUMap } from './lru';
+import { stringMatchesSomePattern } from './string';
+
+const NOT_PROPAGATED_MESSAGE =
+ '[Tracing] Not injecting trace data for url because it does not match tracePropagationTargets:';
+
+/**
+ * Check if a given URL should be propagated to or not.
+ * If no url is defined, or no trace propagation targets are defined, this will always return `true`.
+ * You can also optionally provide a decision map, to cache decisions and avoid repeated regex lookups.
+ */
+export function shouldPropagateTraceForUrl(
+ url: string | undefined,
+ tracePropagationTargets: Options['tracePropagationTargets'],
+ decisionMap?: LRUMap<string, boolean>,
+): boolean {
+ if (typeof url !== 'string' || !tracePropagationTargets) {
+ return true;
+ }
+
+ const cachedDecision = decisionMap?.get(url);
+ if (cachedDecision !== undefined) {
+ !cachedDecision && debug.log(NOT_PROPAGATED_MESSAGE, url);
+ return cachedDecision;
+ }
+
+ const decision = stringMatchesSomePattern(url, tracePropagationTargets);
+ decisionMap?.set(url, decision);
+
+ !decision && debug.log(NOT_PROPAGATED_MESSAGE, url);
+ return decision;
+}

dev-packages/node-core-integration-tests/suites/light-mode/outgoing-fetch/server.js

@@ -0,0 +1,70 @@
+const http = require('http');
+const Sentry = require('@sentry/node-core/light');
+const { loggingTransport, sendPortToRunner } = require('@sentry-internal/node-core-integration-tests');
+
+Sentry.init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ release: '1.0',
+ transport: loggingTransport,
+ tracePropagationTargets: [/\/api\/v0/, 'v1'],
+});
+
+let capturedV0 = {};
+let capturedV1 = {};
+let capturedV2 = {};
+
+const targetServer = http.createServer((req, res) => {
+ const headers = {
+ 'sentry-trace': req.headers['sentry-trace'],
+ baggage: req.headers['baggage'],
+ };
+
+ if (req.url === '/api/v0') {
+ capturedV0 = headers;
+ } else if (req.url === '/api/v1') {
+ capturedV1 = headers;
+ } else if (req.url === '/api/v2') {
+ capturedV2 = headers;
+ }
+
+ res.writeHead(200);
+ res.end('ok');
+});
+
+targetServer.listen(0, () => {
+ const targetPort = targetServer.address().port;
+ const targetUrl = `http://localhost:${targetPort}`;
+
+ const server = http.createServer(async (req, res) => {
+ switch (req.url) {
+ case '/test-auto-propagation': {
+ capturedV0 = {};
+ capturedV1 = {};
+ capturedV2 = {};
+ await fetch(`${targetUrl}/api/v0`);
+ await fetch(`${targetUrl}/api/v1`);
+ await fetch(`${targetUrl}/api/v2`);
+ res.writeHead(200, { 'Content-Type': 'application/json' });
+ res.end(JSON.stringify({ '/api/v0': capturedV0, '/api/v1': capturedV1, '/api/v2': capturedV2 }));
+ break;
+ }
+ case '/test-breadcrumbs': {
+ Sentry.addBreadcrumb({ message: 'manual breadcrumb' });
+ await fetch(`${targetUrl}/api/v0`);
+ await fetch(`${targetUrl}/api/v1`);
+ Sentry.captureException(new Error('foo'));
+ res.writeHead(200);
+ res.end('ok');
+ break;
+ }
+ default: {
+ res.writeHead(404);
+ res.end();
+ }
+ }
+ });
+
+ server.listen(0, () => {
+ sendPortToRunner(server.address().port);
+ });
+});

dev-packages/node-core-integration-tests/suites/light-mode/outgoing-fetch/test.ts

@@ -0,0 +1,79 @@
+import crypto from 'crypto';
+import { afterAll, expect, test } from 'vitest';
+import { conditionalTest } from '../../../utils';
+import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
+
+afterAll(() => {
+ cleanupChildProcesses();
+});
+
+conditionalTest({ min: 22 })('light mode outgoing fetch', () => {
+ test('automatically propagates trace headers to outgoing fetch requests matching tracePropagationTargets', async () => {
+ const traceId = crypto.randomUUID().replace(/-/g, '');
+ const parentSpanId = traceId.substring(0, 16);
+
+ const runner = createRunner(__dirname, 'server.js').start();
+
+ const response = await runner.makeRequest<Record<string, { 'sentry-trace'?: string; baggage?: string }>>(
+ 'get',
+ '/test-auto-propagation',
+ {
+ headers: {
+ 'sentry-trace': `${traceId}-${parentSpanId}-1`,
+ baggage: `sentry-trace_id=${traceId},sentry-environment=test,sentry-public_key=public`,
+ },
+ },
+ );
+
+ // /api/v0 matches tracePropagationTargets - should have headers
+ expect(response?.['/api/v0']?.['sentry-trace']).toMatch(new RegExp(`^${traceId}-[a-f\\d]{16}-1$`));
+ expect(response?.['/api/v0']?.baggage).toContain(`sentry-trace_id=${traceId}`);
+
+ // /api/v1 matches tracePropagationTargets - should have headers
+ expect(response?.['/api/v1']?.['sentry-trace']).toMatch(new RegExp(`^${traceId}-[a-f\\d]{16}-1$`));
+ expect(response?.['/api/v1']?.baggage).toContain(`sentry-trace_id=${traceId}`);
+
+ // /api/v2 does NOT match tracePropagationTargets - should NOT have headers
+ expect(response?.['/api/v2']?.['sentry-trace']).toBeUndefined();
+ expect(response?.['/api/v2']?.baggage).toBeUndefined();
+ });
+
+ test('creates breadcrumbs for outgoing fetch requests', async () => {
+ const runner = createRunner(__dirname, 'server.js')
+ .expect({
+ event: event => {
+ const breadcrumbs = event.breadcrumbs || [];
+ const httpBreadcrumbs = breadcrumbs.filter(b => b.category === 'http');
+
+ expect(httpBreadcrumbs.length).toBe(2);
+
+ expect(httpBreadcrumbs[0]).toEqual(
+ expect.objectContaining({
+ category: 'http',
+ type: 'http',
+ data: expect.objectContaining({
+ 'http.method': 'GET',
+ status_code: 200,
+ }),
+ }),
+ );
+
+ expect(httpBreadcrumbs[1]).toEqual(
+ expect.objectContaining({
+ category: 'http',
+ type: 'http',
+ data: expect.objectContaining({
+ 'http.method': 'GET',
+ status_code: 200,
+ }),
+ }),
+ );
+ },
+ })
+ .start();
+
+ await runner.makeRequest('get', '/test-breadcrumbs');
+
+ await runner.completed();
+ });
+});

dev-packages/node-core-integration-tests/suites/light-mode/outgoing-http/server.js

@@ -0,0 +1,98 @@
+const http = require('http');
+const Sentry = require('@sentry/node-core/light');
+const { loggingTransport, sendPortToRunner } = require('@sentry-internal/node-core-integration-tests');
+
+Sentry.init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ release: '1.0',
+ transport: loggingTransport,
+ tracePropagationTargets: [/\/api\/v0/, 'v1'],
+ beforeBreadcrumb(breadcrumb, hint) {
+ breadcrumb.data = breadcrumb.data || {};
+ const req = hint?.request;
+ if (req?.path) {
+ breadcrumb.data.ADDED_PATH = req.path;
+ }
+ return breadcrumb;
+ },
+});
+
+function makeHttpRequest(url) {
+ return new Promise((resolve, reject) => {
+ const urlObj = new URL(url);
+ const req = http.request(
+ {
+ hostname: urlObj.hostname,
+ port: urlObj.port,
+ path: urlObj.pathname,
+ method: 'GET',
+ },
+ res => {
+ res.on('data', () => {});
+ res.on('end', () => resolve());
+ },
+ );
+ req.on('error', reject);
+ req.end();
+ });
+}
+
+let capturedV0 = {};
+let capturedV1 = {};
+let capturedV2 = {};
+
+const targetServer = http.createServer((req, res) => {
+ const headers = {
+ 'sentry-trace': req.headers['sentry-trace'],
+ baggage: req.headers['baggage'],
+ };
+
+ if (req.url === '/api/v0') {
+ capturedV0 = headers;
+ } else if (req.url === '/api/v1') {
+ capturedV1 = headers;
+ } else if (req.url === '/api/v2') {
+ capturedV2 = headers;
+ }
+
+ res.writeHead(200);
+ res.end('ok');
+});
+
+targetServer.listen(0, () => {
+ const targetPort = targetServer.address().port;
+ const targetUrl = `http://localhost:${targetPort}`;
+
+ const server = http.createServer(async (req, res) => {
+ switch (req.url) {
+ case '/test-auto-propagation': {
+ capturedV0 = {};
+ capturedV1 = {};
+ capturedV2 = {};
+ await makeHttpRequest(`${targetUrl}/api/v0`);
+ await makeHttpRequest(`${targetUrl}/api/v1`);
+ await makeHttpRequest(`${targetUrl}/api/v2`);
+ res.writeHead(200, { 'Content-Type': 'application/json' });
+ res.end(JSON.stringify({ '/api/v0': capturedV0, '/api/v1': capturedV1, '/api/v2': capturedV2 }));
+ break;
+ }
+ case '/test-breadcrumbs': {
+ Sentry.addBreadcrumb({ message: 'manual breadcrumb' });
+ await makeHttpRequest(`${targetUrl}/api/v0`);
+ await makeHttpRequest(`${targetUrl}/api/v1`);
+ Sentry.captureException(new Error('foo'));
+ res.writeHead(200);
+ res.end('ok');
+ break;
+ }
+ default: {
+ res.writeHead(404);
+ res.end();
+ }
+ }
+ });
+
+ server.listen(0, () => {
+ sendPortToRunner(server.address().port);
+ });
+});

dev-packages/node-core-integration-tests/suites/light-mode/outgoing-http/test.ts

@@ -0,0 +1,79 @@
+import crypto from 'crypto';
+import { afterAll, expect, test } from 'vitest';
+import { conditionalTest } from '../../../utils';
+import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
+
+afterAll(() => {
+ cleanupChildProcesses();
+});
+
+conditionalTest({ min: 22 })('light mode outgoing http', () => {
+ test('automatically propagates trace headers to outgoing http requests matching tracePropagationTargets', async () => {
+ const traceId = crypto.randomUUID().replace(/-/g, '');
+ const parentSpanId = traceId.substring(0, 16);
+
+ const runner = createRunner(__dirname, 'server.js').start();
+
+ const response = await runner.makeRequest<Record<string, { 'sentry-trace'?: string; baggage?: string }>>(
+ 'get',
+ '/test-auto-propagation',
+ {
+ headers: {
+ 'sentry-trace': `${traceId}-${parentSpanId}-1`,
+ baggage: `sentry-trace_id=${traceId},sentry-environment=test,sentry-public_key=public`,
+ },
+ },
+ );
+
+ // /api/v0 matches tracePropagationTargets - should have headers
+ expect(response?.['/api/v0']?.['sentry-trace']).toMatch(new RegExp(`^${traceId}-[a-f\\d]{16}-1$`));
+ expect(response?.['/api/v0']?.baggage).toContain(`sentry-trace_id=${traceId}`);
+
+ // /api/v1 matches tracePropagationTargets - should have headers
+ expect(response?.['/api/v1']?.['sentry-trace']).toMatch(new RegExp(`^${traceId}-[a-f\\d]{16}-1$`));
+ expect(response?.['/api/v1']?.baggage).toContain(`sentry-trace_id=${traceId}`);
+
+ // /api/v2 does NOT match tracePropagationTargets - should NOT have headers
+ expect(response?.['/api/v2']?.['sentry-trace']).toBeUndefined();
+ expect(response?.['/api/v2']?.baggage).toBeUndefined();
+ });
+
+ test('creates breadcrumbs for outgoing http requests', async () => {
+ const runner = createRunner(__dirname, 'server.js')
+ .expect({
+ event: event => {
+ const breadcrumbs = event.breadcrumbs || [];
+ const httpBreadcrumbs = breadcrumbs.filter(b => b.category === 'http');
+
+ expect(httpBreadcrumbs.length).toBe(2);
+
+ expect(httpBreadcrumbs[0]).toEqual(
+ expect.objectContaining({
+ category: 'http',
+ type: 'http',
+ data: expect.objectContaining({
+ 'http.method': 'GET',
+ status_code: 200,
+ }),
+ }),
+ );
+
+ expect(httpBreadcrumbs[1]).toEqual(
+ expect.objectContaining({
+ category: 'http',
+ type: 'http',
+ data: expect.objectContaining({
+ 'http.method': 'GET',
+ status_code: 200,
+ }),
+ }),
+ );
+ },
+ })
+ .start();
+
+ await runner.makeRequest('get', '/test-breadcrumbs');
+
+ await runner.completed();
+ });
+});

packages/core/src/index.ts

@@ -92,6 +92,7 @@ export { _setSpanForScope as _INTERNAL_setSpanForScope } from './utils/spanOnSco
 export { parseSampleRate } from './utils/parseSampleRate';
 export { applySdkMetadata } from './utils/sdkMetadata';
 export { getTraceData } from './utils/traceData';
+export { shouldPropagateTraceForUrl } from './utils/tracePropagationTargets';
 export { getTraceMetaTags } from './utils/meta';
 export { debounce } from './utils/debounce';
 export {

packages/core/src/utils/tracePropagationTargets.ts

@@ -0,0 +1,34 @@
+import type { CoreOptions as Options } from '../types-hoist/options';
+import { debug } from './debug-logger';
+import type { LRUMap } from './lru';
+import { stringMatchesSomePattern } from './string';
+
+const NOT_PROPAGATED_MESSAGE =
+ '[Tracing] Not injecting trace data for url because it does not match tracePropagationTargets:';
+
+/**
+ * Check if a given URL should be propagated to or not.
+ * If no url is defined, or no trace propagation targets are defined, this will always return `true`.
+ * You can also optionally provide a decision map, to cache decisions and avoid repeated regex lookups.
+ */
+export function shouldPropagateTraceForUrl(
+ url: string | undefined,
+ tracePropagationTargets: Options['tracePropagationTargets'],
+ decisionMap?: LRUMap<string, boolean>,
+): boolean {
+ if (typeof url !== 'string' || !tracePropagationTargets) {
+ return true;
+ }
+
+ const cachedDecision = decisionMap?.get(url);
+ if (cachedDecision !== undefined) {
+ !cachedDecision && debug.log(NOT_PROPAGATED_MESSAGE, url);
+ return cachedDecision;
+ }
+
+ const decision = stringMatchesSomePattern(url, tracePropagationTargets);
+ decisionMap?.set(url, decision);
+
+ !decision && debug.log(NOT_PROPAGATED_MESSAGE, url);
+ return decision;
+}

dev-packages/node-core-integration-tests/suites/light-mode/outgoing-fetch/server.js

@@ -0,0 +1,70 @@
+const http = require('http');
+const Sentry = require('@sentry/node-core/light');
+const { loggingTransport, sendPortToRunner } = require('@sentry-internal/node-core-integration-tests');
+
+Sentry.init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ release: '1.0',
+ transport: loggingTransport,
+ tracePropagationTargets: [/\/api\/v0/, 'v1'],
+});
+
+let capturedV0 = {};
+let capturedV1 = {};
+let capturedV2 = {};
+
+const targetServer = http.createServer((req, res) => {
+ const headers = {
+ 'sentry-trace': req.headers['sentry-trace'],
+ baggage: req.headers['baggage'],
+ };
+
+ if (req.url === '/api/v0') {
+ capturedV0 = headers;
+ } else if (req.url === '/api/v1') {
+ capturedV1 = headers;
+ } else if (req.url === '/api/v2') {
+ capturedV2 = headers;
+ }
+
+ res.writeHead(200);
+ res.end('ok');
+});
+
+targetServer.listen(0, () => {
+ const targetPort = targetServer.address().port;
+ const targetUrl = `http://localhost:${targetPort}`;
+
+ const server = http.createServer(async (req, res) => {
+ switch (req.url) {
+ case '/test-auto-propagation': {
+ capturedV0 = {};
+ capturedV1 = {};
+ capturedV2 = {};
+ await fetch(`${targetUrl}/api/v0`);
+ await fetch(`${targetUrl}/api/v1`);
+ await fetch(`${targetUrl}/api/v2`);
+ res.writeHead(200, { 'Content-Type': 'application/json' });
+ res.end(JSON.stringify({ '/api/v0': capturedV0, '/api/v1': capturedV1, '/api/v2': capturedV2 }));
+ break;
+ }
+ case '/test-breadcrumbs': {
+ Sentry.addBreadcrumb({ message: 'manual breadcrumb' });
+ await fetch(`${targetUrl}/api/v0`);
+ await fetch(`${targetUrl}/api/v1`);
+ Sentry.captureException(new Error('foo'));
+ res.writeHead(200);
+ res.end('ok');
+ break;
+ }
+ default: {
+ res.writeHead(404);
+ res.end();
+ }
+ }
+ });
+
+ server.listen(0, () => {
+ sendPortToRunner(server.address().port);
+ });
+});

dev-packages/node-core-integration-tests/suites/light-mode/outgoing-fetch/test.ts

@@ -0,0 +1,79 @@
+import crypto from 'crypto';
+import { afterAll, expect, test } from 'vitest';
+import { conditionalTest } from '../../../utils';
+import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
+
+afterAll(() => {
+ cleanupChildProcesses();
+});
+
+conditionalTest({ min: 22 })('light mode outgoing fetch', () => {
+ test('automatically propagates trace headers to outgoing fetch requests matching tracePropagationTargets', async () => {
+ const traceId = crypto.randomUUID().replace(/-/g, '');
+ const parentSpanId = traceId.substring(0, 16);
+
+ const runner = createRunner(__dirname, 'server.js').start();
+
+ const response = await runner.makeRequest<Record<string, { 'sentry-trace'?: string; baggage?: string }>>(
+ 'get',
+ '/test-auto-propagation',
+ {
+ headers: {
+ 'sentry-trace': `${traceId}-${parentSpanId}-1`,
+ baggage: `sentry-trace_id=${traceId},sentry-environment=test,sentry-public_key=public`,
+ },
+ },
+ );
+
+ // /api/v0 matches tracePropagationTargets - should have headers
+ expect(response?.['/api/v0']?.['sentry-trace']).toMatch(new RegExp(`^${traceId}-[a-f\\d]{16}-1$`));
+ expect(response?.['/api/v0']?.baggage).toContain(`sentry-trace_id=${traceId}`);
+
+ // /api/v1 matches tracePropagationTargets - should have headers
+ expect(response?.['/api/v1']?.['sentry-trace']).toMatch(new RegExp(`^${traceId}-[a-f\\d]{16}-1$`));
+ expect(response?.['/api/v1']?.baggage).toContain(`sentry-trace_id=${traceId}`);
+
+ // /api/v2 does NOT match tracePropagationTargets - should NOT have headers
+ expect(response?.['/api/v2']?.['sentry-trace']).toBeUndefined();
+ expect(response?.['/api/v2']?.baggage).toBeUndefined();
+ });
+
+ test('creates breadcrumbs for outgoing fetch requests', async () => {
+ const runner = createRunner(__dirname, 'server.js')
+ .expect({
+ event: event => {
+ const breadcrumbs = event.breadcrumbs || [];
+ const httpBreadcrumbs = breadcrumbs.filter(b => b.category === 'http');
+
+ expect(httpBreadcrumbs.length).toBe(2);
+
+ expect(httpBreadcrumbs[0]).toEqual(
+ expect.objectContaining({
+ category: 'http',
+ type: 'http',
+ data: expect.objectContaining({
+ 'http.method': 'GET',
+ status_code: 200,
+ }),
+ }),
+ );
+
+ expect(httpBreadcrumbs[1]).toEqual(
+ expect.objectContaining({
+ category: 'http',
+ type: 'http',
+ data: expect.objectContaining({
+ 'http.method': 'GET',
+ status_code: 200,
+ }),
+ }),
+ );
+ },
+ })
+ .start();
+
+ await runner.makeRequest('get', '/test-breadcrumbs');
+
+ await runner.completed();
+ });
+});

dev-packages/node-core-integration-tests/suites/light-mode/outgoing-http/server.js

@@ -0,0 +1,98 @@
+const http = require('http');
+const Sentry = require('@sentry/node-core/light');
+const { loggingTransport, sendPortToRunner } = require('@sentry-internal/node-core-integration-tests');
+
+Sentry.init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ release: '1.0',
+ transport: loggingTransport,
+ tracePropagationTargets: [/\/api\/v0/, 'v1'],
+ beforeBreadcrumb(breadcrumb, hint) {
+ breadcrumb.data = breadcrumb.data || {};
+ const req = hint?.request;
+ if (req?.path) {
+ breadcrumb.data.ADDED_PATH = req.path;
+ }
+ return breadcrumb;
+ },
+});
+
+function makeHttpRequest(url) {
+ return new Promise((resolve, reject) => {
+ const urlObj = new URL(url);
+ const req = http.request(
+ {
+ hostname: urlObj.hostname,
+ port: urlObj.port,
+ path: urlObj.pathname,
+ method: 'GET',
+ },
+ res => {
+ res.on('data', () => {});
+ res.on('end', () => resolve());
+ },
+ );
+ req.on('error', reject);
+ req.end();
+ });
+}
+
+let capturedV0 = {};
+let capturedV1 = {};
+let capturedV2 = {};
+
+const targetServer = http.createServer((req, res) => {
+ const headers = {
+ 'sentry-trace': req.headers['sentry-trace'],
+ baggage: req.headers['baggage'],
+ };
+
+ if (req.url === '/api/v0') {
+ capturedV0 = headers;
+ } else if (req.url === '/api/v1') {
+ capturedV1 = headers;
+ } else if (req.url === '/api/v2') {
+ capturedV2 = headers;
+ }
+
+ res.writeHead(200);
+ res.end('ok');
+});
+
+targetServer.listen(0, () => {
+ const targetPort = targetServer.address().port;
+ const targetUrl = `http://localhost:${targetPort}`;
+
+ const server = http.createServer(async (req, res) => {
+ switch (req.url) {
+ case '/test-auto-propagation': {
+ capturedV0 = {};
+ capturedV1 = {};
+ capturedV2 = {};
+ await makeHttpRequest(`${targetUrl}/api/v0`);
+ await makeHttpRequest(`${targetUrl}/api/v1`);
+ await makeHttpRequest(`${targetUrl}/api/v2`);
+ res.writeHead(200, { 'Content-Type': 'application/json' });
+ res.end(JSON.stringify({ '/api/v0': capturedV0, '/api/v1': capturedV1, '/api/v2': capturedV2 }));
+ break;
+ }
+ case '/test-breadcrumbs': {
+ Sentry.addBreadcrumb({ message: 'manual breadcrumb' });
+ await makeHttpRequest(`${targetUrl}/api/v0`);
+ await makeHttpRequest(`${targetUrl}/api/v1`);
+ Sentry.captureException(new Error('foo'));
+ res.writeHead(200);
+ res.end('ok');
+ break;
+ }
+ default: {
+ res.writeHead(404);
+ res.end();
+ }
+ }
+ });
+
+ server.listen(0, () => {
+ sendPortToRunner(server.address().port);
+ });
+});

dev-packages/node-core-integration-tests/suites/light-mode/outgoing-http/test.ts

@@ -0,0 +1,79 @@
+import crypto from 'crypto';
+import { afterAll, expect, test } from 'vitest';
+import { conditionalTest } from '../../../utils';
+import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
+
+afterAll(() => {
+ cleanupChildProcesses();
+});
+
+conditionalTest({ min: 22 })('light mode outgoing http', () => {
+ test('automatically propagates trace headers to outgoing http requests matching tracePropagationTargets', async () => {
+ const traceId = crypto.randomUUID().replace(/-/g, '');
+ const parentSpanId = traceId.substring(0, 16);
+
+ const runner = createRunner(__dirname, 'server.js').start();
+
+ const response = await runner.makeRequest<Record<string, { 'sentry-trace'?: string; baggage?: string }>>(
+ 'get',
+ '/test-auto-propagation',
+ {
+ headers: {
+ 'sentry-trace': `${traceId}-${parentSpanId}-1`,
+ baggage: `sentry-trace_id=${traceId},sentry-environment=test,sentry-public_key=public`,
+ },
+ },
+ );
+
+ // /api/v0 matches tracePropagationTargets - should have headers
+ expect(response?.['/api/v0']?.['sentry-trace']).toMatch(new RegExp(`^${traceId}-[a-f\\d]{16}-1$`));
+ expect(response?.['/api/v0']?.baggage).toContain(`sentry-trace_id=${traceId}`);
+
+ // /api/v1 matches tracePropagationTargets - should have headers
+ expect(response?.['/api/v1']?.['sentry-trace']).toMatch(new RegExp(`^${traceId}-[a-f\\d]{16}-1$`));
+ expect(response?.['/api/v1']?.baggage).toContain(`sentry-trace_id=${traceId}`);
+
+ // /api/v2 does NOT match tracePropagationTargets - should NOT have headers
+ expect(response?.['/api/v2']?.['sentry-trace']).toBeUndefined();
+ expect(response?.['/api/v2']?.baggage).toBeUndefined();
+ });
+
+ test('creates breadcrumbs for outgoing http requests', async () => {
+ const runner = createRunner(__dirname, 'server.js')
+ .expect({
+ event: event => {
+ const breadcrumbs = event.breadcrumbs || [];
+ const httpBreadcrumbs = breadcrumbs.filter(b => b.category === 'http');
+
+ expect(httpBreadcrumbs.length).toBe(2);
+
+ expect(httpBreadcrumbs[0]).toEqual(
+ expect.objectContaining({
+ category: 'http',
+ type: 'http',
+ data: expect.objectContaining({
+ 'http.method': 'GET',
+ status_code: 200,
+ }),
+ }),
+ );
+
+ expect(httpBreadcrumbs[1]).toEqual(
+ expect.objectContaining({
+ category: 'http',
+ type: 'http',
+ data: expect.objectContaining({
+ 'http.method': 'GET',
+ status_code: 200,
+ }),
+ }),
+ );
+ },
+ })
+ .start();
+
+ await runner.makeRequest('get', '/test-breadcrumbs');
+
+ await runner.completed();
+ });
+});

packages/core/src/index.ts

@@ -92,6 +92,7 @@ export { _setSpanForScope as _INTERNAL_setSpanForScope } from './utils/spanOnSco
 export { parseSampleRate } from './utils/parseSampleRate';
 export { applySdkMetadata } from './utils/sdkMetadata';
 export { getTraceData } from './utils/traceData';
+export { shouldPropagateTraceForUrl } from './utils/tracePropagationTargets';
 export { getTraceMetaTags } from './utils/meta';
 export { debounce } from './utils/debounce';
 export {

packages/core/src/utils/tracePropagationTargets.ts

@@ -0,0 +1,34 @@
+import type { CoreOptions as Options } from '../types-hoist/options';
+import { debug } from './debug-logger';
+import type { LRUMap } from './lru';
+import { stringMatchesSomePattern } from './string';
+
+const NOT_PROPAGATED_MESSAGE =
+ '[Tracing] Not injecting trace data for url because it does not match tracePropagationTargets:';
+
+/**
+ * Check if a given URL should be propagated to or not.
+ * If no url is defined, or no trace propagation targets are defined, this will always return `true`.
+ * You can also optionally provide a decision map, to cache decisions and avoid repeated regex lookups.
+ */
+export function shouldPropagateTraceForUrl(
+ url: string | undefined,
+ tracePropagationTargets: Options['tracePropagationTargets'],
+ decisionMap?: LRUMap<string, boolean>,
+): boolean {
+ if (typeof url !== 'string' || !tracePropagationTargets) {
+ return true;
+ }
+
+ const cachedDecision = decisionMap?.get(url);
+ if (cachedDecision !== undefined) {
+ !cachedDecision && debug.log(NOT_PROPAGATED_MESSAGE, url);
+ return cachedDecision;
+ }
+
+ const decision = stringMatchesSomePattern(url, tracePropagationTargets);
+ decisionMap?.set(url, decision);
+
+ !decision && debug.log(NOT_PROPAGATED_MESSAGE, url);
+ return decision;
+}