@pratham.raval/browser-core 6.22.3

package/src/domain/configuration/endpointBuilder.ts

@@ -0,0 +1,119 @@
+import type { Payload } from '../../transport'
+import { timeStampNow } from '../../tools/utils/timeUtils'
+import { normalizeUrl } from '../../tools/utils/urlPolyfill'
+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'
+
+// replaced at build time
+declare const __BUILD_ENV__SDK_VERSION__: string
+
+export type TrackType = 'logs' | 'rum' | 'replay' | 'profile' | 'exposures'
+export type ApiType =
+  | 'fetch-keepalive'
+  | 'fetch'
+  | 'beacon'
+  // 'manual' reflects that the request have been sent manually, outside of the SDK (ex: via curl or
+  // a Node.js script).
+  | 'manual'
+
+export type EndpointBuilder = ReturnType<typeof createEndpointBuilder>
+
+export function createEndpointBuilder(
+  initConfiguration: InitConfiguration,
+  trackType: TrackType,
+  extraParameters?: string[]
+) {
+  const buildUrlWithParameters = createEndpointUrlWithParametersBuilder(initConfiguration, trackType)
+
+  return {
+    build(api: ApiType, payload: Payload) {
+      const parameters = buildEndpointParameters(initConfiguration, trackType, api, payload, extraParameters)
+      return buildUrlWithParameters(parameters)
+    },
+    trackType,
+  }
+}
+
+/**
+ * Create a function used to build a full endpoint url from provided parameters. The goal of this
+ * function is to pre-compute some parts of the URL to avoid re-computing everything on every
+ * request, as only parameters are changing.
+ */
+function createEndpointUrlWithParametersBuilder(
+  initConfiguration: InitConfiguration,
+  trackType: TrackType
+): (parameters: string) => string {
+  const path = `/api/v2/${trackType}`
+  const proxy = initConfiguration.proxy
+  if (typeof proxy === 'string') {
+    const normalizedProxyUrl = normalizeUrl(proxy)
+    return (parameters) => `${normalizedProxyUrl}?ddforward=${encodeURIComponent(`${path}?${parameters}`)}`
+  }
+  if (typeof proxy === 'function') {
+    return (parameters) => proxy({ path, parameters })
+  }
+  const host = buildEndpointHost(trackType, initConfiguration)
+  return (parameters) => `https://${host}${path}?${parameters}`
+}
+
+export function buildEndpointHost(
+  trackType: TrackType,
+  initConfiguration: InitConfiguration & { usePciIntake?: boolean }
+) {
+  const { site = INTAKE_SITE_US1, internalAnalyticsSubdomain } = initConfiguration
+
+  if (trackType === 'logs' && initConfiguration.usePciIntake && site === INTAKE_SITE_US1) {
+    return PCI_INTAKE_HOST_US1
+  }
+
+  if (internalAnalyticsSubdomain && site === INTAKE_SITE_US1) {
+    return `${internalAnalyticsSubdomain}.${INTAKE_SITE_US1}`
+  }
+
+  if (site === INTAKE_SITE_FED_STAGING) {
+    return `http-intake.logs.${site}`
+  }
+
+  const domainParts = site.split('.')
+  const extension = domainParts.pop()
+  return `browser-intake-${domainParts.join('-')}.${extension!}`
+}
+
+/**
+ * Build parameters to be used for an intake request. Parameters should be re-built for each
+ * request, as they change randomly.
+ */
+function buildEndpointParameters(
+  { clientToken, internalAnalyticsSubdomain, source = 'browser' }: InitConfiguration,
+  trackType: TrackType,
+  api: ApiType,
+  { retry, encoding }: Payload,
+  extraParameters: string[] = []
+) {
+  const parameters = [
+    `ddsource=${source}`,
+    `dd-api-key=${clientToken}`,
+    `dd-evp-origin-version=${encodeURIComponent(__BUILD_ENV__SDK_VERSION__)}`,
+    'dd-evp-origin=browser',
+    `dd-request-id=${generateUUID()}`,
+  ].concat(extraParameters)
+
+  if (encoding) {
+    parameters.push(`dd-evp-encoding=${encoding}`)
+  }
+
+  if (trackType === 'rum') {
+    parameters.push(`batch_time=${timeStampNow()}`, `_dd.api=${api}`)
+
+    if (retry) {
+      parameters.push(`_dd.retry_count=${retry.count}`, `_dd.retry_after=${retry.lastFailureStatus}`)
+    }
+  }
+
+  if (internalAnalyticsSubdomain) {
+    parameters.reverse()
+  }
+
+  return parameters.join('&')
+}

package/src/domain/configuration/index.ts

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

package/src/domain/configuration/transportConfiguration.ts

