tests

Author: chargome

dev-packages/browser-integration-tests/suites/tracing/no-parent-span-client-report-streamed/test.ts

@@ -1,16 +1,10 @@
 import { expect } from '@playwright/test';
-import type { ClientReport } from '@sentry/core';
 import { sentryTest } from '../../../utils/fixtures';
-import {
-  envelopeRequestParser,
-  hidePage,
-  shouldSkipTracingTest,
-  testingCdnBundle,
-  waitForClientReportRequest,
-} from '../../../utils/helpers';
+import { shouldSkipTracingTest, testingCdnBundle } from '../../../utils/helpers';
+import { getSpanOp, waitForStreamedSpan } from '../../../utils/spanUtils';
 
 sentryTest(
-  'records no_parent_span client report for fetch requests without an active span',
+  'sends http.client span for fetch requests without an active span when span streaming is enabled',
   async ({ getLocalTestUrl, page }) => {
     sentryTest.skip(shouldSkipTracingTest() || testingCdnBundle());
 
@@ -24,22 +18,14 @@ sentryTest(
 
     const url = await getLocalTestUrl({ testDir: __dirname });
 
-    const clientReportPromise = waitForClientReportRequest(page, report => {
-      return report.discarded_events.some(e => e.reason === 'no_parent_span');
-    });
+    const spanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'http.client');
 
     await page.goto(url);
 
-    await hidePage(page);
-
-    const clientReport = envelopeRequestParser<ClientReport>(await clientReportPromise);
+    const span = await spanPromise;
 
-    expect(clientReport.discarded_events).toEqual([
-      {
-        category: 'span',
-        quantity: 1,
-        reason: 'no_parent_span',
-      },
-    ]);
+    expect(span.name).toMatch(/^GET /);
+    expect(span.attributes?.['sentry.origin']).toEqual({ type: 'string', value: 'auto.http.browser' });
+    expect(span.attributes?.['sentry.op']).toEqual({ type: 'string', value: 'http.client' });
   },
 );

dev-packages/node-integration-tests/suites/tracing/no-parent-span-client-report-streamed/test.ts

@@ -1,24 +1,24 @@
 import { afterAll, describe, expect } from 'vitest';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../utils/runner';
 
-describe('no_parent_span client report (streaming)', () => {
+describe('no_parent_span with streaming enabled', () => {
   afterAll(() => {
     cleanupChildProcesses();
   });
 
   createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument.mjs', (createRunner, test) => {
-    test('records no_parent_span outcome for http.client span without a local parent', async () => {
+    test('sends http.client span without a local parent when span streaming is enabled', async () => {
       const runner = createRunner()
-        .unignore('client_report')
         .expect({
-          client_report: report => {
-            expect(report.discarded_events).toEqual([
-              {
-                category: 'span',
-                quantity: 1,
-                reason: 'no_parent_span',
-              },
-            ]);
+          span: span => {
+            const httpClientSpan = span.items.find(item =>
+              item.attributes?.['sentry.op']
+                ? item.attributes['sentry.op'].type === 'string' && item.attributes['sentry.op'].value === 'http.client'
+                : false,
+            );
+
+            expect(httpClientSpan).toBeDefined();
+            expect(httpClientSpan?.name).toMatch(/^GET /);
           },
         })
         .start();

packages/opentelemetry/test/sampler.test.ts

@@ -348,5 +348,23 @@ describe('SentrySampler', () => {
       expect(spyOnDroppedEvent).toHaveBeenCalledTimes(1);
       expect(spyOnDroppedEvent).toHaveBeenCalledWith('sample_rate', 'span');
     });
+
+    it('always emits streamed http.client spans without a local parent', () => {
+      const client = new TestClient(getDefaultTestClientOptions({ tracesSampleRate: 1, traceLifecycle: 'stream' }));
+      const spyOnDroppedEvent = vi.spyOn(client, 'recordDroppedEvent');
+      const sampler = new SentrySampler(client);
+
+      const ctx = context.active();
+      const traceId = generateTraceId();
+      const spanName = 'GET http://example.com/api';
+      const spanKind = SpanKind.CLIENT;
+      const spanAttributes = {
+        [ATTR_HTTP_REQUEST_METHOD]: 'GET',
+      };
+
+      const actual = sampler.shouldSample(ctx, traceId, spanName, spanKind, spanAttributes, undefined);
+      expect(actual.decision).toBe(SamplingDecision.RECORD_AND_SAMPLED);
+      expect(spyOnDroppedEvent).not.toHaveBeenCalled();
+    });
   });
 });