@openobserve/browser-core 0.3.4 → 0.4.0-beta.2

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

@@ -0,0 +1,55 @@
+import { globalObject } from '../../../tools/globalObject'
+import { Observable } from '../../../tools/observable'
+import { shallowClone } from '../../../tools/utils/objectUtils'
+import { SessionPersistence } from '../sessionConstants'
+import type { SessionState } from '../sessionState'
+import type { SessionStateOperation, SessionStoreStrategy, SessionStoreStrategyType } from './sessionStoreStrategy'
+
+export const MEMORY_SESSION_STORE_KEY = '_DD_SESSION'
+
+export interface MemorySession {
+  state?: SessionState
+  onChange?: (state: SessionState) => void
+}
+
+export interface GlobalObjectWithSession {
+  [MEMORY_SESSION_STORE_KEY]?: MemorySession
+}
+
+export function selectMemorySessionStoreStrategy(): SessionStoreStrategyType {
+  return { type: SessionPersistence.MEMORY }
+}
+
+export function initMemorySessionStoreStrategy(): SessionStoreStrategy {
+  const globalObjectWithSession = globalObject as GlobalObjectWithSession
+
+  // Share the observable across SDK instances (RUM + Logs)
+  if (!globalObjectWithSession[MEMORY_SESSION_STORE_KEY]) {
+    globalObjectWithSession[MEMORY_SESSION_STORE_KEY] = {}
+  }
+  const memorySession = globalObjectWithSession[MEMORY_SESSION_STORE_KEY]
+
+  const sessionObservable = new Observable<SessionState>()
+
+  // Wire the local observable to the shared onChange callback so that
+  // multiple SDK instances (RUM + Logs) can observe each other's changes.
+  const previousOnChange = memorySession.onChange
+  memorySession.onChange = (state: SessionState) => {
+    previousOnChange?.(state)
+    sessionObservable.notify(state)
+  }
+
+  return {
+    async setSessionState(
+      fn: (sessionState: SessionState) => SessionState,
+      _operation: SessionStateOperation
+    ): Promise<void> {
+      const currentState = memorySession.state ?? {}
+      const newState = shallowClone(fn(currentState))
+      memorySession.state = newState
+      await Promise.resolve()
+      memorySession.onChange?.(newState)
+    },
+    sessionObservable,
+  }
+}

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

@@ -1,16 +1,38 @@
 import type { CookieOptions } from '../../../browser/cookie'
 import type { SessionPersistence } from '../sessionConstants'
 import type { SessionState } from '../sessionState'
+import type { Observable } from '../../../tools/observable'
 
-export const SESSION_STORE_KEY = '_oo_s'
+export const SESSION_STORE_KEY = '_oo_s_v2'
+export const LEGACY_SESSION_STORE_KEY = '_oo_s'
+
+export const enum CookieApi {
+  DOCUMENT_COOKIE,
+  COOKIE_STORE,
+}
+
+export interface CookieSessionStoreStrategyType {
+  type: typeof SessionPersistence.COOKIE
+  cookieOptions: CookieOptions
+  cookieApi: CookieApi
+}
 
 export type SessionStoreStrategyType =
-  | { type: typeof SessionPersistence.COOKIE; cookieOptions: CookieOptions }
+  | CookieSessionStoreStrategyType
   | { type: typeof SessionPersistence.LOCAL_STORAGE }
+  | { type: typeof SessionPersistence.MEMORY }
+
+export type SessionStateOperation =
+  | 'initialize'
+  | 'expandOrRenewOnActivity'
+  | 'expandOrRenewOnConsent'
+  | 'expandOnVisibility'
+  | 'initializeOnResume'
+  | 'expireOnTimeout'
+  | 'expire'
+  | 'updateState'
 
 export interface SessionStoreStrategy {
-  isLockEnabled: boolean
-  persistSession: (session: SessionState) => void
-  retrieveSession: () => SessionState
-  expireSession: (previousSessionState: SessionState) => void
+  setSessionState(fn: (sessionState: SessionState) => SessionState, operation: SessionStateOperation): Promise<void>
+  sessionObservable: Observable<SessionState>
 }

package/src/domain/synthetics/syntheticsWorkerValues.ts

@@ -1,14 +1,24 @@
 import { getInitCookie } from '../../browser/cookie'
 import { globalObject, isWorkerEnvironment } from '../../tools/globalObject'
+import { tryJsonParse } from '../../tools/utils/objectUtils'
 
