@leanbase-giangnd/js 0.3.1 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@leanbase-giangnd/js",
-    "version": "0.3.1",
+    "version": "0.4.0",
     "description": "Leanbase browser SDK - event tracking, autocapture, and session replay",
     "repository": {
         "type": "git",
@@ -35,6 +35,7 @@
     "dependencies": {
         "@posthog/core": "workspace:*",
         "@rrweb/record": "2.0.0-alpha.17",
+        "@rrweb/rrweb-plugin-console-record": "2.0.0-alpha.17",
         "fflate": "^0.4.8"
     },
     "devDependencies": {

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

@@ -318,12 +318,18 @@ export class LazyLoadedSessionRecording {
      * Util to help developers working on this feature manually override
      */
     private _forceAllowLocalhostNetworkCapture = false
+    private _debug(...args: any[]) {
+        if (this._instance?.config?.debug) {
+            logger.info(...args)
+        }
+    }
     // "Started" is only true once we have a valid rrweb stop handler AND we have marked recording enabled.
     // If rrweb fails to initialize, we permanently disable replay for this page load.
     private _recording: { stop: listenerHandler } | undefined
     private _stopRrweb: listenerHandler | undefined = undefined
     private _permanentlyDisabled: boolean = false
     private _loggedPermanentlyDisabled: boolean = false
+    private _hasReportedRecordingInitialized: boolean = false
     private _lastActivityTimestamp: number = Date.now()
     /**
      * if pageview capture is disabled,
@@ -536,31 +542,84 @@ export class LazyLoadedSessionRecording {
         }
     }
 
-    private _gatherRRWebPlugins() {
+    private async _loadConsolePlugin(): Promise<RecordPlugin | null> {
+        try {
+            const mod: any = await import('@rrweb/rrweb-plugin-console-record')
+            const factory = mod?.getRecordConsolePlugin ?? mod?.default?.getRecordConsolePlugin
+
+            if (typeof factory === 'function') {
+                const plugin = factory()
+                this._debug('Console plugin loaded')
+                return plugin
+            }
+
+            logger.warn('console plugin factory unavailable after import')
+        } catch (e) {
+            logger.warn('could not load console plugin', e)
+        }
+
+        return null
+    }
+
+    private async _loadNetworkPlugin(
+        networkPayloadCapture: Pick<
+            NetworkRecordOptions,
+            'recordHeaders' | 'recordBody' | 'recordPerformance' | 'payloadHostDenyList'
+        >
+    ): Promise<RecordPlugin | null> {
+        try {
+            const mod: any = await import('./network-plugin')
+            const factory = mod?.getRecordNetworkPlugin ?? mod?.default?.getRecordNetworkPlugin
+
+            if (typeof factory === 'function') {
+                const options = buildNetworkRequestOptions(this._instance.config, networkPayloadCapture)
+                const plugin = factory(options)
+                this._debug('Network plugin loaded')
+                return plugin
+            }
+
+            logger.warn('network plugin factory unavailable after import')
+        } catch (e) {
+            logger.warn('could not load network plugin', e)
+        }
+
+        return null
+    }
+
+    private async _gatherRRWebPlugins(): Promise<RecordPlugin[]> {
         const plugins: RecordPlugin[] = []
 
+        if (!window) {
+            return plugins
+        }
+
         if (this._isConsoleLogCaptureEnabled) {
-            logger.info('Console log capture requested but console plugin is not bundled in this build yet.')
+            const consolePlugin = await this._loadConsolePlugin()
+            if (consolePlugin) {
+                plugins.push(consolePlugin)
+            }
         }
 
         if (this._networkPayloadCapture) {
             const canRecordNetwork = !isLocalhost() || this._forceAllowLocalhostNetworkCapture
 
             if (canRecordNetwork) {
-                const assignableWindow: any = globalThis
-                const networkFactory = assignableWindow.__PosthogExtensions__?.rrwebPlugins?.getRecordNetworkPlugin?.()
-                if (typeof networkFactory === 'function') {
-                    plugins.push(
-                        networkFactory(buildNetworkRequestOptions(this._instance.config, this._networkPayloadCapture))
-                    )
-                } else {
-                    logger.info('Network plugin factory not available yet; skipping network plugin')
+                const networkPlugin = await this._loadNetworkPlugin(this._networkPayloadCapture)
+                if (networkPlugin) {
+                    plugins.push(networkPlugin)
                 }
             } else {
-                logger.info('NetworkCapture not started because we are on localhost.')
+                this._debug('NetworkCapture not started because we are on localhost.')
             }
         }
 
+        if (plugins.length > 0) {
+            this._debug(
+                'Replay plugins loaded',
+                plugins.map((p) => p.name)
+            )
+        }
+
         return plugins
     }
 
@@ -886,7 +945,13 @@ export class LazyLoadedSessionRecording {
         }
 
         if (this.status === ACTIVE) {
-            this._reportStarted(startReason || 'recording_initialized')
+            const reason = startReason || 'recording_initialized'
+            if (reason !== 'recording_initialized' || !this._hasReportedRecordingInitialized) {
+                if (reason === 'recording_initialized') {
+                    this._hasReportedRecordingInitialized = true
+                }
+                this._reportStarted(reason)
+            }
         }
     }
 
@@ -942,19 +1007,36 @@ export class LazyLoadedSessionRecording {
         this._recording = undefined
         this._stopRrweb = undefined
         this._isFullyReady = false
+        this._hasReportedRecordingInitialized = false
 
         logger.info('stopped')
     }
 
     private _snapshotIngestionUrl(): string | null {
         const endpointFor = (this._instance as any)?.requestRouter?.endpointFor
-        if (typeof endpointFor !== 'function') {
+
+        // Prefer requestRouter (parity with Browser SDK)
+        if (typeof endpointFor === 'function') {
+            try {
+                return endpointFor('api', this._endpoint)
+            } catch {
+                return null
+            }
+        }
+
+        // Fallback: construct from host/api_host if requestRouter is unavailable (older IIFE builds)
+        const host = (this._instance.config.api_host || this._instance.config.host || '').trim()
+        if (!host) {
             return null
         }
+
         try {
-            return endpointFor('api', this._endpoint)
+            // eslint-disable-next-line compat/compat
+            return new URL(this._endpoint, host).href
         } catch {
-            return null
+            const normalizedHost = host.endsWith('/') ? host.slice(0, -1) : host
+            const normalizedEndpoint = this._endpoint.startsWith('/') ? this._endpoint : `/${this._endpoint}`
+            return `${normalizedHost}${normalizedEndpoint}`
         }
     }
 
@@ -1315,7 +1397,12 @@ export class LazyLoadedSessionRecording {
         this._instance.registerForSession({
             $session_recording_start_reason: startReason,
         })
-        logger.info(startReason.replace('_', ' '), tagPayload)
+        const message = startReason.replace('_', ' ')
+        if (typeof tagPayload === 'undefined') {
+            logger.info(message)
+        } else {
+            logger.info(message, tagPayload)
+        }
         if (!includes(['recording_initialized', 'session_id_changed'], startReason)) {
             this._tryAddCustomEvent(startReason, tagPayload)
         }
@@ -1547,7 +1634,7 @@ export class LazyLoadedSessionRecording {
             return
         }
 
-        const activePlugins = this._gatherRRWebPlugins()
+        const activePlugins = await this._gatherRRWebPlugins()
 
         let stopHandler: listenerHandler | undefined
         try {

package/src/extensions/replay/session-recording.ts

@@ -25,6 +25,12 @@ export class SessionRecording {
     private _persistFlagsOnSessionListener: (() => void) | undefined = undefined
     private _lazyLoadedSessionRecording: LazyLoadedSessionRecording | undefined
 
+    private _debug(...args: any[]) {
+        if (this._instance?.config?.debug) {
+            log.info(...args)
+        }
+    }
+
     public get started(): boolean {
         return !!this._lazyLoadedSessionRecording?.isStarted
     }
@@ -66,8 +72,10 @@ export class SessionRecording {
 
         const canRunReplay = !isUndefined(Object.assign) && !isUndefined(Array.from)
         if (this._isRecordingEnabled && canRunReplay) {
+            this._debug('Session replay enabled; starting recorder')
             this._lazyLoadAndStart(startReason)
         } else {
+            this._debug('Session replay disabled; stopping recorder')
             this.stopRecording()
         }
     }
@@ -156,13 +164,8 @@ export class SessionRecording {
             log.info('skipping remote config with no sessionRecording', response)
             return
         }
-        this._receivedFlags = true
-
-        if (response.sessionRecording === false) {
-            return
-        }
-
         this._persistRemoteConfig(response)
+        this._receivedFlags = true
         this.startIfEnabledOrStop()
     }
 

package/src/leanbase.ts

@@ -43,7 +43,7 @@ import { PageViewManager } from './page-view'
 import { ScrollManager } from './scroll-manager'
 import { isLikelyBot } from './utils/blocked-uas'
 import { SessionRecording } from './extensions/replay/session-recording'
-import type { RequestRouter } from '../../browser/lib/src/utils/request-router'
+import { RequestRouter } from './utils/request-router'
 import type { ConsentManager } from '../../browser/lib/src/consent'
 
 const defaultConfig = (): LeanbaseConfig => ({
@@ -124,6 +124,9 @@ export class Leanbase extends PostHogCore {
         this.isLoaded = true
         this.persistence = new LeanbasePersistence(this.config)
 
+        // Browser SDK always has a requestRouter; session replay relies on it for $snapshot ingestion URLs.
+        this.requestRouter = new RequestRouter(this)
+
         if (this.config.cookieless_mode !== 'always') {
             this.sessionManager = new SessionIdManager(this)
             this.sessionPropsManager = new SessionPropsManager(this, this.sessionManager, this.persistence)

package/src/utils/request-router.ts

@@ -0,0 +1,39 @@
+import type { Leanbase } from '../leanbase'
+
+export type RequestRouterTarget = 'api' | 'ui' | 'assets'
+
+/**
+ * Leanbase-local version of PostHog's RequestRouter.
+ *
+ * Browser SDK always has a requestRouter instance; Leanbase IIFE needs this too so
+ * features like Session Replay can construct ingestion URLs.
+ */
+export class RequestRouter {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    constructor(private readonly instance: Leanbase) {}
+
+    get apiHost(): string {
+        const configured = (this.instance.config.api_host || this.instance.config.host || '').trim()
+        return configured.replace(/\/$/, '')
+    }
+
+    get uiHost(): string | undefined {
+        const configured = this.instance.config.ui_host?.trim().replace(/\/$/, '')
+        return configured || undefined
+    }
+
+    endpointFor(target: RequestRouterTarget, path: string = ''): string {
+        if (path) {
+            path = path[0] === '/' ? path : `/${path}`
+        }
+
+        if (target === 'ui') {
+            const host = this.uiHost || this.apiHost
+            return host + path
+        }
+
+        // Leanbase doesn't currently do region-based routing; default to apiHost.
+        // Browser's router has special handling for assets; we keep parity in interface, not domains.
+        return this.apiHost + path
+    }
+}

package/src/version.ts

@@ -1 +1 @@
-export const version = '0.3.1'
+export const version = '0.4.0'