fix(core): Fix withStreamedSpan typing error and export from SDKs

Author: Lms24

dev-packages/browser-integration-tests/suites/public-api/beforeSendSpan-streamed/init.js

@@ -0,0 +1,28 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  integrations: [Sentry.browserTracingIntegration(), Sentry.spanStreamingIntegration()],
+  tracesSampleRate: 1,
+  beforeSendSpan: Sentry.withStreamedSpan(span => {
+    if (span.attributes['sentry.op'] === 'pageload') {
+      span.name = 'customPageloadSpanName';
+      span.links = [
+        {
+          context: {
+            traceId: '123',
+            spanId: '456',
+          },
+          attributes: {
+            'sentry.link.type': 'custom_link',
+          },
+        },
+      ];
+      span.attributes['sentry.custom_attribute'] = 'customAttributeValue';
+      span.status = 'something'
+    }
+    return span;
+  }),
+});

dev-packages/browser-integration-tests/suites/public-api/beforeSendSpan-streamed/test.ts

@@ -0,0 +1,35 @@
+import { expect } from '@playwright/test';
+import { sentryTest } from '../../../utils/fixtures';
+import { shouldSkipTracingTest, testingCdnBundle } from '../../../utils/helpers';
+import { getSpanOp, waitForStreamedSpan } from '../../../utils/spanUtils';
+
+sentryTest('beforeSendSpan applies changes to streamed span', async ({ getLocalTestUrl, page }) => {
+  sentryTest.skip(shouldSkipTracingTest() || testingCdnBundle());
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
+
+  await page.goto(url);
+
+  const pageloadSpan = await pageloadSpanPromise;
+
+  expect(pageloadSpan.name).toBe('customPageloadSpanName');
+  expect(pageloadSpan.links).toEqual([
+    {
+      context: {
+        traceId: '123',
+        spanId: '456',
+      },
+      attributes: {
+        'sentry.link.type': { type: 'string', value: 'custom_link' },
+      },
+    },
+  ]);
+  expect(pageloadSpan.attributes?.['sentry.custom_attribute']).toEqual({
+    type: 'string',
+    value: 'customAttributeValue',
+  });
+  // we allow overriding any kinds of fields on the span, so we have to expect invalid values
+  expect(pageloadSpan.status).toBe('something');
+});

dev-packages/node-core-integration-tests/suites/public-api/beforeSendSpan-streamed/scenario.ts

@@ -0,0 +1,43 @@
+import * as Sentry from '@sentry/node-core';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+import { setupOtel } from '../../../utils/setupOtel';
+
+const client = Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  tracesSampleRate: 1.0,
+  traceLifecycle: 'stream',
+  transport: loggingTransport,
+  release: '1.0.0',
+  beforeSendSpan: Sentry.withStreamedSpan(span => {
+    if (span.name === 'test-child-span') {
+      span.name = 'customChildSpanName';
+      if (!span.attributes) {
+        span.attributes = {};
+      }
+      span.attributes['sentry.custom_attribute'] = 'customAttributeValue';
+      // oxlint-disable-next-line typescript/ban-ts-comment
+      // @ts-expect-error - technically this is something we have to expect, despite types saying it's invalid
+      span.status = 'something';
+      span.links = [
+        {
+          trace_id: '123',
+          span_id: '456',
+          attributes: {
+            'sentry.link.type': 'custom_link',
+          },
+        },
+      ];
+    }
+    return span;
+  }),
+});
+
+setupOtel(client);
+
+Sentry.startSpan({ name: 'test-span', op: 'test' }, () => {
+  Sentry.startSpan({ name: 'test-child-span', op: 'test-child' }, () => {
+    // noop
+  });
+});
+
+void Sentry.flush();

dev-packages/node-core-integration-tests/suites/public-api/beforeSendSpan-streamed/test.ts

@@ -0,0 +1,32 @@
+import { expect, test } from 'vitest';
+import { createRunner } from '../../../utils/runner';
+
+test('beforeSendSpan applies changes to streamed span', async () => {
+  await createRunner(__dirname, 'scenario.ts')
+    .expect({
+      span: container => {
+        const spans = container.items;
+        expect(spans.length).toBe(2);
+
+        const customChildSpan = spans.find(s => s.name === 'customChildSpanName');
+
+        expect(customChildSpan).toBeDefined();
+        expect(customChildSpan!.attributes?.['sentry.custom_attribute']).toEqual({
+          type: 'string',
+          value: 'customAttributeValue',
+        });
+        expect(customChildSpan!.status).toBe('something');
+        expect(customChildSpan!.links).toEqual([
+          {
+            trace_id: '123',
+            span_id: '456',
+            attributes: {
+              'sentry.link.type': { type: 'string', value: 'custom_link' },
+            },
+          },
+        ]);
+      },
+    })
+    .start()
+    .completed();
+});

packages/angular/src/sdk.ts

@@ -82,3 +82,11 @@ function checkAndSetAngularVersion(): void {
     setContext('angular', { version: angularVersion });
   }
 }
+
+init({
+  dsn: '__DSN__',
+  traceLifecycle: 'stream',
+  beforeSendSpan: span => {
+    return span;
+  },
+});

packages/astro/src/index.server.ts

@@ -174,6 +174,7 @@ export {
   unleashIntegration,
   growthbookIntegration,
   spanStreamingIntegration,
+  withStreamedSpan,
   metrics,
 } from '@sentry/node';
 

packages/astro/src/index.types.ts

@@ -21,6 +21,7 @@ export declare function init(options: Options | clientSdk.BrowserOptions | NodeO
 export declare const linkedErrorsIntegration: typeof clientSdk.linkedErrorsIntegration;
 export declare const contextLinesIntegration: typeof clientSdk.contextLinesIntegration;
 export declare const spanStreamingIntegration: typeof clientSdk.spanStreamingIntegration;
+export declare const withStreamedSpan: typeof clientSdk.withStreamedSpan;
 
 export declare const getDefaultIntegrations: (options: Options) => Integration[];
 export declare const defaultStackParser: StackParser;

packages/aws-serverless/src/index.ts

@@ -161,6 +161,7 @@ export {
   growthbookIntegration,
   metrics,
   spanStreamingIntegration,
+  withStreamedSpan,
 } from '@sentry/node';
 
 export {

packages/browser/src/exports.ts

@@ -70,6 +70,7 @@ export {
   spanToTraceHeader,
   spanToBaggageHeader,
   updateSpanName,
+  withStreamedSpan,
   metrics,
 } from '@sentry/core';
 

packages/browser/src/integrations/spanstreaming.ts

@@ -19,7 +19,7 @@ export const spanStreamingIntegration = defineIntegration(() => {
       // This avoids the classic double-opt-in problem we'd otherwise have in the browser SDK.
       const clientOptions = client.getOptions();
       if (!clientOptions.traceLifecycle) {
-        DEBUG_BUILD && debug.warn('[SpanStreaming] set `traceLifecycle` to "stream"');
+        DEBUG_BUILD && debug.log('[SpanStreaming] set `traceLifecycle` to "stream"');
         clientOptions.traceLifecycle = 'stream';
       }
     },