@openobserve/browser-core 0.2.8

package/src/domain/session/sessionStore.ts

@@ -0,0 +1,185 @@
+import { clearInterval, setInterval } from '../../tools/timer'
+import { Observable } from '../../tools/observable'
+import { ONE_SECOND, dateNow } from '../../tools/utils/timeUtils'
+import { throttle } from '../../tools/utils/functionUtils'
+import { generateUUID } from '../../tools/utils/stringUtils'
+import type { InitConfiguration } from '../configuration'
+import { SESSION_TIME_OUT_DELAY } from './sessionConstants'
+import { selectCookieStrategy, initCookieStrategy } from './storeStrategies/sessionInCookie'
+import type { SessionStoreStrategyType } from './storeStrategies/sessionStoreStrategy'
+import type { SessionState } from './sessionState'
+import { initLocalStorageStrategy, selectLocalStorageStrategy } from './storeStrategies/sessionInLocalStorage'
+import { processSessionStoreOperations } from './sessionStoreOperations'
+
+export interface SessionStore {
+  expandOrRenewSession: () => void
+  expandSession: () => void
+  getSession: () => SessionState
+  renewObservable: Observable<void>
+  expireObservable: Observable<void>
+  expire: () => void
+  stop: () => void
+}
+
+/**
+ * Every second, the storage will be polled to check for any change that can occur
+ * to the session state in another browser tab, or another window.
+ * This value has been determined from our previous cookie-only implementation.
+ */
+export const STORAGE_POLL_DELAY = ONE_SECOND
+
+/**
+ * Checks if cookies are available as the preferred storage
+ * Else, checks if LocalStorage is allowed and available
+ */
+export function selectSessionStoreStrategyType(
+  initConfiguration: InitConfiguration
+): SessionStoreStrategyType | undefined {
+  let sessionStoreStrategyType = selectCookieStrategy(initConfiguration)
+  if (!sessionStoreStrategyType && initConfiguration.allowFallbackToLocalStorage) {
+    sessionStoreStrategyType = selectLocalStorageStrategy()
+  }
+  return sessionStoreStrategyType
+}
+
+/**
+ * Different session concepts:
+ * - tracked, the session has an id and is updated along the user navigation
+ * - not tracked, the session does not have an id but it is updated along the user navigation
+ * - inactive, no session in store or session expired, waiting for a renew session
+ */
+export function startSessionStore<TrackingType extends string>(
+  sessionStoreStrategyType: SessionStoreStrategyType,
+  productKey: string,
+  computeSessionState: (rawTrackingType?: string) => { trackingType: TrackingType; isTracked: boolean }
+): SessionStore {
+  const renewObservable = new Observable<void>()
+  const expireObservable = new Observable<void>()
+
+  const sessionStoreStrategy =
+    sessionStoreStrategyType.type === 'Cookie'
+      ? initCookieStrategy(sessionStoreStrategyType.cookieOptions)
+      : initLocalStorageStrategy()
+  const { clearSession, retrieveSession } = sessionStoreStrategy
+
+  const watchSessionTimeoutId = setInterval(watchSession, STORAGE_POLL_DELAY)
+  let sessionCache: SessionState = retrieveActiveSession()
+
+  function expandOrRenewSession() {
+    let isTracked: boolean
+    processSessionStoreOperations(
+      {
+        process: (sessionState) => {
+          const synchronizedSession = synchronizeSession(sessionState)
+          isTracked = expandOrRenewSessionState(synchronizedSession)
+          return synchronizedSession
+        },
+        after: (sessionState) => {
+          if (isTracked && !hasSessionInCache()) {
+            renewSessionInCache(sessionState)
+          }
+          sessionCache = sessionState
+        },
+      },
+      sessionStoreStrategy
+    )
+  }
+
+  function expandSession() {
+    processSessionStoreOperations(
+      {
+        process: (sessionState) => (hasSessionInCache() ? synchronizeSession(sessionState) : undefined),
+      },
+      sessionStoreStrategy
+    )
+  }
+
+  /**
+   * allows two behaviors:
+   * - if the session is active, synchronize the session cache without updating the session store
+   * - if the session is not active, clear the session store and expire the session cache
+   */
+  function watchSession() {
+    processSessionStoreOperations(
+      {
+        process: (sessionState) => (!isActiveSession(sessionState) ? {} : undefined),
+        after: synchronizeSession,
+      },
+      sessionStoreStrategy
+    )
+  }
+
+  function synchronizeSession(sessionState: SessionState) {
+    if (!isActiveSession(sessionState)) {
+      sessionState = {}
+    }
+    if (hasSessionInCache()) {
+      if (isSessionInCacheOutdated(sessionState)) {
+        expireSessionInCache()
+      } else {
+        sessionCache = sessionState
+      }
+    }
+    return sessionState
+  }
+
+  function expandOrRenewSessionState(sessionState: SessionState) {
+    const { trackingType, isTracked } = computeSessionState(sessionState[productKey])
+    sessionState[productKey] = trackingType
+    if (isTracked && !sessionState.id) {
+      sessionState.id = generateUUID()
+      sessionState.created = String(dateNow())
+    }
+    return isTracked
+  }
+
+  function hasSessionInCache() {
+    return sessionCache[productKey] !== undefined
+  }
+
+  function isSessionInCacheOutdated(sessionState: SessionState) {
+    return sessionCache.id !== sessionState.id || sessionCache[productKey] !== sessionState[productKey]
+  }
+
+  function expireSessionInCache() {
+    sessionCache = {}
+    expireObservable.notify()
+  }
+
+  function renewSessionInCache(sessionState: SessionState) {
+    sessionCache = sessionState
+    renewObservable.notify()
+  }
+
+  function retrieveActiveSession(): SessionState {
+    const session = retrieveSession()
+    if (isActiveSession(session)) {
+      return session
+    }
+    return {}
+  }
+
+  function isActiveSession(sessionState: SessionState) {
+    // created and expire can be undefined for versions which was not storing them
+    // these checks could be removed when older versions will not be available/live anymore
+    return (
+      (sessionState.created === undefined || dateNow() - Number(sessionState.created) < SESSION_TIME_OUT_DELAY) &&
+      (sessionState.expire === undefined || dateNow() < Number(sessionState.expire))
+    )
+  }
+
+  return {
+    expandOrRenewSession: throttle(expandOrRenewSession, STORAGE_POLL_DELAY).throttled,
+    expandSession,
+    getSession: () => sessionCache,
+    renewObservable,
+    expireObservable,
+    expire: () => {
+      clearSession()
+      synchronizeSession({})
+    },
+    stop: () => {
+      clearInterval(watchSessionTimeoutId)
+    },
+  }
+}

