@leanbase-giangnd/js 0.2.3 → 0.2.4

package/dist/index.cjs

@@ -1171,7 +1171,7 @@ const detectDeviceType = function (user_agent) {
   }
 };
 
-var version = "0.2.3";
+var version = "0.2.4";
 var packageInfo = {
 	version: version};
 
@@ -3847,34 +3847,49 @@ class MutationThrottler {
       }
       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);
@@ -4112,6 +4127,9 @@ class LazyLoadedSessionRecording {
      */
     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();
@@ -4292,7 +4310,11 @@ class LazyLoadedSessionRecording {
     }
   }
   _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 {
@@ -4338,7 +4360,11 @@ class LazyLoadedSessionRecording {
     }
   }
   _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)) {
@@ -4414,6 +4440,7 @@ class LazyLoadedSessionRecording {
     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');
@@ -4453,6 +4480,9 @@ class LazyLoadedSessionRecording {
     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);
@@ -4530,77 +4560,100 @@ class LazyLoadedSessionRecording {
     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 || !core.isObject(rawEvent)) {
+    // Never process rrweb emits until we're fully ready.
+    if (!this._isFullyReady || !this.isStarted) {
       return;
     }
-    if (rawEvent.type === EventType.Meta) {
-      const href = this._maskUrl(rawEvent.data.href);
-      this._lastHref = href;
-      if (!href) {
+    try {
+      this._processQueuedEvents();
+      if (!rawEvent || !core.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.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.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;
+      if (rawEvent.type === EventType.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.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.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);
     }
-    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);
   }
   get status() {
     return this._statusMatcher({
@@ -4678,6 +4731,16 @@ class LazyLoadedSessionRecording {
       }, 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 => {
@@ -4710,13 +4773,25 @@ class LazyLoadedSessionRecording {
     }
   }
   _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 || '';
@@ -4989,7 +5064,11 @@ class LazyLoadedSessionRecording {
     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