feat(baggage): Added double baggage prevention logic and introduce

Author: harshit078

dev-packages/node-integration-tests/suites/tracing/double-baggage-prevention/instrument.mjs

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

dev-packages/node-integration-tests/suites/tracing/double-baggage-prevention/scenario.mjs

@@ -0,0 +1,100 @@
+import http from 'http';
+import * as Sentry from '@sentry/node';
+
+let capturedHeaders = {};
+const targetServer = http.createServer((req, res) => {
+  capturedHeaders = {
+    'sentry-trace': req.headers['sentry-trace'],
+    baggage: req.headers['baggage'],
+  };
+  res.writeHead(200);
+  res.end('ok');
+});
+
+targetServer.listen(0, async () => {
+  const targetPort = targetServer.address().port;
+  const targetUrl = `http://localhost:${targetPort}/target`;
+
+  try {
+    // Step 1: fetch with manual getTraceData() headers
+    console.log('[TEST 1] Fetch with manual getTraceData() headers');
+    capturedHeaders = {};
+    await fetch(targetUrl, { headers: { ...Sentry.getTraceData() } });
+    const fetchHeaders1 = { ...capturedHeaders };
+
+    // Step 2: fetch without manual headers
+    console.log('[TEST 2] Fetch without manual headers');
+    capturedHeaders = {};
+    await fetch(targetUrl);
+    const fetchHeaders2 = { ...capturedHeaders };
+
+    // Step 3: http.request with manual getTraceData() headers
+    console.log('[TEST 3] HTTP request with manual getTraceData() headers');
+    capturedHeaders = {};
+    await new Promise((resolve, reject) => {
+      const traceData = Sentry.getTraceData();
+      const req = http.request(
+        {
+          hostname: 'localhost',
+          port: targetPort,
+          path: '/target',
+          method: 'GET',
+          headers: traceData,
+        },
+        res => {
+          res.on('data', () => {});
+          res.on('end', () => resolve());
+        },
+      );
+      req.on('error', reject);
+      req.end();
+    });
+    const httpHeaders = { ...capturedHeaders };
+
+    // Step 4: fetch with custom + manual sentry baggage
+    console.log('[TEST 4] Fetch with custom baggage + manual sentry baggage');
+    capturedHeaders = {};
+    const traceData = Sentry.getTraceData();
+    await fetch(targetUrl, {
+      headers: {
+        ...traceData,
+        baggage: `custom-key=value,${traceData.baggage}`,
+      },
+    });
+    const fetchHeaders4 = { ...capturedHeaders };
+
+    const results = {
+      test1: {
+        sentryTrace: fetchHeaders1['sentry-trace'],
+        baggage: fetchHeaders1.baggage,
+        hasDuplicateSentryTrace: fetchHeaders1['sentry-trace']?.includes(','),
+        sentryBaggageCount: (fetchHeaders1.baggage?.match(/sentry-/g) || []).length,
+      },
+      test2: {
+        sentryTrace: fetchHeaders2['sentry-trace'],
+        baggage: fetchHeaders2.baggage,
+        hasDuplicateSentryTrace: fetchHeaders2['sentry-trace']?.includes(','),
+        sentryBaggageCount: (fetchHeaders2.baggage?.match(/sentry-/g) || []).length,
+      },
+      test3: {
+        sentryTrace: httpHeaders['sentry-trace'],
+        baggage: httpHeaders.baggage,
+        hasDuplicateSentryTrace: httpHeaders['sentry-trace']?.includes(','),
+        sentryBaggageCount: (httpHeaders.baggage?.match(/sentry-/g) || []).length,
+      },
+      test4: {
+        sentryTrace: fetchHeaders4['sentry-trace'],
+        baggage: fetchHeaders4.baggage,
+        hasDuplicateSentryTrace: fetchHeaders4['sentry-trace']?.includes(','),
+        hasCustomBaggage: fetchHeaders4.baggage?.includes('custom-key=value'),
+        sentryBaggageCount: (fetchHeaders4.baggage?.match(/sentry-/g) || []).length,
+      },
+    };
+
+    console.log('RESULTS:', JSON.stringify(results));
+  } catch (error) {
+    console.error('Test error:', error);
+  } finally {
+    targetServer.close();
+  }
+});

packages/node-core/src/utils/baggage.ts

@@ -1,4 +1,20 @@
-import { objectToBaggageHeader, parseBaggageHeader } from '@sentry/core';
+import { objectToBaggageHeader, parseBaggageHeader, SENTRY_BAGGAGE_KEY_PREFIX } from '@sentry/core';
+
+/**
+ * To check if a baggage header contains any Sentry baggage values.
+ *
+ * @param baggageHeader The baggage header to check
+ * @returns true if the baggage header contains any keys with the 'sentry-' prefix
+ */
+export function hasSentryBaggageValues(baggageHeader: string | string[] | undefined): boolean {
+  if (!baggageHeader) {
+    return false;
+  }
+
+  const baggageString = Array.isArray(baggageHeader) ? baggageHeader.join(',') : baggageHeader;
+
+  return baggageString.split(',').some(entry => entry.trim().startsWith(SENTRY_BAGGAGE_KEY_PREFIX));
+}
 
 /**
  * Merge two baggage headers into one, where the existing one takes precedence.