@kubesense/kubesense-browser-logs 0.0.0-stage → 2.0.0-beta.1

package/esm/transport/startLogsBatch.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"startLogsBatch.mjs","names":[],"sources":["../../src/transport/startLogsBatch.ts"],"sourcesContent":["import type { Context, SessionManager } from '@kubesense/kubesense-browser-core'\nimport { createBatch } from '@kubesense/kubesense-browser-core'\nimport { createEndpointBuilder, createReplicaEndpointBuilder } from '@kubesense/kubesense-js-core/transport'\nimport type { LogsConfiguration } from '../domain/configuration'\nimport type { LifeCycle } from '../domain/lifeCycle'\nimport { LifeCycleEventType } from '../domain/lifeCycle'\nimport type { LogsEvent } from '../logsEvent.types'\n\nexport function startLogsBatch(\n  configuration: LogsConfiguration,\n  lifeCycle: LifeCycle,\n  reportError: (message: string) => void,\n  sessionManager: SessionManager\n) {\n  const endpoints = [createEndpointBuilder(configuration, 'logs')]\n  const replicaEndpoint = createReplicaEndpointBuilder(configuration, 'logs')\n  if (replicaEndpoint) {\n    endpoints.push(replicaEndpoint)\n  }\n\n  const batch = createBatch({ endpoints, reportError })\n  sessionManager.expireObservable.subscribe(() => batch.forceFlush('session_expire'))\n\n  lifeCycle.subscribe(LifeCycleEventType.LOG_COLLECTED, (serverLogsEvent: LogsEvent & Context) => {\n    batch.add(serverLogsEvent)\n  })\n\n  return batch\n}\n"],"mappings":";;;;AAQA,SAAgB,eACd,eACA,WACA,aACA,gBACA;CACA,MAAM,YAAY,CAAC,sBAAsB,eAAe,MAAM,CAAC;CAC/D,MAAM,kBAAkB,6BAA6B,eAAe,MAAM;CAC1E,IAAI,iBACF,UAAU,KAAK,eAAe;CAGhC,MAAM,QAAQ,YAAY;EAAE;EAAW;CAAY,CAAC;CACpD,eAAe,iBAAiB,gBAAgB,MAAM,WAAW,gBAAgB,CAAC;CAElF,UAAU,UAAA,IAA6C,oBAAyC;EAC9F,MAAM,IAAI,eAAe;CAC3B,CAAC;CAED,OAAO;AACT"}

package/esm/transport/startLogsBridge.mjs

@@ -0,0 +1,13 @@
+import "../domain/lifeCycle.mjs";
+import { getEventBridge } from "@kubesense/kubesense-browser-core";
+//#region src/transport/startLogsBridge.ts
+function startLogsBridge(lifeCycle) {
+	const bridge = getEventBridge();
+	lifeCycle.subscribe(1, (serverLogsEvent) => {
+		bridge.send("log", serverLogsEvent);
+	});
+}
+//#endregion
+export { startLogsBridge };
+
+//# sourceMappingURL=startLogsBridge.mjs.map

package/esm/transport/startLogsBridge.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"startLogsBridge.mjs","names":[],"sources":["../../src/transport/startLogsBridge.ts"],"sourcesContent":["import type { Context } from '@kubesense/kubesense-browser-core'\nimport { getEventBridge } from '@kubesense/kubesense-browser-core'\nimport type { LifeCycle } from '../domain/lifeCycle'\nimport { LifeCycleEventType } from '../domain/lifeCycle'\nimport type { LogsEvent } from '../logsEvent.types'\n\nexport function startLogsBridge(lifeCycle: LifeCycle) {\n  const bridge = getEventBridge<'log', LogsEvent>()!\n\n  lifeCycle.subscribe(LifeCycleEventType.LOG_COLLECTED, (serverLogsEvent: LogsEvent & Context) => {\n    bridge.send('log', serverLogsEvent)\n  })\n}\n"],"mappings":";;;AAMA,SAAgB,gBAAgB,WAAsB;CACpD,MAAM,SAAS,eAAiC;CAEhD,UAAU,UAAA,IAA6C,oBAAyC;EAC9F,OAAO,KAAK,OAAO,eAAe;CACpC,CAAC;AACH"}

