tests

Author: chargome

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

@@ -0,0 +1,20 @@
+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,
+  traceLifecycle: 'stream',
+  transport: loggingTransport,
+});
+
+async function run(): Promise<void> {
+  await Sentry.startSpan({ name: 'test_transaction' }, async () => {
+    await fetch(`${process.env.SERVER_URL}/api/v0`);
+  });
+
+  await Sentry.flush();
+}
+
+void run();

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

@@ -0,0 +1,30 @@
+import { createTestServer } from '@sentry-internal/test-utils';
+import { expect, test } from 'vitest';
+import { createRunner } from '../../../../utils/runner';
+
+test('captures streamed spans with sentry.op for outgoing fetch requests', async () => {
+  expect.assertions(2);
+
+  const [SERVER_URL, closeTestServer] = await createTestServer()
+    .get('/api/v0', () => {
+      // Just ensure we're called
+      expect(true).toBe(true);
+    })
+    .start();
+
+  await createRunner(__dirname, 'scenario.ts')
+    .withEnv({ SERVER_URL })
+    .expect({
+      span: container => {
+        const httpClientSpan = container.items.find(
+          item =>
+            item.attributes?.['sentry.op']?.type === 'string' && item.attributes['sentry.op'].value === 'http.client',
+        );
+
+        expect(httpClientSpan).toBeDefined();
+      },
+    })
+    .start()
+    .completed();
+  closeTestServer();
+});

packages/opentelemetry/src/sampler.ts

@@ -88,33 +88,52 @@ export class SentrySampler implements Sampler {
     // Non-root-spans simply inherit the sampling decision from their parent.
     if (!isRootSpan) {
       if (this._isSpanStreaming) {
+        // We only record client outcomes for child spans when streaming
+        if (!parentSampled) {
+          const parentSegmentIgnored = parentContext?.traceState?.get(SENTRY_TRACE_STATE_SEGMENT_IGNORED) === '1';
+          this._client.recordDroppedEvent(parentSegmentIgnored ? 'ignored' : 'sample_rate', 'span');
+          return wrapSamplingDecision({
+            decision: SamplingDecision.NOT_RECORD,
+            context,
+            spanAttributes,
+          });
+        }
+
         // `ignoreSpans` is only applied at span start for streamed spans.
         // Static spans/transactions get filtered at transaction end.
-        // Likewise, we only record client outcomes for child spans when streaming
-        if (parentSampled) {
-          if (ignoreSpans?.length) {
-            const { description: inferredChildName, op: childOp } = inferSpanData(spanName, spanAttributes, spanKind);
-            if (
-              shouldIgnoreSpan(
-                { description: inferredChildName, op: spanAttributes[SEMANTIC_ATTRIBUTE_SENTRY_OP] ?? childOp },
-                ignoreSpans,
-              )
-            ) {
-              this._client.recordDroppedEvent('ignored', 'span');
-              return wrapSamplingDecision({
-                decision: SamplingDecision.NOT_RECORD,
-                context,
-                spanAttributes,
-                ignoredChildSpan: true,
-              });
-            }
+        const { description: inferredChildName, op: childOp } = inferSpanData(spanName, spanAttributes, spanKind);
+        if (ignoreSpans?.length) {
+          if (
+            shouldIgnoreSpan(
+              { description: inferredChildName, op: spanAttributes[SEMANTIC_ATTRIBUTE_SENTRY_OP] ?? childOp },
+              ignoreSpans,
+            )
+          ) {
+            this._client.recordDroppedEvent('ignored', 'span');
+            return wrapSamplingDecision({
+              decision: SamplingDecision.NOT_RECORD,
+              context,
+              spanAttributes,
+              ignoredChildSpan: true,
+            });
           }
         }
 
-        if (!parentSampled) {
-          const parentSegmentIgnored = parentContext?.traceState?.get(SENTRY_TRACE_STATE_SEGMENT_IGNORED) === '1';
-          this._client.recordDroppedEvent(parentSegmentIgnored ? 'ignored' : 'sample_rate', 'span');
-        }
+        // For streamed spans, we need to propagate the inferred `sentry.op` via the SamplingResult attributes
+        // so that OTel sets it on the span at creation time. This is necessary because the streaming serialization
+        // path (`spanToStreamedSpanJSON`) passes raw OTel attributes through without inference, unlike the
+        // non-streamed path where the `SentrySpanExporter` infers the op during export.
+        const inferredOp = spanAttributes[SEMANTIC_ATTRIBUTE_SENTRY_OP] ?? childOp;
+        return {
+          ...wrapSamplingDecision({
+            decision: SamplingDecision.RECORD_AND_SAMPLED,
+            context,
+            spanAttributes,
+          }),
+          attributes: {
+            ...(inferredOp ? { [SEMANTIC_ATTRIBUTE_SENTRY_OP]: inferredOp } : {}),
+          },
+        };
       }
 
       return wrapSamplingDecision({
@@ -224,8 +243,7 @@ export class SentrySampler implements Sampler {
       attributes: {
         // We set the sample rate on the span when a local sample rate was applied to better understand how traces were sampled in Sentry
         [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: localSampleRateWasApplied ? sampleRate : undefined,
-        // For streamed spans, propagate the inferred op onto the span so it's included in the serialized attributes.
-        // Non-streamed spans get the op set during export in the SentrySpanExporter.
+        // See comment above in the `!isRootSpan` branch for why we propagate the op for streamed spans.
         ...(this._isSpanStreaming && op ? { [SEMANTIC_ATTRIBUTE_SENTRY_OP]: op } : {}),
       },
     };