@leanbase-giangnd/js 0.0.7 → 0.1.1

package/package.json

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

package/src/extensions/replay/extension-shim.ts

@@ -0,0 +1,35 @@
+import { window as win } from '../../utils'
+import { record as rrwebRecord } from '@rrweb/record'
+import { LazyLoadedSessionRecording } from './external/lazy-loaded-session-recorder'
+import { getRecordNetworkPlugin } from './external/network-plugin'
+
+// Use a safe global target (prefer `win`, fallback to globalThis)
+const _target: any = (win as any) ?? (globalThis as any)
+
+_target.__PosthogExtensions__ = _target.__PosthogExtensions__ || {}
+
+// Expose rrweb.record under the same contract
+_target.__PosthogExtensions__.rrweb = _target.__PosthogExtensions__.rrweb || {
+    record: rrwebRecord,
+}
+
+// Provide initSessionRecording if not present — return a new LazyLoadedSessionRecording when called
+_target.__PosthogExtensions__.initSessionRecording =
+    _target.__PosthogExtensions__.initSessionRecording ||
+    ((instance: any) => {
+        return new LazyLoadedSessionRecording(instance)
+    })
+
+// Provide a no-op loadExternalDependency that calls the callback immediately (since rrweb is bundled)
+_target.__PosthogExtensions__.loadExternalDependency =
+    _target.__PosthogExtensions__.loadExternalDependency ||
+    ((instance: any, scriptName: string, cb?: (err?: any) => void) => {
+        if (cb) cb(undefined)
+    })
+
+// Provide rrwebPlugins object with network plugin factory if not present
+_target.__PosthogExtensions__.rrwebPlugins = _target.__PosthogExtensions__.rrwebPlugins || {}
+_target.__PosthogExtensions__.rrwebPlugins.getRecordNetworkPlugin =
+    _target.__PosthogExtensions__.rrwebPlugins.getRecordNetworkPlugin || (() => getRecordNetworkPlugin)
+
+export {}

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

@@ -1,5 +1,5 @@
-import { CapturedNetworkRequest, NetworkRecordOptions, PostHogConfig } from '../../../types'
-import { isFunction, isNullish, isString, isUndefined } from '@posthog/core'
+import { CapturedNetworkRequest, LeanbaseConfig, NetworkRecordOptions } from '../../../types'
+import { isArray, isBoolean, isFunction, isNullish, isString, isUndefined } from '@posthog/core'
 import { convertToURL } from '../../../utils/request-utils'
 import { logger } from '../../../utils/logger'
 import { shouldCaptureValue } from '../../../autocapture-utils'
