@multiplayer-app/session-recorder-react-native 0.0.1-alpha.1 → 0.0.1-alpha.3

package/src/recorder/screenRecorder.ts

@@ -11,6 +11,7 @@ export class ScreenRecorder {
   private captureQuality: number = 0.8
   private captureFormat: 'png' | 'jpg' | 'webp' = 'png'
   private screenDimensions: { width: number; height: number } | null = null
+  private currentScreen: string | null = null
 
   init(config: RecorderConfig): void {
     this.config = config
@@ -22,13 +23,13 @@ export class ScreenRecorder {
     this.events = []
     this.captureCount = 0
     this._startPeriodicCapture()
-    console.log('Screen recording started')
+    // Screen recording started
   }
 
   stop(): void {
     this.isRecording = false
     this._stopPeriodicCapture()
-    console.log('Screen recording stopped')
+    // Screen recording stopped
   }
 
   pause(): void {
@@ -46,7 +47,7 @@ export class ScreenRecorder {
       const { Dimensions } = require('react-native')
       this.screenDimensions = Dimensions.get('window')
     } catch (error) {
-      console.warn('Failed to get screen dimensions:', error)
+      // Failed to get screen dimensions - silently continue
       this.screenDimensions = { width: 375, height: 667 } // Default fallback
     }
   }
@@ -79,6 +80,7 @@ export class ScreenRecorder {
 
       if (screenData) {
         const screenEvent: ScreenEvent = {
+          screenName: this.currentScreen || 'unknown',
           type: 'screenCapture',
           timestamp: Date.now(),
           dataUrl: screenData,
@@ -98,7 +100,7 @@ export class ScreenRecorder {
         this._recordOpenTelemetrySpan(screenEvent)
       }
     } catch (error) {
-      console.error('Failed to capture screen:', error)
+      // Failed to capture screen - silently continue
       this._recordScreenCaptureError(error instanceof Error ? error : new Error(String(error)))
     }
   }
@@ -113,17 +115,17 @@ export class ScreenRecorder {
         return await this._captureWithViewShot()
       }
     } catch (error) {
-      console.warn('react-native-view-shot not available:', error)
+      // react-native-view-shot not available - silently continue
     }
 
     try {
       // Try react-native-screenshot
-      // const Screenshot = require('react-native-screenshot')
-      // if (Screenshot && Screenshot.takeScreenshot) {
-      //   return await this._captureWithScreenshot()
-      // }
+      const Screenshot = require('react-native-screenshot')
+      if (Screenshot && Screenshot.takeScreenshot) {
+        return await this._captureWithScreenshot()
+      }
     } catch (error) {
-      console.warn('react-native-screenshot not available:', error)
+      // react-native-screenshot not available - silently continue
     }
 
     // Fallback to placeholder
@@ -148,23 +150,23 @@ export class ScreenRecorder {
         return await ViewShot.captureRef(rootViewRef, options)
       }
     } catch (error) {
-      console.warn('Failed to capture with ViewShot:', error)
+      // Failed to capture with ViewShot - silently continue
     }
     return null
   }
 
   private async _captureWithScreenshot(): Promise<string | null> {
     try {
-      // const Screenshot = require('react-native-screenshot')
+      const Screenshot = require('react-native-screenshot')
 
       const options = {
         format: this.captureFormat,
         quality: this.captureQuality,
       }
 
-      // return await Screenshot.takeScreenshot(options)
+      return await Screenshot.takeScreenshot(options)
     } catch (error) {
-      console.warn('Failed to capture with Screenshot:', error)
+      // Failed to capture with Screenshot - silently continue
     }
     return null
   }
@@ -176,7 +178,7 @@ export class ScreenRecorder {
       const appName = AppRegistry.getAppKeys()[0]
       return appName ? { current: null } : null
     } catch (error) {
-      console.warn('Failed to get root view ref:', error)
+      // Failed to get root view ref - silently continue
       return null
     }
   }
