@leanbase-giangnd/js 0.0.4 → 0.0.7

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@leanbase-giangnd/js",
-    "version": "0.0.4",
-    "description": "Leanbase browser SDK - event tracking, autocapture, and session replay",
+    "version": "0.0.7",
+    "description": "Leanbase bgiangndrowser SDK - event tracking, autocapture, and session replay",
     "repository": {
         "type": "git",
         "directory": "packages/leanbase"
@@ -34,15 +34,14 @@
     },
     "dependencies": {
         "@posthog/core": "workspace:*",
-        "@rrweb/record": "2.0.0-alpha.17",
         "fflate": "^0.4.8"
     },
     "devDependencies": {
-        "@posthog-tooling/tsconfig-base": "workspace:*",
         "@posthog-tooling/rollup-utils": "workspace:*",
+        "@posthog-tooling/tsconfig-base": "workspace:*",
         "jest": "catalog:",
         "jest-environment-jsdom": "catalog:",
-        "rollup": "catalog:",
-        "rimraf": "^6.0.1"
+        "rimraf": "^6.0.1",
+        "rollup": "catalog:"
     }
 }

package/src/extensions/replay/external/README.md

@@ -0,0 +1,5 @@
+files in here are intended for the lazy loaded portion of replay
+
+you aren't supposed to import them from outside the entrypoint file
+
+they could cause an increase in bundle size

package/src/extensions/replay/external/config.ts

@@ -1,5 +1,5 @@
-import { CapturedNetworkRequest, LeanbaseConfig, NetworkRecordOptions } from '../../../types'
-import { isArray, isBoolean, isFunction, isNullish, isString, isUndefined } from '@posthog/core'
+import { CapturedNetworkRequest, NetworkRecordOptions, PostHogConfig } from '../../../types'
+import { isFunction, isNullish, isString, isUndefined } from '@posthog/core'
 import { convertToURL } from '../../../utils/request-utils'
 import { logger } from '../../../utils/logger'
 import { shouldCaptureValue } from '../../../autocapture-utils'