@@ -0,0 +1,78 @@
+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'
+
+export interface TransportConfiguration {
+  logsEndpointBuilder: EndpointBuilder
+  rumEndpointBuilder: EndpointBuilder
+  sessionReplayEndpointBuilder: EndpointBuilder
+  profilingEndpointBuilder: EndpointBuilder
+  exposuresEndpointBuilder: EndpointBuilder
+  datacenter?: string | undefined
+  replica?: ReplicaConfiguration
+  site: Site
+  source: 'browser' | 'flutter' | 'unity'
+}
+
+export interface ReplicaConfiguration {
+  logsEndpointBuilder: EndpointBuilder
+  rumEndpointBuilder: EndpointBuilder
+}
+
+export function computeTransportConfiguration(initConfiguration: InitConfiguration): TransportConfiguration {
+  const site = initConfiguration.site || INTAKE_SITE_US1
+  const source = validateSource(initConfiguration.source)
+
+  const endpointBuilders = computeEndpointBuilders({ ...initConfiguration, site, source })
+  const replicaConfiguration = computeReplicaConfiguration({ ...initConfiguration, site, source })
+
+  return {
+    replica: replicaConfiguration,
+    site,
+    source,
+    ...endpointBuilders,
+  }
+}
+
+function validateSource(source: string | undefined) {
+  if (source === 'flutter' || source === 'unity') {
+    return source
+  }
+  return 'browser'
+}
+
+function computeEndpointBuilders(initConfiguration: InitConfiguration) {
+  return {
+    logsEndpointBuilder: createEndpointBuilder(initConfiguration, 'logs'),
+    rumEndpointBuilder: createEndpointBuilder(initConfiguration, 'rum'),
+    profilingEndpointBuilder: createEndpointBuilder(initConfiguration, 'profile'),
+    sessionReplayEndpointBuilder: createEndpointBuilder(initConfiguration, 'replay'),
+    exposuresEndpointBuilder: createEndpointBuilder(initConfiguration, 'exposures'),
+  }
+}
+
+function computeReplicaConfiguration(initConfiguration: InitConfiguration): ReplicaConfiguration | undefined {
+  if (!initConfiguration.replica) {
+    return
+  }
+
+  const replicaConfiguration: InitConfiguration = {
+    ...initConfiguration,
+    site: INTAKE_SITE_US1,
+    clientToken: initConfiguration.replica.clientToken,
+  }
+
+  return {
+    logsEndpointBuilder: createEndpointBuilder(replicaConfiguration, 'logs'),
+    rumEndpointBuilder: createEndpointBuilder(replicaConfiguration, 'rum', [
+      `application.id=${initConfiguration.replica.applicationId}`,
+    ]),
+  }
+}
+
+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

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

package/src/domain/connectivity/index.ts

@@ -0,0 +1 @@
+export * from './connectivity'

package/src/domain/console/consoleObservable.ts

@@ -0,0 +1,118 @@
+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 { jsonStringify } from '../../tools/serialisation/jsonStringify'
+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 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
+  handlingStack: string
+}
+
+type ConsoleLogForApi<T extends ConsoleApiName> = T extends typeof ConsoleApiName.error
+  ? ErrorConsoleLog
+  : NonErrorConsoleLog
+
+let consoleObservablesByApi: { [K in ConsoleApiName]?: Observable<ConsoleLogForApi<K>> } = {}
+
+export function initConsoleObservable<T extends ConsoleApiName[]>(apis: T): Observable<ConsoleLogForApi<T[number]>> {
+  const consoleObservables = apis.map((api) => {
+    if (!consoleObservablesByApi[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] as unknown as Observable<ConsoleLogForApi<T[number]>>
+  })
+
+  return mergeObservables(...consoleObservables)
+}
+
+export function resetConsoleObservable() {
+  consoleObservablesByApi = {}
+}
+
+function createConsoleObservable(api: ConsoleApiName) {
+  return new Observable<ConsoleLog>((observable) => {
+    const originalConsoleApi = globalConsole[api]
+
+    globalConsole[api] = (...params: unknown[]) => {
+      originalConsoleApi.apply(console, params)
+      const handlingStack = createHandlingStack('console error')
+
+      callMonitored(() => {
+        observable.notify(buildConsoleLog(params, api, handlingStack))
+      })
+    }
+
+    return () => {
+      globalConsole[api] = originalConsoleApi
+    }
+  })
+}
+
+function buildConsoleLog(params: unknown[], api: ConsoleApiName, handlingStack: string): ConsoleLog {
+  const message = params.map((param) => formatConsoleParameters(param)).join(' ')
+
+  if (api === ConsoleApiName.error) {
+    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,
+    error: undefined,
+    handlingStack,
+  }
+}
+
+function formatConsoleParameters(param: unknown) {
+  if (typeof param === 'string') {
+    return sanitize(param)
+  }
+  if (isError(param)) {
+    return formatErrorMessage(computeStackTrace(param))
+  }
+  return jsonStringify(sanitize(param), undefined, 2)
+}

package/src/domain/context/contextConstants.ts

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,85 @@
+import { deepClone } from '../../tools/mergeInto'
+import { sanitize } from '../../tools/serialisation/sanitize'
+import type { Context } from '../../tools/serialisation/context'
+import { Observable } from '../../tools/observable'
+import { display } from '../../tools/display'
+import { checkContext } from './contextUtils'
+
+export type ContextManager = ReturnType<typeof createContextManager>
+
+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: unknown) => {
+      if (checkContext(newContext)) {
+        context = sanitize(ensureProperties(newContext, propertiesConfig, name))
+      } else {
+        contextManager.clearContext()
+      }
+      changeObservable.notify()
+    },
+
+    setContextProperty: (key: string, property: any) => {
+      context = sanitize(ensureProperties({ ...context, [key]: property }, propertiesConfig, name))
+      changeObservable.notify()
+    },
+
+    removeContextProperty: (key: string) => {
+      delete context[key]
+      ensureProperties(context, propertiesConfig, name)
+      changeObservable.notify()
+    },
+
+    clearContext: () => {
+      context = {}
+      changeObservable.notify()
+    },
+
+    changeObservable,
+  }
+  return contextManager
+}

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

