put util functions in utils

Author: s1gr1d

packages/browser/src/profiling/integration.ts

@@ -3,7 +3,7 @@ import { debug, defineIntegration, getActiveSpan, getRootSpan, hasSpansEnabled }
 import type { BrowserOptions } from '../client';
 import { DEBUG_BUILD } from '../debug-build';
 import { WINDOW } from '../helpers';
-import { BrowserTraceLifecycleProfiler } from './session/traceLifecycleProfiler';
+import { BrowserTraceLifecycleProfiler } from './lifecycleMode/traceLifecycleProfiler';
 import { startProfileForSpan } from './startProfileForSpan';
 import type { ProfiledEvent } from './utils';
 import {

packages/browser/src/profiling/session/traceLifecycleProfiler.ts renamed to packages/browser/src/profiling/lifecycleMode/traceLifecycleProfiler.ts

@@ -11,7 +11,7 @@ import {
 } from '@sentry/core';
 import { DEBUG_BUILD } from '../../debug-build';
 import type { JSSelfProfiler } from '../jsSelfProfiling';
-import { applyDebugMetadata as applyDebugImages, startJSSelfProfile } from '../utils';
+import { createProfileChunkPayload, startJSSelfProfile } from '../utils';
 
 const CHUNK_INTERVAL_MS = 60_000;
 
@@ -222,8 +222,9 @@ export class BrowserTraceLifecycleProfiler {
 
     try {
       const profile = await profiler.stop();
-      const continuous = this._toContinuousProfile(profile);
-      const chunk: ProfileChunk = this._makeProfileChunk(continuous);
+
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      const chunk = createProfileChunkPayload(profile, this._client!, this._profilerId);
 
       this._sendProfileChunk(chunk);
       DEBUG_BUILD && debug.log('[Profiling] Collected browser profile chunk.');
@@ -257,88 +258,4 @@ export class BrowserTraceLifecycleProfiler {
       DEBUG_BUILD && debug.error('Error while sending profile chunk envelope:', reason);
     });
   }
-
-  /**
-   * Convert from JSSelfProfile format to ContinuousThreadCpuProfile format.
-   */
-  private _toContinuousProfile(input: {
-    frames: { name: string; resourceId?: number; line?: number; column?: number }[];
-    stacks: { frameId: number; parentId?: number }[];
-    samples: { timestamp: number; stackId?: number }[];
-    resources: string[];
-  }): ContinuousThreadCpuProfile {
-    const frames: ContinuousThreadCpuProfile['frames'] = [];
-    for (let i = 0; i < input.frames.length; i++) {
-      const f = input.frames[i];
-      if (!f) {
-        continue;
-      }
-      frames[i] = {
-        function: f.name,
-        abs_path: typeof f.resourceId === 'number' ? input.resources[f.resourceId] : undefined,
-        lineno: f.line,
-        colno: f.column,
-      };
-    }
-
-    const stacks: ContinuousThreadCpuProfile['stacks'] = [];
-    for (let i = 0; i < input.stacks.length; i++) {
-      const s = input.stacks[i];
-      if (!s) {
-        continue;
-      }
-      const list: number[] = [];
-      let cur: { frameId: number; parentId?: number } | undefined = s;
-      while (cur) {
-        list.push(cur.frameId);
-        cur = cur.parentId === undefined ? undefined : input.stacks[cur.parentId];
-      }
-      stacks[i] = list;
-    }
-
-    const samples: ContinuousThreadCpuProfile['samples'] = [];
-    for (let i = 0; i < input.samples.length; i++) {
-      const s = input.samples[i];
-      if (!s) {
-        continue;
-      }
-      samples[i] = {
-        stack_id: s.stackId ?? 0,
-        thread_id: '0',
-        timestamp: performance.timeOrigin + s.timestamp,
-      };
-    }
-
-    return {
-      frames,
-      stacks,
-      samples,
-      thread_metadata: { '0': { name: 'main' } },
-    };
-  }
-
-  /**
-   * Create a profile chunk envelope item from a ContinuousThreadCpuProfile.
-   */
-  private _makeProfileChunk(profile: ContinuousThreadCpuProfile): ProfileChunk {
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const client = this._client!;
-    const options = client.getOptions();
-    const sdk = client.getSdkMetadata?.()?.sdk;
-
-    return {
-      chunk_id: uuid4(),
-      client_sdk: {
-        name: sdk?.name ?? 'sentry.javascript.browser',
-        version: sdk?.version ?? '0.0.0',
-      },
-      profiler_id: this._profilerId || uuid4(),
-      platform: 'javascript',
-      version: '2',
-      release: options.release ?? '',
-      environment: options.environment ?? 'production',
-      debug_meta: { images: applyDebugImages([]) },
-      profile,
-    };
-  }
 }

