@multiplayer-app/session-recorder-react-native 0.0.1-alpha.9 → 0.0.1-beta.10

package/src/context/SessionRecorderContext.tsx

@@ -1,143 +0,0 @@
-import React, { createContext, useContext, ReactNode, PropsWithChildren, useState, useEffect, useRef, useCallback } from 'react'
-import { Pressable, Text, View } from 'react-native'
-import { SessionRecorderOptions, SessionState } from '../types'
-import SessionRecorder from '../session-recorder'
-import { GestureCaptureWrapper } from '../components/GestureCaptureWrapper'
-import sessionRecorder from '../session-recorder'
-import { logger } from '../utils'
-
-interface SessionRecorderContextType {
-  instance: typeof SessionRecorder
-}
-
-const SessionRecorderContext = createContext<SessionRecorderContextType | null>(null)
-
-export interface SessionRecorderProviderProps extends PropsWithChildren {
-  options: SessionRecorderOptions
-}
-
-export const SessionRecorderProvider: React.FC<SessionRecorderProviderProps> = ({ children, options }) => {
-  const [sessionState, setSessionState] = useState<SessionState | null>(null)
-  const optionsRef = useRef<string>()
-
-  useEffect(() => {
-    const newOptions = JSON.stringify(options)
-    if (optionsRef.current === JSON.stringify(options)) return
-    optionsRef.current = newOptions
-    SessionRecorder.init(options)
-  }, [options])
-
-  useEffect(() => {
-    setSessionState(SessionRecorder.sessionState)
-    SessionRecorder.on('state-change', (state: SessionState) => {
-      setSessionState(state)
-    })
-  }, [])
-
-  const onToggleSession = () => {
-    if (SessionRecorder.sessionState === SessionState.started) {
-      SessionRecorder.stop()
-    } else {
-      SessionRecorder.start()
-    }
-  }
-
-  return (
-    <SessionRecorderContext.Provider value={{ instance: sessionRecorder }}>
-      <GestureEventCapture>
-        {children}
-        <Pressable onPress={onToggleSession}>
-          <View
-            style={{
-              position: 'absolute',
-              right: 0,
-              bottom: 100,
-              width: 48,
-              height: 48,
-              paddingTop: 16,
-              paddingLeft: 10,
-              backgroundColor: 'red',
-              borderTopLeftRadius: 24,
-              borderBottomLeftRadius: 24
-            }}
-          >
-            <Text style={{ color: 'white' }}>{sessionState === SessionState.started ? 'Stop' : 'Start'}</Text>
-          </View>
-        </Pressable>
-      </GestureEventCapture>
-    </SessionRecorderContext.Provider>
-  )
-}
-
-// Gesture-based event capture component
-const GestureEventCapture: React.FC<{ children: ReactNode }> = ({ children }) => {
-  // Set up gesture recording callback
-  const handleGestureRecord = useCallback((gestureType: string, data: any) => {
-    if (SessionRecorder.sessionState !== SessionState.started) {
-      logger.debug('SessionRecorderContext', 'Gesture recording skipped', {
-        client: !!SessionRecorder.sessionState,
-        sessionState: SessionRecorder.sessionState
-      })
-      return
-    }
-    logger.debug('SessionRecorderContext', 'Gesture recorded', { gestureType, data })
-    try {
-      // Record gesture as appropriate touch events
-      switch (gestureType) {
-        case 'tap':
-          // For tap, record both touch start and end
-          logger.debug('SessionRecorderContext', 'Recording tap as touch start + end')
-          SessionRecorder.recordTouchStart?.(data.x, data.y, undefined, 1.0)
-          SessionRecorder.recordTouchEnd?.(data.x, data.y, undefined, 1.0)
-          break
-
-        case 'pan_start':
-          logger.debug('SessionRecorderContext', 'Recording pan_start as touch start')
-          SessionRecorder.recordTouchStart?.(data.x, data.y, undefined, 1.0)
-          break
-
-        case 'pan_update':
-          logger.debug('SessionRecorderContext', 'Recording pan_update as touch move')
-          SessionRecorder.recordTouchMove?.(data.x, data.y, undefined, 1.0)
-          break
-
-        case 'pan_end':
-          logger.debug('SessionRecorderContext', 'Recording pan_end as touch end')
-          SessionRecorder.recordTouchEnd?.(data.x, data.y, undefined, 1.0)
-          break
-
-        case 'long_press':
-          logger.debug('SessionRecorderContext', 'Recording long_press as touch start + end')
-          SessionRecorder.recordTouchStart?.(data.x, data.y, undefined, 1.0)
-          SessionRecorder.recordTouchEnd?.(data.x, data.y, undefined, 1.0)
-          break
-        default:
-      }
-    } catch (error) {
-      logger.error('SessionRecorderContext', 'Failed to record gesture event', error)
-    }
-  }, [])
-
-  // Callback ref to set the viewshot ref immediately when available
-  const setViewShotRef = (ref: View | null) => {
-    if (ref) {
-      SessionRecorder.setViewShotRef?.(ref)
-    }
-  }
-
-  return (
-    <GestureCaptureWrapper onGestureRecord={handleGestureRecord}>
-      <View ref={setViewShotRef} style={{ flex: 1 }}>
-        {children}
-      </View>
-    </GestureCaptureWrapper>
-  )
-}
-
-export const useSessionRecorder = (): SessionRecorderContextType => {
-  const context = useContext(SessionRecorderContext)
-  if (!context) {
-    throw new Error('useSessionRecorder must be used within a SessionRecorderProvider')
-  }
-  return context
-}

