ref(replay): Make options and recordingOptions private

Author: mydea

packages/replay/src/replay.ts

@@ -67,9 +67,9 @@ export class ReplayContainer implements ReplayContainerInterface {
   /**
    * Options to pass to `rrweb.record()`
    */
-  readonly recordingOptions: RecordingOptions;
+  private readonly _recordingOptions: RecordingOptions;
 
-  readonly options: ReplayPluginOptions;
+  private readonly _options: ReplayPluginOptions;
 
   private _performanceObserver: PerformanceObserver | null = null;
 
@@ -123,11 +123,11 @@ export class ReplayContainer implements ReplayContainerInterface {
   };
 
   constructor({ options, recordingOptions }: { options: ReplayPluginOptions; recordingOptions: RecordingOptions }) {
-    this.recordingOptions = recordingOptions;
-    this.options = options;
+    this._recordingOptions = recordingOptions;
+    this._options = options;
 
-    this._debouncedFlush = debounce(() => this.flush(), this.options.flushMinDelay, {
-      maxWait: this.options.flushMaxDelay,
+    this._debouncedFlush = debounce(() => this.flush(), this._options.flushMinDelay, {
+      maxWait: this._options.flushMaxDelay,
     });
   }
 
@@ -146,6 +146,11 @@ export class ReplayContainer implements ReplayContainerInterface {
     return this._isPaused;
   }
 
+  /** Get the replay integration options. */
+  public getOptions(): ReplayPluginOptions {
+    return this._options;
+  }
+
   /**
    * Initializes the plugin.
    *
@@ -181,7 +186,7 @@ export class ReplayContainer implements ReplayContainerInterface {
     this.updateSessionActivity();
 
     this.eventBuffer = createEventBuffer({
-      useCompression: Boolean(this.options.useCompression),
+      useCompression: Boolean(this._options.useCompression),
     });
 
     this.addListeners();
@@ -199,7 +204,7 @@ export class ReplayContainer implements ReplayContainerInterface {
   startRecording(): void {
     try {
       this._stopRecording = record({
-        ...this.recordingOptions,
+        ...this._recordingOptions,
         // When running in error sampling mode, we need to overwrite `checkoutEveryNth`
         // Without this, it would record forever, until an error happens, which we don't want
         // instead, we'll always keep the last 60 seconds of replay before an error happened
@@ -273,7 +278,7 @@ export class ReplayContainer implements ReplayContainerInterface {
   handleException(error: unknown): void {
     __DEBUG_BUILD__ && logger.error('[Replay]', error);
 
-    if (__DEBUG_BUILD__ && this.options._experiments && this.options._experiments.captureExceptions) {
+    if (__DEBUG_BUILD__ && this._options._experiments && this._options._experiments.captureExceptions) {
       captureException(error);
     }
   }
@@ -295,10 +300,10 @@ export class ReplayContainer implements ReplayContainerInterface {
   loadSession({ expiry }: { expiry: number }): void {
     const { type, session } = getSession({
       expiry,
-      stickySession: Boolean(this.options.stickySession),
+      stickySession: Boolean(this._options.stickySession),
       currentSession: this.session,
-      sessionSampleRate: this.options.sessionSampleRate,
-      errorSampleRate: this.options.errorSampleRate,
+      sessionSampleRate: this._options.sessionSampleRate,
+      errorSampleRate: this._options.errorSampleRate,
     });
 
     // If session was newly created (i.e. was not loaded from storage), then
@@ -480,7 +485,7 @@ export class ReplayContainer implements ReplayContainerInterface {
       // a previous session ID. In this case, we want to buffer events
       // for a set amount of time before flushing. This can help avoid
       // capturing replays of users that immediately close the window.
-      setTimeout(() => this.conditionalFlush(), this.options.initialFlushDelay);
+      setTimeout(() => this.conditionalFlush(), this._options.initialFlushDelay);
 
       // Cancel any previously debounced flushes to ensure there are no [near]
       // simultaneous flushes happening. The latter request should be
@@ -953,8 +958,8 @@ export class ReplayContainer implements ReplayContainerInterface {
 
           preparedEvent.tags = {
             ...preparedEvent.tags,
-            sessionSampleRate: this.options.sessionSampleRate,
-            errorSampleRate: this.options.errorSampleRate,
+            sessionSampleRate: this._options.sessionSampleRate,
+            errorSampleRate: this._options.errorSampleRate,
             replayType: this.session?.sampled,
           };
 
@@ -1059,7 +1064,7 @@ export class ReplayContainer implements ReplayContainerInterface {
 
   /** Save the session, if it is sticky */
   private _maybeSaveSession(): void {
-    if (this.session && this.options.stickySession) {
+    if (this.session && this._options.stickySession) {
       saveSession(this.session);
     }
   }

packages/replay/src/types.ts

@@ -227,4 +227,5 @@ export interface ReplayContainer {
   flushImmediate(): void;
   triggerUserActivity(): void;
   addUpdate(cb: AddUpdateCallback): void;
+  getOptions(): ReplayPluginOptions;
 }

packages/replay/test/unit/index-integrationSettings.test.ts

@@ -9,13 +9,13 @@ describe('integration settings', () => {
     it('sets the correct configuration when `blockAllMedia` is disabled', async () => {
       const { replay } = await mockSdk({ replayOptions: { blockAllMedia: false } });
 
-      expect(replay.recordingOptions.blockSelector).toBe('[data-sentry-block]');
+      expect(replay['_recordingOptions'].blockSelector).toBe('[data-sentry-block]');
     });
 
     it('sets the correct configuration when `blockSelector` is empty and `blockAllMedia` is enabled', async () => {
       const { replay } = await mockSdk({ replayOptions: { blockSelector: '' } });
 
-      expect(replay.recordingOptions.blockSelector).toMatchInlineSnapshot(
+      expect(replay['_recordingOptions'].blockSelector).toMatchInlineSnapshot(
         '"img,image,svg,path,rect,area,video,object,picture,embed,map,audio"',
       );
     });
@@ -25,7 +25,7 @@ describe('integration settings', () => {
         replayOptions: { blockSelector: '[data-test-blockSelector]' },
       });
 
-      expect(replay.recordingOptions.blockSelector).toMatchInlineSnapshot(
+      expect(replay['_recordingOptions'].blockSelector).toMatchInlineSnapshot(
         '"[data-test-blockSelector],img,image,svg,path,rect,area,video,object,picture,embed,map,audio"',
       );
     });
@@ -48,7 +48,7 @@ describe('integration settings', () => {
         sentryOptions: { replaysSessionSampleRate: undefined },
       });
 
-      expect(replay.options.sessionSampleRate).toBe(0.5);
+      expect(replay.getOptions().sessionSampleRate).toBe(0.5);
       expect(mockConsole).toBeCalledTimes(1);
     });
 
@@ -58,21 +58,21 @@ describe('integration settings', () => {
         sentryOptions: { replaysSessionSampleRate: undefined },
       });
 
-      expect(replay.options.sessionSampleRate).toBe(0);
+      expect(replay.getOptions().sessionSampleRate).toBe(0);
       expect(mockConsole).toBeCalledTimes(1);
     });
 
     it('works with defining settings in SDK', async () => {
       const { replay } = await mockSdk({ sentryOptions: { replaysSessionSampleRate: 0.5 }, replayOptions: {} });
 
-      expect(replay.options.sessionSampleRate).toBe(0.5);
+      expect(replay.getOptions().sessionSampleRate).toBe(0.5);
       expect(mockConsole).toBeCalledTimes(0);
     });
 
     it('works with defining 0 in SDK', async () => {
       const { replay } = await mockSdk({ sentryOptions: { replaysSessionSampleRate: 0 }, replayOptions: {} });
 
-      expect(replay.options.sessionSampleRate).toBe(0);
+      expect(replay.getOptions().sessionSampleRate).toBe(0);
       expect(mockConsole).toBeCalledTimes(0);
     });
 
@@ -82,7 +82,7 @@ describe('integration settings', () => {
         replayOptions: { sessionSampleRate: 0.1 },
       });
 
-      expect(replay.options.sessionSampleRate).toBe(0.5);
+      expect(replay.getOptions().sessionSampleRate).toBe(0.5);
       expect(mockConsole).toBeCalledTimes(1);
     });
 