package/src/domain/session/sessionStoreOperations.ts

@@ -0,0 +1,112 @@
+import { setTimeout } from '../../tools/timer'
+import { generateUUID } from '../../tools/utils/stringUtils'
+import { isChromium } from '../../tools/utils/browserDetection'
+import type { SessionStoreStrategy } from './storeStrategies/sessionStoreStrategy'
+import type { SessionState } from './sessionState'
+import { expandSessionState, isSessionInExpiredState } from './sessionState'
+
+type Operations = {
+  process: (sessionState: SessionState) => SessionState | undefined
+  after?: (sessionState: SessionState) => void
+}
+
+export const LOCK_RETRY_DELAY = 10
+export const LOCK_MAX_TRIES = 100
+const bufferedOperations: Operations[] = []
+let ongoingOperations: Operations | undefined
+
+export function processSessionStoreOperations(
+  operations: Operations,
+  sessionStoreStrategy: SessionStoreStrategy,
+  numberOfRetries = 0
+) {
+  const { retrieveSession, persistSession, clearSession } = sessionStoreStrategy
+  const lockEnabled = isLockEnabled()
+
+  if (!ongoingOperations) {
+    ongoingOperations = operations
+  }
+  if (operations !== ongoingOperations) {
+    bufferedOperations.push(operations)
+    return
+  }
+  if (lockEnabled && numberOfRetries >= LOCK_MAX_TRIES) {
+    next(sessionStoreStrategy)
+    return
+  }
+  let currentLock: string
+  let currentSession = retrieveSession()
+  if (lockEnabled) {
+    // if someone has lock, retry later
+    if (currentSession.lock) {
+      retryLater(operations, sessionStoreStrategy, numberOfRetries)
+      return
+    }
+    // acquire lock
+    currentLock = generateUUID()
+    currentSession.lock = currentLock
+    persistSession(currentSession)
+    // if lock is not acquired, retry later
+    currentSession = retrieveSession()
+    if (currentSession.lock !== currentLock) {
+      retryLater(operations, sessionStoreStrategy, numberOfRetries)
+      return
+    }
+  }
+  let processedSession = operations.process(currentSession)
+  if (lockEnabled) {
+    // if lock corrupted after process, retry later
+    currentSession = retrieveSession()
+    if (currentSession.lock !== currentLock!) {
+      retryLater(operations, sessionStoreStrategy, numberOfRetries)
+      return
+    }
+  }
+  if (processedSession) {
+    if (isSessionInExpiredState(processedSession)) {
+      clearSession()
+    } else {
+      expandSessionState(processedSession)
+      persistSession(processedSession)
+    }
+  }
+  if (lockEnabled) {
+    // correctly handle lock around expiration would require to handle this case properly at several levels
+    // since we don't have evidence of lock issues around expiration, let's just not do the corruption check for it
+    if (!(processedSession && isSessionInExpiredState(processedSession))) {
+      // if lock corrupted after persist, retry later
+      currentSession = retrieveSession()
+      if (currentSession.lock !== currentLock!) {
+        retryLater(operations, sessionStoreStrategy, numberOfRetries)
+        return
+      }
+      delete currentSession.lock
+      persistSession(currentSession)
+      processedSession = currentSession
+    }
+  }
+  // call after even if session is not persisted in order to perform operations on
+  // up-to-date session state value => the value could have been modified by another tab
+  operations.after?.(processedSession || currentSession)
+  next(sessionStoreStrategy)
+}
+
+/**
+ * Lock strategy allows mitigating issues due to concurrent access to cookie.
+ * This issue concerns only chromium browsers and enabling this on firefox increases cookie write failures.
+ */
+export const isLockEnabled = () => isChromium()
+
+function retryLater(operations: Operations, sessionStore: SessionStoreStrategy, currentNumberOfRetries: number) {
+  setTimeout(() => {
+    processSessionStoreOperations(operations, sessionStore, currentNumberOfRetries + 1)
+  }, LOCK_RETRY_DELAY)
+}
+
+function next(sessionStore: SessionStoreStrategy) {
+  ongoingOperations = undefined
+  const nextOperations = bufferedOperations.shift()
+  if (nextOperations) {
+    processSessionStoreOperations(nextOperations, sessionStore)
+  }
+}