-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'
+const cookieNamePrefix = 'openobserve-synthetics-'
+export const SYNTHETICS_TEST_ID_COOKIE_NAME = `${cookieNamePrefix}public-id`
+export const SYNTHETICS_RESULT_ID_COOKIE_NAME = `${cookieNamePrefix}result-id`
+export const SYNTHETICS_INJECTS_RUM_COOKIE_NAME = `${cookieNamePrefix}injects-rum`
+export const SYNTHETICS_CONTEXT_COOKIE_NAME = `${cookieNamePrefix}rum-context`
 
-export interface BrowserWindow extends Window {
+export interface BrowserWindow {
   _OO_SYNTHETICS_PUBLIC_ID?: unknown
   _OO_SYNTHETICS_RESULT_ID?: unknown
   _OO_SYNTHETICS_INJECTS_RUM?: unknown
+  _OO_SYNTHETICS_RUM_CONTEXT?: unknown
+}
+
+export interface SyntheticsContext {
+  test_id: string
+  result_id: string
+  [key: string]: unknown
 }
 
 export function willSyntheticsInjectRum(): boolean {
@@ -22,17 +32,38 @@ export function willSyntheticsInjectRum(): boolean {
   )
 }
 
-export function getSyntheticsTestId(): string | undefined {
-  const value = (window as BrowserWindow)._OO_SYNTHETICS_PUBLIC_ID || getInitCookie(SYNTHETICS_TEST_ID_COOKIE_NAME)
-  return typeof value === 'string' ? value : undefined
+export function getSyntheticsContext(): SyntheticsContext | undefined {
+  const raw = getRawSyntheticsContext()
+  return isValidSyntheticsContext(raw) ? raw : undefined
 }
 
-export function getSyntheticsResultId(): string | undefined {
-  const value =
-    (window as BrowserWindow)._OO_SYNTHETICS_RESULT_ID || getInitCookie(SYNTHETICS_RESULT_ID_COOKIE_NAME)
-  return typeof value === 'string' ? value : undefined
+export function isSyntheticsTest(): boolean {
+  return Boolean(getSyntheticsContext())
 }
 
-export function isSyntheticsTest(): boolean {
-  return Boolean(getSyntheticsTestId() && getSyntheticsResultId())
+function getRawSyntheticsContext(): unknown {
+  const rawGlobal = (globalObject as BrowserWindow)._OO_SYNTHETICS_RUM_CONTEXT
+  if (rawGlobal) {
+    return rawGlobal
+  }
+
+  const rawCookie = getInitCookie(SYNTHETICS_CONTEXT_COOKIE_NAME)
+  if (rawCookie) {
+    return tryJsonParse(decodeURIComponent(rawCookie))
+  }
+
+  return {
+    test_id: (window as BrowserWindow)._OO_SYNTHETICS_PUBLIC_ID || getInitCookie(SYNTHETICS_TEST_ID_COOKIE_NAME),
+    result_id:
+      (window as BrowserWindow)._OO_SYNTHETICS_RESULT_ID || getInitCookie(SYNTHETICS_RESULT_ID_COOKIE_NAME),
+  }
+}
+
+function isValidSyntheticsContext(value: unknown): value is SyntheticsContext {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    typeof (value as Record<string, unknown>).test_id === 'string' &&
+    typeof (value as Record<string, unknown>).result_id === 'string'
+  )
 }

package/src/domain/tags.ts

@@ -52,25 +52,9 @@ export function sanitizeTag(tag: string) {
 }
 
 function hasForbiddenCharacters(rawValue: string) {
-  // Unicode property escapes is not supported in all browsers, so we use a try/catch.
-  // Todo: Remove the try/catch when dropping support for Chrome 63 and Firefox 67
-  // see: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Regular_expressions/Unicode_character_class_escape#browser_compatibility
-  if (!supportUnicodePropertyEscapes()) {
-    return false
-  }
-
   // We use the Unicode property escapes to match any character that is a letter including other languages like Chinese, Japanese, etc.
   // p{Ll} matches a lowercase letter.
   // p{Lo} matches a letter that is neither uppercase nor lowercase (ex: Japanese characters).
   // See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Regular_expressions/Unicode_character_class_escape#unicode_property_escapes_vs._character_classes
   return new RegExp('[^\\p{Ll}\\p{Lo}0-9_:./-]', 'u').test(rawValue)
 }
-
-export function supportUnicodePropertyEscapes() {
-  try {
-    new RegExp('[\\p{Ll}]', 'u')
-    return true
-  } catch {
-    return false
-  }
-}

package/src/domain/telemetry/telemetry.ts

@@ -1,19 +1,22 @@
+import { clocksNow } from '@openobserve/js-core/time'
+import { getDebugMode, combine } from '@openobserve/js-core/util'
+import type { Hook } from '@openobserve/js-core/assembly'
+import type { RecursivePartial } from '@openobserve/js-core/util'
+import { DISCARDED } from '@openobserve/js-core/assembly'
 import type { Context } from '../../tools/serialisation/context'
-import { ConsoleApiName } from '../../tools/display'
 import { NO_ERROR_STACK_PRESENT_MESSAGE, isError } from '../error/error'
 import { toStackTraceString } from '../../tools/stackTrace/handlingStack'
 import { getExperimentalFeatures } from '../../tools/experimentalFeatures'
+import { createEndpointBuilder, createReplicaEndpointBuilder } from '../configuration'
 import type { Configuration } from '../configuration'
 import { buildTags } from '../tags'
-import { INTAKE_SITE_STAGING, INTAKE_SITE_US1_FED } from '../intakeSites'
+import { INTAKE_SITE_STAGING, INTAKE_SITE_US1_FED, INTAKE_SITE_US2_FED } from '../intakeSites'
 import { BufferedObservable, Observable } from '../../tools/observable'
-import { clocksNow } from '../../tools/utils/timeUtils'
-import { displayIfDebugEnabled, startMonitorErrorCollection } from '../../tools/monitor'
+import { startMonitorErrorCollection } from '../../tools/monitor'
+import { display } from '../../tools/display'
 import { sendToExtension } from '../../tools/sendToExtension'
 import { performDraw } from '../../tools/utils/numberUtils'
 import { jsonStringify } from '../../tools/serialisation/jsonStringify'
-import { combine } from '../../tools/mergeInto'
-import type { RawError } from '../error/error.types'
 import { NonErrorPrefix } from '../error/error.types'
 import type { StackTrace } from '../../tools/stackTrace/computeStackTrace'
 import { computeStackTrace } from '../../tools/stackTrace/computeStackTrace'
@@ -25,12 +28,10 @@ import {
   getEventBridge,
   createBatch,
 } from '../../transport'
-import type { Encoder } from '../../tools/encoder'
-import type { PageMayExitEvent } from '../../browser/pageMayExitObservable'
-import { DeflateEncoderStreamId } from '../deflate'
-import type { AbstractHooks, RecursivePartial } from '../../tools/abstractHooks'
-import { HookNames, DISCARDED } from '../../tools/abstractHooks'
+import { createIdentityEncoder } from '../../tools/encoder'
+import { createPageMayExitObservable } from '../../browser/pageMayExitObservable'
 import { globalObject, isWorkerEnvironment } from '../../tools/globalObject'
+import { noop } from '../../tools/utils/functionUtils'
 import type { TelemetryEvent } from './telemetryEvent.types'
 import type {
   RawTelemetryConfiguration,
@@ -45,6 +46,10 @@ declare const __BUILD_ENV__SDK_VERSION__: string
 declare const __BUILD_ENV__SDK_SETUP__: string
 
 const ALLOWED_FRAME_URLS = [
+  'https://www.datadoghq-browser-agent.com',
+  'https://www.datad0g-browser-agent.com',
+  'https://d3uc069fcn7uxw.cloudfront.net',
+  'https://d20xtzwzcl0ceb.cloudfront.net',
   'http://localhost',
   '<anonymous>',
 ]
@@ -66,11 +71,12 @@ export const enum TelemetryMetrics {
   RECORDER_INIT_METRICS_TELEMETRY_NAME = 'Recorder init metrics',
   SEGMENT_METRICS_TELEMETRY_NAME = 'Segment network request metrics',
   INITIAL_VIEW_METRICS_TELEMETRY_NAME = 'Initial view metrics',
+  SESSION_MANAGER_INIT_METRICS_TELEMETRY_NAME = 'Session manager init metrics',
 }
 
 const METRIC_SAMPLE_RATE = 1
 
-const TELEMETRY_EXCLUDED_SITES: string[] = [INTAKE_SITE_US1_FED]
+const TELEMETRY_EXCLUDED_SITES: string[] = [INTAKE_SITE_US1_FED, INTAKE_SITE_US2_FED]
 const MAX_TELEMETRY_EVENTS_PER_PAGE = 15
 
 let telemetryObservable: BufferedObservable<{ rawEvent: RawTelemetryEvent; metricName?: string }> | undefined
@@ -85,17 +91,11 @@ export function getTelemetryObservable() {
 export function startTelemetry(
   telemetryService: TelemetryService,
   configuration: Configuration,
-  hooks: AbstractHooks,
-  reportError: (error: RawError) => void,
-  pageMayExitObservable: Observable<PageMayExitEvent>,
-  createEncoder: (streamId: DeflateEncoderStreamId) => Encoder
+  hook: Hook<any, any>
 ): Telemetry {
   const observable = new Observable<TelemetryEvent & Context>()
-
-  const { stop } = startTelemetryTransport(configuration, reportError, pageMayExitObservable, createEncoder, observable)
-
-  const { enabled, metricsEnabled } = startTelemetryCollection(telemetryService, configuration, hooks, observable)
-
+  const { enabled, metricsEnabled } = startTelemetryCollection(telemetryService, configuration, hook, observable)
+  const { stop } = startTelemetryTransport(configuration, observable)
   return {
     stop,
     enabled,
@@ -106,7 +106,7 @@ export function startTelemetry(
 export function startTelemetryCollection(
   telemetryService: TelemetryService,
   configuration: Configuration,
-  hooks: AbstractHooks,
+  hook: Hook<any, any>,
   observable: Observable<TelemetryEvent & Context>,
   metricSampleRate = METRIC_SAMPLE_RATE,
   maxTelemetryEventsPerPage = MAX_TELEMETRY_EVENTS_PER_PAGE
@@ -146,7 +146,7 @@ export function startTelemetryCollection(
       return
     }
 
-    const defaultTelemetryEventAttributes = hooks.triggerHook(HookNames.AssembleTelemetry, {
+    const defaultTelemetryEventAttributes = hook.trigger({
       startTime: clocksNow().relative,
     })
 
@@ -202,11 +202,8 @@ export function startTelemetryCollection(
   }
 }
 
-function startTelemetryTransport(
+export function startTelemetryTransport(
   configuration: Configuration,
-  reportError: (error: RawError) => void,
-  pageMayExitObservable: Observable<PageMayExitEvent>,
-  createEncoder: (streamId: DeflateEncoderStreamId) => Encoder,
   telemetryObservable: Observable<TelemetryEvent & Context>
 ) {
   const cleanupTasks: Array<() => void> = []
@@ -215,15 +212,20 @@ function startTelemetryTransport(
     const telemetrySubscription = telemetryObservable.subscribe((event) => bridge.send('internal_telemetry', event))
     cleanupTasks.push(telemetrySubscription.unsubscribe)
   } else {
-    const endpoints = [configuration.rumEndpointBuilder]
-    if (configuration.replica && isTelemetryReplicationAllowed(configuration)) {
-      endpoints.push(configuration.replica.rumEndpointBuilder)
+    const endpoints = [createEndpointBuilder(configuration, 'rum')]
+    const replicaEndpoint = createReplicaEndpointBuilder(configuration, 'rum')
+    if (replicaEndpoint && isTelemetryReplicationAllowed(configuration)) {
+      endpoints.push(replicaEndpoint)
     }
     const telemetryBatch = createBatch({
-      encoder: createEncoder(DeflateEncoderStreamId.TELEMETRY),
-      request: createHttpRequest(endpoints, reportError),
+      encoder: createIdentityEncoder(),
+      request: createHttpRequest(
+        endpoints,
+        // Ignore transport errors for telemetry
+        noop
+      ),
       flushController: createFlushController({
-        pageMayExitObservable,
+        pageMayExitObservable: createPageMayExitObservable(),
 
         // We don't use an actual session expire observable here, to make telemetry collection
         // independent of the session. This allows to start and send telemetry events earlier.
@@ -260,7 +262,9 @@ function isTelemetryReplicationAllowed(configuration: Configuration) {
 }
 
 export function addTelemetryDebug(message: string, context?: Context) {
-  displayIfDebugEnabled(ConsoleApiName.debug, message, context)
+  if (getDebugMode()) {
+    display.debug('[Telemetry]', message, context)
+  }
   getTelemetryObservable().notify({
     rawEvent: {
       type: TelemetryType.LOG,

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

@@ -1,4 +1,3 @@
-/* eslint-disable */
 /**
  * DO NOT MODIFY IT BY HAND. Run `yarn json-schemas:sync` instead.
  */
@@ -188,7 +187,7 @@ export type TelemetryConfigurationEvent = CommonTelemetryProperties & {
       /**
        * Configure the storage strategy for persisting sessions
        */
-      session_persistence?: 'local-storage' | 'cookie'
+      session_persistence?: 'local-storage' | 'cookie' | 'memory'
       /**
        * Whether contexts are stored in local storage
        */
@@ -224,7 +223,7 @@ export type TelemetryConfigurationEvent = CommonTelemetryProperties & {
       /**
        * A list of selected tracing propagators
        */
-      selected_tracing_propagators?: ('openobserve' | 'tracecontext' | 'b3' | 'b3multi')[]
+      selected_tracing_propagators?: ('datadog' | 'openobserve' | 'b3' | 'b3multi' | 'tracecontext')[]
       /**
        * Session replay default privacy level
        */
@@ -297,10 +296,10 @@ export type TelemetryConfigurationEvent = CommonTelemetryProperties & {
        * View tracking strategy
        */
       view_tracking_strategy?:
-      | 'ActivityViewTrackingStrategy'
-      | 'FragmentViewTrackingStrategy'
-      | 'MixedViewTrackingStrategy'
-      | 'NavigationViewTrackingStrategy'
+        | 'ActivityViewTrackingStrategy'
+        | 'FragmentViewTrackingStrategy'
+        | 'MixedViewTrackingStrategy'
+        | 'NavigationViewTrackingStrategy'
       /**
        * Whether SwiftUI view instrumentation is enabled
        */
@@ -389,6 +388,10 @@ export type TelemetryConfigurationEvent = CommonTelemetryProperties & {
        * The version of Unity used in a Unity application
        */
       unity_version?: string
+      /**
+       * The version of MAUI used in a .NET MAUI application
+       */
+      maui_version?: string
       /**
        * The threshold used for iOS App Hangs monitoring (in milliseconds)
        */
@@ -448,7 +451,7 @@ export type TelemetryConfigurationEvent = CommonTelemetryProperties & {
        */
       sdk_version?: string
       /**
-       * The source of the SDK, e.g., 'browser', 'ios', 'android', 'flutter', 'react-native', 'unity', 'kotlin-multiplatform'.
+       * The source of the SDK, e.g., 'browser', 'ios', 'android', 'flutter', 'react-native', 'unity', 'kotlin-multiplatform', 'maui'.
        */
       source?: string
       /**
@@ -471,6 +474,10 @@ export type TelemetryConfigurationEvent = CommonTelemetryProperties & {
        * Whether trace baggage is propagated to child spans
        */
       propagate_trace_baggage?: boolean
+      /**
+       * How the SDK tracks resource request/response headers
+       */
+      track_resource_headers?: 'default_headers' | 'custom'
       /**
        * Whether the beta encode cookie options is enabled
        */
@@ -528,6 +535,8 @@ export type TelemetryCommonFeaturesUsage =
   | ClearAccount
   | AddFeatureFlagEvaluation
   | AddOperationStepVital
+  | GraphQLRequest
+  | AddViewLoadingTime
 /**
  * Schema of browser specific features usage
  */
@@ -536,10 +545,15 @@ export type TelemetryBrowserFeaturesUsage =
   | StartDurationVital
   | StopDurationVital
   | AddDurationVital
+  | StartAction
+  | StopAction
+  | StartResource
+  | StopResource
+  | SourceCodeContext
 /**
  * Schema of mobile specific features usage
  */
-export type TelemetryMobileFeaturesUsage = AddViewLoadingTime
+export type TelemetryMobileFeaturesUsage = TrackWebView | AndroidNetworkInstrumentation
 
 /**
  * Schema of common properties of Telemetry events
@@ -570,7 +584,17 @@ export interface CommonTelemetryProperties {
   /**
    * The source of this event
    */
-  readonly source: 'android' | 'ios' | 'browser' | 'flutter' | 'react-native' | 'unity' | 'kotlin-multiplatform'
+  readonly source:
+    | 'android'
+    | 'ios'
+    | 'browser'
+    | 'flutter'
+    | 'react-native'
+    | 'unity'
+    | 'kotlin-multiplatform'
+    | 'electron'
+    | 'rum-cpp'
+    | 'maui'
   /**
    * The version of the SDK generating the telemetry event
    */
@@ -612,7 +636,7 @@ export interface CommonTelemetryProperties {
     /**
      * UUID of the action
      */
-    id: string
+    readonly id: string | string[]
     [k: string]: unknown
   }
   /**
@@ -640,6 +664,18 @@ export interface CommonTelemetryProperties {
        * Model of the device
        */
       model?: string
+      /**
+       * Number of logical CPU cores available for scheduling on the device at runtime, as reported by the operating system.
+       */
+      readonly logical_cpu_count?: number
+      /**
+       * Total RAM in megabytes
+       */
+      readonly total_ram?: number
+      /**
+       * Whether the device is considered a low RAM device (Android)
+       */
+      readonly is_low_ram?: boolean
       [k: string]: unknown
     }
     /**
@@ -854,6 +890,32 @@ export interface AddOperationStepVital {
   action_type: 'start' | 'succeed' | 'fail'
   [k: string]: unknown
 }
+export interface GraphQLRequest {
+  /**
+   * GraphQL request detected
+   */
+  feature: 'graphql-request'
+  [k: string]: unknown
+}
+export interface AddViewLoadingTime {
+  /**
+   * addViewLoadingTime API
+   */
+  feature: 'addViewLoadingTime'
+  /**
+   * Whether the view is not available
+   */
+  no_view?: boolean
+  /**
+   * Whether the available view is not active
+   */
+  no_active_view?: boolean
+  /**
+   * Whether this call overwrote a previously set loading time
+   */
+  overwritten?: boolean
+  [k: string]: unknown
+}
 export interface StartSessionReplayRecording {
   /**
    * startSessionReplayRecording API
@@ -886,22 +948,56 @@ export interface AddDurationVital {
   feature: 'add-duration-vital'
   [k: string]: unknown
 }
-export interface AddViewLoadingTime {
+export interface StartAction {
   /**
-   * addViewLoadingTime API
+   * startAction API
    */
-  feature: 'addViewLoadingTime'
+  feature: 'start-action'
+  [k: string]: unknown
+}
+export interface StopAction {
   /**
-   * Whether the view is not available
+   * stopAction API
    */
-  no_view: boolean
+  feature: 'stop-action'
+  [k: string]: unknown
+}
+export interface StartResource {
   /**
-   * Whether the available view is not active
+   * startResource API
+   */
+  feature: 'start-resource'
+  [k: string]: unknown
+}
+export interface StopResource {
+  /**
+   * stopResource API
+   */
+  feature: 'stop-resource'
+  [k: string]: unknown
+}
+export interface SourceCodeContext {
+  /**
+   * DD_SOURCE_CODE_CONTEXT global for microfrontends
+   */
+  feature: 'source-code-context'
+  [k: string]: unknown
+}
+export interface TrackWebView {
+  /**
+   * trackWebView API
+   */
+  feature: 'trackWebView'
+  [k: string]: unknown
+}
+export interface AndroidNetworkInstrumentation {
+  /**
+   * Android network instrumentation
    */
-  no_active_view: boolean
+  feature: 'androidNetworkInstrumentation'
   /**
-   * Whether the loading time was overwritten
+   * The network instrumentation API used
    */
-  overwritten: boolean
+  type: 'CRONET' | 'OKHTTP' | 'LEGACY_OKHTTP'
   [k: string]: unknown
 }

package/src/domain/trackingConsent.ts

@@ -11,24 +11,39 @@ export interface TrackingConsentState {
   update: (trackingConsent: TrackingConsent) => void
   isGranted: () => boolean
   observable: Observable<void>
+  onGrantedOnce: (callback: () => void) => void
 }
 
 export function createTrackingConsentState(currentConsent?: TrackingConsent): TrackingConsentState {
   const observable = new Observable<void>()
 
+  function isGranted() {
+    return currentConsent === TrackingConsent.GRANTED
+  }
+
   return {
     tryToInit(trackingConsent: TrackingConsent) {
       if (!currentConsent) {
         currentConsent = trackingConsent
       }
     },
+    onGrantedOnce(fn) {
+      if (isGranted()) {
+        fn()
+      } else {
+        const subscription = observable.subscribe(() => {
+          if (isGranted()) {
+            fn()
+            subscription.unsubscribe()
+          }
+        })
+      }
+    },
     update(trackingConsent: TrackingConsent) {
       currentConsent = trackingConsent
       observable.notify()
     },
-    isGranted() {
-      return currentConsent === TrackingConsent.GRANTED
-    },
+    isGranted,
     observable,
   }
 }