@leanbase-giangnd/js 0.2.3 → 0.2.4

package/dist/leanbase.iife.js

@@ -2846,7 +2846,7 @@ var leanbase = (function () {
       }
     };
 
-    var version = "0.2.3";
+    var version = "0.2.4";
     var packageInfo = {
     	version: version};
 
@@ -6106,34 +6106,49 @@ var leanbase = (function () {
           }
           return [id, node];
         };
-        this._getNode = id => this._rrweb.mirror.getNode(id);
+        this._getNode = id => {
+          // eslint-disable-next-line posthog-js/no-direct-undefined-check, posthog-js/no-direct-null-check
+          if (id === null || id === undefined) {
+            return null;
+          }
+          try {
+            return this._rrweb.mirror.getNode(id) ?? null;
+          } catch {
+            return null;
+          }
+        };
         this._numberOfChanges = data => {
           return (data.removes?.length ?? 0) + (data.attributes?.length ?? 0) + (data.texts?.length ?? 0) + (data.adds?.length ?? 0);
         };
         this.throttleMutations = event => {
-          if (event.type !== INCREMENTAL_SNAPSHOT_EVENT_TYPE || event.data.source !== MUTATION_SOURCE_TYPE) {
+          try {
+            if (event.type !== INCREMENTAL_SNAPSHOT_EVENT_TYPE || event.data.source !== MUTATION_SOURCE_TYPE) {
+              return event;
+            }
+            const data = event.data;
+            const initialMutationCount = this._numberOfChanges(data);
+            if (data.attributes) {
+              // Most problematic mutations come from attrs where the style or minor properties are changed rapidly
+              data.attributes = data.attributes.filter(attr => {
+                const id = attr?.id;
+                if (typeof id !== 'number') {
+                  return true;
+                }
+                const [nodeId] = this._getNodeOrRelevantParent(id);
+                const isRateLimited = this._rateLimiter.consumeRateLimit(nodeId);
+                return !isRateLimited;
+              });
+            }
+            // Check if every part of the mutation is empty in which case there is nothing to do
+            const mutationCount = this._numberOfChanges(data);
+            if (mutationCount === 0 && initialMutationCount !== mutationCount) {
+              // If we have modified the mutation count and the remaining count is 0, then we don't need the event.
+              return;
+            }
+            return event;
+          } catch {
             return event;
           }
-          const data = event.data;
-          const initialMutationCount = this._numberOfChanges(data);
-          if (data.attributes) {
-            // Most problematic mutations come from attrs where the style or minor properties are changed rapidly
-            data.attributes = data.attributes.filter(attr => {
-              const [nodeId] = this._getNodeOrRelevantParent(attr.id);
-              const isRateLimited = this._rateLimiter.consumeRateLimit(nodeId);
-              if (isRateLimited) {
-                return false;
-              }
-              return attr;
-            });
-          }
-          // Check if every part of the mutation is empty in which case there is nothing to do
-          const mutationCount = this._numberOfChanges(data);
-          if (mutationCount === 0 && initialMutationCount !== mutationCount) {
-            // If we have modified the mutation count and the remaining count is 0, then we don't need the event.
-            return;
-          }
-          return event;
         };
         const configuredBucketSize = this._options.bucketSize ?? 100;
         const effectiveBucketSize = Math.max(configuredBucketSize - 1, 1);
@@ -6371,6 +6386,9 @@ var leanbase = (function () {
          */
         this._queuedRRWebEvents = [];
         this._isIdle = 'unknown';
+        // Replay should not process rrweb emits until all critical dependencies are ready.
+        this._isFullyReady = false;
+        this._loggedMissingEndpointFor = false;
         // we need to be able to check the state of the event and url triggers separately
         // as we make some decisions based on them without referencing LinkedFlag etc
         this._triggerMatching = new PendingTriggerMatching();
@@ -6551,7 +6569,11 @@ var leanbase = (function () {
         }
       }
       _tryAddCustomEvent(tag, payload) {
-        return this._tryRRWebMethod(newQueuedEvent(() => getRRWebRecord().addCustomEvent(tag, payload)));
+        const rrwebRecord = getRRWebRecord();
+        if (!rrwebRecord || typeof rrwebRecord.addCustomEvent !== 'function') {
+          return false;
+        }
+        return this._tryRRWebMethod(newQueuedEvent(() => rrwebRecord.addCustomEvent(tag, payload)));
       }
       _pageViewFallBack() {
         try {
@@ -6597,7 +6619,11 @@ var leanbase = (function () {
         }
       }
       _tryTakeFullSnapshot() {
-        return this._tryRRWebMethod(newQueuedEvent(() => getRRWebRecord().takeFullSnapshot()));
+        const rrwebRecord = getRRWebRecord();
+        if (!rrwebRecord || typeof rrwebRecord.takeFullSnapshot !== 'function') {
+          return false;
+        }
+        return this._tryRRWebMethod(newQueuedEvent(() => rrwebRecord.takeFullSnapshot()));
       }
       get _fullSnapshotIntervalMillis() {
         if (this._triggerMatching.triggerStatus(this.sessionId) === TRIGGER_PENDING && !['sampled', 'active'].includes(this.status)) {
@@ -6673,6 +6699,7 @@ var leanbase = (function () {
         return parsedConfig;
       }
       async start(startReason) {
+        this._isFullyReady = false;
         const config = this._remoteConfig;
         if (!config) {
           logger.info('remote config must be stored in persistence before recording can start');
@@ -6712,6 +6739,9 @@ var leanbase = (function () {
         if (!this.isStarted) {
           return;
         }
+        // Only start processing rrweb emits once the ingestion endpoint is available.
+        // If it isn't available, we must degrade to a no-op (never crash the host app).
+        this._isFullyReady = this._canCaptureSnapshots();
         // calling addEventListener multiple times is safe and will not add duplicates
         addEventListener(win, 'beforeunload', this._onBeforeUnload);
         addEventListener(win, 'offline', this._onOffline);
@@ -6789,77 +6819,100 @@ var leanbase = (function () {
         this._queuedRRWebEvents = [];
         this._stopRrweb?.();
         this._stopRrweb = undefined;
+        this._isFullyReady = false;
         logger.info('stopped');
       }
+      _snapshotIngestionUrl() {
+        const endpointFor = this._instance?.requestRouter?.endpointFor;
+        if (typeof endpointFor !== 'function') {
+          return null;
+        }
+        try {
+          return endpointFor('api', this._endpoint);
+        } catch {
+          return null;
+        }
+      }
+      _canCaptureSnapshots() {
+        return !!this._snapshotIngestionUrl();
+      }
       onRRwebEmit(rawEvent) {
-        this._processQueuedEvents();
-        if (!rawEvent || !isObject(rawEvent)) {
+        // Never process rrweb emits until we're fully ready.
+        if (!this._isFullyReady || !this.isStarted) {
           return;
         }
-        if (rawEvent.type === EventType$1.Meta) {
-          const href = this._maskUrl(rawEvent.data.href);
-          this._lastHref = href;
-          if (!href) {
+        try {
+          this._processQueuedEvents();
+          if (!rawEvent || !isObject(rawEvent)) {
             return;
           }
-          rawEvent.data.href = href;
-        } else {
-          this._pageViewFallBack();
-        }
-        // Check if the URL matches any trigger patterns
-        this._urlTriggerMatching.checkUrlTriggerConditions(() => this._pauseRecording(), () => this._resumeRecording(), triggerType => this._activateTrigger(triggerType));
-        // always have to check if the URL is blocked really early,
-        // or you risk getting stuck in a loop
-        if (this._urlTriggerMatching.urlBlocked && !isRecordingPausedEvent(rawEvent)) {
-          return;
-        }
-        // we're processing a full snapshot, so we should reset the timer
-        if (rawEvent.type === EventType$1.FullSnapshot) {
-          this._scheduleFullSnapshot();
-          // Full snapshots reset rrweb's node IDs, so clear any logged node tracking
-          this._mutationThrottler?.reset();
-        }
-        // Clear the buffer if waiting for a trigger and only keep data from after the current full snapshot
-        // we always start trigger pending so need to wait for flags before we know if we're really pending
-        if (rawEvent.type === EventType$1.FullSnapshot && this._triggerMatching.triggerStatus(this.sessionId) === TRIGGER_PENDING) {
-          this._clearBufferBeforeMostRecentMeta();
-        }
-        const throttledEvent = this._mutationThrottler ? this._mutationThrottler.throttleMutations(rawEvent) : rawEvent;
-        if (!throttledEvent) {
-          return;
-        }
-        // TODO: Re-add ensureMaxMessageSize once we are confident in it
-        const event = truncateLargeConsoleLogs(throttledEvent);
-        this._updateWindowAndSessionIds(event);
-        // When in an idle state we keep recording but don't capture the events,
-        // we don't want to return early if idle is 'unknown'
-        if (this._isIdle === true && !isSessionIdleEvent(event)) {
-          return;
-        }
-        if (isSessionIdleEvent(event)) {
-          // session idle events have a timestamp when rrweb sees them
-          // which can artificially lengthen a session
-          // we know when we detected it based on the payload and can correct the timestamp
-          const payload = event.data.payload;
-          if (payload) {
-            const lastActivity = payload.lastActivityTimestamp;
-            const threshold = payload.threshold;
-            event.timestamp = lastActivity + threshold;
-          }
-        }
-        const eventToSend = this._instance.config.session_recording?.compress_events ?? true ? compressEvent(event) : event;
-        const size = estimateSize(eventToSend);
-        const properties = {
-          $snapshot_bytes: size,
-          $snapshot_data: eventToSend,
-          $session_id: this._sessionId,
-          $window_id: this._windowId
-        };
-        if (this.status === DISABLED) {
-          this._clearBuffer();
-          return;
+          if (rawEvent.type === EventType$1.Meta) {
+            const href = this._maskUrl(rawEvent.data.href);
+            this._lastHref = href;
+            if (!href) {
+              return;
+            }
+            rawEvent.data.href = href;
+          } else {
+            this._pageViewFallBack();
+          }
+          // Check if the URL matches any trigger patterns
+          this._urlTriggerMatching.checkUrlTriggerConditions(() => this._pauseRecording(), () => this._resumeRecording(), triggerType => this._activateTrigger(triggerType));
+          // always have to check if the URL is blocked really early,
+          // or you risk getting stuck in a loop
+          if (this._urlTriggerMatching.urlBlocked && !isRecordingPausedEvent(rawEvent)) {
+            return;
+          }
+          // we're processing a full snapshot, so we should reset the timer
+          if (rawEvent.type === EventType$1.FullSnapshot) {
+            this._scheduleFullSnapshot();
+            // Full snapshots reset rrweb's node IDs, so clear any logged node tracking
+            this._mutationThrottler?.reset();
+          }
+          // Clear the buffer if waiting for a trigger and only keep data from after the current full snapshot
+          // we always start trigger pending so need to wait for flags before we know if we're really pending
+          if (rawEvent.type === EventType$1.FullSnapshot && this._triggerMatching.triggerStatus(this.sessionId) === TRIGGER_PENDING) {
+            this._clearBufferBeforeMostRecentMeta();
+          }
+          const throttledEvent = this._mutationThrottler ? this._mutationThrottler.throttleMutations(rawEvent) : rawEvent;
+          if (!throttledEvent) {
+            return;
+          }
+          // TODO: Re-add ensureMaxMessageSize once we are confident in it
+          const event = truncateLargeConsoleLogs(throttledEvent);
+          this._updateWindowAndSessionIds(event);
+          // When in an idle state we keep recording but don't capture the events,
+          // we don't want to return early if idle is 'unknown'
+          if (this._isIdle === true && !isSessionIdleEvent(event)) {
+            return;
+          }
+          if (isSessionIdleEvent(event)) {
+            // session idle events have a timestamp when rrweb sees them
+            // which can artificially lengthen a session
+            // we know when we detected it based on the payload and can correct the timestamp
+            const payload = event.data.payload;
+            if (payload) {
+              const lastActivity = payload.lastActivityTimestamp;
+              const threshold = payload.threshold;
+              event.timestamp = lastActivity + threshold;
+            }
+          }
+          const eventToSend = this._instance.config.session_recording?.compress_events ?? true ? compressEvent(event) : event;
+          const size = estimateSize(eventToSend);
+          const properties = {
+            $snapshot_bytes: size,
+            $snapshot_data: eventToSend,
+            $session_id: this._sessionId,
+            $window_id: this._windowId
+          };
+          if (this.status === DISABLED) {
+            this._clearBuffer();
+            return;
+          }
+          this._captureSnapshotBuffered(properties);
+        } catch (e) {
+          logger.error('error processing rrweb event', e);
         }
-        this._captureSnapshotBuffered(properties);
       }
       get status() {
         return this._statusMatcher({
@@ -6937,6 +6990,16 @@ var leanbase = (function () {
           }, RECORDING_BUFFER_TIMEOUT);
           return this._buffer;
         }
+        if (!this._canCaptureSnapshots()) {
+          if (!this._loggedMissingEndpointFor) {
+            this._loggedMissingEndpointFor = true;
+            logger.warn('snapshot capture skipped because requestRouter.endpointFor is unavailable');
+          }
+          this._flushBufferTimer = setTimeout(() => {
+            this._flushBuffer();
+          }, RECORDING_BUFFER_TIMEOUT);
+          return this._buffer;
+        }
         if (this._buffer.data.length > 0) {
           const snapshotEvents = splitBuffer(this._buffer);
           snapshotEvents.forEach(snapshotBuffer => {
@@ -6969,13 +7032,25 @@ var leanbase = (function () {
         }
       }
       _captureSnapshot(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._instance.requestRouter.endpointFor('api', this._endpoint),
-          _noTruncate: true,
-          _batchKey: SESSION_RECORDING_BATCH_KEY,
-          skip_client_rate_limiting: true
-        });
+        const url = this._snapshotIngestionUrl();
+        if (!url) {
+          if (!this._loggedMissingEndpointFor) {
+            this._loggedMissingEndpointFor = true;
+            logger.warn('snapshot capture skipped because requestRouter.endpointFor is unavailable');
+          }
+          return;
+        }
+        try {
+          // :TRICKY: Make sure we batch these requests, use a custom endpoint and don't truncate the strings.
+          this._instance.capture('$snapshot', properties, {
+            _url: url,
+            _noTruncate: true,
+            _batchKey: SESSION_RECORDING_BATCH_KEY,
+            skip_client_rate_limiting: true
+          });
+        } catch (e) {
+          logger.error('failed to capture snapshot', e);
+        }
       }
       _snapshotUrl() {
         const host = this._instance.config.host || '';
@@ -7248,7 +7323,11 @@ var leanbase = (function () {
         try {
           this._stopRrweb = rrwebRecord({
             emit: event => {
-              this.onRRwebEmit(event);
+              try {
+                this.onRRwebEmit(event);
+              } catch (e) {
+                logger.error('error in rrweb emit handler', e);
+              }
             },
             plugins: activePlugins,
             ...sessionRecordingOptions