package/src/domain/session/storeStrategies/sessionInCookie.ts

@@ -0,0 +1,56 @@
+import type { CookieOptions } from '../../../browser/cookie'
+import { getCurrentSite, areCookiesAuthorized, deleteCookie, getCookie, setCookie } from '../../../browser/cookie'
+import type { InitConfiguration } from '../../configuration'
+import { tryOldCookiesMigration } from '../oldCookiesMigration'
+import { SESSION_EXPIRATION_DELAY } from '../sessionConstants'
+import type { SessionState } from '../sessionState'
+import { toSessionString, toSessionState } from '../sessionState'
+import type { SessionStoreStrategy, SessionStoreStrategyType } from './sessionStoreStrategy'
+import { SESSION_STORE_KEY } from './sessionStoreStrategy'
+
+export function selectCookieStrategy(initConfiguration: InitConfiguration): SessionStoreStrategyType | undefined {
+  const cookieOptions = buildCookieOptions(initConfiguration)
+  return areCookiesAuthorized(cookieOptions) ? { type: 'Cookie', cookieOptions } : undefined
+}
+
+export function initCookieStrategy(cookieOptions: CookieOptions): SessionStoreStrategy {
+  const cookieStore = {
+    persistSession: persistSessionCookie(cookieOptions),
+    retrieveSession: retrieveSessionCookie,
+    clearSession: deleteSessionCookie(cookieOptions),
+  }
+
+  tryOldCookiesMigration(cookieStore)
+
+  return cookieStore
+}
+
+function persistSessionCookie(options: CookieOptions) {
+  return (session: SessionState) => {
+    setCookie(SESSION_STORE_KEY, toSessionString(session), SESSION_EXPIRATION_DELAY, options)
+  }
+}
+
+function retrieveSessionCookie(): SessionState {
+  const sessionString = getCookie(SESSION_STORE_KEY)
+  return toSessionState(sessionString)
+}
+
+function deleteSessionCookie(options: CookieOptions) {
+  return () => {
+    deleteCookie(SESSION_STORE_KEY, options)
+  }
+}
+
+export function buildCookieOptions(initConfiguration: InitConfiguration) {
+  const cookieOptions: CookieOptions = {}
+
+  cookieOptions.secure = !!initConfiguration.useSecureSessionCookie || !!initConfiguration.useCrossSiteSessionCookie
+  cookieOptions.crossSite = !!initConfiguration.useCrossSiteSessionCookie
+
+  if (initConfiguration.trackSessionAcrossSubdomains) {
+    cookieOptions.domain = getCurrentSite()
+  }
+
+  return cookieOptions
+}

