fix(v10/browser): Skip profiling for unsampled active root spans (#25502)

Backport of: #25498

## Differences to the original PR

- `packages/browser/test/profiling/integration.test.ts`: the two new
tests use v10's existing `import * as Sentry from '@sentry/browser'`
style (`Sentry.init`, `Sentry.addIntegration`, etc.) instead of named
imports from `../../src/index`. That import block conflicted because
v10's test file still uses the namespace import.
- Same file: the unsampled-pageload test uses `Sentry.spanToJSON`
instead of `spanToStaticSpanJSON`, because `spanToStaticSpanJSON`
doesn't exist on v10.

Co-authored-by: sentry-junior[bot] <264270552+sentry-junior[bot]@users.noreply.github.com>

Author: sentry-junior[bot]

packages/browser/src/profiling/UIProfiler.ts

@@ -135,7 +135,8 @@ export class UIProfiler implements ContinuousProfiler<Client> {
 
   /** Handle an already-active root span at integration setup time (used only in trace mode). */
   public notifyRootSpanActive(rootSpan: Span): void {
-    if (this._lifecycleMode !== 'trace' || !this._sessionSampled) {
+    // Only count sampled root spans, same as the `spanStart` listener
+    if (this._lifecycleMode !== 'trace' || !this._sessionSampled || !rootSpan.isRecording()) {
       return;
     }
 

packages/browser/test/profiling/integration.test.ts

@@ -68,6 +68,114 @@ describe('BrowserProfilingIntegration', () => {
     expect(profile.profile.frames[0]).toMatchObject({ function: 'pageload_fn', lineno: 1, colno: 1 });
   });
 
+  it('does not profile an already active pageload span that is not sampled in trace lifecycle mode', async () => {
+    const mockProfiler = vi.fn().mockImplementation(function () {
+      return {
+        stop: vi.fn().mockResolvedValue({
+          frames: [{ name: 'pageload_fn', line: 1, column: 1 }],
+          stacks: [{ frameId: 0 }],
+          samples: [
+            { stackId: 0, timestamp: 0 },
+            { stackId: 0, timestamp: 100 },
+          ],
+          resources: [],
+        }),
+        addEventListener: vi.fn(),
+      };
+    });
+
+    // @ts-expect-error this is a mock constructor
+    window.Profiler = mockProfiler;
+
+    const send = vi.fn().mockResolvedValue(undefined);
+    const client = Sentry.init({
+      tracesSampleRate: 0,
+      traceLifecycle: 'static',
+      profileSessionSampleRate: 1,
+      profileLifecycle: 'trace',
+      dsn: 'https://examplePublicKey@o0.ingest.sentry.io/0',
+      transport: () => ({
+        flush: vi.fn().mockResolvedValue(true),
+        send,
+      }),
+      integrations: [Sentry.browserTracingIntegration(), Sentry.browserProfilingIntegration()],
+    });
+
+    const pageloadSpan = Sentry.getActiveSpan();
+    expect(pageloadSpan).toBeDefined();
+    expect(Sentry.spanToJSON(pageloadSpan!).op).toBe('pageload');
+    expect(pageloadSpan!.isRecording()).toBe(false);
+
+    // The integration re-checks the active root span in a timeout after setup.
+    await new Promise(resolve => setTimeout(resolve, 0));
+
+    pageloadSpan?.end();
+    await Promise.resolve();
+    await client?.flush(1000);
+
+    expect(mockProfiler).not.toHaveBeenCalled();
+    const profileChunkEnvelope = send.mock.calls.find(call => call[0][1][0][0].type === 'profile_chunk');
+    expect(profileChunkEnvelope).toBeUndefined();
+  });
+
+  it('profiles a sampled root span that is already active when the integration is added', async () => {
+    const stopProfile = vi.fn().mockResolvedValue({
+      frames: [{ name: 'pageload_fn', line: 1, column: 1 }],
+      stacks: [{ frameId: 0 }],
+      samples: [
+        { stackId: 0, timestamp: 0 },
+        { stackId: 0, timestamp: 100 },
+      ],
+      resources: [],
+    });
+
+    const mockProfiler = vi.fn().mockImplementation(function () {
+      return {
+        stop: stopProfile,
+        addEventListener: vi.fn(),
+      };
+    });
+
+    // @ts-expect-error this is a mock constructor
+    window.Profiler = mockProfiler;
+
+    const send = vi.fn().mockResolvedValue(undefined);
+    const client = Sentry.init({
+      tracesSampleRate: 1,
+      traceLifecycle: 'static',
+      profileSessionSampleRate: 1,
+      profileLifecycle: 'trace',
+      dsn: 'https://examplePublicKey@o0.ingest.sentry.io/0',
+      transport: () => ({
+        flush: vi.fn().mockResolvedValue(true),
+        send,
+      }),
+      integrations: [Sentry.browserTracingIntegration()],
+    });
+
+    const pageloadSpan = Sentry.getActiveSpan();
+    expect(pageloadSpan!.isRecording()).toBe(true);
+
+    // The pageload span started before the profiler listens to `spanStart`,
+    // so only the integration setup can start the profiler for it.
+    Sentry.addIntegration(Sentry.browserProfilingIntegration());
+    const profilerCallsAfterSetup = mockProfiler.mock.calls.length;
+
+    // The re-check in a timeout notifies the same root span again, which must not start another profiler.
+    await new Promise(resolve => setTimeout(resolve, 0));
+    const profilerCallsAfterRecheck = mockProfiler.mock.calls.length;
+
+    pageloadSpan?.end();
+    await Promise.resolve();
+    await client?.flush(1000);
+
+    expect(profilerCallsAfterSetup).toBe(1);
+    expect(profilerCallsAfterRecheck).toBe(1);
+    expect(stopProfile).toHaveBeenCalledTimes(1);
+    const profileChunkEnvelope = send.mock.calls.find(call => call[0][1][0][0].type === 'profile_chunk');
+    expect(profileChunkEnvelope).toBeDefined();
+  });
+
   it("warns when profileLifecycle is 'trace' but tracing is disabled", async () => {
     const warnSpy = vi.spyOn(debug, 'warn').mockImplementation(() => {});