package/package.json

@@ -1,6 +1,56 @@
 {
   "name": "@kubesense/kubesense-browser-logs",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "2.0.0-beta.1",
+  "keywords": [
+    "kubesense",
+    "browser",
+    "logs",
+    "logging",
+    "log-collection",
+    "monitoring",
+    "observability",
+    "error-tracking",
+    "telemetry"
+  ],
+  "description": "Kubesense Browser Logs SDK — collect and forward browser logs and errors to Kubesense.",
+  "license": "Apache-2.0",
+  "main": "cjs/entries/main.js",
+  "module": "esm/entries/main.mjs",
+  "types": "cjs/entries/main.d.ts",
+  "files": [
+    "bundle/**/*.js",
+    "cjs",
+    "esm",
+    "src",
+    "!src/**/*.spec.ts",
+    "!src/**/*.specHelper.ts"
+  ],
+  "scripts": {
+    "build": "node ../../scripts/build/build-package.ts --modules --bundle kubesense-logs.js",
+    "build:bundle": "node ../../scripts/build/build-package.ts --bundle kubesense-logs.js",
+    "prepack": "yarn build"
+  },
+  "dependencies": {
+    "@kubesense/kubesense-browser-core": "2.0.0-beta.1",
+    "@kubesense/kubesense-js-core": "2.0.0-beta.1"
+  },
+  "peerDependencies": {
+    "@kubesense/kubesense-browser-rum": "2.0.0-beta.1"
+  },
+  "peerDependenciesMeta": {
+    "@kubesense/kubesense-browser-rum": {
+      "optional": true
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kubesense-ai/kubesense-browser-sdk.git",
+    "directory": "packages/logs"
+  },
+  "volta": {
+    "extends": "../../package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
 }

package/src/boot/logsPublicApi.ts

@@ -0,0 +1,427 @@
+import type {
+  TrackingConsent,
+  PublicApi,
+  ContextManager,
+  Account,
+  Context,
+  User,
+} from '@kubesense/kubesense-browser-core'
+import {
+  ContextManagerMethod,
+  CustomerContextKey,
+  addTelemetryUsage,
+  makePublicApi,
+  sanitize,
+  displayAlreadyInitializedError,
+  createTrackingConsentState,
+  defineContextMethod,
+  startBufferingData,
+  mockable,
+} from '@kubesense/kubesense-browser-core'
+import { monitor, callMonitored } from '@kubesense/kubesense-js-core/monitor'
+import { deepClone } from '@kubesense/kubesense-js-core/util'
+import type { LogsInitConfiguration } from '../domain/configuration'
+import type { HandlerType } from '../domain/logger'
+import type { StatusType } from '../domain/logger/isAuthorized'
+import { Logger } from '../domain/logger'
+import { buildCommonContext } from '../domain/contexts/commonContext'
+import { callPluginsMethod } from '../domain/plugins'
+import type { InternalContext } from '../domain/contexts/internalContext'
+import type { StartLogsResult } from './startLogs'
+import { startLogs } from './startLogs'
+import { createPreStartStrategy } from './preStartLogs'
+
+export interface LoggerConfiguration {
+  level?: StatusType
+  handler?: HandlerType | HandlerType[]
+  context?: object
+}
+
+/**
+ * Public API for the Logs browser SDK.
+ *
+ * See [Browser Log Collection](https://docs.kubesense.ai/logs/log_collection/javascript) for further information.
+ *
+ * @category Main
+ */
+export interface LogsPublicApi extends PublicApi {
+  /**
+   * The default logger
+   *
+   * @category Logger
+   */
+  logger: Logger
+
+  /**
+   * Init the Logs browser SDK.
+   *
+   * See [Browser Log Collection](https://docs.kubesense.ai/logs/log_collection/javascript) for further information.
+   *
+   * @category Init
+   * @param initConfiguration - Configuration options of the SDK
+   */
+  init: (initConfiguration: LogsInitConfiguration) => void
+
+  /**
+   * Set the tracking consent of the current user.
+   *
+   * Logs will be sent only if it is set to "granted". This value won't be stored by the library
+   * across page loads: you will need to call this method or set the appropriate `trackingConsent`
+   * field in the init() method at each page load.
+   *
+   * If this method is called before the init() method, the provided value will take precedence
+   * over the one provided as initialization parameter.
+   *
+   * See [User tracking consent](https://docs.kubesense.ai/logs/log_collection/javascript/#user-tracking-consent) for further information.
+   *
+   * @category Privacy
+   * @param trackingConsent - The user tracking consent
+   */
+  setTrackingConsent: (trackingConsent: TrackingConsent) => void
+
+  /**
+   * Set the global context information to all events, stored in `@context`
+   * See [Global context](https://docs.kubesense.ai/logs/log_collection/javascript/#overwrite-context) for further information.
+   *
+   * @category Context - Global Context
+   * @param context - Global context
+   */
+  setGlobalContext: (context: any) => void
+
+  /**
+   * Get the global Context
+   *
+   * See [Global context](https://docs.kubesense.ai/logs/log_collection/javascript/#overwrite-context) for further information.
+   *
+   * @category Context - Global Context
+   */
+  getGlobalContext: () => Context
+
+  /**
+   * Set or update a global context property, stored in `@context.<key>`
+   *
+   * See [Global context](https://docs.kubesense.ai/logs/log_collection/javascript/#overwrite-context) for further information.
+   *
+   * @category Context - Global Context
+   * @param key - Key of the property
+   * @param value - Value of the property
+   */
+  setGlobalContextProperty: (key: any, value: any) => void
+
+  /**
+   * Remove a global context property
+   *
+   * See [Global context](https://docs.kubesense.ai/logs/log_collection/javascript/#overwrite-context) for further information.
+   *
+   * @category Context - Global Context
+   */
+  removeGlobalContextProperty: (key: any) => void
+
+  /**
+   * Clear the global context
+   *
+   * See [Global context](https://docs.kubesense.ai/logs/log_collection/javascript/#overwrite-context) for further information.
+   *
+   * @category Context - Global Context
+   */
+  clearGlobalContext: () => void
+
+  /**
+   * Set user information to all events, stored in `@usr`
+   *
+   * See [User session](https://docs.kubesense.ai/logs/log_collection/javascript/#user-context) for further information.
+   *
+   * @category Context - User
+   * @param newUser - User information
+   */
+  setUser(newUser: User & { id: string }): void
+
+  /**
+   * Set user information to all events, stored in `@usr`
+   *
+   * @category Context - User
+   * @deprecated You must specify a user id, favor using {@link setUser} instead
+   * @param newUser - User information with optional id
+   */
+  setUser(newUser: User): void
+
+  /**
+   * Get user information
+   *
+   * See [User session](https://docs.kubesense.ai/logs/log_collection/javascript/#user-context) for further information.
+   *
+   * @category Context - User
+   * @returns User information
+   */
+  getUser: () => Context
+
+  /**
+   * Set or update the user property, stored in `@usr.<key>`
+   *
+   * See [User session](https://docs.kubesense.ai/logs/log_collection/javascript/#user-context) for further information.
+   *
+   * @category Context - User
+   * @param key - Key of the property
+   * @param property - Value of the property
+   */
+  setUserProperty: (key: any, property: any) => void
+
+  /**
+   * Remove a user property
+   *
+   * @category Context - User
+   * @param key - Key of the property to remove
+   * @see [User session](https://docs.kubesense.ai/logs/log_collection/javascript/#user-context) for further information.
+   */
+  removeUserProperty: (key: any) => void
+
+  /**
+   * Clear all user information
+   *
+   * See [User session](https://docs.kubesense.ai/logs/log_collection/javascript/#user-context) for further information.
+   *
+   * @category Context - User
+   */
+  clearUser: () => void
+
+  /**
+   * Set account information to all events, stored in `@account`
+   *
+   * @category Context - Account
+   * @param newAccount - Account information
+   */
+  setAccount: (newAccount: Account) => void
+
+  /**
+   * Get account information
+   *
+   * @category Context - Account
+   * @returns Account information
+   */
+  getAccount: () => Context
+
+  /**
+   * Set or update the account property, stored in `@account.<key>`
+   *
+   * @category Context - Account
+   * @param key - Key of the property
+   * @param property - Value of the property
+   */
+  setAccountProperty: (key: string, property: any) => void
+
+  /**
+   * Remove an account property
+   *
+   * @category Context - Account
+   * @param key - Key of the property to remove
+   */
+  removeAccountProperty: (key: string) => void
+
+  /**
+   * Clear all account information
+   *
+   * @category Context - Account
+   * @returns Clear all account information
+   */
+  clearAccount: () => void
+
+  /**
+   * The KubeSense browser logs SDK contains a default logger `KUBESENSE_LOGS.logger`, but this API allows to create different ones.
+   *
+   * See [Define multiple loggers](https://docs.kubesense.ai/logs/log_collection/javascript/#define-multiple-loggers) for further information.
+   *
+   * @category Logger
+   * @param name - Name of the logger
+   * @param conf - Configuration of the logger (level, handler, context)
+   */
+  createLogger: (name: string, conf?: LoggerConfiguration) => Logger
+
+  /**
+   * Get a logger
+   *
+   * See [Define multiple loggers](https://docs.kubesense.ai/logs/log_collection/javascript/#define-multiple-loggers) for further information.
+   *
+   * @category Logger
+   * @param name - Name of the logger
+   */
+  getLogger: (name: string) => Logger | undefined
+
+  /**
+   * Get the init configuration
+   *
+   * @category Init
+   * @returns The init configuration
+   */
+  getInitConfiguration: () => LogsInitConfiguration | undefined
+
+  /**
+   * [Internal API] Get the internal SDK context
+   *
+   * See [Access internal context](https://docs.kubesense.ai/logs/log_collection/javascript/#access-internal-context) for further information.
+   *
+   * @internal
+   */
+  getInternalContext: (startTime?: number) => InternalContext | undefined
+}
+
+export interface Strategy {
+  init: (initConfiguration: LogsInitConfiguration, publicApi: LogsPublicApi, errorStack?: string) => void
+  initConfiguration: LogsInitConfiguration | undefined
+  globalContext: ContextManager
+  accountContext: ContextManager
+  userContext: ContextManager
+  getInternalContext: StartLogsResult['getInternalContext']
+  handleLog: StartLogsResult['handleLog']
+}
+
+export interface LogsPublicApiOptions {
+  sdkName?: string
+}
+
+export function makeLogsPublicApi(options: LogsPublicApiOptions = {}): LogsPublicApi {
+  const trackingConsentState = createTrackingConsentState()
+  const bufferedDataObservable = startBufferingData().observable
+
+  let strategy = createPreStartStrategy(
+    buildCommonContext,
+    trackingConsentState,
+    (configuration, logsSessionManager, hooks) => {
+      const startLogsResult = mockable(startLogs)(
+        configuration,
+        logsSessionManager,
+        buildCommonContext,
+        bufferedDataObservable,
+        hooks
+      )
+
+      strategy = createPostStartStrategy(strategy, startLogsResult)
+      callPluginsMethod(configuration.plugins, 'onLogsStart', {
+        handleLog: startLogsResult.handleLog,
+      })
+      return startLogsResult
+    },
+    options.sdkName
+  )
+
+  const getStrategy = () => strategy
+
+  const customLoggers: { [name: string]: Logger | undefined } = {}
+
+  const mainLogger = new Logger((...params) => strategy.handleLog(...params))
+
+  const logsPublicApi: LogsPublicApi = makePublicApi<LogsPublicApi>({
+    logger: mainLogger,
+
+    init: (initConfiguration) => {
+      const errorStack = new Error().stack
+      callMonitored(() => strategy.init(initConfiguration, logsPublicApi, errorStack))
+    },
+
+    setTrackingConsent: monitor((trackingConsent) => {
+      trackingConsentState.update(trackingConsent)
+      addTelemetryUsage({ feature: 'set-tracking-consent', tracking_consent: trackingConsent })
+    }),
+
+    getGlobalContext: defineContextMethod(
+      getStrategy,
+      CustomerContextKey.globalContext,
+      ContextManagerMethod.getContext
+    ),
+    setGlobalContext: defineContextMethod(
+      getStrategy,
+      CustomerContextKey.globalContext,
+      ContextManagerMethod.setContext
+    ),
+
+    setGlobalContextProperty: defineContextMethod(
+      getStrategy,
+      CustomerContextKey.globalContext,
+      ContextManagerMethod.setContextProperty
+    ),
+
+    removeGlobalContextProperty: defineContextMethod(
+      getStrategy,
+      CustomerContextKey.globalContext,
+      ContextManagerMethod.removeContextProperty
+    ),
+
+    clearGlobalContext: defineContextMethod(
+      getStrategy,
+      CustomerContextKey.globalContext,
+      ContextManagerMethod.clearContext
+    ),
+
+    createLogger: monitor((name, conf = {}) => {
+      customLoggers[name] = new Logger(
+        (...params) => strategy.handleLog(...params),
+        sanitize(name),
+        conf.handler,
+        conf.level,
+        sanitize(conf.context) as object
+      )
+
+      return customLoggers[name]
+    }),
+
+    getLogger: monitor((name) => customLoggers[name]),
+
+    getInitConfiguration: monitor(() => deepClone(strategy.initConfiguration)),
+
+    getInternalContext: monitor((startTime) => strategy.getInternalContext(startTime)),
+
+    setUser: defineContextMethod(getStrategy, CustomerContextKey.userContext, ContextManagerMethod.setContext),
+
+    getUser: defineContextMethod(getStrategy, CustomerContextKey.userContext, ContextManagerMethod.getContext),
+
+    setUserProperty: defineContextMethod(
+      getStrategy,
+      CustomerContextKey.userContext,
+      ContextManagerMethod.setContextProperty
+    ),
+
+    removeUserProperty: defineContextMethod(
+      getStrategy,
+      CustomerContextKey.userContext,
+      ContextManagerMethod.removeContextProperty
+    ),
+
+    clearUser: defineContextMethod(getStrategy, CustomerContextKey.userContext, ContextManagerMethod.clearContext),
+
+    setAccount: defineContextMethod(getStrategy, CustomerContextKey.accountContext, ContextManagerMethod.setContext),
+
+    getAccount: defineContextMethod(getStrategy, CustomerContextKey.accountContext, ContextManagerMethod.getContext),
+
+    setAccountProperty: defineContextMethod(
+      getStrategy,
+      CustomerContextKey.accountContext,
+      ContextManagerMethod.setContextProperty
+    ),
+
+    removeAccountProperty: defineContextMethod(
+      getStrategy,
+      CustomerContextKey.accountContext,
+      ContextManagerMethod.removeContextProperty
+    ),
+
+    clearAccount: defineContextMethod(
+      getStrategy,
+      CustomerContextKey.accountContext,
+      ContextManagerMethod.clearContext
+    ),
+  })
+
+  return logsPublicApi
+}
+
+function createPostStartStrategy(preStartStrategy: Strategy, startLogsResult: StartLogsResult): Strategy {
+  return {
+    ...preStartStrategy,
+    init: (initConfiguration: LogsInitConfiguration) => {
+      displayAlreadyInitializedError('KUBESENSE_LOGS', initConfiguration)
+    },
+    getInternalContext: startLogsResult.getInternalContext,
+    globalContext: startLogsResult.globalContext,
+    userContext: startLogsResult.userContext,
+    accountContext: startLogsResult.accountContext,
+  }
+}

package/src/boot/preStartLogs.ts

@@ -0,0 +1,192 @@
+import { timeStampNow } from '@kubesense/kubesense-js-core/time'
+import { monitorError } from '@kubesense/kubesense-js-core/monitor'
+import type { TrackingConsentState, SessionManager } from '@kubesense/kubesense-browser-core'
+import {
+  BufferedObservable,
+  canUseEventBridge,
+  display,
+  displayAlreadyInitializedError,
+  initFeatureFlags,
+  noop,
+  buildAccountContextManager,
+  CustomerContextKey,
+  bufferContextCalls,
+  addTelemetryConfiguration,
+  addTelemetryDebug,
+  buildGlobalContextManager,
+  buildUserContextManager,
+  startSessionManager,
+  startSessionManagerStub,
+  startTelemetry,
+  TelemetryService,
+  mockable,
+  startTelemetrySessionContext,
+  setAllowUntrustedEvents,
+  isAllowedTrackingOrigins,
+} from '@kubesense/kubesense-browser-core'
+import type { Hooks } from '../domain/hooks'
+import { createHooks } from '../domain/hooks'
+import type { LogsConfiguration, LogsInitConfiguration } from '../domain/configuration'
+import { serializeLogsConfiguration, validateAndBuildLogsConfiguration } from '../domain/configuration'
+import { applyCachedLogsSdkConfiguration, scheduleLogsSdkConfigurationRefresh } from '../domain/remoteSdkConfiguration'
+import type { CommonContext } from '../rawLogsEvent.types'
+import { startTrackingConsentContext } from '../domain/contexts/trackingConsentContext'
+import { callPluginsMethod } from '../domain/plugins'
+import type { Strategy } from './logsPublicApi'
+import type { StartLogsResult } from './startLogs'
+
+export type DoStartLogs = (
+  configuration: LogsConfiguration,
+  sessionManager: SessionManager,
+  hooks: Hooks
+) => StartLogsResult
+
+export function createPreStartStrategy(
+  getCommonContext: () => CommonContext,
+  trackingConsentState: TrackingConsentState,
+  doStartLogs: DoStartLogs,
+  sdkName?: string
+): Strategy {
+  const BUFFER_LIMIT = 500
+  const bufferApiCalls = new BufferedObservable<(startLogsResult: StartLogsResult) => void>(BUFFER_LIMIT, (count) => {
+    // monitor-until: 2026-10-14
+    addTelemetryDebug('preStartLogs buffer data lost', { count })
+  })
+
+  // TODO next major: remove the globalContext, accountContextManager, userContext from preStartStrategy and use an empty context instead
+  const globalContext = buildGlobalContextManager()
+  bufferContextCalls(globalContext, CustomerContextKey.globalContext, bufferApiCalls)
+
+  const accountContext = buildAccountContextManager()
+  bufferContextCalls(accountContext, CustomerContextKey.accountContext, bufferApiCalls)
+
+  const userContext = buildUserContextManager()
+  bufferContextCalls(userContext, CustomerContextKey.userContext, bufferApiCalls)
+
+  let cachedInitConfiguration: LogsInitConfiguration | undefined
+  let cachedConfiguration: LogsConfiguration | undefined
+  let sessionManager: SessionManager | undefined
+  const hooks = createHooks()
+  const trackingConsentStateSubscription = trackingConsentState.observable.subscribe(tryStartLogs)
+
+  function tryStartLogs() {
+    if (!cachedConfiguration || !cachedInitConfiguration || !sessionManager) {
+      return
+    }
+
+    trackingConsentStateSubscription.unsubscribe()
+    const startLogsResult = doStartLogs(cachedConfiguration, sessionManager, hooks)
+
+    bufferApiCalls.subscribe((callback) => callback(startLogsResult))
+    bufferApiCalls.unbuffer()
+  }
+
+  return {
+    init(initConfiguration, publicApi, errorStack) {
+      if (!initConfiguration) {
+        display.error('Missing configuration')
+        return
+      }
+      // Set the experimental feature flags as early as possible, so we can use them in most places
+      initFeatureFlags(initConfiguration.enableExperimentalFeatures)
+      setAllowUntrustedEvents(initConfiguration.allowUntrustedEvents)
+
+      if (canUseEventBridge()) {
+        initConfiguration = overrideInitConfigurationForBridge(initConfiguration)
+      }
+
+      const remoteSdkConfigurationEnabled = !!initConfiguration.enableRemoteSdkConfiguration
+
+      // A cached document that stops Logs from starting must never be a one-way door: without a
+      // refresh on those paths the browser replays the same bad document on every load and can
+      // never learn about a corrected one.
+      const refreshRemoteSdkConfiguration = () => {
+        if (remoteSdkConfigurationEnabled) {
+          scheduleLogsSdkConfigurationRefresh(initConfiguration).catch(noop)
+        }
+      }
+
+      if (remoteSdkConfigurationEnabled) {
+        // Reading the cached document is synchronous and network-free, so it does not delay
+        // initialization. The document fetched below only applies from the next page load.
+        const cachedSdkConfiguration = applyCachedLogsSdkConfiguration(initConfiguration)
+        initConfiguration = cachedSdkConfiguration.initConfiguration
+
+        if (!cachedSdkConfiguration.logsEnabled) {
+          // Logs is switched off from the dashboard. Still refresh the document, otherwise the
+          // switch would be one-way: the SDK could never learn it has been turned back on.
+          cachedInitConfiguration = initConfiguration
+          refreshRemoteSdkConfiguration()
+          return
+        }
+      }
+
+      // Expose the initial configuration regardless of initialization success.
+      cachedInitConfiguration = initConfiguration
+
+      if (cachedConfiguration) {
+        displayAlreadyInitializedError('KUBESENSE_LOGS', initConfiguration)
+        return
+      }
+
+      callPluginsMethod(initConfiguration.plugins, 'onInit', {
+        initConfiguration,
+        publicApi,
+        registerAssembleEventHook: hooks.assembleEvent.register,
+      })
+
+      const configuration = validateAndBuildLogsConfiguration(initConfiguration)
+      if (!configuration || !isAllowedTrackingOrigins(configuration, errorStack ?? '')) {
+        refreshRemoteSdkConfiguration()
+        return
+      }
+
+      cachedConfiguration = configuration
+
+      trackingConsentState.tryToInit(configuration.trackingConsent)
+
+      trackingConsentState.onGrantedOnce(() => {
+        startTrackingConsentContext(hooks, trackingConsentState)
+        mockable(startTelemetry)(TelemetryService.LOGS, configuration, hooks.assembleTelemetry, sdkName)
+        const sessionManagerPromise = canUseEventBridge()
+          ? startSessionManagerStub()
+          : mockable(startSessionManager)(configuration, trackingConsentState)
+
+        void sessionManagerPromise
+          .then((newSessionManager) => {
+            if (!newSessionManager) {
+              return
+            }
+            sessionManager = newSessionManager
+            startTelemetrySessionContext(hooks.assembleTelemetry, sessionManager)
+            addTelemetryConfiguration(serializeLogsConfiguration(initConfiguration))
+            tryStartLogs()
+
+            // Fire-and-forget, after the SDK is running: refreshes the cache for the next page load.
+            refreshRemoteSdkConfiguration()
+          })
+          .catch(monitorError)
+      })
+    },
+
+    get initConfiguration() {
+      return cachedInitConfiguration
+    },
+
+    globalContext,
+    accountContext,
+    userContext,
+
+    getInternalContext: noop as () => undefined,
+
+    handleLog(message, statusType, handlingStack, context = getCommonContext(), date = timeStampNow()) {
+      bufferApiCalls.notify((startLogsResult) =>
+        startLogsResult.handleLog(message, statusType, handlingStack, context, date)
+      )
+    },
+  }
+}
+
+function overrideInitConfigurationForBridge(initConfiguration: LogsInitConfiguration): LogsInitConfiguration {
+  return { ...initConfiguration, clientToken: 'empty' }
+}