package/src/domain/session/storeStrategies/sessionInLocalStorage.ts

@@ -0,0 +1,41 @@
+import { generateUUID } from '../../../tools/utils/stringUtils'
+import type { SessionState } from '../sessionState'
+import { toSessionString, toSessionState } from '../sessionState'
+import type { SessionStoreStrategy, SessionStoreStrategyType } from './sessionStoreStrategy'
+import { SESSION_STORE_KEY } from './sessionStoreStrategy'
+
+const LOCAL_STORAGE_TEST_KEY = '_oo_test_'
+
+export function selectLocalStorageStrategy(): SessionStoreStrategyType | undefined {
+  try {
+    const id = generateUUID()
+    const testKey = `${LOCAL_STORAGE_TEST_KEY}${id}`
+    localStorage.setItem(testKey, id)
+    const retrievedId = localStorage.getItem(testKey)
+    localStorage.removeItem(testKey)
+    return id === retrievedId ? { type: 'LocalStorage' } : undefined
+  } catch (e) {
+    return undefined
+  }
+}
+
+export function initLocalStorageStrategy(): SessionStoreStrategy {
+  return {
+    persistSession: persistInLocalStorage,
+    retrieveSession: retrieveSessionFromLocalStorage,
+    clearSession: clearSessionFromLocalStorage,
+  }
+}
+
+function persistInLocalStorage(sessionState: SessionState) {
+  localStorage.setItem(SESSION_STORE_KEY, toSessionString(sessionState))
+}
+
+function retrieveSessionFromLocalStorage(): SessionState {
+  const sessionString = localStorage.getItem(SESSION_STORE_KEY)
+  return toSessionState(sessionString)
+}
+
+function clearSessionFromLocalStorage() {
+  localStorage.removeItem(SESSION_STORE_KEY)
+}

package/src/domain/session/storeStrategies/sessionStoreStrategy.ts

@@ -0,0 +1,12 @@
+import type { CookieOptions } from '../../../browser/cookie'
+import type { SessionState } from '../sessionState'
+
+export const SESSION_STORE_KEY = '_oo_s'
+
+export type SessionStoreStrategyType = { type: 'Cookie'; cookieOptions: CookieOptions } | { type: 'LocalStorage' }
+
+export interface SessionStoreStrategy {
+  persistSession: (session: SessionState) => void
+  retrieveSession: () => SessionState
+  clearSession: () => void
+}

package/src/domain/synthetics/syntheticsWorkerValues.ts

@@ -0,0 +1,27 @@
+import { getCookie } from '../../browser/cookie'
+
+export const SYNTHETICS_TEST_ID_COOKIE_NAME = 'openobserve-synthetics-public-id'
+export const SYNTHETICS_RESULT_ID_COOKIE_NAME = 'openobserve-synthetics-result-id'
+export const SYNTHETICS_INJECTS_RUM_COOKIE_NAME = 'openobserve-synthetics-injects-rum'
+
+export interface BrowserWindow extends Window {
+  _OO_SYNTHETICS_PUBLIC_ID?: unknown
+  _OO_SYNTHETICS_RESULT_ID?: unknown
+  _OO_SYNTHETICS_INJECTS_RUM?: unknown
+}
+
+export function willSyntheticsInjectRum(): boolean {
+  return Boolean(
+    (window as BrowserWindow)._OO_SYNTHETICS_INJECTS_RUM || getCookie(SYNTHETICS_INJECTS_RUM_COOKIE_NAME)
+  )
+}
+
+export function getSyntheticsTestId(): string | undefined {
+  const value = (window as BrowserWindow)._OO_SYNTHETICS_PUBLIC_ID || getCookie(SYNTHETICS_TEST_ID_COOKIE_NAME)
+  return typeof value === 'string' ? value : undefined
+}
+
+export function getSyntheticsResultId(): string | undefined {
+  const value = (window as BrowserWindow)._OO_SYNTHETICS_RESULT_ID || getCookie(SYNTHETICS_RESULT_ID_COOKIE_NAME)
+  return typeof value === 'string' ? value : undefined
+}

