test(ember): Restore the assertions dropped in the streaming conversion

The conversion weakened every child span check: status, span_id, trace_id,
both timestamps and the exact attribute set were gone, and parent_span_id had
become a filter rather than an assertion. Two of the segment spans also lost
`url.path` and `url.full`.

`expectChildSpan` puts all of them back on all 8 child spans. Exact attribute
matching needs the SDK's own attributes stripped first, since every streamed
span carries the segment, sdk, replay and user-agent ones.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: Lms24

dev-packages/e2e-tests/test-applications/ember-classic/tests/performance.test.ts

@@ -5,6 +5,55 @@ import { collectStreamedSpansUntilSegment, getSpanOp, waitForStreamedSpan } from
 // This app runs on the default `traceLifecycle: 'stream'`, so it emits spans, not transactions.
 // `ember-embroider` and `ember-vite` cover the same routes on the static lifecycle.
 
+// The SDK stamps these onto every streamed span, whatever produced it. Stripping them lets the
+// instrumentation's own attributes be asserted exactly, the way the static suites assert `span.data`.
+const SDK_ATTRIBUTES = [
+  'sentry.trace_lifecycle',
+  'sentry.segment.name',
+  'sentry.segment.id',
+  'sentry.sdk.name',
+  'sentry.sdk.version',
+  'sentry.sdk.integrations',
+  'sentry.environment',
+  'sentry.release',
+  'sentry.sample_rate',
+  'user.id',
+  'user.email',
+  'user.ip_address',
+  'user.username',
+  // `httpContextIntegration` sets this on every span; replay is enabled in this app, so it tags
+  // every span too.
+  'user_agent.original',
+  'sentry.replay_id',
+  'sentry._internal.replay_is_buffering',
+];
+
+function instrumentationAttributes(span: SerializedStreamedSpan): Record<string, unknown> {
+  return Object.fromEntries(
+    Object.entries(span.attributes)
+      .filter(([key]) => !SDK_ATTRIBUTES.includes(key))
+      .map(([key, attribute]) => [key, attribute.value]),
+  );
+}
+
+function expectChildSpan(
+  span: SerializedStreamedSpan | undefined,
+  segmentSpan: SerializedStreamedSpan,
+  expected: { name: string; attributes: Record<string, unknown> },
+): void {
+  expect(span).toMatchObject({
+    name: expected.name,
+    is_segment: false,
+    status: 'ok',
+    parent_span_id: segmentSpan.span_id,
+    span_id: expect.stringMatching(/^[a-f0-9]{16}$/),
+    trace_id: segmentSpan.trace_id,
+    start_timestamp: expect.any(Number),
+    end_timestamp: expect.any(Number),
+  });
+  expect(instrumentationAttributes(span!)).toEqual(expected.attributes);
+}
+
 test('sends a pageload span with a parameterized URL', async ({ page }) => {
   const pageloadSpanPromise = waitForStreamedSpan(
     'ember-classic',
@@ -87,6 +136,8 @@ test('sends a navigation span even if the pageload span is still active', async
       'sentry.origin': { type: 'string', value: 'auto.pageload.ember' },
       'sentry.segment.name.source': { type: 'string', value: 'route' },
       'url.template': { type: 'string', value: '/' },
+      'url.path': { type: 'string', value: '/' },
+      'url.full': { type: 'string', value: expect.stringMatching(/^https?:\/\/localhost:\d+\/$/) },
     },
   });
 
@@ -98,6 +149,8 @@ test('sends a navigation span even if the pageload span is still active', async
       'sentry.origin': { type: 'string', value: 'auto.navigation.ember' },
       'sentry.segment.name.source': { type: 'string', value: 'route' },
       'url.template': { type: 'string', value: '/tracing' },
+      'url.path': { type: 'string', value: '/tracing' },
+      'url.full': { type: 'string', value: expect.stringMatching(/^https?:\/\/localhost:\d+\/tracing$/) },
     },
   });
 });