@@ -15,11 +15,12 @@ export const defaultNetworkOptions: Required<NetworkRecordOptions> = {
         'beacon',
         'body',
         'css',
-        'early-hints',
+        'early-hint',
         'embed',
         'fetch',
         'frame',
         'iframe',
+        'icon',
         'image',
         'img',
         'input',
@@ -91,17 +92,11 @@ const PAYLOAD_CONTENT_DENY_LIST = [
 const removeAuthorizationHeader = (data: CapturedNetworkRequest): CapturedNetworkRequest => {
     const headers = data.requestHeaders
     if (!isNullish(headers)) {
-        const mutableHeaders: Record<string, any> = isArray(headers)
-            ? Object.fromEntries(headers as any)
-            : (headers as any)
-
-        each(Object.keys(mutableHeaders ?? {}), (header) => {
+        each(Object.keys(headers ?? {}), (header) => {
             if (HEADER_DENY_LIST.includes(header.toLowerCase())) {
-                mutableHeaders[header] = REDACTED
+                headers[header] = REDACTED
             }
         })
-
-        data.requestHeaders = mutableHeaders as any
     }
     return data
 }
@@ -111,12 +106,12 @@ const POSTHOG_PATHS_TO_IGNORE = ['/s/', '/e/', '/i/']
 // because calls to PostHog would be reported using a call to PostHog which would be reported....
 const ignorePostHogPaths = (
     data: CapturedNetworkRequest,
-    apiHostConfig: LeanbaseConfig['host']
+    apiHostConfig: PostHogConfig['api_host']
 ): CapturedNetworkRequest | undefined => {
     const url = convertToURL(data.name)
 
-    const host = apiHostConfig || ''
-    let replaceValue = host.indexOf('http') === 0 ? convertToURL(host)?.pathname : host
+    // we need to account for api host config as e.g. pathname could be /ingest/s/ and we want to ignore that
+    let replaceValue = apiHostConfig.indexOf('http') === 0 ? convertToURL(apiHostConfig)?.pathname : apiHostConfig
     if (replaceValue === '/') {
         replaceValue = ''
     }
@@ -210,47 +205,44 @@ function scrubPayloads(capturedRequest: CapturedNetworkRequest | undefined): Cap
  *  if someone complains then we'll add an opt-in to let them override it
  */
 export const buildNetworkRequestOptions = (
-    instanceConfig: LeanbaseConfig,
+    instanceConfig: PostHogConfig,
     remoteNetworkOptions: Pick<
         NetworkRecordOptions,
         'recordHeaders' | 'recordBody' | 'recordPerformance' | 'payloadHostDenyList'
-    > = {}
+    >
 ): NetworkRecordOptions => {
-    const remoteOptions = remoteNetworkOptions || {}
     const config: NetworkRecordOptions = {
         payloadSizeLimitBytes: defaultNetworkOptions.payloadSizeLimitBytes,
         performanceEntryTypeToObserve: [...defaultNetworkOptions.performanceEntryTypeToObserve],
         payloadHostDenyList: [
-            ...(remoteOptions.payloadHostDenyList || []),
+            ...(remoteNetworkOptions.payloadHostDenyList || []),
             ...defaultNetworkOptions.payloadHostDenyList,
         ],
     }
     // client can always disable despite remote options
-    const sessionRecordingConfig = instanceConfig.session_recording || {}
-    const capturePerformanceConfig = instanceConfig.capture_performance
-    const userPerformanceOptIn = isBoolean(capturePerformanceConfig)
-        ? capturePerformanceConfig
-        : !!capturePerformanceConfig?.network_timing
-    const canRecordHeaders = sessionRecordingConfig.recordHeaders === true && !!remoteOptions.recordHeaders
-    const canRecordBody = sessionRecordingConfig.recordBody === true && !!remoteOptions.recordBody
-    const canRecordPerformance = userPerformanceOptIn && !!remoteOptions.recordPerformance
+    const canRecordHeaders =
+        instanceConfig.session_recording.recordHeaders === false ? false : remoteNetworkOptions.recordHeaders
+    const canRecordBody =
+        instanceConfig.session_recording.recordBody === false ? false : remoteNetworkOptions.recordBody
+    const canRecordPerformance =
+        instanceConfig.capture_performance === false ? false : remoteNetworkOptions.recordPerformance
 
     const payloadLimiter = limitPayloadSize(config)
 
     const enforcedCleaningFn: NetworkRecordOptions['maskRequestFn'] = (d: CapturedNetworkRequest) =>
-        payloadLimiter(ignorePostHogPaths(removeAuthorizationHeader(d), instanceConfig.host || ''))
+        payloadLimiter(ignorePostHogPaths(removeAuthorizationHeader(d), instanceConfig.api_host))
 
-    const hasDeprecatedMaskFunction = isFunction(sessionRecordingConfig.maskNetworkRequestFn)
+    const hasDeprecatedMaskFunction = isFunction(instanceConfig.session_recording.maskNetworkRequestFn)
 
-    if (hasDeprecatedMaskFunction && isFunction(sessionRecordingConfig.maskCapturedNetworkRequestFn)) {
+    if (hasDeprecatedMaskFunction && isFunction(instanceConfig.session_recording.maskCapturedNetworkRequestFn)) {
         logger.warn(
             'Both `maskNetworkRequestFn` and `maskCapturedNetworkRequestFn` are defined. `maskNetworkRequestFn` will be ignored.'
         )
     }
 
     if (hasDeprecatedMaskFunction) {
-        sessionRecordingConfig.maskCapturedNetworkRequestFn = (data: CapturedNetworkRequest) => {
-            const cleanedURL = sessionRecordingConfig.maskNetworkRequestFn!({ url: data.name })
+        instanceConfig.session_recording.maskCapturedNetworkRequestFn = (data: CapturedNetworkRequest) => {
+            const cleanedURL = instanceConfig.session_recording.maskNetworkRequestFn!({ url: data.name })
             return {
                 ...data,
                 name: cleanedURL?.url,
@@ -258,11 +250,11 @@ export const buildNetworkRequestOptions = (
         }
     }
 
-    config.maskRequestFn = isFunction(sessionRecordingConfig.maskCapturedNetworkRequestFn)
+    config.maskRequestFn = isFunction(instanceConfig.session_recording.maskCapturedNetworkRequestFn)
         ? (data) => {
               const cleanedRequest = enforcedCleaningFn(data)
               return cleanedRequest
-                  ? (sessionRecordingConfig.maskCapturedNetworkRequestFn?.(cleanedRequest) ?? undefined)
+                  ? (instanceConfig.session_recording.maskCapturedNetworkRequestFn?.(cleanedRequest) ?? undefined)
                   : undefined
           }
         : (data) => scrubPayloads(enforcedCleaningFn(data))

package/src/extensions/replay/external/lazy-loaded-session-recorder.ts

@@ -1,5 +1,3 @@
-import { record as rrwebRecord } from '@rrweb/record'
-import { clampToRange, includes, isBoolean, isNullish, isNumber, isObject, isString, isUndefined } from '@posthog/core'
 import type { recordOptions, rrwebRecord as rrwebRecordType } from '../types/rrweb'
 import {
     type customEvent,
@@ -10,7 +8,6 @@ import {
     RecordPlugin,
 } from '../types/rrweb-types'
 import { buildNetworkRequestOptions } from './config'
-import { getRecordNetworkPlugin } from './network-plugin'
 import {
     ACTIVE,
     allMatchSessionRecordingStatus,
@@ -34,16 +31,28 @@ import {
 } from './triggerMatching'
 import { estimateSize, INCREMENTAL_SNAPSHOT_EVENT_TYPE, truncateLargeConsoleLogs } from './sessionrecording-utils'
 import { gzipSync, strFromU8, strToU8 } from 'fflate'
-import { window, document, addEventListener } from '../../../utils'
+import { assignableWindow, LazyLoadedSessionRecordingInterface, window, document } from '../../../utils/globals'
+import { addEventListener } from '../../../utils'
 import { MutationThrottler } from './mutation-throttler'
 import { createLogger } from '../../../utils/logger'
+import {
+    clampToRange,
+    includes,
+    isBoolean,
+    isFunction,
+    isNullish,
+    isNumber,
+    isObject,
+    isString,
+    isUndefined,
+} from '@posthog/core'
 import {
     SESSION_RECORDING_EVENT_TRIGGER_ACTIVATED_SESSION,
     SESSION_RECORDING_IS_SAMPLED,
     SESSION_RECORDING_REMOTE_CONFIG,
     SESSION_RECORDING_URL_TRIGGER_ACTIVATED_SESSION,
 } from '../../../constants'
-import { Leanbase } from '../../../leanbase'
+import { PostHog } from '../../../posthog-core'
 import {
     CaptureResult,
     NetworkRecordOptions,
@@ -118,7 +127,7 @@ const newQueuedEvent = (rrwebMethod: () => void): QueuedRRWebEvent => ({
 })
 
 function getRRWebRecord(): rrwebRecordType | undefined {
-    return rrwebRecord as unknown as rrwebRecordType
+    return assignableWindow?.__PosthogExtensions__?.rrweb?.record
 }
 
 export type compressedFullSnapshotEvent = {
@@ -249,7 +258,7 @@ export function splitBuffer(buffer: SnapshotBuffer, sizeLimit: number = SEVEN_ME
     }
 }
 
-export class LazyLoadedSessionRecording {
+export class LazyLoadedSessionRecording implements LazyLoadedSessionRecordingInterface {
     private _endpoint: string = BASE_ENDPOINT
     private _mutationThrottler?: MutationThrottler
     /**
@@ -300,7 +309,7 @@ export class LazyLoadedSessionRecording {
     }
 
     private get _sessionIdleThresholdMilliseconds(): number {
-        return this._instance.config.session_recording?.session_idle_threshold_ms || RECORDING_IDLE_THRESHOLD_MS
+        return this._instance.config.session_recording.session_idle_threshold_ms || RECORDING_IDLE_THRESHOLD_MS
     }
 
     private get _isSampled(): boolean | null {
@@ -328,7 +337,7 @@ export class LazyLoadedSessionRecording {
     private _samplingSessionListener: (() => void) | undefined = undefined
     private _forceIdleSessionIdListener: (() => void) | undefined = undefined
 
-    constructor(private readonly _instance: Leanbase) {
+    constructor(private readonly _instance: PostHog) {
         // we know there's a sessionManager, so don't need to start without a session id
         const { sessionId, windowId } = this._sessionManager.checkAndGetSessionAndWindowId()
         this._sessionId = sessionId
@@ -371,7 +380,7 @@ export class LazyLoadedSessionRecording {
     }
 
     private get _canvasRecording(): { enabled: boolean; fps: number; quality: number } {
-        const canvasRecording_client_side = this._instance.config.session_recording?.captureCanvas
+        const canvasRecording_client_side = this._instance.config.session_recording.captureCanvas
         const canvasRecording_server_side = this._remoteConfig?.canvasRecording
 
         const enabled: boolean =
@@ -407,60 +416,44 @@ export class LazyLoadedSessionRecording {
     // network payload capture config has three parts
     // each can be configured server side or client side
     private get _networkPayloadCapture():
-        | Pick<NetworkRecordOptions, 'recordHeaders' | 'recordBody' | 'recordPerformance' | 'payloadHostDenyList'>
+        | Pick<NetworkRecordOptions, 'recordHeaders' | 'recordBody' | 'recordPerformance'>
         | undefined {
         const networkPayloadCapture_server_side = this._remoteConfig?.networkPayloadCapture
         const networkPayloadCapture_client_side = {
             recordHeaders: this._instance.config.session_recording?.recordHeaders,
             recordBody: this._instance.config.session_recording?.recordBody,
         }
-        const headersOptIn = networkPayloadCapture_client_side?.recordHeaders === true
-        const bodyOptIn = networkPayloadCapture_client_side?.recordBody === true
-        const clientPerformanceConfig = this._instance.config.capture_performance
-        const clientPerformanceOptIn = isObject(clientPerformanceConfig)
-            ? !!clientPerformanceConfig.network_timing
-            : !!clientPerformanceConfig
-        const serverAllowsHeaders = networkPayloadCapture_server_side?.recordHeaders ?? true
-        const serverAllowsBody = networkPayloadCapture_server_side?.recordBody ?? true
-        const capturePerfResponse = networkPayloadCapture_server_side?.capturePerformance
-        const serverAllowsPerformance = (() => {
-            if (isObject(capturePerfResponse)) {
-                return !!capturePerfResponse.network_timing
-            }
-            return capturePerfResponse ?? true
-        })()
-
-        const headersEnabled = headersOptIn && serverAllowsHeaders
-        const bodyEnabled = bodyOptIn && serverAllowsBody
-        const networkTimingEnabled = clientPerformanceOptIn && serverAllowsPerformance
-
-        if (!headersEnabled && !bodyEnabled && !networkTimingEnabled) {
-            return undefined
-        }
-
-        return {
-            recordHeaders: headersEnabled,
-            recordBody: bodyEnabled,
-            recordPerformance: networkTimingEnabled,
-            payloadHostDenyList: networkPayloadCapture_server_side?.payloadHostDenyList,
-        }
+        const headersEnabled =
+            networkPayloadCapture_client_side?.recordHeaders || networkPayloadCapture_server_side?.recordHeaders
+        const bodyEnabled =
+            networkPayloadCapture_client_side?.recordBody || networkPayloadCapture_server_side?.recordBody
+        const clientConfigForPerformanceCapture = isObject(this._instance.config.capture_performance)
+            ? this._instance.config.capture_performance.network_timing
+            : this._instance.config.capture_performance
+        const networkTimingEnabled = !!(isBoolean(clientConfigForPerformanceCapture)
+            ? clientConfigForPerformanceCapture
+            : networkPayloadCapture_server_side?.capturePerformance)
+
+        return headersEnabled || bodyEnabled || networkTimingEnabled
+            ? { recordHeaders: headersEnabled, recordBody: bodyEnabled, recordPerformance: networkTimingEnabled }
+            : undefined
     }
 
     private _gatherRRWebPlugins() {
         const plugins: RecordPlugin[] = []
 
-        if (this._isConsoleLogCaptureEnabled) {
-            logger.info('Console log capture requested but console plugin is not bundled in this build yet.')
+        const recordConsolePlugin = assignableWindow.__PosthogExtensions__?.rrwebPlugins?.getRecordConsolePlugin
+        if (recordConsolePlugin && this._isConsoleLogCaptureEnabled) {
+            plugins.push(recordConsolePlugin())
         }
 
-        if (this._networkPayloadCapture) {
+        const networkPlugin = assignableWindow.__PosthogExtensions__?.rrwebPlugins?.getRecordNetworkPlugin
+        if (!!this._networkPayloadCapture && isFunction(networkPlugin)) {
             const canRecordNetwork = !isLocalhost() || this._forceAllowLocalhostNetworkCapture
 
             if (canRecordNetwork) {
                 plugins.push(
-                    getRecordNetworkPlugin(
-                        buildNetworkRequestOptions(this._instance.config, this._networkPayloadCapture)
-                    )
+                    networkPlugin(buildNetworkRequestOptions(this._instance.config, this._networkPayloadCapture))
                 )
             } else {
                 logger.info('NetworkCapture not started because we are on localhost.')
@@ -471,7 +464,7 @@ export class LazyLoadedSessionRecording {
     }
 
     private _maskUrl(url: string): string | undefined {
-        const userSessionRecordingOptions = this._instance.config.session_recording || {}
+        const userSessionRecordingOptions = this._instance.config.session_recording
 
         if (userSessionRecordingOptions.maskNetworkRequestFn) {
             let networkRequest: NetworkRequest | null | undefined = {
@@ -673,8 +666,8 @@ export class LazyLoadedSessionRecording {
             this._statusMatcher = allMatchSessionRecordingStatus
             this._triggerMatching = new AndTriggerMatching([this._eventTriggerMatching, this._urlTriggerMatching])
         }
-        this._instance.registerForSession({
-            $sdk_debug_replay_remote_trigger_matching_config: config?.triggerMatchType ?? null,
+        this._instance.register_for_session({
+            $sdk_debug_replay_remote_trigger_matching_config: config?.triggerMatchType,
         })
 
         this._urlTriggerMatching.onConfig(config)
@@ -877,7 +870,7 @@ export class LazyLoadedSessionRecording {
         }
 
         const eventToSend =
-            (this._instance.config.session_recording?.compress_events ?? true) ? compressEvent(event) : event
+            (this._instance.config.session_recording.compress_events ?? true) ? compressEvent(event) : event
         const size = estimateSize(eventToSend)
 
         const properties = {
@@ -1020,25 +1013,36 @@ export class LazyLoadedSessionRecording {
     }
 
     private _captureSnapshot(properties: Properties) {
-        // :TRICKY: Make sure we batch these requests, use a custom endpoint and don't truncate the strings.
-        this._instance.capture('$snapshot', properties, {
-            _url: this._snapshotUrl(),
+        // Send snapshots immediately via the stateless immediate path so they are
+        // not mixed into general event batches. This ensures the client will
+        // choose the snapshot-only endpoint (`/s/`). Fall back to normal
+        // capture if the immediate API isn't available at runtime.
+        const opts = {
             _noTruncate: true,
             _batchKey: SESSION_RECORDING_BATCH_KEY,
             skip_client_rate_limiting: true,
-        })
-    }
+        }
 
-    private _snapshotUrl(): string {
-        const host = this._instance.config.host || ''
         try {
-            // eslint-disable-next-line compat/compat
-            return new URL(this._endpoint, host).href
-        } catch {
-            const normalizedHost = host.endsWith('/') ? host.slice(0, -1) : host
-            const normalizedEndpoint = this._endpoint.startsWith('/') ? this._endpoint.slice(1) : this._endpoint
-            return `${normalizedHost}/${normalizedEndpoint}`
+            const maybeCaptureStatelessImmediate = (this._instance as any).captureStatelessImmediate
+            if (isFunction(maybeCaptureStatelessImmediate)) {
+                const distinctId = (this._instance as any).getDistinctId?.() || undefined
+                // captureStatelessImmediate expects (distinctId, event, properties, options)
+                ;(this._instance as any).captureStatelessImmediate(distinctId, '$snapshot', properties, opts)
+                return
+            }
+        } catch (e) {
+            // if anything goes wrong, fall through to the safe capture path below
+            logger.error('Failed to send snapshot via stateless immediate path, falling back to capture', e)
         }
+
+        // :TRICKY: Fallback - use the standard capture path. Keep the explicit
+        // _url for compatibility with environments that expect a pre-computed
+        // endpoint, even though the immediate path above is preferred.
+        this._instance.capture('$snapshot', properties, {
+            _url: this._instance.requestRouter.endpointFor('api', this._endpoint),
+            ...opts,
+        })
     }
 
     private get _sessionDuration(): number | null {
@@ -1099,7 +1103,7 @@ export class LazyLoadedSessionRecording {
     }
 
     private _reportStarted(startReason: SessionStartReason, tagPayload?: Record<string, any>) {
-        this._instance.registerForSession({
+        this._instance.register_for_session({
             $session_recording_start_reason: startReason,
         })
         logger.info(startReason.replace('_', ' '), tagPayload)
@@ -1333,8 +1337,8 @@ export class LazyLoadedSessionRecording {
         this._mutationThrottler =
             this._mutationThrottler ??
             new MutationThrottler(rrwebRecord, {
-                refillRate: this._instance.config.session_recording?.__mutationThrottlerRefillRate,
-                bucketSize: this._instance.config.session_recording?.__mutationThrottlerBucketSize,
+                refillRate: this._instance.config.session_recording.__mutationThrottlerRefillRate,
+                bucketSize: this._instance.config.session_recording.__mutationThrottlerBucketSize,
                 onBlockedNode: (id, node) => {
                     const message = `Too many mutations on node '${id}'. Rate limiting. This could be due to SVG animations or something similar`
                     logger.info(message, {

package/src/extensions/replay/external/mutation-throttler.ts

@@ -16,11 +16,8 @@ export class MutationThrottler {
             onBlockedNode?: (id: number, node: Node | null) => void
         } = {}
     ) {
-        const configuredBucketSize = this._options.bucketSize ?? 100
-        const effectiveBucketSize = Math.max(configuredBucketSize - 1, 1)
-
         this._rateLimiter = new BucketedRateLimiter({
-            bucketSize: effectiveBucketSize,
+            bucketSize: this._options.bucketSize ?? 100,
             refillRate: this._options.refillRate ?? 10,
             refillInterval: 1000, // one second
             _onBucketRateLimited: this._onNodeRateLimited,

package/src/extensions/replay/external/network-plugin.ts

@@ -12,6 +12,7 @@
 import type { IWindow, listenerHandler, RecordPlugin } from '../types/rrweb-types'
 import { CapturedNetworkRequest, Headers, InitiatorType, NetworkRecordOptions } from '../../../types'
 import { isArray, isBoolean, isFormData, isNull, isNullish, isString, isUndefined, isObject } from '@posthog/core'
+import { isDocument } from '../../../utils/type-utils'
 import { createLogger } from '../../../utils/logger'
 import { formDataToQuery } from '../../../utils/request-utils'
 import { patch } from '../rrweb-plugins/patch'
@@ -45,10 +46,6 @@ export function findLast<T>(array: Array<T>, predicate: (value: T) => boolean):
     return undefined
 }
 
-function isDocument(value: any): value is Document {
-    return !!value && typeof value === 'object' && 'nodeType' in value && (value as any).nodeType === 9
-}
-
 function initPerformanceObserver(cb: networkCallback, win: IWindow, options: Required<NetworkRecordOptions>) {
     // if we are only observing timings then we could have a single observer for all types, with buffer true,
     // but we are going to filter by initiatorType _if we are wrapping fetch and xhr as the wrapped functions
@@ -671,16 +668,12 @@ function initNetworkObserver(
         fetchObserver = initFetchObserver(cb, win, networkOptions)
     }
 
-    const teardown: listenerHandler = () => {
+    initialisedHandler = () => {
         performanceObserver()
         xhrObserver()
         fetchObserver()
-        // allow future observers to initialize after cleanup
-        initialisedHandler = null
     }
-
-    initialisedHandler = teardown
-    return teardown
+    return initialisedHandler
 }
 
 // use the plugin name so that when this functionality is adopted into rrweb

package/src/extensions/replay/external/triggerMatching.ts

@@ -2,10 +2,10 @@ import {
     SESSION_RECORDING_EVENT_TRIGGER_ACTIVATED_SESSION,
     SESSION_RECORDING_URL_TRIGGER_ACTIVATED_SESSION,
 } from '../../../constants'
-import { Leanbase } from '../../../leanbase'
-import { RemoteConfig, SessionRecordingPersistedConfig, SessionRecordingUrlTrigger } from '../../../types'
+import { PostHog } from '../../../posthog-core'
+import { FlagVariant, RemoteConfig, SessionRecordingPersistedConfig, SessionRecordingUrlTrigger } from '../../../types'
 import { isNullish, isBoolean, isString, isObject } from '@posthog/core'
-import { window } from '../../../utils'
+import { window } from '../../../utils/globals'
 
 export const DISABLED = 'disabled'
 export const SAMPLED = 'sampled'
@@ -133,7 +133,7 @@ export class URLTriggerMatching implements TriggerStatusMatching {
 
     urlBlocked: boolean = false
 
-    constructor(private readonly _instance: Leanbase) {}
+    constructor(private readonly _instance: PostHog) {}
 
     onConfig(config: ReplayConfigType) {
         this._urlTriggers =
@@ -172,7 +172,7 @@ export class URLTriggerMatching implements TriggerStatusMatching {
         const eitherIsPending = urlTriggerStatus === TRIGGER_PENDING
 
         const result = eitherIsActivated ? TRIGGER_ACTIVATED : eitherIsPending ? TRIGGER_PENDING : TRIGGER_DISABLED
-        this._instance.registerForSession({
+        this._instance.register_for_session({
             $sdk_debug_replay_url_trigger_status: result,
         })
         return result
@@ -212,10 +212,10 @@ export class URLTriggerMatching implements TriggerStatusMatching {
 }
 
 export class LinkedFlagMatching implements TriggerStatusMatching {
-    linkedFlag: string | { flag: string; variant: string } | null = null
+    linkedFlag: string | FlagVariant | null = null
     linkedFlagSeen: boolean = false
     private _flagListenerCleanup: () => void = () => {}
-    constructor(private readonly _instance: Leanbase) {}
+    constructor(private readonly _instance: PostHog) {}
 
     triggerStatus(): TriggerStatus {
         let result = TRIGGER_PENDING
@@ -225,7 +225,7 @@ export class LinkedFlagMatching implements TriggerStatusMatching {
         if (this.linkedFlagSeen) {
             result = TRIGGER_ACTIVATED
         }
-        this._instance.registerForSession({
+        this._instance.register_for_session({
             $sdk_debug_replay_linked_flag_trigger_status: result,
         })
         return result
@@ -242,11 +242,11 @@ export class LinkedFlagMatching implements TriggerStatusMatching {
         if (!isNullish(this.linkedFlag) && !this.linkedFlagSeen) {
             const linkedFlag = isString(this.linkedFlag) ? this.linkedFlag : this.linkedFlag.flag
             const linkedVariant = isString(this.linkedFlag) ? null : this.linkedFlag.variant
-            this._flagListenerCleanup = this._instance.onFeatureFlags((flags) => {
-                const flagIsPresent = isObject(flags) && linkedFlag in (flags as any)
+            this._flagListenerCleanup = this._instance.onFeatureFlags((_flags: any, variants: any) => {
+                const flagIsPresent = isObject(variants) && linkedFlag in variants
                 let linkedFlagMatches = false
                 if (flagIsPresent) {
-                    const variantForFlagKey = (flags as any)[linkedFlag]
+                    const variantForFlagKey = variants[linkedFlag]
                     if (isBoolean(variantForFlagKey)) {
                         linkedFlagMatches = variantForFlagKey === true
                     } else if (linkedVariant) {
@@ -279,7 +279,7 @@ export class LinkedFlagMatching implements TriggerStatusMatching {
 export class EventTriggerMatching implements TriggerStatusMatching {
     _eventTriggers: string[] = []
 
-    constructor(private readonly _instance: Leanbase) {}
+    constructor(private readonly _instance: PostHog) {}
 
     onConfig(config: ReplayConfigType) {
         this._eventTriggers =
@@ -314,7 +314,7 @@ export class EventTriggerMatching implements TriggerStatusMatching {
                 : eventTriggerStatus === TRIGGER_PENDING
                   ? TRIGGER_PENDING
                   : TRIGGER_DISABLED
-        this._instance.registerForSession({
+        this._instance.register_for_session({
             $sdk_debug_replay_event_trigger_status: result,
         })
         return result

package/src/extensions/replay/rrweb-plugins/patch.ts

@@ -1,3 +1,6 @@
+// import { patch } from 'rrweb/typings/utils'
+// copied from https://github.com/rrweb-io/rrweb/blob/8aea5b00a4dfe5a6f59bd2ae72bb624f45e51e81/packages/rrweb/src/utils.ts#L129
+// which was copied from https://github.com/getsentry/sentry-javascript/blob/b2109071975af8bf0316d3b5b38f519bdaf5dc15/packages/utils/src/object.ts
 import { isFunction } from '@posthog/core'
 
 export function patch(
@@ -15,6 +18,8 @@ export function patch(
         const original = source[name] as () => unknown
         const wrapped = replacement(original)
 
+        // Make sure it's a function first, as we need to attach an empty prototype for `defineProperties` to work
+        // otherwise it'll throw "TypeError: Object.defineProperties called on non-object"
         if (isFunction(wrapped)) {
             // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             wrapped.prototype = wrapped.prototype || {}
@@ -35,5 +40,7 @@ export function patch(
         return () => {
             //
         }
+        // This can throw if multiple fill happens on a global object like XMLHttpRequest
+        // Fixes https://github.com/getsentry/sentry-javascript/issues/2043
     }
 }