@@ -206,12 +208,8 @@ export class ScreenRecorder {
   }
 
   private _sendEvent(event: ScreenEvent): void {
-    console.log('Screen event recorded:', {
-      type: event.type,
-      timestamp: event.timestamp,
-      captureCount: event.metadata?.captureCount,
-      captureTime: event.metadata?.captureTime,
-    })
+    // Screen event recorded
+    // Send event to backend or store locally
   }
 
   private _recordOpenTelemetrySpan(event: ScreenEvent): void {
@@ -233,7 +231,7 @@ export class ScreenRecorder {
       span.setStatus({ code: SpanStatusCode.OK })
       span.end()
     } catch (error) {
-      console.warn('Failed to record OpenTelemetry span for screen:', error)
+      // Failed to record OpenTelemetry span for screen - silently continue
     }
   }
 
@@ -252,14 +250,14 @@ export class ScreenRecorder {
       span.recordException(error)
       span.end()
     } catch (spanError) {
-      console.warn('Failed to record error span:', spanError)
+      // Failed to record error span - silently continue
     }
   }
 
   // Manual screen capture methods
   async captureScreenNow(): Promise<string | null> {
     if (!this.isRecording) {
-      console.warn('Screen recording not active')
+      // Screen recording not active - silently continue
       return null
     }
 
@@ -281,7 +279,7 @@ export class ScreenRecorder {
 
       return await ViewShot.captureRef(elementRef, captureOptions)
     } catch (error) {
-      console.error('Failed to capture specific element:', error)
+      // Failed to capture specific element - silently continue
       return null
     }
   }
