@multiplayer-app/session-recorder-react-native 1.3.36 → 2.0.17-alpha.10

package/lib/module/session-recorder.js

@@ -1,750 +0,0 @@
-"use strict";
-
-import { SessionType } from '@multiplayer-app/session-recorder-common';
-import { Observable } from 'lib0/observable';
-import { TracerReactNativeSDK } from "./otel/index.js";
-import { RecorderReactNativeSDK } from "./recorder/index.js";
-import { logger } from "./utils/index.js";
-import { SessionState } from "./types/index.js";
-import { SESSION_STOPPED_EVENT, REMOTE_SESSION_RECORDING_START, REMOTE_SESSION_RECORDING_STOP, SESSION_SAVE_BUFFER_EVENT } from "./config/index.js";
-import { getFormattedDate, isSessionActive, getNavigatorInfo } from "./utils/index.js";
-import { setShouldRecordHttpData, setMaxCapturingHttpPayloadSize } from "./patch/index.js";
-import { BASE_CONFIG, getSessionRecorderConfig } from "./config/index.js";
-import { StorageService } from "./services/storage.service.js";
-import { NetworkService } from "./services/network.service.js";
-import { CrashBufferService } from "./services/crashBuffer.service.js";
-import { ApiService } from "./services/api.service.js";
-import { SocketService } from "./services/socket.service.js";
-class SessionRecorder extends Observable {
-  _apiService = new ApiService();
-  _socketService = new SocketService();
-  _tracer = new TracerReactNativeSDK();
-  _recorder = new RecorderReactNativeSDK();
-  _storageService = StorageService.getInstance();
-  _networkService = NetworkService.getInstance();
-  _crashBuffer = CrashBufferService.getInstance();
-  _isFlushingBuffer = false;
-  _startRequestController = null;
-
-  // Whether the session recorder is initialized
-  _isInitialized = false;
-  get isInitialized() {
-    return this._isInitialized;
-  }
-  set isInitialized(isInitialized) {
-    this._isInitialized = isInitialized;
-  }
-
-  // Session ID and state are stored in AsyncStorage
-  _sessionId = null;
-  get sessionId() {
-    return this._sessionId;
-  }
-  set sessionId(sessionId) {
-    this._sessionId = sessionId;
-    if (sessionId) {
-      this._storageService.saveSessionId(sessionId);
-    }
-  }
-  _sessionType = SessionType.MANUAL;
-  get sessionType() {
-    return this._sessionType;
-  }
-  set sessionType(sessionType) {
-    this._sessionType = sessionType;
-    this._storageService.saveSessionType(sessionType);
-  }
-  get continuousRecording() {
-    return this.sessionType === SessionType.CONTINUOUS;
-  }
-  _sessionState = null;
-  get sessionState() {
-    return this._sessionState || SessionState.stopped;
-  }
-  set sessionState(state) {
-    this._sessionState = state;
-    this.emit('state-change', [state || SessionState.stopped, this.sessionType]);
-    if (state) {
-      this._storageService.saveSessionState(state);
-    }
-  }
-  _session = null;
-  get session() {
-    return this._session;
-  }
-  set session(session) {
-    this._session = session;
-    if (session) {
-      this._storageService.saveSessionObject(session);
-    }
-  }
-  _sessionAttributes = null;
-  get sessionAttributes() {
-    return this._sessionAttributes || {};
-  }
-  set sessionAttributes(attributes) {
-    this._sessionAttributes = attributes;
-  }
-  _userAttributes = null;
-  get userAttributes() {
-    return this._userAttributes;
-  }
-  set userAttributes(userAttributes) {
-    this._userAttributes = userAttributes;
-  }
-  /**
-   * Error message getter and setter
-   */
-  get error() {
-    return this._error || '';
-  }
-  set error(v) {
-    this._error = v;
-  }
-  _error = '';
-
-  /**
-   * React Native doesn't have HTML elements, so we return null
-   */
-  get sessionWidgetButtonElement() {
-    return null;
-  }
-  get config() {
-    return this._configs;
-  }
-  /**
-   * Initialize debugger with default or custom configurations
-   */
-  constructor() {
-    super();
-    this._configs = BASE_CONFIG;
-    // Initialize with stored session data if available
-    StorageService.initialize();
-  }
-
-  /**
-   * Capture an exception manually and send it as an error trace.
-   */
-  captureException(error, errorInfo) {
-    try {
-      const normalizedError = this._normalizeError(error);
-      const normalizedErrorInfo = this._normalizeErrorInfo(errorInfo);
-      this._tracer.captureException(normalizedError, normalizedErrorInfo);
-    } catch (e) {
-      this.error = e?.message || 'Failed to capture exception';
-    }
-  }
-  async _flushBuffer(sessionId) {
-    if (!sessionId || !this._crashBuffer || this._isFlushingBuffer || !this._configs?.buffering?.enabled || this.sessionState !== SessionState.stopped) {
-      return null;
-    }
-    this._isFlushingBuffer = true;
-    try {
-      const {
-        events,
-        spans,
-        startedAt,
-        stoppedAt
-      } = await this._crashBuffer.snapshot();
-      if (events.length === 0 && spans.length === 0) {
-        return null;
-      }
-      await Promise.all([this._tracer.exportTraces(spans.map(s => s.span)), this._apiService.exportEvents(sessionId, {
-        events: events.map(e => e.event)
-      }), this._apiService.updateSessionAttributes(sessionId, {
-        startedAt: new Date(startedAt).toISOString(),
-        stoppedAt: new Date(stoppedAt).toISOString(),
-        sessionAttributes: this.sessionAttributes,
-        resourceAttributes: getNavigatorInfo(),
-        userAttributes: this._userAttributes || undefined
-      })]);
-    } catch (_e) {
-      // swallow: flush is best-effort; never throw into app code
-    } finally {
-      await this._crashBuffer.clear();
-      this._isFlushingBuffer = false;
-    }
-  }
-  async _createExceptionSession(span) {
-    try {
-      const session = await this._apiService.createErrorSession({
-        span
-      });
-      if (session?._id) {
-        void this._flushBuffer(session._id);
-      }
-    } catch (_ignored) {
-      // best-effort
-    }
-  }
-  async _loadStoredSessionData() {
-    try {
-      await StorageService.initialize();
-      const storedData = await this._storageService.getAllSessionData();
-      if (isSessionActive(storedData.sessionObject, storedData.sessionType)) {
-        this.session = storedData.sessionObject;
-        this.sessionId = storedData.sessionId;
-        this.sessionType = storedData.sessionType || SessionType.MANUAL;
-        this.sessionState = storedData.sessionState;
-      } else {
-        this.session = null;
-        this.sessionId = null;
-        this.sessionState = null;
-        this.sessionType = SessionType.MANUAL;
-      }
-    } catch (error) {
-      logger.error('SessionRecorder', 'Failed to load stored session data', error);
-      this.session = null;
-      this.sessionId = null;
-      this.sessionState = null;
-      this.sessionType = SessionType.MANUAL;
-    }
-  }
-
-  /**
-   * Initialize the session debugger
-   * @param configs - custom configurations for session debugger
-   */
-  async init(configs) {
-    if (this._isInitialized) return;
-    this._isInitialized = true;
-    this._configs = getSessionRecorderConfig({
-      ...this._configs,
-      ...configs
-    });
-    logger.configure(this._configs.logger);
-    await this._loadStoredSessionData();
-    setMaxCapturingHttpPayloadSize(this._configs.maxCapturingHttpPayloadSize);
-    setShouldRecordHttpData(this._configs.captureBody, this._configs.captureHeaders);
-
-    // Crash buffer wiring (RN): set BEFORE tracer init so early spans don't get exported.
-    const bufferEnabled = Boolean(this._configs.buffering?.enabled);
-    const windowMs = Math.max(10_000, (this._configs.buffering?.windowMinutes || 0.5) * 60 * 1000);
-    this._tracer.setCrashBuffer(bufferEnabled ? this._crashBuffer : undefined, windowMs);
-    this._tracer.init(this._configs);
-    this._apiService.init(this._configs);
-    this._socketService.init({
-      apiKey: this._configs.apiKey,
-      socketUrl: this._configs.apiBaseUrl,
-      keepAlive: this._configs.useWebsocket,
-      clientId: this._tracer.clientId
-    });
-    this._recorder.init(this._configs, this._socketService, bufferEnabled ? this._crashBuffer : undefined, {
-      enabled: bufferEnabled,
-      windowMs
-    });
-    this._crashBuffer.on('error-span-appended', payload => {
-      if (!payload.span || this.sessionId || this.sessionState !== SessionState.stopped) {
-        return;
-      }
-      this._createExceptionSession(payload.span);
-    });
-    await this._networkService.init();
-    this._setupNetworkCallbacks();
-    this._registerSocketServiceListeners();
-    if (this.sessionId && (this.sessionState === SessionState.started || this.sessionState === SessionState.paused)) {
-      this._start();
-    } else {
-      this._startBufferOnlyRecording();
-    }
-    this.emit('init', []);
-  }
-  _startBufferOnlyRecording() {
-    if (this.sessionId || !this._crashBuffer || !this._configs?.buffering?.enabled || this.sessionState !== SessionState.stopped) {
-      return;
-    }
-    const windowMs = Math.max(10_000, (this._configs.buffering.windowMinutes || 0.5) * 60 * 1000);
-
-    // Wire buffer into tracer + recorder (only used when sessionId is null).
-    this._tracer.setCrashBuffer(this._crashBuffer, windowMs);
-    this._recorder.init(this._configs, this._socketService, this._crashBuffer, {
-      enabled: true,
-      windowMs
-    });
-
-    // Start capturing events without an active debug session id.
-    try {
-      this._recorder.stop();
-    } catch (_e) {}
-    this._recorder.start(null, SessionType.MANUAL);
-  }
-
-  /**
-   * Register socket service event listeners
-   */
-  _registerSocketServiceListeners() {
-    this._socketService.on(SESSION_STOPPED_EVENT, () => {
-      this._stop();
-      this._clearSession();
-    });
-    this._socketService.on(REMOTE_SESSION_RECORDING_START, payload => {
-      logger.info('SessionRecorder', 'Remote session recording started', payload);
-      if (this.sessionState === SessionState.stopped) {
-        this.start();
-      }
-    });
-    this._socketService.on(REMOTE_SESSION_RECORDING_STOP, payload => {
-      logger.info('SessionRecorder', 'Remote session recording stopped', payload);
-      if (this.sessionState !== SessionState.stopped) {
-        this.stop();
-      }
-    });
-    this._socketService.on(SESSION_SAVE_BUFFER_EVENT, payload => {
-      this._flushBuffer(payload?.debugSession?._id);
-    });
-  }
-
-  /**
-   * Setup network state change callbacks
-   */
-  _setupNetworkCallbacks() {
-    this._networkService.addCallback(state => {
-      if (!state.isConnected && this.sessionState === SessionState.started) {
-        logger.info('SessionRecorder', 'Network went offline - pausing session recording');
-        this.pause();
-      } else if (state.isConnected && this.sessionState === SessionState.paused) {
-        logger.info('SessionRecorder', 'Network came back online - resuming session recording');
-        this.resume();
-      }
-    });
-  }
-
-  /**
-   * Start a new session
-   * @param type - the type of session to start
-   * @param session - the session to start
-   */
-  async start(type = SessionType.MANUAL, session) {
-    this._checkOperation('start');
-
-    // Check if offline - don't start recording if offline
-    if (!this._networkService.isOnline()) {
-      logger.warn('SessionRecorder', 'Cannot start session recording - device is offline');
-      throw new Error('Cannot start session recording while offline');
-    }
-
-    // If continuous recording is disabled, force plain mode
-    if (type === SessionType.CONTINUOUS && !this._configs?.showContinuousRecording) {
-      type = SessionType.MANUAL;
-    }
-    logger.info('SessionRecorder', 'Starting session with type:', type);
-    this.sessionType = type;
-    this._startRequestController = new AbortController();
-    if (session) {
-      this._setupSessionAndStart(session, true);
-    } else {
-      await this._createSessionAndStart();
-    }
-  }
-
-  /**
-   * Stop the current session with an optional comment
-   * @param comment - user-provided comment to include in session session attributes
-   */
-  async stop(comment) {
-    try {
-      this._checkOperation('stop');
-      this._stop();
-      if (this.continuousRecording) {
-        await this._apiService.stopContinuousDebugSession(this.sessionId);
-        this.sessionType = SessionType.MANUAL;
-      } else {
-        const request = {
-          sessionAttributes: {
-            comment
-          },
-          stoppedAt: Date.now()
-        };
-        await this._apiService.stopSession(this.sessionId, request);
-      }
-      this._clearSession();
-    } catch (error) {
-      this.error = error.message;
-    }
-  }
-
-  /**
-   * Pause the current session
-   */
-  async pause() {
-    try {
-      this._checkOperation('pause');
-      this._pause();
-    } catch (error) {
-      this.error = error.message;
-    }
-  }
-
-  /**
-   * Resume the current session
-   */
-  async resume() {
-    try {
-      this._checkOperation('resume');
-      this._resume();
-    } catch (error) {
-      this.error = error.message;
-    }
-  }
-
-  /**
-   * Cancel the current session
-   */
-  async cancel() {
-    try {
-      this._checkOperation('cancel');
-      this._stop();
-      if (this.continuousRecording) {
-        await this._apiService.stopContinuousDebugSession(this.sessionId);
-        this.sessionType = SessionType.MANUAL;
-      } else {
-        await this._apiService.cancelSession(this.sessionId);
-      }
-      this._clearSession();
-    } catch (error) {
-      this.error = error.message;
-    }
-  }
-
-  /**
-   * Save the continuous recording session
-   */
-  async save() {
-    try {
-      this._checkOperation('save');
-      if (!this.continuousRecording || !this._configs?.showContinuousRecording) {
-        return;
-      }
-      const res = await this._apiService.saveContinuousDebugSession(this.sessionId, {
-        sessionAttributes: this.sessionAttributes,
-        resourceAttributes: getNavigatorInfo(),
-        stoppedAt: Date.now(),
-        name: this._getSessionName()
-      });
-      return res;
-    } catch (error) {
-      this.error = error.message;
-    }
-  }
-
-  /**
-   * Set the session attributes
-   * @param attributes - the attributes to set
-   */
-  setSessionAttributes(attributes) {
-    this._sessionAttributes = attributes;
-  }
-
-  /**
-   * Set the user attributes
-   * @param userAttributes - the user attributes to set
-   */
-  setUserAttributes(userAttributes) {
-    if (!this._userAttributes && !userAttributes) {
-      return;
-    }
-    this._userAttributes = userAttributes;
-    const data = {
-      userAttributes: this._userAttributes,
-      clientId: this._tracer.clientId
-    };
-    this._socketService.setUser(data);
-  }
-
-  /**
-   * @description Check if session should be started/stopped automatically
-   * @param {ISession} [sessionPayload]
-   * @returns {Promise<void>}
-   */
-  async checkRemoteContinuousSession(sessionPayload) {
-    this._checkOperation('autoStartRemoteContinuousSession');
-    if (!this._configs?.showContinuousRecording) {
-      return;
-    }
-    const payload = {
-      sessionAttributes: {
-        ...this.sessionAttributes,
-        ...(sessionPayload?.sessionAttributes || {})
-      },
-      resourceAttributes: {
-        ...getNavigatorInfo(),
-        ...(sessionPayload?.resourceAttributes || {})
-      },
-      ...(this._userAttributes ? {
-        userAttributes: this._userAttributes
-      } : {})
-    };
-    const {
-      state
-    } = await this._apiService.checkRemoteSession(payload);
-    if (state == 'START') {
-      if (this.sessionState !== SessionState.started) {
-        await this.start(SessionType.CONTINUOUS);
-      }
-    } else if (state == 'STOP') {
-      if (this.sessionState !== SessionState.stopped) {
-        await this.stop();
-      }
-    }
-  }
-
-  /**
-   * Create a new session and start it
-   */
-  async _createSessionAndStart() {
-    const signal = this._startRequestController?.signal;
-    try {
-      const payload = {
-        sessionAttributes: this.sessionAttributes,
-        resourceAttributes: getNavigatorInfo(),
-        name: this._getSessionName(),
-        ...(this._userAttributes ? {
-          userAttributes: this._userAttributes
-        } : {})
-      };
-      const request = !this.continuousRecording ? payload : {
-        debugSessionData: payload
-      };
-      const session = this.continuousRecording ? await this._apiService.startContinuousDebugSession(request, signal) : await this._apiService.startSession(request, signal);
-      if (session) {
-        session.sessionType = this.continuousRecording ? SessionType.CONTINUOUS : SessionType.MANUAL;
-        this._setupSessionAndStart(session, false);
-      }
-    } catch (error) {
-      this.error = error.message;
-      logger.error('SessionRecorder', 'Error creating session:', error.message);
-      if (this.continuousRecording) {
-        this.sessionType = SessionType.MANUAL;
-      }
-    }
-  }
-
-  /**
-   * Start tracing and recording for the session
-   */
-  _start() {
-    this.sessionState = SessionState.started;
-    this.sessionType = this.sessionType;
-    if (this.sessionId) {
-      // Switch from buffer-only recording to session recording cleanly.
-      try {
-        this._recorder.stop();
-      } catch (_e) {}
-      this._tracer.start(this.sessionId, this.sessionType);
-      this._recorder.start(this.sessionId, this.sessionType);
-      if (this.session) {
-        this._socketService.subscribeToSession(this.session);
-      }
-    }
-  }
-
-  /**
-   * Stop tracing and recording for the session
-   */
-  _stop() {
-    this.sessionState = SessionState.stopped;
-    this._socketService.unsubscribeFromSession(true);
-    this._tracer.stop();
-    this._recorder.stop();
-    this._startBufferOnlyRecording();
-  }
-
-  /**
-   * Pause the session tracing and recording
-   */
-  _pause() {
-    this._tracer.stop();
-    this._recorder.stop();
-    this.sessionState = SessionState.paused;
-  }
-
-  /**
-   * Resume the session tracing and recording
-   */
-  _resume() {
-    if (this.sessionId) {
-      this._tracer.start(this.sessionId, this.sessionType);
-      try {
-        this._recorder.stop();
-      } catch (_e) {}
-      this._recorder.start(this.sessionId, this.sessionType);
-    }
-    this.sessionState = SessionState.started;
-  }
-  _setupSessionAndStart(session, configureExporters = true) {
-    if (configureExporters && session.tempApiKey) {
-      this._configs.apiKey = session.tempApiKey;
-      this._tracer.setApiKey(session.tempApiKey);
-      this._apiService.setApiKey(session.tempApiKey);
-      this._socketService.updateConfigs({
-        apiKey: session.tempApiKey
-      });
-    }
-    this._setSession(session);
-    this._start();
-  }
-
-  /**
-   * Set the session ID in storage
-   * @param sessionId - the session ID to set or clear
-   */
-  _setSession(session) {
-    this.session = {
-      ...session,
-      createdAt: session.createdAt || new Date().toISOString()
-    };
-    this.sessionId = session?.shortId || session?._id;
-  }
-  _clearSession() {
-    this.session = null;
-    this.sessionId = null;
-    this.sessionState = SessionState.stopped;
-    this._storageService.clearSessionData();
-  }
-
-  /**
-   * Check the operation validity based on the session state and action
-   * @param action - action being checked ('init', 'start', 'stop', 'cancel', 'pause', 'resume')
-   */
-  _checkOperation(action, _payload) {
-    if (!this._isInitialized) {
-      throw new Error('Configuration not initialized. Call init() before performing any actions.');
-    }
-    switch (action) {
-      case 'start':
-        if (this.sessionState === SessionState.started) {
-          throw new Error('Session is already started.');
-        }
-        break;
-      case 'stop':
-        if (this.sessionState !== SessionState.paused && this.sessionState !== SessionState.started) {
-          throw new Error('Cannot stop. Session is not currently started.');
-        }
-        break;
-      case 'cancel':
-        if (this.sessionState === SessionState.stopped) {
-          throw new Error('Cannot cancel. Session has already been stopped.');
-        }
-        break;
-      case 'pause':
-        if (this.sessionState !== SessionState.started) {
-          throw new Error('Cannot pause. Session is not running.');
-        }
-        break;
-      case 'resume':
-        if (this.sessionState !== SessionState.paused) {
-          throw new Error('Cannot resume. Session is not paused.');
-        }
-        break;
-      case 'save':
-        if (!this.continuousRecording) {
-          throw new Error('Cannot save continuous recording session. Continuous recording is not enabled.');
-        }
-        if (this.sessionState !== SessionState.started) {
-          throw new Error('Cannot save continuous recording session. Session is not started.');
-        }
-        break;
-      case 'autoStartRemoteContinuousSession':
-        if (this.sessionState !== SessionState.stopped) {
-          throw new Error('Cannot start remote continuous session. Session is not stopped.');
-        }
-        break;
-    }
-  }
-  // Session attributes
-  setSessionAttribute(key, value) {
-    if (this._session) {
-      if (!this._session.sessionAttributes) {
-        this._session.sessionAttributes = {};
-      }
-      this._session.sessionAttributes[key] = value;
-      this._session.updatedAt = new Date().toISOString();
-    }
-  }
-
-  /**
-   * Record a custom rrweb event
-   * Note: Screen capture and touch events are recorded automatically when session is started
-   * @param event - The rrweb event to record
-   */
-  recordEvent(event) {
-    if (!this._isInitialized || this.sessionState !== SessionState.started) {
-      return;
-    }
-
-    // Forward the event to the recorder SDK
-    this._recorder.recordEvent(event);
-  }
-
-  /**
-   * Set the viewshot ref for screen capture
-   * @param ref - React Native View ref for screen capture
-   */
-  setViewShotRef(ref) {
-    if (this._recorder) {
-      this._recorder.setViewShotRef(ref);
-    }
-  }
-
-  /**
-   * Set the navigation ref for navigation tracking
-   * @param ref - React Native Navigation ref for navigation tracking
-   */
-  setNavigationRef(ref) {
-    if (this._recorder) {
-      this._recorder.setNavigationRef(ref);
-    }
-  }
-
-  /**
-   * Cleanup resources and unsubscribe from network monitoring
-   */
-  cleanup() {
-    this._networkService.cleanup();
-  }
-
-  /**
-   * Normalize an error to an Error object
-   * @param error - the error to normalize
-   * @returns the normalized error
-   */
-  _normalizeError(error) {
-    if (error instanceof Error) return error;
-    if (typeof error === 'string') return new Error(error);
-    try {
-      return new Error(JSON.stringify(error));
-    } catch (_e) {
-      return new Error(String(error));
-    }
-  }
-
-  /**
-   * Normalize an error info object to a Record<string, any>
-   * @param errorInfo - the error info to normalize
-   * @returns the normalized error info
-   */
-  _normalizeErrorInfo(errorInfo) {
-    if (!errorInfo) return {};
-    try {
-      return JSON.parse(JSON.stringify(errorInfo));
-    } catch (_e) {
-      return {
-        errorInfo: String(errorInfo)
-      };
-    }
-  }
-
-  /**
-   * Get the session name
-   * @returns the session name
-   */
-  _getSessionName(date = new Date()) {
-    const userName = this.sessionAttributes?.userName || this._userAttributes?.userName || this._userAttributes?.name || '';
-    return userName ? `${userName}'s session on ${getFormattedDate(date, {
-      month: 'short',
-      day: 'numeric'
-    })}` : `Session on ${getFormattedDate(date)}`;
-  }
-}
-export default new SessionRecorder();
-//# sourceMappingURL=session-recorder.js.map