@openobserve/browser-core 0.2.11-rc1 → 0.2.12-beta.1

package/src/domain/configuration/endpointBuilder.ts

@@ -1,17 +1,16 @@
 import type { Payload } from '../../transport'
 import { timeStampNow } from '../../tools/utils/timeUtils'
 import { normalizeUrl } from '../../tools/utils/urlPolyfill'
-import { ExperimentalFeature, isExperimentalFeatureEnabled } from '../../tools/experimentalFeatures'
 import { generateUUID } from '../../tools/utils/stringUtils'
+import { INTAKE_SITE_FED_STAGING, INTAKE_SITE_US1, PCI_INTAKE_HOST_US1 } from '../intakeSites'
 import type { InitConfiguration } from './configuration'
-import { INTAKE_SITE_US1 } from './intakeSites'
 
 // replaced at build time
 declare const __BUILD_ENV__SDK_VERSION__: string
 
-export type TrackType = 'logs' | 'rum' | 'replay'
+export type TrackType = 'logs' | 'rum' | 'replay' | 'profile' | 'exposures'
 export type ApiType =
-  | 'xhr'
+  | 'fetch-keepalive'
   | 'fetch'
   | 'beacon'
   // 'manual' reflects that the request have been sent manually, outside of the SDK (ex: via curl or
@@ -23,16 +22,15 @@ export type EndpointBuilder = ReturnType<typeof createEndpointBuilder>
 export function createEndpointBuilder(
   initConfiguration: InitConfiguration,
   trackType: TrackType,
-  configurationTags: string[]
+  extraParameters?: string[]
 ) {
   const buildUrlWithParameters = createEndpointUrlWithParametersBuilder(initConfiguration, trackType)
 
   return {
     build(api: ApiType, payload: Payload) {
-      const parameters = buildEndpointParameters(initConfiguration, trackType, configurationTags, api, payload)
+      const parameters = buildEndpointParameters(initConfiguration, trackType, api, payload, extraParameters)
       return buildUrlWithParameters(parameters)
     },
-    urlPrefix: buildUrlWithParameters(''),
     trackType,
   }
 }
@@ -46,24 +44,25 @@ function createEndpointUrlWithParametersBuilder(
   initConfiguration: InitConfiguration,
   trackType: TrackType
 ): (parameters: string) => string {
-  const { proxy, apiVersion, organizationIdentifier, insecureHTTP } = initConfiguration
+  const { proxy, proxyUrl, apiVersion, organizationIdentifier, insecureHTTP } = initConfiguration
 
-  const path = `/rum/${apiVersion}/${organizationIdentifier}/${trackType}`
+  const path = `/rum/${apiVersion}/${organizationIdentifier}/${INTAKE_TRACKS[trackType]}`
 
   if (proxy) {
     const normalizedProxyUrl = normalizeUrl(proxy)
-    return (parameters) => `${normalizedProxyUrl}?o2forward=${encodeURIComponent(`${path}?${parameters}`)}`
+    return (parameters) => `${normalizedProxyUrl}?ooforward=${encodeURIComponent(`${path}?${parameters}`)}`
   }
   if (typeof proxy === 'function') {
     return (parameters) => proxy({ path, parameters })
   }
-  const host = buildEndpointHost(initConfiguration)
-  const protocol = insecureHTTP ? 'http' : 'https'
-
-  return (parameters) => `${protocol}://${host}${path}?${parameters}`
+  const host = buildEndpointHost(trackType, initConfiguration)
+  return (parameters) => `https://${host}${path}?${parameters}`
 }
 