@@ -115,9 +168,15 @@ test('captures correct spans for navigation', async ({ page }) => {
   await page.getByText('Measure Things!').click();
   const spans = await spansPromise;
 
-  const navigationSpan = spans.find(span => span.is_segment);
+  const navigationSpan = spans.find(span => span.is_segment)!;
+
+  expect(navigationSpan.trace_id).toEqual(expect.stringMatching(/^[a-f0-9]{32}$/));
+  expect(navigationSpan.span_id).toEqual(expect.stringMatching(/^[a-f0-9]{16}$/));
+
   expect(navigationSpan).toMatchObject({
     name: 'route:slow-loading-route.index',
+    is_segment: true,
+    status: 'ok',
     attributes: {
       'sentry.op': { type: 'string', value: 'navigation' },
       'sentry.origin': { type: 'string', value: 'auto.navigation.ember' },
@@ -132,7 +191,7 @@ test('captures correct spans for navigation', async ({ page }) => {
     spans.filter(
       span =>
         !span.is_segment &&
-        span.parent_span_id === navigationSpan?.span_id &&
+        span.parent_span_id === navigationSpan.span_id &&
         getSpanOp(span) === op &&
         (functionName === undefined || span.attributes['code.function.name']?.value === functionName),
     );
@@ -141,9 +200,7 @@ test('captures correct spans for navigation', async ({ page }) => {
   const beforeModelSpans = childrenOf('function', 'beforeModel');
   const modelSpans = childrenOf('function', 'model');
   const afterModelSpans = childrenOf('function', 'afterModel');
-  const runloopRenderSpans = childrenOf('ui.task').filter(
-    span => span.attributes['ember.runloop.queue']?.value === 'render',
-  );
+  const renderSpans = childrenOf('ui.task').filter(span => span.attributes['ember.runloop.queue']?.value === 'render');
 
   expect(transitionSpans).toHaveLength(1);
 
@@ -153,15 +210,15 @@ test('captures correct spans for navigation', async ({ page }) => {
   expect(afterModelSpans).toHaveLength(2);
 
   // There may be many render spans...
-  expect(runloopRenderSpans.length).toBeGreaterThan(1);
+  expect(renderSpans.length).toBeGreaterThan(1);
 
   // Ember has no route template for the transition itself, so a streamed router span takes the
   // static fallback rather than the `route:a -> route:b` pair it uses on the static lifecycle.
-  expect(transitionSpans[0]).toMatchObject({
+  expectChildSpan(transitionSpans[0], navigationSpan, {
     name: 'Router',
     attributes: {
-      'sentry.op': { type: 'string', value: 'router' },
-      'sentry.origin': { type: 'string', value: 'auto.ui.ember' },
+      'sentry.op': 'router',
+      'sentry.origin': 'auto.ui.ember',
     },
   });
 
@@ -172,25 +229,33 @@ test('captures correct spans for navigation', async ({ page }) => {
     ['model', modelSpans],
     ['afterModel', afterModelSpans],
   ] as const) {
-    expect(hookSpans.map(span => span.name)).toEqual([hookName, hookName]);
-    expect(hookSpans).toMatchObject(
-      ['slow-loading-route', 'slow-loading-route.index'].map(fullRouteName => ({
-        attributes: {
-          'code.function.name': { type: 'string', value: hookName },
-          'sentry.description': { type: 'string', value: fullRouteName },
-          'sentry.op': { type: 'string', value: 'function' },
-          'sentry.origin': { type: 'string', value: 'auto.ui.ember' },
-        },
-      })),
-    );
+    expectChildSpan(hookSpans[0], navigationSpan, {
+      name: hookName,
+      attributes: {
+        'code.function.name': hookName,
+        'sentry.description': 'slow-loading-route',
+        'sentry.op': 'function',
+        'sentry.origin': 'auto.ui.ember',
+      },
+    });
+
+    expectChildSpan(hookSpans[1], navigationSpan, {
+      name: hookName,
+      attributes: {
+        'code.function.name': hookName,
+        'sentry.description': 'slow-loading-route.index',
+        'sentry.op': 'function',
+        'sentry.origin': 'auto.ui.ember',
+      },
+    });
   }
 
-  expect(runloopRenderSpans[0]).toMatchObject({
+  expectChildSpan(renderSpans[0], navigationSpan, {
     name: 'runloop',
     attributes: {
-      'ember.runloop.queue': { type: 'string', value: 'render' },
-      'sentry.op': { type: 'string', value: 'ui.task' },
-      'sentry.origin': { type: 'string', value: 'auto.ui.ember' },
+      'ember.runloop.queue': 'render',
+      'sentry.op': 'ui.task',
+      'sentry.origin': 'auto.ui.ember',
     },
   });
 });
@@ -202,6 +267,7 @@ test('captures a `ui.resolve` span alongside the `ui.render` span for a componen
 
   const spans = await spansPromise;
 
+  const pageloadSpan = spans.find(span => span.is_segment)!;
   const resolveSpans = spans.filter(span => getSpanOp(span) === 'ui.resolve');
   const renderSpans = spans.filter(span => getSpanOp(span) === 'ui.render');
 
@@ -211,9 +277,22 @@ test('captures a `ui.resolve` span alongside the `ui.render` span for a componen
   // Resolving a component definition and rendering it are separate steps, so they must not share
   // an op even though they carry the same component name.
   const resolveSpan = resolveSpans[0]!;
-  expect(resolveSpan.attributes).toMatchObject({
-    'sentry.op': { type: 'string', value: 'ui.resolve' },
-    'sentry.origin': { type: 'string', value: 'auto.ui.ember' },
-    'ui.component_name': { type: 'string', value: resolveSpan.name },
+  expectChildSpan(resolveSpan, pageloadSpan, {
+    name: resolveSpan.name,
+    attributes: {
+      'sentry.op': 'ui.resolve',
+      'sentry.origin': 'auto.ui.ember',
+      'ui.component_name': resolveSpan.name,
+    },
+  });
+
+  const renderSpan = renderSpans[0]!;
+  expectChildSpan(renderSpan, pageloadSpan, {
+    name: renderSpan.name,
+    attributes: {
+      'sentry.op': 'ui.render',
+      'sentry.origin': 'auto.ui.ember',
+      'ui.component_name': renderSpan.name,
+    },
   });
 });