@@ -92,7 +92,7 @@ describe('integration settings', () => {
         replayOptions: { sessionSampleRate: 0.1 },
       });
 
-      expect(replay.options.sessionSampleRate).toBe(0);
+      expect(replay.getOptions().sessionSampleRate).toBe(0);
       expect(mockConsole).toBeCalledTimes(1);
     });
   });
@@ -114,7 +114,7 @@ describe('integration settings', () => {
         sentryOptions: { replaysOnErrorSampleRate: undefined },
       });
 
-      expect(replay.options.errorSampleRate).toBe(0.5);
+      expect(replay.getOptions().errorSampleRate).toBe(0.5);
       expect(mockConsole).toBeCalledTimes(1);
     });
 
@@ -124,21 +124,21 @@ describe('integration settings', () => {
         sentryOptions: { replaysOnErrorSampleRate: undefined },
       });
 
-      expect(replay.options.errorSampleRate).toBe(0);
+      expect(replay.getOptions().errorSampleRate).toBe(0);
       expect(mockConsole).toBeCalledTimes(1);
     });
 
     it('works with defining settings in SDK', async () => {
       const { replay } = await mockSdk({ sentryOptions: { replaysOnErrorSampleRate: 0.5 }, replayOptions: {} });
 
-      expect(replay.options.errorSampleRate).toBe(0.5);
+      expect(replay.getOptions().errorSampleRate).toBe(0.5);
       expect(mockConsole).toBeCalledTimes(0);
     });
 
     it('works with defining 0 in SDK', async () => {
       const { replay } = await mockSdk({ sentryOptions: { replaysOnErrorSampleRate: 0 }, replayOptions: {} });
 
-      expect(replay.options.errorSampleRate).toBe(0);
+      expect(replay.getOptions().errorSampleRate).toBe(0);
       expect(mockConsole).toBeCalledTimes(0);
     });
 