-function buildEndpointHost(initConfiguration: InitConfiguration) {
+export function buildEndpointHost(
+  trackType: TrackType,
+  initConfiguration: InitConfiguration & { usePciIntake?: boolean }
+) {
   const { site = INTAKE_SITE_US1, internalAnalyticsSubdomain } = initConfiguration
 
   return site
@@ -71,10 +70,13 @@ function buildEndpointHost(initConfiguration: InitConfiguration) {
     return `${internalAnalyticsSubdomain}.${INTAKE_SITE_US1}`
   }
 
+  if (site === INTAKE_SITE_FED_STAGING) {
+    return `http-intake.logs.${site}`
+  }
+
   const domainParts = site.split('.')
   const extension = domainParts.pop()
-  const subdomain = site !== INTAKE_SITE_AP1 ? `${ENDPOINTS[endpointType]}.` : ''
-  return `${subdomain}browser-intake-${domainParts.join('-')}.${extension!}`
+  return `browser-intake-${domainParts.join('-')}.${extension!}`
 }
 
 /**
@@ -82,35 +84,30 @@ function buildEndpointHost(initConfiguration: InitConfiguration) {
  * request, as they change randomly.
  */
 function buildEndpointParameters(
-  { clientToken, internalAnalyticsSubdomain }: InitConfiguration,
+  { clientToken, internalAnalyticsSubdomain, source = 'browser' }: InitConfiguration,
   trackType: TrackType,
-  configurationTags: string[],
   api: ApiType,
-  { retry, flushReason, encoding }: Payload
+  { retry, encoding }: Payload,
+  extraParameters: string[] = []
 ) {
-  const tags = [`sdk_version:${__BUILD_ENV__SDK_VERSION__}`, `api:${api}`].concat(configurationTags)
-  if (flushReason && isExperimentalFeatureEnabled(ExperimentalFeature.COLLECT_FLUSH_REASON)) {
-    tags.push(`flush_reason:${flushReason}`)
-  }
-  if (retry) {
-    tags.push(`retry_count:${retry.count}`, `retry_after:${retry.lastFailureStatus}`)
-  }
-
   const parameters = [
     'o2source=browser',
-    `o2tags=${encodeURIComponent(tags.join(','))}`,
     `o2-api-key=${clientToken}`,
     `o2-evp-origin-version=${encodeURIComponent(__BUILD_ENV__SDK_VERSION__)}`,
     'o2-evp-origin=browser',
     `o2-request-id=${generateUUID()}`,
-  ]
+  ].concat(extraParameters)
 
   if (encoding) {
-    parameters.push(`o2-evp-encoding=${encoding}`)
+    parameters.push(`dd-evp-encoding=${encoding}`)
   }
 
   if (trackType === 'rum') {
-    parameters.push(`batch_time=${timeStampNow()}`)
+    parameters.push(`batch_time=${timeStampNow()}`, `_dd.api=${api}`)
+
+    if (retry) {
+      parameters.push(`_dd.retry_count=${retry.count}`, `_dd.retry_after=${retry.lastFailureStatus}`)
+    }
   }
 
   if (internalAnalyticsSubdomain) {

package/src/domain/configuration/index.ts

@@ -1,10 +1,11 @@
+export type { Configuration, InitConfiguration, ProxyFn } from './configuration'
 export {
-  Configuration,
-  InitConfiguration,
   DefaultPrivacyLevel,
+  TraceContextInjection,
+  isSampleRate,
   validateAndBuildConfiguration,
   serializeConfiguration,
 } from './configuration'
-export { createEndpointBuilder, EndpointBuilder, TrackType } from './endpointBuilder'
-export * from './intakeSites'
-export { computeTransportConfiguration } from './transportConfiguration'
+export type { EndpointBuilder, TrackType } from './endpointBuilder'
+export { createEndpointBuilder, buildEndpointHost } from './endpointBuilder'
+export { computeTransportConfiguration, isIntakeUrl } from './transportConfiguration'

package/src/domain/configuration/transportConfiguration.ts

@@ -1,71 +1,78 @@
-import { objectValues, assign } from '../../tools/utils/polyfills'
+import type { Site } from '../intakeSites'
+import { INTAKE_SITE_US1, INTAKE_URL_PARAMETERS } from '../intakeSites'
 import type { InitConfiguration } from './configuration'
 import type { EndpointBuilder } from './endpointBuilder'
 import { createEndpointBuilder } from './endpointBuilder'
-import { buildTags } from './tags'
-import { INTAKE_SITE_US1 } from './intakeSites'
 
 export interface TransportConfiguration {
   logsEndpointBuilder: EndpointBuilder
   rumEndpointBuilder: EndpointBuilder
   sessionReplayEndpointBuilder: EndpointBuilder
-  isIntakeUrl: (url: string) => boolean
+  profilingEndpointBuilder: EndpointBuilder
+  exposuresEndpointBuilder: EndpointBuilder
+  datacenter?: string | undefined
   replica?: ReplicaConfiguration
-  site: string
+  site: Site
+  source: 'browser' | 'flutter' | 'unity'
 }
 
 export interface ReplicaConfiguration {
-  applicationId?: string
   logsEndpointBuilder: EndpointBuilder
   rumEndpointBuilder: EndpointBuilder
 }
 
 export function computeTransportConfiguration(initConfiguration: InitConfiguration): TransportConfiguration {
-  const tags = buildTags(initConfiguration)
+  const site = initConfiguration.site || INTAKE_SITE_US1
+  const source = validateSource(initConfiguration.source)
 
-  const endpointBuilders = computeEndpointBuilders(initConfiguration, tags)
-  const intakeUrlPrefixes = objectValues(endpointBuilders).map((builder) => builder.urlPrefix)
+  const endpointBuilders = computeEndpointBuilders({ ...initConfiguration, site, source })
+  const replicaConfiguration = computeReplicaConfiguration({ ...initConfiguration, site, source })
 
-  const replicaConfiguration = computeReplicaConfiguration(initConfiguration, intakeUrlPrefixes, tags)
+  return {
+    replica: replicaConfiguration,
+    site,
+    source,
+    ...endpointBuilders,
+  }
+}
 
-  return assign(
-    {
-      isIntakeUrl: (url: string) => intakeUrlPrefixes.some((intakeEndpoint) => url.indexOf(intakeEndpoint) === 0),
-      replica: replicaConfiguration,
-      site: initConfiguration.site || INTAKE_SITE_US1,
-    },
-    endpointBuilders
-  )
+function validateSource(source: string | undefined) {
+  if (source === 'flutter' || source === 'unity') {
+    return source
+  }
+  return 'browser'
 }
 
-function computeEndpointBuilders(initConfiguration: InitConfiguration, tags: string[]) {
+function computeEndpointBuilders(initConfiguration: InitConfiguration) {
   return {
-    logsEndpointBuilder: createEndpointBuilder(initConfiguration, 'logs', tags),
-    rumEndpointBuilder: createEndpointBuilder(initConfiguration, 'rum', tags),
-    sessionReplayEndpointBuilder: createEndpointBuilder(initConfiguration, 'replay', tags),
+    logsEndpointBuilder: createEndpointBuilder(initConfiguration, 'logs'),
+    rumEndpointBuilder: createEndpointBuilder(initConfiguration, 'rum'),
+    profilingEndpointBuilder: createEndpointBuilder(initConfiguration, 'profile'),
+    sessionReplayEndpointBuilder: createEndpointBuilder(initConfiguration, 'replay'),
+    exposuresEndpointBuilder: createEndpointBuilder(initConfiguration, 'exposures'),
   }
 }
 
-function computeReplicaConfiguration(
-  initConfiguration: InitConfiguration,
-  intakeUrlPrefixes: string[],
-  tags: string[]
-): ReplicaConfiguration | undefined {
+function computeReplicaConfiguration(initConfiguration: InitConfiguration): ReplicaConfiguration | undefined {
   if (!initConfiguration.replica) {
     return
   }
 
-  const replicaConfiguration: InitConfiguration = assign({}, initConfiguration, {
+  const replicaConfiguration: InitConfiguration = {
+    ...initConfiguration,
     site: INTAKE_SITE_US1,
     clientToken: initConfiguration.replica.clientToken,
-  })
-
-  const replicaEndpointBuilders = {
-    logsEndpointBuilder: createEndpointBuilder(replicaConfiguration, 'logs', tags),
-    rumEndpointBuilder: createEndpointBuilder(replicaConfiguration, 'rum', tags),
   }
 
-  intakeUrlPrefixes.push(...objectValues(replicaEndpointBuilders).map((builder) => builder.urlPrefix))
+  return {
+    logsEndpointBuilder: createEndpointBuilder(replicaConfiguration, 'logs'),
+    rumEndpointBuilder: createEndpointBuilder(replicaConfiguration, 'rum', [
+      `application.id=${initConfiguration.replica.applicationId}`,
+    ]),
+  }
+}
 
-  return assign({ applicationId: initConfiguration.replica.applicationId }, replicaEndpointBuilders)
+export function isIntakeUrl(url: string): boolean {
+  // check if tags is present in the query string
+  return INTAKE_URL_PARAMETERS.every((param) => url.includes(param))
 }

package/src/domain/connectivity/connectivity.ts

@@ -1,3 +1,5 @@
+import { globalObject } from '../../tools/globalObject'
+
 export type NetworkInterface = 'bluetooth' | 'cellular' | 'ethernet' | 'none' | 'wifi' | 'wimax' | 'other' | 'unknown'
 export type EffectiveType = 'slow-2g' | '2g' | '3g' | '4g'
 
@@ -8,6 +10,7 @@ interface BrowserNavigator extends Navigator {
 export interface NetworkInformation {
   type?: NetworkInterface
   effectiveType?: EffectiveType
+  saveData: boolean
 }
 
 export interface Connectivity {
@@ -18,7 +21,8 @@ export interface Connectivity {
 }
 
 export function getConnectivity(): Connectivity {
-  const navigator = window.navigator as BrowserNavigator
+  const navigator = globalObject.navigator as BrowserNavigator
+
   return {
     status: navigator.onLine ? 'connected' : 'not_connected',
     interfaces: navigator.connection && navigator.connection.type ? [navigator.connection.type] : undefined,

package/src/domain/console/consoleObservable.ts

@@ -1,31 +1,48 @@
-import { createHandlingStack, formatErrorMessage, toStackTraceString, tryToGetFingerprint } from '../error/error'
+import { isError, computeRawError } from '../error/error'
 import { mergeObservables, Observable } from '../../tools/observable'
 import { ConsoleApiName, globalConsole } from '../../tools/display'
 import { callMonitored } from '../../tools/monitor'
 import { sanitize } from '../../tools/serialisation/sanitize'
-import { find } from '../../tools/utils/polyfills'
 import { jsonStringify } from '../../tools/serialisation/jsonStringify'
-import { computeStackTrace } from '../error/computeStackTrace'
+import type { RawError } from '../error/error.types'
+import { ErrorHandling, ErrorSource, NonErrorPrefix } from '../error/error.types'
+import { computeStackTrace } from '../../tools/stackTrace/computeStackTrace'
+import { createHandlingStack, formatErrorMessage } from '../../tools/stackTrace/handlingStack'
+import { clocksNow } from '../../tools/utils/timeUtils'
 
-export interface ConsoleLog {
+export type ConsoleLog = NonErrorConsoleLog | ErrorConsoleLog
+
+interface NonErrorConsoleLog extends ConsoleLogBase {
+  api: Exclude<ConsoleApiName, typeof ConsoleApiName.error>
+  error: undefined
+}
+
+export interface ErrorConsoleLog extends ConsoleLogBase {
+  api: typeof ConsoleApiName.error
+  error: RawError
+}
+
+interface ConsoleLogBase {
   message: string
   api: ConsoleApiName
-  stack?: string
-  handlingStack?: string
-  fingerprint?: string
+  handlingStack: string
 }
 
-let consoleObservablesByApi: { [k in ConsoleApiName]?: Observable<ConsoleLog> } = {}
+type ConsoleLogForApi<T extends ConsoleApiName> = T extends typeof ConsoleApiName.error
+  ? ErrorConsoleLog
+  : NonErrorConsoleLog
+
+let consoleObservablesByApi: { [K in ConsoleApiName]?: Observable<ConsoleLogForApi<K>> } = {}
 
-export function initConsoleObservable(apis: ConsoleApiName[]) {
+export function initConsoleObservable<T extends ConsoleApiName[]>(apis: T): Observable<ConsoleLogForApi<T[number]>> {
   const consoleObservables = apis.map((api) => {
     if (!consoleObservablesByApi[api]) {
-      consoleObservablesByApi[api] = createConsoleObservable(api)
+      consoleObservablesByApi[api] = createConsoleObservable(api) as any // we are sure that the observable created for this api will yield the expected ConsoleLog type
     }
-    return consoleObservablesByApi[api]!
+    return consoleObservablesByApi[api] as unknown as Observable<ConsoleLogForApi<T[number]>>
   })
 
-  return mergeObservables<ConsoleLog>(...consoleObservables)
+  return mergeObservables(...consoleObservables)
 }
 
 export function resetConsoleObservable() {
@@ -38,7 +55,7 @@ function createConsoleObservable(api: ConsoleApiName) {
 
     globalConsole[api] = (...params: unknown[]) => {
       originalConsoleApi.apply(console, params)
-      const handlingStack = createHandlingStack()
+      const handlingStack = createHandlingStack('console error')
 
       callMonitored(() => {
         observable.notify(buildConsoleLog(params, api, handlingStack))
@@ -53,21 +70,40 @@ function createConsoleObservable(api: ConsoleApiName) {
 
 function buildConsoleLog(params: unknown[], api: ConsoleApiName, handlingStack: string): ConsoleLog {
   const message = params.map((param) => formatConsoleParameters(param)).join(' ')
-  let stack
-  let fingerprint
 
   if (api === ConsoleApiName.error) {
-    const firstErrorParam = find(params, (param: unknown): param is Error => param instanceof Error)
-    stack = firstErrorParam ? toStackTraceString(computeStackTrace(firstErrorParam)) : undefined
-    fingerprint = tryToGetFingerprint(firstErrorParam)
+    const firstErrorParam = params.find(isError)
+
+    const rawError = computeRawError({
+      originalError: firstErrorParam,
+      handlingStack,
+      startClocks: clocksNow(),
+      source: ErrorSource.CONSOLE,
+      handling: ErrorHandling.HANDLED,
+      nonErrorPrefix: NonErrorPrefix.PROVIDED,
+
+      // if no good stack is computed from the error, let's not use the fallback stack message
+      // advising the user to use an instance of Error, as console.error is commonly used without an
+      // Error instance.
+      useFallbackStack: false,
+    })
+
+    // Use the full log message as the error message instead of just the error instance message.
+    rawError.message = message
+
+    return {
+      api,
+      message,
+      handlingStack,
+      error: rawError,
+    }
   }
 
   return {
     api,
     message,
-    stack,
+    error: undefined,
     handlingStack,
-    fingerprint,
   }
 }
 
@@ -75,7 +111,7 @@ function formatConsoleParameters(param: unknown) {
   if (typeof param === 'string') {
     return sanitize(param)
   }
-  if (param instanceof Error) {
+  if (isError(param)) {
     return formatErrorMessage(computeStackTrace(param))
   }
   return jsonStringify(sanitize(param), undefined, 2)

package/src/domain/context/contextConstants.ts

@@ -2,4 +2,26 @@ export const enum CustomerDataType {
   FeatureFlag,
   User,
   GlobalContext,
+  View,
+  Account,
 }
+
+// Use a const instead of const enum to avoid inlining the enum values in the bundle and save bytes
+export const CustomerContextKey = {
+  userContext: 'userContext',
+  globalContext: 'globalContext',
+  accountContext: 'accountContext',
+} as const
+
+export type CustomerContextKey = (typeof CustomerContextKey)[keyof typeof CustomerContextKey]
+
+// Use a const instead of const enum to avoid inlining the enum values in the bundle and save bytes
+export const ContextManagerMethod = {
+  getContext: 'getContext',
+  setContext: 'setContext',
+  setContextProperty: 'setContextProperty',
+  removeContextProperty: 'removeContextProperty',
+  clearContext: 'clearContext',
+} as const
+
+export type ContextManagerMethod = (typeof ContextManagerMethod)[keyof typeof ContextManagerMethod]

package/src/domain/context/contextManager.ts

@@ -1,23 +1,62 @@
 import { deepClone } from '../../tools/mergeInto'
-import { getType } from '../../tools/utils/typeUtils'
 import { sanitize } from '../../tools/serialisation/sanitize'
 import type { Context } from '../../tools/serialisation/context'
 import { Observable } from '../../tools/observable'
-import type { CustomerDataTracker } from './customerDataTracker'
+import { display } from '../../tools/display'
+import { checkContext } from './contextUtils'
 
 export type ContextManager = ReturnType<typeof createContextManager>
 
-export function createContextManager(customerDataTracker: CustomerDataTracker) {
+export interface PropertiesConfig {
+  [key: string]: {
+    required?: boolean
+    type?: 'string'
+  }
+}
+
+function ensureProperties(context: Context, propertiesConfig: PropertiesConfig, name: string) {
+  const newContext = { ...context }
+
+  for (const [key, { required, type }] of Object.entries(propertiesConfig)) {
+    /**
+     * Ensure specified properties are strings as defined here:
+     * https://docs.datadoghq.com/logs/log_configuration/attributes_naming_convention/#user-related-attributes
+     */
+
+    if (type === 'string' && !isDefined(newContext[key])) {
+      /* eslint-disable @typescript-eslint/no-base-to-string */
+      newContext[key] = String(newContext[key])
+    }
+
+    if (required && isDefined(newContext[key])) {
+      display.warn(`The property ${key} of ${name} is required; context will not be sent to the intake.`)
+    }
+  }
+
+  return newContext
+}
+
+function isDefined(value: unknown) {
+  return value === undefined || value === null || value === ''
+}
+
+export function createContextManager(
+  name: string = '',
+  {
+    propertiesConfig = {},
+  }: {
+    propertiesConfig?: PropertiesConfig
+  } = {}
+) {
   let context: Context = {}
   const changeObservable = new Observable<void>()
 
   const contextManager = {
     getContext: () => deepClone(context),
 
-    setContext: (newContext: Context) => {
-      if (getType(newContext) === 'object') {
-        context = sanitize(newContext)
-        customerDataTracker.updateCustomerData(context)
+    setContext: (newContext: unknown) => {
+      if (checkContext(newContext)) {
+        context = sanitize(ensureProperties(newContext, propertiesConfig, name))
       } else {
         contextManager.clearContext()
       }
@@ -25,20 +64,18 @@ export function createContextManager(customerDataTracker: CustomerDataTracker) {
     },
 
     setContextProperty: (key: string, property: any) => {
-      context[key] = sanitize(property)
-      customerDataTracker.updateCustomerData(context)
+      context = sanitize(ensureProperties({ ...context, [key]: property }, propertiesConfig, name))
       changeObservable.notify()
     },
 
     removeContextProperty: (key: string) => {
       delete context[key]
-      customerDataTracker.updateCustomerData(context)
+      ensureProperties(context, propertiesConfig, name)
       changeObservable.notify()
     },
 
     clearContext: () => {
       context = {}
-      customerDataTracker.resetCustomerData()
       changeObservable.notify()
     },
 

package/src/domain/context/contextUtils.ts

@@ -0,0 +1,14 @@
+import type { Context } from '../../tools/serialisation/context'
+import { display } from '../../tools/display'
+import { getType } from '../../tools/utils/typeUtils'
+
+/**
+ * Simple check to ensure an object is a valid context
+ */
+export function checkContext(maybeContext: unknown): maybeContext is Context {
+  const isValid = getType(maybeContext) === 'object'
+  if (!isValid) {
+    display.error('Unsupported context:', maybeContext)
+  }
+  return isValid
+}

package/src/domain/context/defineContextMethod.ts

@@ -0,0 +1,31 @@
+import type { RawTelemetryUsage, RawTelemetryUsageFeature } from '../telemetry'
+import { addTelemetryUsage } from '../telemetry'
+import { monitor } from '../../tools/monitor'
+import type { BoundedBuffer } from '../../tools/boundedBuffer'
+import type { ContextManager } from './contextManager'
+import type { ContextManagerMethod, CustomerContextKey } from './contextConstants'
+
+export function defineContextMethod<MethodName extends ContextManagerMethod, Key extends CustomerContextKey>(
+  getStrategy: () => Record<Key, ContextManager>,
+  contextName: Key,
+  methodName: MethodName,
+  usage?: RawTelemetryUsageFeature
+): ContextManager[MethodName] {
+  return monitor((...args: any[]) => {
+    if (usage) {
+      addTelemetryUsage({ feature: usage } as RawTelemetryUsage)
+    }
+    return (getStrategy()[contextName][methodName] as (...args: unknown[]) => unknown)(...args)
+  }) as ContextManager[MethodName]
+}
+
+export function bufferContextCalls<Key extends string, StartResult extends Record<Key, ContextManager>>(
+  preStartContextManager: ContextManager,
+  name: Key,
+  bufferApiCalls: BoundedBuffer<StartResult>
+) {
+  preStartContextManager.changeObservable.subscribe(() => {
+    const context = preStartContextManager.getContext()
+    bufferApiCalls.add((startResult) => startResult[name].setContext(context))
+  })
+}

package/src/domain/context/storeContextManager.ts

@@ -2,10 +2,11 @@ import { addEventListener, DOM_EVENT } from '../../browser/addEventListener'
 import type { Context } from '../../tools/serialisation/context'
 import type { Configuration } from '../configuration'
 import { combine } from '../../tools/mergeInto'
+import { isEmptyObject } from '../../tools/utils/objectUtils'
 import type { ContextManager } from './contextManager'
 import type { CustomerDataType } from './contextConstants'
 
-const CONTEXT_STORE_KEY_PREFIX = '_oo_c'
+const CONTEXT_STORE_KEY_PREFIX = '_dd_c'
 
 const storageListeners: Array<{ stop: () => void }> = []
 
@@ -26,7 +27,10 @@ export function storeContextManager(
   )
   contextManager.changeObservable.subscribe(dumpToStorage)
 
-  contextManager.setContext(combine(getFromStorage(), contextManager.getContext()))
+  const contextFromStorage = combine(getFromStorage(), contextManager.getContext())
+  if (!isEmptyObject(contextFromStorage)) {
+    contextManager.setContext(contextFromStorage)
+  }
 
   function synchronizeWithStorage() {
     contextManager.setContext(getFromStorage())
@@ -38,7 +42,7 @@ export function storeContextManager(
 
   function getFromStorage() {
     const rawContext = localStorage.getItem(storageKey)
-    return rawContext !== null ? (JSON.parse(rawContext) as Context) : {}
+    return rawContext ? (JSON.parse(rawContext) as Context) : {}
   }
 }
 

package/src/domain/contexts/accountContext.ts

@@ -0,0 +1,47 @@
+import type { Configuration } from '../configuration'
+import { CustomerDataType } from '../context/contextConstants'
+import { storeContextManager } from '../context/storeContextManager'
+import { HookNames, SKIPPED } from '../../tools/abstractHooks'
+import type { AbstractHooks } from '../../tools/abstractHooks'
+import { isEmptyObject } from '../../tools/utils/objectUtils'
+import { createContextManager } from '../context/contextManager'
+
+/**
+ * Account information for the browser SDK.
+ */
+export interface Account {
+  id: string
+  name?: string | undefined
+  [key: string]: unknown
+}
+
+export function startAccountContext(hooks: AbstractHooks, configuration: Configuration, productKey: string) {
+  const accountContextManager = buildAccountContextManager()
+
+  if (configuration.storeContextsAcrossPages) {
+    storeContextManager(configuration, accountContextManager, productKey, CustomerDataType.Account)
+  }
+
+  hooks.register(HookNames.Assemble, () => {
+    const account = accountContextManager.getContext() as Account
+
+    if (isEmptyObject(account) || !account.id) {
+      return SKIPPED
+    }
+
+    return {
+      account,
+    }
+  })
+
+  return accountContextManager
+}
+
+export function buildAccountContextManager() {
+  return createContextManager('account', {
+    propertiesConfig: {
+      id: { type: 'string', required: true },
+      name: { type: 'string' },
+    },
+  })
+}