packages/browser/src/profiling/utils.ts

@@ -1,5 +1,16 @@
 /* eslint-disable max-lines */
-import type { DebugImage, Envelope, Event, EventEnvelope, Profile, Span, ThreadCpuProfile } from '@sentry/core';
+import type {
+  Client,
+  ContinuousThreadCpuProfile,
+  DebugImage,
+  Envelope,
+  Event,
+  EventEnvelope,
+  Profile,
+  ProfileChunk,
+  Span,
+  ThreadCpuProfile,
+} from '@sentry/core';
 import {
   browserPerformanceTimeOrigin,
   debug,
@@ -196,6 +207,109 @@ export function createProfilePayload(
   return profile;
 }
 
+/**
+ * Create a profile chunk envelope item
+ */
+export function createProfileChunkPayload(
+  jsSelfProfile: JSSelfProfile,
+  client: Client,
+  profilerId?: string,
+): ProfileChunk {
+  if (jsSelfProfile === undefined || jsSelfProfile === null) {
+    throw new TypeError(
+      `Cannot construct profiling event envelope without a valid profile. Got ${jsSelfProfile} instead.`,
+    );
+  }
+
+  const continuousProfile = convertToContinuousProfile(jsSelfProfile);
+
+  const options = client.getOptions();
+  const sdk = client.getSdkMetadata?.()?.sdk;
+
+  return {
+    chunk_id: uuid4(),
+    client_sdk: {
+      name: sdk?.name ?? 'sentry.javascript.browser',
+      version: sdk?.version ?? '0.0.0',
+    },
+    profiler_id: profilerId || uuid4(),
+    platform: 'javascript',
+    version: '2',
+    release: options.release ?? '',
+    environment: options.environment ?? 'production',
+    debug_meta: { images: applyDebugMetadata([]) },
+    profile: continuousProfile,
+  };
+}
+
+/**
+ * Convert from JSSelfProfile format to ContinuousThreadCpuProfile format.
+ */
+function convertToContinuousProfile(input: {
+  frames: { name: string; resourceId?: number; line?: number; column?: number }[];
+  stacks: { frameId: number; parentId?: number }[];
+  samples: { timestamp: number; stackId?: number }[];
+  resources: string[];
+}): ContinuousThreadCpuProfile {
+  // Frames map 1:1 by index; fill only when present to avoid sparse writes
+  const frames: ContinuousThreadCpuProfile['frames'] = [];
+  for (let i = 0; i < input.frames.length; i++) {
+    const frame = input.frames[i];
+    if (!frame) {
+      continue;
+    }
+    frames[i] = {
+      function: frame.name,
+      abs_path: typeof frame.resourceId === 'number' ? input.resources[frame.resourceId] : undefined,
+      lineno: frame.line,
+      colno: frame.column,
+    };
+  }
+
+  // Build stacks by following parent links, top->down order (root last)
+  const stacks: ContinuousThreadCpuProfile['stacks'] = [];
+  for (let i = 0; i < input.stacks.length; i++) {
+    const stackHead = input.stacks[i];
+    if (!stackHead) {
+      continue;
+    }
+    const list: number[] = [];
+    let current: { frameId: number; parentId?: number } | undefined = stackHead;
+    while (current) {
+      list.push(current.frameId);
+      current = current.parentId === undefined ? undefined : input.stacks[current.parentId];
+    }
+    stacks[i] = list;
+  }
+
+  // Align timestamps to SDK time origin to match span/event timelines
+  const perfOrigin = browserPerformanceTimeOrigin();
+  const origin = typeof performance.timeOrigin === 'number' ? performance.timeOrigin : perfOrigin || 0;
+  const adjustForOriginChange = origin - (perfOrigin || origin);
+
+  const samples: ContinuousThreadCpuProfile['samples'] = [];
+  for (let i = 0; i < input.samples.length; i++) {
+    const sample = input.samples[i];
+    if (!sample) {
+      continue;
+    }
+    // Convert ms to seconds epoch-based timestamp
+    const timestampSeconds = (origin + (sample.timestamp - adjustForOriginChange)) / 1000;
+    samples[i] = {
+      stack_id: sample.stackId ?? 0,
+      thread_id: THREAD_ID_STRING,
+      timestamp: timestampSeconds,
+    };
+  }
+
+  return {
+    frames,
+    stacks,
+    samples,
+    thread_metadata: { [THREAD_ID_STRING]: { name: THREAD_NAME } },
+  };
+}
+
 /**
  *
  */