@leanbase-giangnd/js 0.0.3 → 0.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leanbase-giangnd/js",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "Leanbase browser SDK - event tracking, autocapture, and session replay",
   "repository": {
     "type": "git",
@@ -31,8 +31,8 @@
     "jest-environment-jsdom": "^29.7.0",
     "rollup": "^4.44.1",
     "rimraf": "^6.0.1",
-    "@posthog-tooling/rollup-utils": "1.0.0",
-    "@posthog-tooling/tsconfig-base": "1.0.0"
+    "@posthog-tooling/tsconfig-base": "1.0.0",
+    "@posthog-tooling/rollup-utils": "1.0.0"
   },
   "scripts": {
     "clean": "rimraf dist coverage",

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

@@ -43,6 +43,7 @@ import {
     SESSION_RECORDING_REMOTE_CONFIG,
     SESSION_RECORDING_URL_TRIGGER_ACTIVATED_SESSION,
 } from '../../../constants'
+import { sendSnapshotDirect } from './snapshot-transport'
 import { Leanbase } from '../../../leanbase'
 import {
     CaptureResult,
@@ -1019,14 +1020,32 @@ 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(),
-            _noTruncate: true,
-            _batchKey: SESSION_RECORDING_BATCH_KEY,
-            skip_client_rate_limiting: true,
-        })
+    private async _captureSnapshot(properties: Properties) {
+        // Send snapshots directly to the recorder endpoint to avoid the core
+        // analytics batching and persisted queue. The lifecycle gate in
+        // SessionRecording ensures this method is only called when recording
+        // is allowed.
+        try {
+            const url = this._snapshotUrl()
+            // include minimal metadata expected by /s/ endpoint
+            const payload = {
+                $snapshot_bytes: properties.$snapshot_bytes,
+                $snapshot_data: properties.$snapshot_data,
+                $session_id: properties.$session_id,
+                $window_id: properties.$window_id,
+                $lib: properties.$lib,
+                $lib_version: properties.$lib_version,
+                // include distinct_id from persistence for server-side association
+                distinct_id: this._instance.persistence?.get_property('distinct_id'),
+            }
+
+            await sendSnapshotDirect(this._instance, url, payload)
+        } catch (err) {
+            try {
+                // eslint-disable-next-line no-console
+                console.debug('[SessionRecording] snapshot send failed', err)
+            } catch {}
+        }
     }
 
     private _snapshotUrl(): string {

package/src/extensions/replay/external/snapshot-transport.ts

@@ -0,0 +1,50 @@
+import { gzipSync, strToU8 } from 'fflate'
+import { Leanbase } from '../../../leanbase'
+
+/**
+ * Leanbase-only SnapshotTransport
+ * Sends gzip-compressed snapshot payloads directly to the /s/ endpoint.
+ * This bypasses `posthog.capture()` and the analytics /batch/ queue.
+ *
+ * Reasoning: session replay snapshots must not enter the batch/persisted
+ * queues managed by @posthog/core. This transport posts directly to the
+ * recorder endpoint and uses the instance.fetch() implementation so it
+ * runs in the same environment the SDK uses.
+ */
+export async function sendSnapshotDirect(instance: Leanbase, url: string, payload: unknown) {
+    const fetchFn: any =
+        instance && (instance as any).fetch ? (instance as any).fetch.bind(instance) : (globalThis as any).fetch
+
+    const body = JSON.stringify(payload)
+    const compressed = gzipSync(strToU8(body))
+
+    const headers: Record<string, string> = {
+        'Content-Encoding': 'gzip',
+        'Content-Type': 'application/json',
+        Accept: 'application/json',
+    }
+
+    if (!fetchFn) {
+        // best-effort: if no fetch available, fail silently (recorder should not crash app)
+        try {
+            // eslint-disable-next-line no-console
+            console.debug('[SnapshotTransport] no fetch available, dropping snapshot')
+        } catch {}
+        return { status: 0 }
+    }
+
+    try {
+        // Use the instance.fetch wrapper so environment-specific shims are used.
+        return await fetchFn(url, {
+            method: 'POST',
+            body: compressed,
+            headers,
+        })
+    } catch (err) {
+        try {
+            // eslint-disable-next-line no-console
+            console.debug('[SnapshotTransport] send failed', err)
+        } catch {}
+        return { status: 0 }
+    }
+}

package/src/leanbase.ts

@@ -36,7 +36,7 @@ import { decompressSync, strFromU8 } from 'fflate'
 import Config from './config'
 import { Autocapture } from './autocapture'
 import { logger } from './leanbase-logger'
-import { COOKIELESS_MODE_FLAG_PROPERTY, USER_STATE } from './constants'
+import { COOKIELESS_MODE_FLAG_PROPERTY, USER_STATE, SESSION_RECORDING_REMOTE_CONFIG } from './constants'
 import { getEventProperties } from './utils/event-utils'
 import { SessionIdManager } from './sessionid'
 import { SessionPropsManager } from './session-props'
@@ -293,6 +293,36 @@ export class Leanbase extends PostHogCore {
                         )
                     } catch {}
 
+                    // If remote config has explicitly disabled session recording, drop snapshot events
+                    try {
+                        // Read persisted remote config that SessionRecording stores
+                        const persisted: any = this.get_property(SESSION_RECORDING_REMOTE_CONFIG)
+                        const serverAllowsRecording = !(
+                            (persisted && persisted.enabled === false) ||
+                            this.config.disable_session_recording === true
+                        )
+
+                        if (!serverAllowsRecording && hasSnapshot) {
+                            // remove snapshot events from the batch before sending to /batch/
+                            parsed.batch = parsed.batch.filter((item: any) => !(item && item.event === '$snapshot'))
+                            // If no events remain, short-circuit and avoid sending an empty batch
+                            if (!parsed.batch.length) {
+                                try {
+                                    // eslint-disable-next-line no-console
+                                    console.debug(
+                                        '[Leanbase.fetch] sessionRecording disabled, dropping snapshot-only batch'
+                                    )
+                                } catch {}
+                                return { status: 200, json: async () => ({}) } as any
+                            }
+                            // re-encode the body so the underlying fetch receives the modified batch
+                            try {
+                                const newBody = JSON.stringify(parsed)
+                                options = { ...options, body: newBody }
+                            } catch {}
+                        }
+                    } catch {}
+
                     if (hasSnapshot) {
                         const host = (this.config && this.config.host) || ''
                         const newUrl = host ? `${host.replace(/\/$/, '')}/s/` : url

package/src/version.ts

@@ -1 +1 @@
-export const version = '0.0.3'
+export const version = '0.0.5'