@@ -148,7 +148,7 @@ describe('integration settings', () => {
         replayOptions: { errorSampleRate: 0.1 },
       });
 
-      expect(replay.options.errorSampleRate).toBe(0.5);
+      expect(replay.getOptions().errorSampleRate).toBe(0.5);
       expect(mockConsole).toBeCalledTimes(1);
     });
 
@@ -158,7 +158,7 @@ describe('integration settings', () => {
         replayOptions: { errorSampleRate: 0.1 },
       });
 
-      expect(replay.options.errorSampleRate).toBe(0);
+      expect(replay.getOptions().errorSampleRate).toBe(0);
       expect(mockConsole).toBeCalledTimes(1);
     });
   });
@@ -168,25 +168,25 @@ describe('integration settings', () => {
       const { replay } = await mockSdk({ replayOptions: {} });
 
       // Default is true
-      expect(replay.recordingOptions.maskTextSelector).toBe('*');
+      expect(replay['_recordingOptions'].maskTextSelector).toBe('*');
     });
 
     it('works with true', async () => {
       const { replay } = await mockSdk({ replayOptions: { maskAllText: true } });
 
-      expect(replay.recordingOptions.maskTextSelector).toBe('*');
+      expect(replay['_recordingOptions'].maskTextSelector).toBe('*');
     });
 
     it('works with false', async () => {
       const { replay } = await mockSdk({ replayOptions: { maskAllText: false } });
 
-      expect(replay.recordingOptions.maskTextSelector).toBe(undefined);
+      expect(replay['_recordingOptions'].maskTextSelector).toBe(undefined);
     });
 
     it('overwrites custom maskTextSelector option', async () => {
       const { replay } = await mockSdk({ replayOptions: { maskAllText: true, maskTextSelector: '[custom]' } });
 
-      expect(replay.recordingOptions.maskTextSelector).toBe('*');
+      expect(replay['_recordingOptions'].maskTextSelector).toBe('*');
     });
   });
 
@@ -197,7 +197,7 @@ describe('integration settings', () => {
         sentryOptions: {},
       });
 
-      expect(replay.options._experiments).toEqual({ captureExceptions: true });
+      expect(replay.getOptions()._experiments).toEqual({ captureExceptions: true });
     });
 
     it('works without defining _experiments in integration', async () => {
@@ -206,7 +206,7 @@ describe('integration settings', () => {
         sentryOptions: {},
       });
 
-      expect(replay.options._experiments).toEqual({});
+      expect(replay.getOptions()._experiments).toEqual({});
     });
   });
 });