package/src/expo.ts

@@ -1,11 +0,0 @@
-import './patch'
-import SessionRecorder from './session-recorder'
-export * from '@multiplayer-app/session-recorder-common'
-export * from './context/SessionRecorderContext'
-
-export { SessionRecorder }
-// Export the instance as default
-export default SessionRecorder
-
-// Export Expo-specific utilities
-export { isExpoEnvironment, getPlatformAttributes } from './utils/platform'

package/src/index.ts

@@ -1,9 +0,0 @@
-import './patch'
-import SessionRecorder from './session-recorder'
-export * from '@multiplayer-app/session-recorder-common'
-export * from './context/SessionRecorderContext'
-
-
-export { SessionRecorder }
-// Export the instance as default
-export default SessionRecorder

package/src/otel/helpers.ts

@@ -1,275 +0,0 @@
-import { Span } from '@opentelemetry/api'
-import {
-  MULTIPLAYER_TRACE_DEBUG_PREFIX,
-  MULTIPLAYER_TRACE_CONTINUOUS_DEBUG_PREFIX,
-  ATTR_MULTIPLAYER_HTTP_REQUEST_BODY,
-  ATTR_MULTIPLAYER_HTTP_REQUEST_HEADERS,
-  ATTR_MULTIPLAYER_HTTP_RESPONSE_BODY,
-  ATTR_MULTIPLAYER_HTTP_RESPONSE_HEADERS,
-} from '@multiplayer-app/session-recorder-common'
-import { logger } from '../utils'
-import { SessionRecorderSdk } from '@multiplayer-app/session-recorder-common'
-import { TracerReactNativeConfig } from '../types'
-
-const { schemify } = SessionRecorderSdk
-
-export interface HttpPayloadData {
-  requestBody?: any
-  responseBody?: any
-  requestHeaders?: Record<string, string>
-  responseHeaders?: Record<string, string>
-}
-
-export interface ProcessedHttpPayload {
-  requestBody?: string
-  responseBody?: string
-  requestHeaders?: string
-  responseHeaders?: string
-}
-
-/**
- * Checks if the trace should be processed based on trace ID prefixes
- */
-export function shouldProcessTrace(traceId: string): boolean {
-  return (
-    traceId.startsWith(MULTIPLAYER_TRACE_DEBUG_PREFIX) ||
-    traceId.startsWith(MULTIPLAYER_TRACE_CONTINUOUS_DEBUG_PREFIX)
-  )
-}
-
-/**
- * Processes request and response body based on trace type and configuration
- */
-export function processBody(
-  payload: HttpPayloadData,
-  config: TracerReactNativeConfig,
-  span: Span,
-): { requestBody?: string; responseBody?: string } {
-  const { captureBody, masking } = config
-  const traceId = span.spanContext().traceId
-
-  if (!captureBody) {
-    return {}
-  }
-
-  let { requestBody, responseBody } = payload
-
-  if (requestBody !== undefined && requestBody !== null) {
-    requestBody = JSON.parse(JSON.stringify(requestBody))
-  }
-  if (responseBody !== undefined && responseBody !== null) {
-    responseBody = JSON.parse(JSON.stringify(responseBody))
-  }
-
-  // Apply masking for debug traces
-  if (
-    traceId.startsWith(MULTIPLAYER_TRACE_DEBUG_PREFIX) ||
-    traceId.startsWith(MULTIPLAYER_TRACE_CONTINUOUS_DEBUG_PREFIX)
-  ) {
-    if (masking.isContentMaskingEnabled) {
-      requestBody = requestBody && masking.maskBody?.(requestBody, span)
-      responseBody = responseBody && masking.maskBody?.(responseBody, span)
-    }
-  }
-
-  // Convert to string if needed
-  if (typeof requestBody !== 'string') {
-    requestBody = JSON.stringify(requestBody)
-  }
-
-  if (typeof responseBody !== 'string') {
-    responseBody = JSON.stringify(responseBody)
-  }
-
-  return {
-    requestBody: requestBody?.length ? requestBody : undefined,
-    responseBody: responseBody?.length ? responseBody : undefined,
-  }
-}
-
-/**
- * Processes request and response headers based on configuration
- */
-export function processHeaders(
-  payload: HttpPayloadData,
-  config: TracerReactNativeConfig,
-  span: Span,
-): { requestHeaders?: string; responseHeaders?: string } {
-  const { captureHeaders, masking } = config
-
-  if (!captureHeaders) {
-    return {}
-  }
-
-  let { requestHeaders = {}, responseHeaders = {} } = payload
-
-  // Handle header filtering
-  if (
-    !masking.headersToInclude?.length &&
-    !masking.headersToExclude?.length
-  ) {
-    // Add null checks to prevent JSON.parse error when headers is undefined
-    if (requestHeaders !== undefined && requestHeaders !== null) {
-      requestHeaders = JSON.parse(JSON.stringify(requestHeaders))
-    }
-    if (responseHeaders !== undefined && responseHeaders !== null) {
-      responseHeaders = JSON.parse(JSON.stringify(responseHeaders))
-    }
-  } else {
-    if (masking.headersToInclude) {
-      const _requestHeaders: Record<string, string> = {}
-      const _responseHeaders: Record<string, string> = {}
-
-      for (const headerName of masking.headersToInclude) {
-        if (requestHeaders[headerName]) {
-          _requestHeaders[headerName] = requestHeaders[headerName]
-        }
-        if (responseHeaders[headerName]) {
-          _responseHeaders[headerName] = responseHeaders[headerName]
-        }
-      }
-
-      requestHeaders = _requestHeaders
-      responseHeaders = _responseHeaders
-    }
-
-    if (masking.headersToExclude?.length) {
-      for (const headerName of masking.headersToExclude) {
-        delete requestHeaders[headerName]
-        delete responseHeaders[headerName]
-      }
-    }
-  }
-
-  // Apply masking
-  const maskedRequestHeaders = masking.maskHeaders?.(requestHeaders, span) || requestHeaders
-  const maskedResponseHeaders = masking.maskHeaders?.(responseHeaders, span) || responseHeaders
-
-  // Convert to string
-  const requestHeadersStr = typeof maskedRequestHeaders === 'string'
-    ? maskedRequestHeaders
-    : JSON.stringify(maskedRequestHeaders)
-
-  const responseHeadersStr = typeof maskedResponseHeaders === 'string'
-    ? maskedResponseHeaders
-    : JSON.stringify(maskedResponseHeaders)
-
-  return {
-    requestHeaders: requestHeadersStr?.length ? requestHeadersStr : undefined,
-    responseHeaders: responseHeadersStr?.length ? responseHeadersStr : undefined,
-  }
-}
-
-/**
- * Processes HTTP payload (body and headers) and sets span attributes
- */
-export function processHttpPayload(
-  payload: HttpPayloadData,
-  config: TracerReactNativeConfig,
-  span: Span,
-): void {
-  const traceId = span.spanContext().traceId
-
-  if (!shouldProcessTrace(traceId)) {
-    return
-  }
-
-  const { requestBody, responseBody } = processBody(payload, config, span)
-  const { requestHeaders, responseHeaders } = processHeaders(payload, config, span)
-
-  // Set span attributes
-  if (requestBody) {
-    span.setAttribute(ATTR_MULTIPLAYER_HTTP_REQUEST_BODY, requestBody)
-  }
-
-  if (responseBody) {
-    span.setAttribute(ATTR_MULTIPLAYER_HTTP_RESPONSE_BODY, responseBody)
-  }
-
-  if (requestHeaders) {
-    span.setAttribute(ATTR_MULTIPLAYER_HTTP_REQUEST_HEADERS, requestHeaders)
-  }
-
-  if (responseHeaders) {
-    span.setAttribute(ATTR_MULTIPLAYER_HTTP_RESPONSE_HEADERS, responseHeaders)
-  }
-}
-
-/**
- * Converts Headers object to plain object
- */
-export function headersToObject(headers: Headers | Record<string, string> | Record<string, string | string[]> | string[][] | undefined): Record<string, string> {
-  const result: Record<string, string> = {}
-
-  if (!headers) {
-    return result
-  }
-
-  if (headers instanceof Headers) {
-    headers.forEach((value: string, key: string) => {
-      result[key] = value
-    })
-  } else if (Array.isArray(headers)) {
-    // Handle array of [key, value] pairs
-    for (const [key, value] of headers) {
-      if (typeof key === 'string' && typeof value === 'string') {
-        result[key] = value
-      }
-    }
-  } else if (typeof headers === 'object' && !Array.isArray(headers)) {
-    for (const [key, value] of Object.entries(headers)) {
-      if (typeof key === 'string' && typeof value === 'string') {
-        result[key] = value
-      }
-    }
-  }
-
-  return result
-}
-
-/**
- * Extracts response body as string from Response object
- */
-export async function extractResponseBody(response: Response): Promise<string | null> {
-  if (!response.body) {
-    return null
-  }
-
-  try {
-    if (response.body instanceof ReadableStream) {
-      // Check if response body is already consumed
-      if (response.bodyUsed) {
-        return null
-      }
-
-      const responseClone = response.clone()
-      return responseClone.text()
-    } else {
-      return JSON.stringify(response.body)
-    }
-  } catch (error) {
-    // If cloning fails (body already consumed), return null
-    // eslint-disable-next-line no-console
-    logger.warn('DEBUGGER_LIB', 'Failed to extract response body', error)
-    return null
-  }
-}
-
-export const getExporterEndpoint = (exporterEndpoint: string): string => {
-  const hasPath = exporterEndpoint && (() => {
-    try {
-      const url = new URL(exporterEndpoint)
-      return url.pathname !== '/' && url.pathname !== ''
-    } catch {
-      return false
-    }
-  })()
-
-  if (hasPath) {
-    return exporterEndpoint
-  }
-
-  const trimmedExporterEndpoint = new URL(exporterEndpoint).origin
-
-  return `${trimmedExporterEndpoint}/v1/traces`
-}