package/src/domain/telemetry/index.ts

@@ -0,0 +1,14 @@
+export {
+  Telemetry,
+  TelemetryService,
+  addTelemetryDebug,
+  addTelemetryError,
+  startFakeTelemetry,
+  resetTelemetry,
+  startTelemetry,
+  isTelemetryReplicationAllowed,
+  addTelemetryConfiguration,
+} from './telemetry'
+
+export * from './rawTelemetryEvent.types'
+export * from './telemetryEvent.types'

package/src/domain/telemetry/rawTelemetryEvent.types.ts

@@ -0,0 +1,14 @@
+import type { TelemetryEvent, TelemetryConfigurationEvent } from './telemetryEvent.types'
+
+export const TelemetryType = {
+  log: 'log',
+  configuration: 'configuration',
+} as const
+
+export const enum StatusType {
+  debug = 'debug',
+  error = 'error',
+}
+
+export type RawTelemetryEvent = TelemetryEvent['telemetry']
+export type RawTelemetryConfiguration = TelemetryConfigurationEvent['telemetry']['configuration']

package/src/domain/telemetry/telemetry.ts

@@ -0,0 +1,195 @@
+import type { Context } from '../../tools/serialisation/context'
+import { ConsoleApiName } from '../../tools/display'
+import { toStackTraceString, NO_ERROR_STACK_PRESENT_MESSAGE } from '../error/error'
+import { getExperimentalFeatures } from '../../tools/experimentalFeatures'
+import type { Configuration } from '../configuration'
+import { INTAKE_SITE_STAGING, INTAKE_SITE_US1_FED } from '../configuration'
+import type { StackTrace } from '../tracekit'
+import { computeStackTrace } from '../tracekit'
+import { Observable } from '../../tools/observable'
+import { timeStampNow } from '../../tools/utils/timeUtils'
+import { displayIfDebugEnabled, startMonitorErrorCollection } from '../../tools/monitor'
+import { sendToExtension } from '../../tools/sendToExtension'
+import { startsWith, arrayFrom, includes, assign } from '../../tools/utils/polyfills'
+import { performDraw } from '../../tools/utils/numberUtils'
+import { jsonStringify } from '../../tools/serialisation/jsonStringify'
+import { combine } from '../../tools/mergeInto'
+import { NonErrorPrefix } from '../error/error.types'
+import type { TelemetryEvent } from './telemetryEvent.types'
+import type { RawTelemetryConfiguration, RawTelemetryEvent } from './rawTelemetryEvent.types'
+import { StatusType, TelemetryType } from './rawTelemetryEvent.types'
+
+// replaced at build time
+declare const __BUILD_ENV__SDK_VERSION__: string
+
+const ALLOWED_FRAME_URLS = [
+  'http://localhost',
+  '<anonymous>',
+]
+
+export const enum TelemetryService {
+  LOGS = 'browser-logs-sdk',
+  RUM = 'browser-rum-sdk',
+}
+
+export interface Telemetry {
+  setContextProvider: (provider: () => Context) => void
+  observable: Observable<TelemetryEvent & Context>
+  enabled: boolean
+}
+
+const TELEMETRY_EXCLUDED_SITES: string[] = [INTAKE_SITE_US1_FED]
+
+const telemetryConfiguration: {
+  maxEventsPerPage: number
+  sentEventCount: number
+  telemetryEnabled: boolean
+  telemetryConfigurationEnabled: boolean
+} = { maxEventsPerPage: 0, sentEventCount: 0, telemetryEnabled: false, telemetryConfigurationEnabled: false }
+
+let onRawTelemetryEventCollected: ((event: RawTelemetryEvent) => void) | undefined
+
+export function startTelemetry(telemetryService: TelemetryService, configuration: Configuration): Telemetry {
+  let contextProvider: () => Context
+  const observable = new Observable<TelemetryEvent & Context>()
+
+  telemetryConfiguration.telemetryEnabled =
+    !includes(TELEMETRY_EXCLUDED_SITES, configuration.site) && performDraw(configuration.telemetrySampleRate)
+  telemetryConfiguration.telemetryConfigurationEnabled =
+    telemetryConfiguration.telemetryEnabled && performDraw(configuration.telemetryConfigurationSampleRate)
+
+  onRawTelemetryEventCollected = (rawEvent: RawTelemetryEvent) => {
+    if (telemetryConfiguration.telemetryEnabled) {
+      const event = toTelemetryEvent(telemetryService, rawEvent)
+      observable.notify(event)
+      sendToExtension('telemetry', event)
+    }
+  }
+  startMonitorErrorCollection(addTelemetryError)
+
+  assign(telemetryConfiguration, {
+    maxEventsPerPage: configuration.maxTelemetryEventsPerPage,
+    sentEventCount: 0,
+  })
+
+  function toTelemetryEvent(telemetryService: TelemetryService, event: RawTelemetryEvent): TelemetryEvent & Context {
+    return combine(
+      {
+        type: 'telemetry' as const,
+        date: timeStampNow(),
+        service: telemetryService,
+        version: __BUILD_ENV__SDK_VERSION__,
+        source: 'browser' as const,
+        _oo: {
+          format_version: 2 as const,
+        },
+        telemetry: event as any, // https://github.com/microsoft/TypeScript/issues/48457
+        experimental_features: arrayFrom(getExperimentalFeatures()),
+      },
+      contextProvider !== undefined ? contextProvider() : {}
+    )
+  }
+
+  return {
+    setContextProvider: (provider: () => Context) => {
+      contextProvider = provider
+    },
+    observable,
+    enabled: telemetryConfiguration.telemetryEnabled,
+  }
+}
+
+export function startFakeTelemetry() {
+  const events: RawTelemetryEvent[] = []
+  assign(telemetryConfiguration, {
+    maxEventsPerPage: Infinity,
+    sentEventCount: 0,
+  })
+
+  onRawTelemetryEventCollected = (event: RawTelemetryEvent) => {
+    events.push(event)
+  }
+
+  return events
+}
+
+export function resetTelemetry() {
+  onRawTelemetryEventCollected = undefined
+}
+
+/**
+ * Avoid mixing telemetry events from different data centers
+ * but keep replicating staging events for reliability
+ */
+export function isTelemetryReplicationAllowed(configuration: Configuration) {
+  return configuration.site === INTAKE_SITE_STAGING
+}
+
+export function addTelemetryDebug(message: string, context?: Context) {
+  displayIfDebugEnabled(ConsoleApiName.debug, message, context)
+  addTelemetry(
+    assign(
+      {
+        type: TelemetryType.log,
+        message,
+        status: StatusType.debug,
+      },
+      context
+    )
+  )
+}
+
+export function addTelemetryError(e: unknown, context?: Context) {
+  addTelemetry(
+    assign(
+      {
+        type: TelemetryType.log,
+        status: StatusType.error,
+      },
+      formatError(e),
+      context
+    )
+  )
+}
+
+export function addTelemetryConfiguration(configuration: RawTelemetryConfiguration) {
+  if (telemetryConfiguration.telemetryConfigurationEnabled) {
+    addTelemetry({
+      type: TelemetryType.configuration,
+      configuration,
+    })
+  }
+}
+
+function addTelemetry(event: RawTelemetryEvent) {
+  if (onRawTelemetryEventCollected && telemetryConfiguration.sentEventCount < telemetryConfiguration.maxEventsPerPage) {
+    telemetryConfiguration.sentEventCount += 1
+    onRawTelemetryEventCollected(event)
+  }
+}
+
+export function formatError(e: unknown) {
+  if (e instanceof Error) {
+    const stackTrace = computeStackTrace(e)
+    return {
+      error: {
+        kind: stackTrace.name,
+        stack: toStackTraceString(scrubCustomerFrames(stackTrace)),
+      },
+      message: stackTrace.message!,
+    }
+  }
+  return {
+    error: {
+      stack: NO_ERROR_STACK_PRESENT_MESSAGE,
+    },
+    message: `${NonErrorPrefix.UNCAUGHT} ${jsonStringify(e)!}`,
+  }
+}
+
+export function scrubCustomerFrames(stackTrace: StackTrace) {
+  stackTrace.stack = stackTrace.stack.filter(
+    (frame) => !frame.url || ALLOWED_FRAME_URLS.some((allowedFrameUrl) => startsWith(frame.url!, allowedFrameUrl))
+  )
+  return stackTrace
+}