@@ -15,12 +15,11 @@ export const defaultNetworkOptions: Required<NetworkRecordOptions> = {
         'beacon',
         'body',
         'css',
-        'early-hint',
+        'early-hints',
         'embed',
         'fetch',
         'frame',
         'iframe',
-        'icon',
         'image',
         'img',
         'input',
@@ -92,11 +91,17 @@ const PAYLOAD_CONTENT_DENY_LIST = [
 const removeAuthorizationHeader = (data: CapturedNetworkRequest): CapturedNetworkRequest => {
     const headers = data.requestHeaders
     if (!isNullish(headers)) {
-        each(Object.keys(headers ?? {}), (header) => {
+        const mutableHeaders: Record<string, any> = isArray(headers)
+            ? Object.fromEntries(headers as any)
+            : (headers as any)
+
+        each(Object.keys(mutableHeaders ?? {}), (header) => {
             if (HEADER_DENY_LIST.includes(header.toLowerCase())) {
-                headers[header] = REDACTED
+                mutableHeaders[header] = REDACTED
             }
         })
+
+        data.requestHeaders = mutableHeaders as any
     }
     return data
 }
@@ -106,12 +111,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: PostHogConfig['api_host']
+    apiHostConfig: LeanbaseConfig['host']
 ): CapturedNetworkRequest | undefined => {
     const url = convertToURL(data.name)
 
-    // 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
+    const host = apiHostConfig || ''
+    let replaceValue = host.indexOf('http') === 0 ? convertToURL(host)?.pathname : host
     if (replaceValue === '/') {
         replaceValue = ''
     }
@@ -205,44 +210,47 @@ 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: PostHogConfig,
+    instanceConfig: LeanbaseConfig,
     remoteNetworkOptions: Pick<
         NetworkRecordOptions,
         'recordHeaders' | 'recordBody' | 'recordPerformance' | 'payloadHostDenyList'
-    >
+    > = {}
 ): NetworkRecordOptions => {
+    const remoteOptions = remoteNetworkOptions || {}
     const config: NetworkRecordOptions = {
         payloadSizeLimitBytes: defaultNetworkOptions.payloadSizeLimitBytes,
         performanceEntryTypeToObserve: [...defaultNetworkOptions.performanceEntryTypeToObserve],
         payloadHostDenyList: [
-            ...(remoteNetworkOptions.payloadHostDenyList || []),
+            ...(remoteOptions.payloadHostDenyList || []),
             ...defaultNetworkOptions.payloadHostDenyList,
         ],
     }
     // client can always disable despite remote options
-    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 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 payloadLimiter = limitPayloadSize(config)
 
     const enforcedCleaningFn: NetworkRecordOptions['maskRequestFn'] = (d: CapturedNetworkRequest) =>
-        payloadLimiter(ignorePostHogPaths(removeAuthorizationHeader(d), instanceConfig.api_host))
+        payloadLimiter(ignorePostHogPaths(removeAuthorizationHeader(d), instanceConfig.host || ''))
 
-    const hasDeprecatedMaskFunction = isFunction(instanceConfig.session_recording.maskNetworkRequestFn)
+    const hasDeprecatedMaskFunction = isFunction(sessionRecordingConfig.maskNetworkRequestFn)
 
-    if (hasDeprecatedMaskFunction && isFunction(instanceConfig.session_recording.maskCapturedNetworkRequestFn)) {
+    if (hasDeprecatedMaskFunction && isFunction(sessionRecordingConfig.maskCapturedNetworkRequestFn)) {
         logger.warn(
             'Both `maskNetworkRequestFn` and `maskCapturedNetworkRequestFn` are defined. `maskNetworkRequestFn` will be ignored.'
         )
     }
 
     if (hasDeprecatedMaskFunction) {
-        instanceConfig.session_recording.maskCapturedNetworkRequestFn = (data: CapturedNetworkRequest) => {
-            const cleanedURL = instanceConfig.session_recording.maskNetworkRequestFn!({ url: data.name })
+        sessionRecordingConfig.maskCapturedNetworkRequestFn = (data: CapturedNetworkRequest) => {
+            const cleanedURL = sessionRecordingConfig.maskNetworkRequestFn!({ url: data.name })
             return {
                 ...data,
                 name: cleanedURL?.url,
@@ -250,11 +258,11 @@ export const buildNetworkRequestOptions = (
         }
     }
 
-    config.maskRequestFn = isFunction(instanceConfig.session_recording.maskCapturedNetworkRequestFn)
+    config.maskRequestFn = isFunction(sessionRecordingConfig.maskCapturedNetworkRequestFn)
         ? (data) => {
               const cleanedRequest = enforcedCleaningFn(data)
               return cleanedRequest
-                  ? (instanceConfig.session_recording.maskCapturedNetworkRequestFn?.(cleanedRequest) ?? undefined)
+                  ? (sessionRecordingConfig.maskCapturedNetworkRequestFn?.(cleanedRequest) ?? undefined)
                   : undefined
           }
         : (data) => scrubPayloads(enforcedCleaningFn(data))

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

@@ -1,3 +1,6 @@
+import { record as rrwebRecord } from '@rrweb/record'
+import '../extension-shim'
+import { clampToRange, includes, isBoolean, isNullish, isNumber, isObject, isString, isUndefined } from '@posthog/core'
 import type { recordOptions, rrwebRecord as rrwebRecordType } from '../types/rrweb'
 import {
     type customEvent,
@@ -8,6 +11,7 @@ import {
     RecordPlugin,
 } from '../types/rrweb-types'
 import { buildNetworkRequestOptions } from './config'
+import { getRecordNetworkPlugin } from './network-plugin'
 import {
     ACTIVE,
     allMatchSessionRecordingStatus,
@@ -31,28 +35,16 @@ import {
 } from './triggerMatching'
 import { estimateSize, INCREMENTAL_SNAPSHOT_EVENT_TYPE, truncateLargeConsoleLogs } from './sessionrecording-utils'
 import { gzipSync, strFromU8, strToU8 } from 'fflate'
-import { assignableWindow, LazyLoadedSessionRecordingInterface, window, document } from '../../../utils/globals'
-import { addEventListener } from '../../../utils'
+import { window, document, 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 { PostHog } from '../../../posthog-core'
+import { Leanbase } from '../../../leanbase'
 import {
     CaptureResult,
     NetworkRecordOptions,
@@ -127,7 +119,17 @@ const newQueuedEvent = (rrwebMethod: () => void): QueuedRRWebEvent => ({
 })
 
 function getRRWebRecord(): rrwebRecordType | undefined {
-    return assignableWindow?.__PosthogExtensions__?.rrweb?.record
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const ext = (globalThis as any).__PosthogExtensions__
+        if (ext && ext.rrweb && ext.rrweb.record) {
+            return ext.rrweb.record as unknown as rrwebRecordType
+        }
+    } catch {
+        // ignore
+    }
+
+    return rrwebRecord as unknown as rrwebRecordType
 }
 
 export type compressedFullSnapshotEvent = {
@@ -258,7 +260,7 @@ export function splitBuffer(buffer: SnapshotBuffer, sizeLimit: number = SEVEN_ME
     }
 }
 
-export class LazyLoadedSessionRecording implements LazyLoadedSessionRecordingInterface {
+export class LazyLoadedSessionRecording {
     private _endpoint: string = BASE_ENDPOINT
     private _mutationThrottler?: MutationThrottler
     /**
@@ -309,7 +311,7 @@ export class LazyLoadedSessionRecording implements LazyLoadedSessionRecordingInt
     }
 
     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 {
@@ -337,7 +339,7 @@ export class LazyLoadedSessionRecording implements LazyLoadedSessionRecordingInt
     private _samplingSessionListener: (() => void) | undefined = undefined
     private _forceIdleSessionIdListener: (() => void) | undefined = undefined
 
-    constructor(private readonly _instance: PostHog) {
+    constructor(private readonly _instance: Leanbase) {
         // 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
@@ -380,7 +382,7 @@ export class LazyLoadedSessionRecording implements LazyLoadedSessionRecordingInt
     }
 
     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 =
@@ -416,44 +418,60 @@ export class LazyLoadedSessionRecording implements LazyLoadedSessionRecordingInt
     // network payload capture config has three parts
     // each can be configured server side or client side
     private get _networkPayloadCapture():
-        | Pick<NetworkRecordOptions, 'recordHeaders' | 'recordBody' | 'recordPerformance'>
+        | Pick<NetworkRecordOptions, 'recordHeaders' | 'recordBody' | 'recordPerformance' | 'payloadHostDenyList'>
         | 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 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
+        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,
+        }
     }
 
     private _gatherRRWebPlugins() {
         const plugins: RecordPlugin[] = []
 
-        const recordConsolePlugin = assignableWindow.__PosthogExtensions__?.rrwebPlugins?.getRecordConsolePlugin
-        if (recordConsolePlugin && this._isConsoleLogCaptureEnabled) {
-            plugins.push(recordConsolePlugin())
+        if (this._isConsoleLogCaptureEnabled) {
+            logger.info('Console log capture requested but console plugin is not bundled in this build yet.')
         }
 
-        const networkPlugin = assignableWindow.__PosthogExtensions__?.rrwebPlugins?.getRecordNetworkPlugin
-        if (!!this._networkPayloadCapture && isFunction(networkPlugin)) {
+        if (this._networkPayloadCapture) {
             const canRecordNetwork = !isLocalhost() || this._forceAllowLocalhostNetworkCapture
 
             if (canRecordNetwork) {
                 plugins.push(
-                    networkPlugin(buildNetworkRequestOptions(this._instance.config, this._networkPayloadCapture))
+                    getRecordNetworkPlugin(
+                        buildNetworkRequestOptions(this._instance.config, this._networkPayloadCapture)
+                    )
                 )
             } else {
                 logger.info('NetworkCapture not started because we are on localhost.')
@@ -464,7 +482,7 @@ export class LazyLoadedSessionRecording implements LazyLoadedSessionRecordingInt
     }
 
     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 = {
@@ -666,8 +684,8 @@ export class LazyLoadedSessionRecording implements LazyLoadedSessionRecordingInt
             this._statusMatcher = allMatchSessionRecordingStatus
             this._triggerMatching = new AndTriggerMatching([this._eventTriggerMatching, this._urlTriggerMatching])
         }
-        this._instance.register_for_session({
-            $sdk_debug_replay_remote_trigger_matching_config: config?.triggerMatchType,
+        this._instance.registerForSession({
+            $sdk_debug_replay_remote_trigger_matching_config: config?.triggerMatchType ?? null,
         })
 
         this._urlTriggerMatching.onConfig(config)
@@ -870,7 +888,7 @@ export class LazyLoadedSessionRecording implements LazyLoadedSessionRecordingInt
         }
 
         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 = {
@@ -1013,36 +1031,25 @@ export class LazyLoadedSessionRecording implements LazyLoadedSessionRecordingInt
     }
 
     private _captureSnapshot(properties: Properties) {
-        // 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 = {
+        // :TRICKY: Make sure we batch these requests, use a custom endpoint and don't truncate the strings.
+        this._instance.capture('$snapshot', properties, {
+            _url: this._instance.requestRouter.endpointFor('api', this._endpoint),
             _noTruncate: true,
             _batchKey: SESSION_RECORDING_BATCH_KEY,
             skip_client_rate_limiting: true,
-        }
+        })
+    }
 
+    private _snapshotUrl(): string {
+        const host = this._instance.config.host || ''
         try {
-            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)
+            // 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}`
         }
-
-        // :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 {
@@ -1103,7 +1110,7 @@ export class LazyLoadedSessionRecording implements LazyLoadedSessionRecordingInt
     }
 
     private _reportStarted(startReason: SessionStartReason, tagPayload?: Record<string, any>) {
-        this._instance.register_for_session({
+        this._instance.registerForSession({
             $session_recording_start_reason: startReason,
         })
         logger.info(startReason.replace('_', ' '), tagPayload)
@@ -1337,8 +1344,8 @@ export class LazyLoadedSessionRecording implements LazyLoadedSessionRecordingInt
         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,8 +16,11 @@ 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: this._options.bucketSize ?? 100,
+            bucketSize: effectiveBucketSize,
             refillRate: this._options.refillRate ?? 10,
             refillInterval: 1000, // one second
             _onBucketRateLimited: this._onNodeRateLimited,

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

@@ -12,7 +12,6 @@
 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'
@@ -46,6 +45,10 @@ 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
@@ -668,12 +671,16 @@ function initNetworkObserver(
         fetchObserver = initFetchObserver(cb, win, networkOptions)
     }
 
-    initialisedHandler = () => {
+    const teardown: listenerHandler = () => {
         performanceObserver()
         xhrObserver()
         fetchObserver()
+        // allow future observers to initialize after cleanup
+        initialisedHandler = null
     }
-    return initialisedHandler
+
+    initialisedHandler = teardown
+    return teardown
 }
 
 // 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 { PostHog } from '../../../posthog-core'
-import { FlagVariant, RemoteConfig, SessionRecordingPersistedConfig, SessionRecordingUrlTrigger } from '../../../types'
+import { Leanbase } from '../../../leanbase'
+import { RemoteConfig, SessionRecordingPersistedConfig, SessionRecordingUrlTrigger } from '../../../types'
 import { isNullish, isBoolean, isString, isObject } from '@posthog/core'
-import { window } from '../../../utils/globals'
+import { window } from '../../../utils'
 
 export const DISABLED = 'disabled'
 export const SAMPLED = 'sampled'
@@ -133,7 +133,7 @@ export class URLTriggerMatching implements TriggerStatusMatching {
 
     urlBlocked: boolean = false
 
-    constructor(private readonly _instance: PostHog) {}
+    constructor(private readonly _instance: Leanbase) {}
 
     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.register_for_session({
+        this._instance.registerForSession({
             $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 | FlagVariant | null = null
+    linkedFlag: string | { flag: string; variant: string } | null = null
     linkedFlagSeen: boolean = false
     private _flagListenerCleanup: () => void = () => {}
-    constructor(private readonly _instance: PostHog) {}
+    constructor(private readonly _instance: Leanbase) {}
 
     triggerStatus(): TriggerStatus {
         let result = TRIGGER_PENDING
@@ -225,7 +225,7 @@ export class LinkedFlagMatching implements TriggerStatusMatching {
         if (this.linkedFlagSeen) {
             result = TRIGGER_ACTIVATED
         }
-        this._instance.register_for_session({
+        this._instance.registerForSession({
             $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: any, variants: any) => {
-                const flagIsPresent = isObject(variants) && linkedFlag in variants
+            this._flagListenerCleanup = this._instance.onFeatureFlags((flags) => {
+                const flagIsPresent = isObject(flags) && linkedFlag in (flags as any)
                 let linkedFlagMatches = false
                 if (flagIsPresent) {
-                    const variantForFlagKey = variants[linkedFlag]
+                    const variantForFlagKey = (flags as any)[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: PostHog) {}
+    constructor(private readonly _instance: Leanbase) {}
 
     onConfig(config: ReplayConfigType) {
         this._eventTriggers =
@@ -314,7 +314,7 @@ export class EventTriggerMatching implements TriggerStatusMatching {
                 : eventTriggerStatus === TRIGGER_PENDING
                   ? TRIGGER_PENDING
                   : TRIGGER_DISABLED
-        this._instance.register_for_session({
+        this._instance.registerForSession({
             $sdk_debug_replay_event_trigger_status: result,
         })
         return result

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

@@ -1,6 +1,3 @@
-// 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(
@@ -18,8 +15,6 @@ 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 || {}
@@ -40,7 +35,5 @@ 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
     }
 }