@@ -314,6 +312,7 @@ export class ScreenRecorder {
   // Performance monitoring
   recordScreenPerformance(screenName: string, loadTime: number): void {
     const event: ScreenEvent = {
+      screenName,
       type: 'screenCapture',
       timestamp: Date.now(),
       metadata: {
@@ -333,6 +332,7 @@ export class ScreenRecorder {
   // Error tracking
   recordScreenError(error: Error, screenName?: string): void {
     const event: ScreenEvent = {
+      screenName: screenName || 'unknown',
       type: 'screenCapture',
       timestamp: Date.now(),
       metadata: {
@@ -406,6 +406,6 @@ export class ScreenRecorder {
   shutdown(): void {
     this.stop()
     this.clearEvents()
-    console.log('Screen recorder shutdown')
+    // Screen recorder shutdown
   }
 }

package/src/services/api.service.ts

@@ -1,4 +1,4 @@
-import { ISession, SessionRecorderOptions } from '../types'
+import { SessionRecorderOptions, IResourceAttributes, ISessionAttributes } from '../types'
 
 // Type definitions for fetch API
 type RequestInit = {
@@ -9,70 +9,202 @@ type RequestInit = {
 }
 
 export interface StartSessionRequest {
-  application: string
-  version: string
-  environment: string
-  metadata?: Record<string, any>
+  name?: string
+  stoppedAt?: string | number
+  sessionAttributes?: ISessionAttributes
+  resourceAttributes?: IResourceAttributes
+  debugSessionData?: Record<string, any>
 }
 
 export interface StopSessionRequest {
-  sessionId: string
-  comment?: string
+  sessionAttributes?: ISessionAttributes
+  stoppedAt: string | number
 }
 
 export class ApiService {
   private config?: SessionRecorderOptions
   private baseUrl: string = 'https://api.multiplayer.app'
 
+  constructor() {
+    this.config = {
+      apiKey: '',
+      apiBaseUrl: '',
+      exporterEndpoint: '',
+      version: '',
+      application: '',
+      environment: '',
+    } as SessionRecorderOptions
+  }
+
   init(config: SessionRecorderOptions): void {
-    this.config = config
+    this.config = {
+      ...this.config,
+      ...config,
+    }
     if (config.apiBaseUrl) {
       this.baseUrl = config.apiBaseUrl
     }
   }
 
-  private async makeRequest<T>(
-    endpoint: string,
-    options: RequestInit = {},
-  ): Promise<T> {
-    if (!this.config?.apiKey) {
-      throw new Error('API key not configured')
+  /**
+   * Update the API service configuration
+   * @param config - Partial configuration to update
+   */
+  public updateConfigs(config: Partial<SessionRecorderOptions>) {
+    if (this.config) {
+      this.config = { ...this.config, ...config }
     }
+  }
 
-    const url = `${this.baseUrl}${endpoint}`
-    const response = await fetch(url, {
-      ...options,
+  /**
+   * Make a request to the session debugger API
+   * @param path - API endpoint path (relative to the base URL)
+   * @param method - HTTP method (GET, POST, PATCH, etc.)
+   * @param body - request payload
+   * @param signal - AbortSignal to set request's signal
+   */
+  private async makeRequest(
+    path: string,
+    method: string,
+    body?: any,
+    signal?: AbortSignal,
+  ): Promise<any> {
+    const url = `${this.baseUrl}/v0/radar${path}`
+    const params = {
+      method,
+      body: body ? JSON.stringify(body) : null,
       headers: {
         'Content-Type': 'application/json',
-        'Authorization': `Bearer ${this.config.apiKey}`,
-        ...options.headers,
+        ...(this.config?.apiKey && { 'X-Api-Key': this.config.apiKey }),
       },
-    })
+    }
+
+    try {
+      const response = await fetch(url, {
+        ...params,
+        signal,
+      })
+
+      if (!response.ok) {
+        throw new Error('Network response was not ok: ' + response.statusText)
+      }
+
+      if (response.status === 204) {
+        return null
+      }
 
-    if (!response.ok) {
-      throw new Error(`API request failed: ${response.statusText}`)
+      return await response.json()
+    } catch (error: any) {
+      if (error?.name === 'AbortError') {
+        throw new Error('Request aborted')
+      }
+      throw new Error('Error making request: ' + error.message)
     }
+  }
+
+  /**
+   * Start a new debug session
+   * @param request - Session start request data
+   * @param signal - Optional AbortSignal for request cancellation
+   */
+  async startSession(
+    request: StartSessionRequest,
+    signal?: AbortSignal,
+  ): Promise<any> {
+    return this.makeRequest(
+      '/debug-sessions/start',
+      'POST',
+      request,
+      signal,
+    )
+  }
+
+  /**
+   * Stop an active debug session
+   * @param sessionId - ID of the session to stop
+   * @param request - Session stop request data
+   */
+  async stopSession(
+    sessionId: string,
+    request: StopSessionRequest,
+  ): Promise<any> {
+    return this.makeRequest(
+      `/debug-sessions/${sessionId}/stop`,
+      'PATCH',
+      request,
+    )
+  }
+
+  /**
+   * Cancel an active debug session
+   * @param sessionId - ID of the session to cancel
+   */
+  async cancelSession(sessionId: string): Promise<any> {
+    return this.makeRequest(
+      `/debug-sessions/${sessionId}/cancel`,
+      'DELETE',
+    )
+  }
 
-    return response.json()
+  /**
+   * Start a new continuous debug session
+   * @param request - Session start request data
+   * @param signal - Optional AbortSignal for request cancellation
+   */
+  async startContinuousDebugSession(
+    request: StartSessionRequest,
+    signal?: AbortSignal,
+  ): Promise<any> {
+    return this.makeRequest(
+      '/continuous-debug-sessions/start',
+      'POST',
+      request,
+      signal,
+    )
   }
 
-  async startSession(request: StartSessionRequest): Promise<ISession> {
-    return this.makeRequest<ISession>('/sessions', {
-      method: 'POST',
-      body: JSON.stringify(request),
-    })
+  /**
+   * Save a continuous debug session
+   * @param sessionId - ID of the session to save
+   * @param request - Session save request data
+   * @param signal - Optional AbortSignal for request cancellation
+   */
+  async saveContinuousDebugSession(
+    sessionId: string,
+    request: StartSessionRequest,
+    signal?: AbortSignal,
+  ): Promise<any> {
+    return this.makeRequest(
+      `/continuous-debug-sessions/${sessionId}/save`,
+      'POST',
+      request,
+      signal,
+    )
   }
 
-  async stopSession(request: StopSessionRequest): Promise<void> {
-    return this.makeRequest<void>(`/sessions/${request.sessionId}/stop`, {
-      method: 'POST',
-      body: JSON.stringify({ comment: request.comment }),
-    })
+  /**
+   * Stop an active continuous debug session
+   * @param sessionId - ID of the session to stop
+   */
+  async stopContinuousDebugSession(sessionId: string): Promise<any> {
+    return this.makeRequest(
+      `/continuous-debug-sessions/${sessionId}/cancel`,
+      'DELETE',
+    )
   }
 
-  async saveSession(sessionId: string): Promise<ISession> {
-    return this.makeRequest<ISession>(`/sessions/${sessionId}/save`, {
-      method: 'POST',
-    })
+  /**
+   * Check debug session should be started remotely
+   */
+  async checkRemoteSession(
+    requestBody: StartSessionRequest,
+    signal?: AbortSignal,
+  ): Promise<{ state: 'START' | 'STOP' }> {
+    return this.makeRequest(
+      '/remote-debug-session/check',
+      'POST',
+      requestBody,
+      signal,
+    )
   }
 }

package/src/services/storage.service.ts

@@ -1,6 +1,13 @@
 import AsyncStorage from '@react-native-async-storage/async-storage'
-import { ISession, SessionState } from '../types'
 import { SessionType } from '@multiplayer-app/session-recorder-common'
+import { ISession, SessionState } from '../types'
+
+interface CacheData {
+  sessionId: string | null
+  sessionType: SessionType | null
+  sessionState: SessionState | null
+  sessionObject: ISession | null
+}
 
 export class StorageService {
   private static readonly SESSION_ID_KEY = 'session_id'
@@ -8,123 +15,143 @@ export class StorageService {
   private static readonly SESSION_STATE_KEY = 'session_state'
   private static readonly SESSION_OBJECT_KEY = 'session_object'
 
-  async saveSessionId(sessionId: string): Promise<void> {
-    try {
-      await AsyncStorage.setItem(StorageService.SESSION_ID_KEY, sessionId)
-    } catch (error) {
-      console.error('Failed to save session ID:', error)
-      throw error
-    }
+  private static cache: CacheData = {
+    sessionId: null,
+    sessionType: null,
+    sessionState: null,
+    sessionObject: null,
+  }
+
+  private static cacheInitialized = false
+
+  constructor() {
+    StorageService.initialize()
   }
 
-  async getSessionId(): Promise<string | null> {
+  private static async initializeCache(): Promise<void> {
+    if (StorageService.cacheInitialized) return
+
     try {
-      return await AsyncStorage.getItem(StorageService.SESSION_ID_KEY)
+      const [sessionId, sessionType, sessionState, sessionObject] = await Promise.all([
+        AsyncStorage.getItem(StorageService.SESSION_ID_KEY),
+        AsyncStorage.getItem(StorageService.SESSION_TYPE_KEY),
+        AsyncStorage.getItem(StorageService.SESSION_STATE_KEY),
+        AsyncStorage.getItem(StorageService.SESSION_OBJECT_KEY),
+      ])
+
+      StorageService.cache = {
+        sessionId,
+        sessionType: sessionType as SessionType | null,
+        sessionState: sessionState as SessionState | null,
+        sessionObject: sessionObject ? JSON.parse(sessionObject) : null,
+      }
+      StorageService.cacheInitialized = true
     } catch (error) {
-      console.error('Failed to get session ID:', error)
-      return null
+      // Failed to initialize cache - silently continue
+      StorageService.cacheInitialized = true // Mark as initialized to prevent retries
     }
   }
 
-  async saveSessionType(sessionType: SessionType): Promise<void> {
+  saveSessionId(sessionId: string): void {
     try {
-      await AsyncStorage.setItem(StorageService.SESSION_TYPE_KEY, sessionType)
+      StorageService.cache.sessionId = sessionId
+      AsyncStorage.setItem(StorageService.SESSION_ID_KEY, sessionId).catch(error => {
+        // Failed to persist session ID - silently continue
+      })
     } catch (error) {
-      console.error('Failed to save session type:', error)
+      // Failed to save session ID - silently continue
       throw error
     }
   }
 
-  async getSessionType(): Promise<SessionType | null> {
-    try {
-      const type = await AsyncStorage.getItem(StorageService.SESSION_TYPE_KEY)
-      return type as SessionType | null
-    } catch (error) {
-      console.error('Failed to get session type:', error)
-      return null
-    }
+  getSessionId(): string | null {
+    return StorageService.cache.sessionId
   }
 
-  async saveSessionState(state: SessionState): Promise<void> {
+  saveSessionType(sessionType: SessionType): void {
     try {
-      await AsyncStorage.setItem(StorageService.SESSION_STATE_KEY, state)
+      StorageService.cache.sessionType = sessionType
+      AsyncStorage.setItem(StorageService.SESSION_TYPE_KEY, sessionType).catch(error => {
+        // Failed to persist session type - silently continue
+      })
     } catch (error) {
-      console.error('Failed to save session state:', error)
+      // Failed to save session type - silently continue
       throw error
     }
   }
 
-  async getSessionState(): Promise<SessionState | null> {
-    try {
-      const state = await AsyncStorage.getItem(StorageService.SESSION_STATE_KEY)
-      return state as SessionState | null
-    } catch (error) {
-      console.error('Failed to get session state:', error)
-      return null
-    }
+  getSessionType(): SessionType | null {
+    return StorageService.cache.sessionType
   }
 
-  async saveSessionObject(session: ISession): Promise<void> {
+  saveSessionState(state: SessionState): void {
     try {
-      await AsyncStorage.setItem(StorageService.SESSION_OBJECT_KEY, JSON.stringify(session))
+      StorageService.cache.sessionState = state
+      AsyncStorage.setItem(StorageService.SESSION_STATE_KEY, state).catch(error => {
+        // Failed to persist session state - silently continue
+      })
     } catch (error) {
-      console.error('Failed to save session object:', error)
+      // Failed to save session state - silently continue
       throw error
     }
   }
 
-  async getSessionObject(): Promise<ISession | null> {
+  getSessionState(): SessionState | null {
+    return StorageService.cache.sessionState
+  }
+
+  saveSessionObject(session: ISession): void {
     try {
-      const sessionData = await AsyncStorage.getItem(StorageService.SESSION_OBJECT_KEY)
-      return sessionData ? JSON.parse(sessionData) : null
+      StorageService.cache.sessionObject = session
+      AsyncStorage.setItem(StorageService.SESSION_OBJECT_KEY, JSON.stringify(session)).catch(error => {
+        // Failed to persist session object - silently continue
+      })
     } catch (error) {
-      console.error('Failed to get session object:', error)
-      return null
+      // Failed to save session object - silently continue
+      throw error
     }
   }
 
-  async clearSessionData(): Promise<void> {
+  getSessionObject(): ISession | null {
+    return StorageService.cache.sessionObject
+  }
+
+  clearSessionData(): void {
     try {
-      await AsyncStorage.multiRemove([
+      // Clear cache immediately
+      StorageService.cache = {
+        sessionId: null,
+        sessionType: null,
+        sessionState: null,
+        sessionObject: null,
+      }
+
+      // Clear persistent storage asynchronously
+      AsyncStorage.multiRemove([
         StorageService.SESSION_ID_KEY,
         StorageService.SESSION_TYPE_KEY,
         StorageService.SESSION_STATE_KEY,
         StorageService.SESSION_OBJECT_KEY,
-      ])
+      ]).catch(error => {
+        // Failed to clear session data from storage - silently continue
+      })
     } catch (error) {
-      console.error('Failed to clear session data:', error)
+      // Failed to clear session data - silently continue
       throw error
     }
   }
 
-  async getAllSessionData(): Promise<{
-    sessionId: string | null
-    sessionType: SessionType | null
-    sessionState: SessionState | null
-    sessionObject: ISession | null
-  }> {
-    try {
-      const [sessionId, sessionType, sessionState, sessionObject] = await Promise.all([
-        this.getSessionId(),
-        this.getSessionType(),
-        this.getSessionState(),
-        this.getSessionObject(),
-      ])
-
-      return {
-        sessionId,
-        sessionType,
-        sessionState,
-        sessionObject,
-      }
-    } catch (error) {
-      console.error('Failed to get all session data:', error)
-      return {
-        sessionId: null,
-        sessionType: null,
-        sessionState: null,
-        sessionObject: null,
-      }
+  getAllSessionData(): CacheData {
+    return {
+      sessionId: StorageService.cache.sessionId,
+      sessionType: StorageService.cache.sessionType,
+      sessionState: StorageService.cache.sessionState,
+      sessionObject: StorageService.cache.sessionObject,
     }
   }
+
+  // Initialize cache on first use - call this method when the service is first used
+  static async initialize(): Promise<void> {
+    await StorageService.initializeCache()
+  }
 }