@@ -0,0 +1,55 @@
+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 = '_dd_c'
+
+const storageListeners: Array<{ stop: () => void }> = []
+
+export function storeContextManager(
+  configuration: Configuration,
+  contextManager: ContextManager,
+  productKey: string,
+  customerDataType: CustomerDataType
+) {
+  const storageKey = buildStorageKey(productKey, customerDataType)
+
+  storageListeners.push(
+    addEventListener(configuration, window, DOM_EVENT.STORAGE, ({ key }) => {
+      if (storageKey === key) {
+        synchronizeWithStorage()
+      }
+    })
+  )
+  contextManager.changeObservable.subscribe(dumpToStorage)
+
+  const contextFromStorage = combine(getFromStorage(), contextManager.getContext())
+  if (!isEmptyObject(contextFromStorage)) {
+    contextManager.setContext(contextFromStorage)
+  }
+
+  function synchronizeWithStorage() {
+    contextManager.setContext(getFromStorage())
+  }
+
+  function dumpToStorage() {
+    localStorage.setItem(storageKey, JSON.stringify(contextManager.getContext()))
+  }
+
+  function getFromStorage() {
+    const rawContext = localStorage.getItem(storageKey)
+    return rawContext ? (JSON.parse(rawContext) as Context) : {}
+  }
+}
+
+export function buildStorageKey(productKey: string, customerDataType: CustomerDataType) {
+  return `${CONTEXT_STORE_KEY_PREFIX}_${productKey}_${customerDataType}`
+}
+
+export function removeStorageListeners() {
+  storageListeners.map((listener) => listener.stop())
+}

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' },
+    },
+  })
+}

package/src/domain/contexts/globalContext.ts

@@ -0,0 +1,30 @@
+import type { AbstractHooks } from '../../tools/abstractHooks'
+import { CustomerDataType } from '../context/contextConstants'
+import { storeContextManager } from '../context/storeContextManager'
+import { HookNames } from '../../tools/abstractHooks'
+import { createContextManager } from '../context/contextManager'
+import type { Configuration } from '../configuration'
+
+export function startGlobalContext(
+  hooks: AbstractHooks,
+  configuration: Configuration,
+  productKey: string,
+  useContextNamespace: boolean
+) {
+  const globalContextManager = buildGlobalContextManager()
+
+  if (configuration.storeContextsAcrossPages) {
+    storeContextManager(configuration, globalContextManager, productKey, CustomerDataType.GlobalContext)
+  }
+
+  hooks.register(HookNames.Assemble, () => {
+    const context = globalContextManager.getContext()
+    return useContextNamespace ? { context } : context
+  })
+
+  return globalContextManager
+}
+
+export function buildGlobalContextManager() {
+  return createContextManager('global context')
+}

package/src/domain/contexts/rumInternalContext.type.ts

@@ -0,0 +1,15 @@
+import type { Context } from '../../tools/serialisation/context'
+
+export interface RumInternalContext extends Context {
+  application_id: string
+  session_id: string | undefined
+  view?: {
+    id: string
+    url: string
+    referrer: string
+    name?: string
+  }
+  user_action?: {
+    id: string | string[]
+  }
+}