package/src/otel/index.ts

@@ -1,149 +0,0 @@
-import { resourceFromAttributes } from '@opentelemetry/resources'
-import { W3CTraceContextPropagator } from '@opentelemetry/core'
-import { BatchSpanProcessor } from '@opentelemetry/sdk-trace-base'
-import * as SemanticAttributes from '@opentelemetry/semantic-conventions'
-import { registerInstrumentations } from '@opentelemetry/instrumentation'
-import {
-  SessionType,
-  ATTR_MULTIPLAYER_SESSION_ID,
-  SessionRecorderIdGenerator,
-  SessionRecorderTraceIdRatioBasedSampler,
-  SessionRecorderBrowserTraceExporter,
-} from '@multiplayer-app/session-recorder-common'
-import { TracerReactNativeConfig } from '../types'
-import { getInstrumentations } from './instrumentations'
-import { getExporterEndpoint } from './helpers'
-import { ReactNavigationInstrumentation } from './instrumentations/reactNavigationInstrumentation'
-import { GestureInstrumentation } from './instrumentations/gestureInstrumentation'
-import { getPlatformAttributes } from '../utils/platform'
-import { WebTracerProvider } from '@opentelemetry/sdk-trace-web'
-
-
-
-
-export class TracerReactNativeSDK {
-  private tracerProvider?: WebTracerProvider
-  private config?: TracerReactNativeConfig
-
-  private sessionId = ''
-  private idGenerator?: SessionRecorderIdGenerator
-  private exporter?: any
-  private navigationInstrumentation?: ReactNavigationInstrumentation
-  private gestureInstrumentation?: GestureInstrumentation
-  private isInitialized = false
-
-  constructor() { }
-
-  private _setSessionId(
-    sessionId: string,
-    sessionType: SessionType = SessionType.PLAIN,
-  ) {
-    this.sessionId = sessionId
-    this.idGenerator?.setSessionId(sessionId, sessionType)
-  }
-
-  init(options: TracerReactNativeConfig): void {
-    this.config = options
-
-    const { application, version, environment } = this.config
-
-    this.idGenerator = new SessionRecorderIdGenerator()
-
-    this.exporter = new SessionRecorderBrowserTraceExporter({
-      apiKey: options.apiKey,
-      url: getExporterEndpoint(options.exporterEndpoint),
-      usePostMessageFallback: options.usePostMessageFallback,
-    })
-
-    this.tracerProvider = new WebTracerProvider({
-      resource: resourceFromAttributes({
-        [SemanticAttributes.SEMRESATTRS_SERVICE_NAME]: application,
-        [SemanticAttributes.SEMRESATTRS_SERVICE_VERSION]: version,
-        [SemanticAttributes.SEMRESATTRS_DEPLOYMENT_ENVIRONMENT]: environment,
-        ...getPlatformAttributes(),
-      }),
-      idGenerator: this.idGenerator,
-      sampler: new SessionRecorderTraceIdRatioBasedSampler(this.config.sampleTraceRatio || 0.15),
-      spanProcessors: [
-        this._getSpanSessionIdProcessor(),
-        new BatchSpanProcessor(this.exporter),
-      ],
-    })
-
-    this.tracerProvider.register({
-      propagator: new W3CTraceContextPropagator(),
-    })
-
-    // Register instrumentations
-    registerInstrumentations({
-      tracerProvider: this.tracerProvider,
-      instrumentations: getInstrumentations(this.config),
-    })
-
-    // // Initialize React Native specific instrumentations
-    // this.navigationInstrumentation = new ReactNavigationInstrumentation()
-    // this.gestureInstrumentation = new GestureInstrumentation()
-
-    // // Enable the custom instrumentations
-    // this.navigationInstrumentation.enable()
-    // this.gestureInstrumentation.enable()
-
-    this.isInitialized = true
-  }
-
-  private _getSpanSessionIdProcessor() {
-    return {
-      onStart: (span: any) => {
-        if (this.sessionId) {
-          span.setAttribute(ATTR_MULTIPLAYER_SESSION_ID, this.sessionId)
-        }
-        // Add React Native specific attributes
-        span.setAttribute('platform', 'react-native')
-        span.setAttribute('timestamp', Date.now())
-      },
-      onEnd: () => { },
-      shutdown: () => Promise.resolve(),
-      forceFlush: () => Promise.resolve(),
-    }
-  }
-
-  start(sessionId: string, sessionType: SessionType): void {
-    if (!this.tracerProvider) {
-      throw new Error(
-        'Configuration not initialized. Call init() before start().',
-      )
-    }
-
-    this._setSessionId(sessionId, sessionType)
-  }
-
-  stop(): void {
-    if (!this.tracerProvider) {
-      throw new Error(
-        'Configuration not initialized. Call init() before start().',
-      )
-    }
-
-    this._setSessionId('')
-  }
-
-  setApiKey(apiKey: string): void {
-    if (!this.exporter) {
-      throw new Error(
-        'Configuration not initialized. Call init() before setApiKey().',
-      )
-    }
-
-    this.exporter.setApiKey?.(apiKey)
-  }
-
-  setSessionId(sessionId: string, sessionType: SessionType): void {
-    this._setSessionId(sessionId, sessionType)
-  }
-
-  // Shutdown (React Native specific)
-  shutdown(): Promise<void> {
-    this.isInitialized = false
-    return Promise.resolve()
-  }
-}