ref(core): Export performanceTimeToSeconds with the _INTERNAL_ prefix

It is only meant for other Sentry packages, not for users.

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

Author: Lms24

packages/browser-utils/src/performance/entries.ts

@@ -4,7 +4,7 @@ import {
   BROWSER_NAVIGATION_TIMING_SPAN_NAMES,
   getActiveSpan,
   parseUrl,
-  performanceTimeToSeconds,
+  _INTERNAL_performanceTimeToSeconds,
   RESOURCE_SPAN_NAME_FALLBACK,
   setMeasurement,
   spanToJSON,
@@ -108,7 +108,7 @@ export function startTrackingLongTasks(): void {
     const { attributes: parentAttributes, start_timestamp: parentStartTimestamp } = spanToJSON(parent);
 
     for (const entry of entries) {
-      const startTime = performanceTimeToSeconds(entry.startTime);
+      const startTime = _INTERNAL_performanceTimeToSeconds(entry.startTime);
       if (!startTime) {
         continue;
       }
@@ -146,7 +146,7 @@ export function startTrackingLongAnimationFrames(): void {
       return;
     }
     for (const entry of list.getEntries() as PerformanceLongAnimationFrameTiming[]) {
-      const startTime = performanceTimeToSeconds(entry.startTime);
+      const startTime = _INTERNAL_performanceTimeToSeconds(entry.startTime);
       if (!startTime || !entry.scripts[0]) {
         continue;
       }
@@ -223,7 +223,7 @@ export function addPerformanceEntries(span: Span, options: AddPerformanceEntries
   const { attributes, start_timestamp: transactionStartTime } = spanToJSON(span);
 
   performanceEntries.slice(_performanceCursor).forEach(entry => {
-    const startTimestamp = performanceTimeToSeconds(entry.startTime);
+    const startTimestamp = _INTERNAL_performanceTimeToSeconds(entry.startTime);
     if (!startTimestamp) {
       return;
     }
@@ -313,7 +313,7 @@ export function _addNavigationSpans(
  */
 function _navigationTimeToSeconds(entry: PerformanceNavigationTiming, time: number): number {
   // The cast is safe: `addPerformanceEntries` only adds navigation spans if the time origin is available.
-  return performanceTimeToSeconds(time, entry.startTime) as number;
+  return _INTERNAL_performanceTimeToSeconds(time, entry.startTime) as number;
 }
 
 type StartEventName =

packages/browser-utils/src/performance/interactions.ts

@@ -22,7 +22,7 @@ import {
   getActiveSpan,
   getRootSpan,
   hasSpanStreamingEnabled,
-  performanceTimeToSeconds,
+  _INTERNAL_performanceTimeToSeconds,
   spanToJSON,
   UI_ACTION_CLICK_SPAN_NAME_FALLBACK,
   UI_INTERACTION_CLICK_SPAN_NAME_FALLBACK,
@@ -242,7 +242,7 @@ function trackInteractionsAsSpans(client: Client): void {
     }
     for (const entry of entries) {
       if (entry.name === 'click') {
-        const startTime = performanceTimeToSeconds(entry.startTime);
+        const startTime = _INTERNAL_performanceTimeToSeconds(entry.startTime);
         if (!startTime) {
           continue;
         }

packages/browser-utils/src/performance/resourceTiming.ts

@@ -1,5 +1,5 @@
 import type { SpanAttributes } from '@sentry/core';
-import { performanceTimeToSeconds } from '@sentry/core';
+import { _INTERNAL_performanceTimeToSeconds } from '@sentry/core';
 import { extractNetworkProtocol, msToSec } from './utils';
 
 /**
@@ -22,15 +22,15 @@ export function resourceTimingToSpanAttributes(resourceTiming: PerformanceResour
     timingSpanData['network.protocol.name'] = name;
   }
 
-  if (performanceTimeToSeconds(resourceTiming.startTime) === undefined) {
+  if (_INTERNAL_performanceTimeToSeconds(resourceTiming.startTime) === undefined) {
     return timingSpanData;
   }
 
   // Use the origin from the request start for all timings, so the durations between them stay correct.
   const getAbsoluteTime = (time: number | undefined): number | undefined =>
     // falsy values should be preserved so that we can later on drop undefined values and
     // preserve 0 vals for cross-origin resources without proper `Timing-Allow-Origin` header.
-    time ? performanceTimeToSeconds(time, resourceTiming.startTime) : time;
+    time ? _INTERNAL_performanceTimeToSeconds(time, resourceTiming.startTime) : time;
 
   return dropUndefinedKeysFromObject({
     ...timingSpanData,

packages/browser-utils/src/performance/userTiming.ts

@@ -3,7 +3,7 @@ import type { IntegrationFn, Span, SpanAttributes, SpanAttributeValue } from '@s
 import {
   defineIntegration,
   isPrimitive,
-  performanceTimeToSeconds,
+  _INTERNAL_performanceTimeToSeconds,
   spanToJSON,
   stringMatchesSomePattern,
 } from '@sentry/core';
@@ -47,7 +47,7 @@ const _userTimingIntegration = ((options: UserTimingOptions = {}) => {
             continue;
           }
 
-          const startTimestamp = performanceTimeToSeconds(entry.startTime);
+          const startTimestamp = _INTERNAL_performanceTimeToSeconds(entry.startTime);
           if (!startTimestamp) {
             continue;
           }
@@ -56,14 +56,14 @@ const _userTimingIntegration = ((options: UserTimingOptions = {}) => {
             continue;
           }
 
-          const endTimestamp = performanceTimeToSeconds(
+          const endTimestamp = _INTERNAL_performanceTimeToSeconds(
             entry.startTime + Math.max(0, entry.duration),
             entry.startTime,
           ) as number;
 
           // We convert the request start with the entry's time origin, so that the clamp in `_addUserTimingSpan` compares
           // timestamps on the same timeline, even if the time origin was corrected between the request and the entry.
-          const requestTimestamp = performanceTimeToSeconds(requestStart, entry.startTime) as number;
+          const requestTimestamp = _INTERNAL_performanceTimeToSeconds(requestStart, entry.startTime) as number;
 
           _addUserTimingSpan(idleSpan, entry, startTimestamp, endTimestamp, requestTimestamp, options.ignore ?? []);
         }

packages/browser-utils/src/web-vitals/spans.ts

@@ -7,7 +7,7 @@ import {
   getClient,
   getRootSpan,
   hasSpanStreamingEnabled,
-  performanceTimeToSeconds,
+  _INTERNAL_performanceTimeToSeconds,
   spanToJSON,
   timestampInSeconds,
   UI_INTERACTION_CLICK_SPAN_NAME_FALLBACK,
@@ -196,11 +196,11 @@ export function _sendLcpSpan(
   // keeps its duration equal to the reported value. The span's end uses the same origin, even if
   // the time origin was corrected in between.
   const navigationStart = navigationStartTime || 0;
-  const startTime = performanceTimeToSeconds(navigationStart) ?? msToSec(navigationStart);
+  const startTime = _INTERNAL_performanceTimeToSeconds(navigationStart) ?? msToSec(navigationStart);
   // Without an entry there is no render time to end at, so the span lasts the value it reports,
   // like an entry-less INP does. Ending at the time origin instead would invert the span.
   const endTime = entry
-    ? (performanceTimeToSeconds(entry.startTime, navigationStart) ?? msToSec(entry.startTime))
+    ? (_INTERNAL_performanceTimeToSeconds(entry.startTime, navigationStart) ?? msToSec(entry.startTime))
     : startTime + msToSec(lcpValue);
   const selector = entry ? htmlTreeAsString(entry.element) : undefined;
   const componentName = entry?.element ? getComponentName(entry.element) : null;
@@ -303,7 +303,7 @@ export function _sendClsSpan(
   // land it outside that navigation, on the route that follows it.
   const offset = entry?.startTime ?? navigationStartTime ?? 0;
   // CLS is only reported on pagehide, so we use the time origin from when the layout shift happened.
-  const startTime = performanceTimeToSeconds(offset) ?? timestampInSeconds();
+  const startTime = _INTERNAL_performanceTimeToSeconds(offset) ?? timestampInSeconds();
   const firstSourceNode = entry?.sources[0]?.node;
   const selector = entry ? htmlTreeAsString(firstSourceNode) : undefined;
   const componentName = firstSourceNode ? getComponentName(firstSourceNode) : null;
@@ -412,7 +412,7 @@ export function _sendInpSpan(
   // at the start of the navigation it belongs to rather than at the interaction.
   // INP is reported on pagehide, often long after the interaction, so we use the time origin from when the
   // interaction happened.
-  const startTime = performanceTimeToSeconds(entry?.startTime ?? metric?.navigationStartTime ?? 0);
+  const startTime = _INTERNAL_performanceTimeToSeconds(entry?.startTime ?? metric?.navigationStartTime ?? 0);
   if (!startTime) {
     return;
   }

packages/browser-utils/test/performance/addPerformanceEntries.test.ts

@@ -13,7 +13,7 @@ vi.mock('@sentry/core', async () => {
   return {
     ...actual,
     browserPerformanceTimeOrigin,
-    performanceTimeToSeconds: (time: number, entryStartTime = time) =>
+    _INTERNAL_performanceTimeToSeconds: (time: number, entryStartTime = time) =>
       (browserPerformanceTimeOrigin(entryStartTime) + time) / 1000,
   };
 });

packages/browser-utils/test/performance/resourceTiming.test.ts

@@ -11,7 +11,7 @@ describe('resourceTimingToSpanAttributes', () => {
   beforeEach(() => {
     vi.clearAllMocks();
     browserPerformanceTimeOriginSpy = vi.spyOn(utils, 'browserPerformanceTimeOrigin');
-    vi.spyOn(utils, 'performanceTimeToSeconds').mockImplementation((time, entryStartTime = time) => {
+    vi.spyOn(utils, '_INTERNAL_performanceTimeToSeconds').mockImplementation((time, entryStartTime = time) => {
       const origin = utils.browserPerformanceTimeOrigin(entryStartTime);
       return origin ? (origin + time) / 1000 : undefined;
     });

packages/browser-utils/test/performance/userTiming.test.ts

@@ -1,6 +1,12 @@
 import type * as SentryCore from '@sentry/core';
 import type { Span } from '@sentry/core';
-import { getMainCarrier, performanceTimeToSeconds, SentrySpan, setCurrentClient, spanToJSON } from '@sentry/core';
+import {
+  getMainCarrier,
+  _INTERNAL_performanceTimeToSeconds,
+  SentrySpan,
+  setCurrentClient,
+  spanToJSON,
+} from '@sentry/core';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { _addUserTimingSpan, userTimingIntegration } from '../../src/performance/userTiming';
 import * as utils from '../../src/performance/utils';
@@ -9,7 +15,7 @@ import { getDefaultClientOptions, TestClient } from '../utils/TestClient';
 
 vi.mock('@sentry/core', async importOriginal => {
   const actual = await importOriginal<typeof SentryCore>();
-  return { ...actual, performanceTimeToSeconds: vi.fn(actual.performanceTimeToSeconds) };
+  return { ...actual, _INTERNAL_performanceTimeToSeconds: vi.fn(actual._INTERNAL_performanceTimeToSeconds) };
 });
 
 describe('userTimingIntegration', () => {
@@ -19,7 +25,7 @@ describe('userTimingIntegration', () => {
 
   beforeEach(() => {
     vi.restoreAllMocks();
-    vi.mocked(performanceTimeToSeconds).mockReset();
+    vi.mocked(_INTERNAL_performanceTimeToSeconds).mockReset();
     getMainCarrier().__SENTRY__ = undefined;
 
     client = new TestClient(getDefaultClientOptions({ tracesSampleRate: 1 }));
@@ -147,14 +153,14 @@ describe('userTimingIntegration', () => {
 
       client.emit('beforeIdleSpanEnd', new SentrySpan({ op: 'pageload', name: '/', sampled: true }));
 
-      expect(spanToJSON(spans[i]!).start_timestamp).toBe(performanceTimeToSeconds(requestStart, 0));
+      expect(spanToJSON(spans[i]!).start_timestamp).toBe(_INTERNAL_performanceTimeToSeconds(requestStart, 0));
     }
   });
 
   it('keeps measures recorded after the wall clock was corrected backwards', () => {
     const timeOrigin = performance.timeOrigin;
     // The time origin was corrected 60s backwards at 1000ms, e.g. by NTP.
-    vi.mocked(performanceTimeToSeconds).mockImplementation(
+    vi.mocked(_INTERNAL_performanceTimeToSeconds).mockImplementation(
       (monotonicTimeInMs, entryStartTimeInMs = monotonicTimeInMs) =>
         ((entryStartTimeInMs < 1000 ? timeOrigin : timeOrigin - 60_000) + monotonicTimeInMs) / 1000,
     );

packages/browser-utils/test/web-vitals/spans.test.ts

@@ -22,7 +22,7 @@ vi.mock('@sentry/core', async () => {
   return {
     ...actual,
     browserPerformanceTimeOrigin: vi.fn(),
-    performanceTimeToSeconds: vi.fn(),
+    _INTERNAL_performanceTimeToSeconds: vi.fn(),
     timestampInSeconds: vi.fn(),
     getCurrentScope: vi.fn(),
     getClient: vi.fn(),
@@ -379,7 +379,7 @@ describe('_sendLcpSpan', () => {
   beforeEach(() => {
     vi.mocked(SentryCore.getCurrentScope).mockReturnValue(mockScope as any);
     vi.mocked(SentryCore.browserPerformanceTimeOrigin).mockReturnValue(1000);
-    vi.mocked(SentryCore.performanceTimeToSeconds).mockImplementation(
+    vi.mocked(SentryCore._INTERNAL_performanceTimeToSeconds).mockImplementation(
       (time, entryStartTime = time) => (SentryCore.browserPerformanceTimeOrigin(entryStartTime)! + time) / 1000,
     );
     vi.mocked(htmlTreeAsString).mockImplementation((node: any) => `<${node?.tagName || 'div'}>`);
@@ -517,7 +517,7 @@ describe('_sendClsSpan', () => {
   beforeEach(() => {
     vi.mocked(SentryCore.getCurrentScope).mockReturnValue(mockScope as any);
     vi.mocked(SentryCore.browserPerformanceTimeOrigin).mockReturnValue(1000);
-    vi.mocked(SentryCore.performanceTimeToSeconds).mockImplementation(time => (1000 + time) / 1000);
+    vi.mocked(SentryCore._INTERNAL_performanceTimeToSeconds).mockImplementation(time => (1000 + time) / 1000);
     vi.mocked(SentryCore.timestampInSeconds).mockReturnValue(1.5);
     vi.mocked(htmlTreeAsString).mockImplementation((node: any) => `<${node?.tagName || 'div'}>`);
     vi.mocked(SentryCoreBrowser.startInactiveSpan).mockReturnValue(mockSpan as any);
@@ -611,7 +611,7 @@ describe('_sendClsSpan', () => {
 
   it('falls back to the current time when there is no performance time origin', () => {
     vi.mocked(SentryCore.browserPerformanceTimeOrigin).mockReturnValue(undefined);
-    vi.mocked(SentryCore.performanceTimeToSeconds).mockReturnValue(undefined);
+    vi.mocked(SentryCore._INTERNAL_performanceTimeToSeconds).mockReturnValue(undefined);
 
     _sendClsSpan(0, undefined);
 
@@ -634,7 +634,7 @@ describe('_sendInpSpan', () => {
   beforeEach(() => {
     vi.mocked(SentryCore.getCurrentScope).mockReturnValue(mockScope as any);
     vi.mocked(SentryCore.browserPerformanceTimeOrigin).mockReturnValue(1000);
-    vi.mocked(SentryCore.performanceTimeToSeconds).mockImplementation(time => (1000 + time) / 1000);
+    vi.mocked(SentryCore._INTERNAL_performanceTimeToSeconds).mockImplementation(time => (1000 + time) / 1000);
     vi.mocked(htmlTreeAsString).mockReturnValue('<button>');
     vi.mocked(SentryCoreBrowser.startInactiveSpan).mockReturnValue(mockSpan as any);
     vi.mocked(SentryCore.getActiveSpan).mockReturnValue(undefined);
@@ -697,7 +697,7 @@ describe('_sendInpSpan', () => {
     // should still use the old one.
     const sleepDurationMs = 3_600_000;
     vi.mocked(SentryCore.browserPerformanceTimeOrigin).mockReturnValue(1000 + sleepDurationMs);
-    vi.mocked(SentryCore.performanceTimeToSeconds).mockImplementation(time =>
+    vi.mocked(SentryCore._INTERNAL_performanceTimeToSeconds).mockImplementation(time =>
       time < 500 ? (1000 + sleepDurationMs + time) / 1000 : (1000 + time) / 1000,
     );
 
@@ -838,7 +838,7 @@ describe('trackInpAsSpan', () => {
 
   beforeEach(() => {
     vi.mocked(SentryCore.browserPerformanceTimeOrigin).mockReturnValue(1000);
-    vi.mocked(SentryCore.performanceTimeToSeconds).mockImplementation(time => (1000 + time) / 1000);
+    vi.mocked(SentryCore._INTERNAL_performanceTimeToSeconds).mockImplementation(time => (1000 + time) / 1000);
     vi.mocked(SentryCore.getCurrentScope).mockReturnValue(mockScope as any);
     vi.mocked(SentryCore.getActiveSpan).mockReturnValue(undefined);
     vi.mocked(SentryCoreBrowser.startInactiveSpan).mockReturnValue({ end: vi.fn() } as any);
@@ -937,7 +937,7 @@ describe('soft navigation web vitals', () => {
       supportedEntryTypes: ['largest-contentful-paint', 'layout-shift', 'soft-navigation'],
     });
     vi.mocked(SentryCore.browserPerformanceTimeOrigin).mockReturnValue(1000);
-    vi.mocked(SentryCore.performanceTimeToSeconds).mockImplementation(time => (1000 + time) / 1000);
+    vi.mocked(SentryCore._INTERNAL_performanceTimeToSeconds).mockImplementation(time => (1000 + time) / 1000);
     vi.mocked(SentryCore.getCurrentScope).mockReturnValue(mockScope as any);
     vi.mocked(SentryCoreBrowser.startInactiveSpan).mockReturnValue({ end: vi.fn() } as any);
     vi.mocked(SentryCore.spanToJSON).mockImplementation(

packages/browser/src/profiling/utils.ts

@@ -5,7 +5,7 @@ import {
   getClient,
   getDebugImagesForResources,
   GLOBAL_OBJ,
-  performanceTimeToSeconds,
+  _INTERNAL_performanceTimeToSeconds,
   uuid4,
 } from '@sentry/core';
 import type { BrowserOptions } from '../client';
@@ -155,7 +155,7 @@ function convertToContinuousProfile(input: {
     }
     // Sample timestamps are relative to `performance.timeOrigin`, so we convert them like performance entries.
     // The cast is safe: the JS Self-Profiling API only exists if the Performance API does.
-    const timestampSeconds = performanceTimeToSeconds(sample.timestamp) as number;
+    const timestampSeconds = _INTERNAL_performanceTimeToSeconds(sample.timestamp) as number;
     samples[i] = {
       stack_id: sample.stackId ?? 0,
       thread_id: PROFILER_THREAD_ID_STRING,