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

package/src/instrumentations/SessionRecorderHttpInstrumentationHooksNode.ts

@@ -1,356 +0,0 @@
-import type {
-  IncomingMessage,
-  ServerResponse,
-  ClientRequest,
-} from 'http'
-import * as zlib from 'zlib'
-import type { Span } from '@opentelemetry/api'
-import {
-  ATTR_MULTIPLAYER_HTTP_REQUEST_BODY,
-  ATTR_MULTIPLAYER_HTTP_REQUEST_HEADERS,
-  ATTR_MULTIPLAYER_HTTP_RESPONSE_BODY,
-  ATTR_MULTIPLAYER_HTTP_RESPONSE_HEADERS,
-  MULTIPLAYER_MAX_HTTP_REQUEST_RESPONSE_SIZE,
-  ATTR_MULTIPLAYER_HTTP_RESPONSE_BODY_ENCODING,
-  MULTIPLAYER_TRACE_DEBUG_PREFIX,
-} from '../constants/constants.node'
-import {
-  mask,
-  isGzip,
-} from '../sdk'
-import {
-  sensitiveFields,
-  sensitiveHeaders,
-} from '../sdk/mask'
-
-interface HttpResponseHookOptions {
-  maxPayloadSizeBytes?: number
-  uncompressPayload?: boolean
-
-  captureHeaders?: boolean
-  captureBody?: boolean
-
-  isMaskBodyEnabled?: boolean
-  isMaskHeadersEnabled?: boolean
-
-  maskBody?: (arg: any, span: Span) => any
-  maskHeaders?: (arg: any, span: Span) => any
-
-  maskBodyFieldsList?: string[]
-  maskHeadersList?: string[]
-
-  headersToInclude?: string[]
-  headersToExclude?: string[]
-}
-
-interface HttpRequestHookOptions {
-  maxPayloadSizeBytes?: number
-
-  captureHeaders?: boolean
-  captureBody?: boolean
-
-  isMaskBodyEnabled?: boolean
-  isMaskHeadersEnabled?: boolean
-
-  maskBody?: (arg: any, span: Span) => any
-  maskHeaders?: (arg: any, span: Span) => any
-
-  maskBodyFieldsList?: string[]
-  maskHeadersList?: string[]
-
-  headersToInclude?: string[]
-  headersToExclude?: string[]
-}
-
-const setDefaultOptions = (
-  options: HttpResponseHookOptions | HttpResponseHookOptions,
-): Omit<HttpResponseHookOptions & HttpResponseHookOptions, 'maskBody' | 'maskHeaders'>
-  & {
-    maskBody: (arg: any, span: Span) => any
-    maskHeaders: (arg: any, span: Span) => any
-    captureHeaders: boolean,
-    captureBody: boolean,
-    isMaskBodyEnabled: boolean
-    isMaskHeadersEnabled: boolean
-    uncompressPayload: boolean,
-    maxPayloadSizeBytes: number
-  } => {
-  options.captureHeaders = 'captureHeaders' in options
-    ? options.captureHeaders
-    : true
-  options.captureBody = 'captureBody' in options
-    ? options.captureBody
-    : true
-  options.isMaskBodyEnabled = 'isMaskBodyEnabled' in options
-    ? options.isMaskBodyEnabled
-    : true
-  options.isMaskHeadersEnabled = 'isMaskHeadersEnabled' in options
-    ? options.isMaskHeadersEnabled
-    : true
-  options.uncompressPayload = 'uncompressPayload' in options
-    ? options.uncompressPayload
-    : true
-  options.maskBody = options.maskBody || mask([
-    ...(
-      Array.isArray(options.maskBodyFieldsList)
-        ? options.maskBodyFieldsList
-        : sensitiveFields
-    ),
-    ...(
-      Array.isArray(options.maskHeadersList)
-        ? options.maskHeadersList
-        : sensitiveHeaders
-    ),
-  ])
-  options.maskHeaders = options.maskHeaders || mask([
-    ...(
-      Array.isArray(options.maskBodyFieldsList)
-        ? options.maskBodyFieldsList
-        : sensitiveFields
-    ),
-    ...(
-      Array.isArray(options.maskHeadersList)
-        ? options.maskHeadersList
-        : sensitiveHeaders
-    ),
-  ])
-  options.maxPayloadSizeBytes = options.maxPayloadSizeBytes || MULTIPLAYER_MAX_HTTP_REQUEST_RESPONSE_SIZE
-
-  return options as Omit<HttpResponseHookOptions & HttpResponseHookOptions, 'maskBody' | 'maskHeaders'>
-    & {
-      maskBody: (arg: any, span: Span) => any
-      maskHeaders: (arg: any, span: Span) => any
-      captureHeaders: boolean,
-      captureBody: boolean,
-      isMaskBodyEnabled: boolean,
-      isMaskHeadersEnabled: boolean,
-      uncompressPayload: boolean,
-      maxPayloadSizeBytes: number
-    }
-}
-
-export const SessionRecorderHttpInstrumentationHooksNode = {
-  responseHook: (options: HttpResponseHookOptions = {}) =>
-    (span: Span, response: IncomingMessage | ServerResponse) => {
-      try {
-        const _options = setDefaultOptions(options)
-
-        if (!_options.captureBody && !_options.captureHeaders) {
-          return
-        }
-
-        const _response = response as ServerResponse
-        const traceId = span.spanContext().traceId
-
-        if (_response.setHeader) {
-          _response.setHeader('X-Trace-Id', traceId)
-        }
-
-        const [oldWrite, oldEnd] = [_response.write, _response.end]
-
-        const chunks: Buffer[] = []
-
-        if (_options.captureBody) {
-          (_response.write as unknown) = function (...restArgs: any[]) {
-            chunks.push(Buffer.from(restArgs[0]))
-
-            // @ts-ignore
-            oldWrite.apply(_response, restArgs)
-          }
-        }
-
-
-        // @ts-ignore
-        _response.end = async function (...restArgs) {
-          if (_options.captureBody && restArgs[0]) {
-            chunks.push(Buffer.from(restArgs[0]))
-          }
-
-          const responseBuffer = Buffer.concat(chunks)
-
-          if (
-            _options.captureBody
-            && responseBuffer.byteLength > 0
-            && responseBuffer.byteLength < _options.maxPayloadSizeBytes
-          ) {
-            let responseBody: string
-            let skipResponseBodyModification = false
-
-            if (isGzip(responseBuffer)) {
-              if (_options.uncompressPayload) {
-                const dezippedBuffer = await new Promise((resolve) => zlib
-                  .gunzip(responseBuffer, function (err, dezipped) {
-                    if (err) {
-                      return resolve(Buffer.from(''))
-                    } else {
-                      return resolve(dezipped)
-                    }
-                  })) as Buffer
-                responseBody = dezippedBuffer.toString('utf-8')
-              } else {
-                span.setAttribute(
-                  ATTR_MULTIPLAYER_HTTP_RESPONSE_BODY_ENCODING,
-                  'gzip',
-                )
-
-                skipResponseBodyModification = true
-                responseBody = responseBuffer.toString('hex')
-              }
-            } else {
-              responseBody = responseBuffer.toString('utf-8')
-            }
-
-            if (responseBody.length) {
-              responseBody = JSON.parse(JSON.stringify(responseBody))
-            }
-
-            if (!skipResponseBodyModification) {
-              if (
-                traceId.startsWith(MULTIPLAYER_TRACE_DEBUG_PREFIX)
-                && _options.isMaskBodyEnabled
-              ) {
-                responseBody = _options.maskBody(responseBody, span)
-              } else if (typeof responseBody !== 'string') {
-                responseBody = JSON.stringify(responseBody)
-              }
-            }
-
-            if (responseBody.length) {
-              span.setAttribute(
-                ATTR_MULTIPLAYER_HTTP_RESPONSE_BODY,
-                responseBody,
-              )
-            }
-          }
-
-          if (_options.captureHeaders) {
-            let _headers = JSON.parse(JSON.stringify(_response.getHeaders() || {}))
-            if (_options.isMaskHeadersEnabled) {
-              _headers = _options.maskHeaders(_headers, span)
-            }
-
-            if (_options.headersToInclude) {
-              const filteredHeaders: any = {}
-              for (const headerName of _options.headersToInclude) {
-                filteredHeaders[headerName] = _headers[headerName]
-              }
-              _headers = filteredHeaders
-            }
-
-            if (_options.headersToExclude?.length) {
-              for (const headerName of _options.headersToExclude) {
-                delete _headers[headerName]
-              }
-            }
-
-            const stringifiedHeaders = JSON.stringify(_headers)
-
-            if (stringifiedHeaders?.length) {
-              span.setAttribute(
-                ATTR_MULTIPLAYER_HTTP_RESPONSE_HEADERS,
-                stringifiedHeaders,
-              )
-            }
-          }
-
-
-          // @ts-ignore
-          return oldEnd.apply(_response, restArgs)
-        }
-      } catch (error) {
-        // eslint-disable-next-line
-        console.error('An error occured in multiplayer otlp http responseHook', error)
-      }
-    },
-  requestHook: (options: HttpRequestHookOptions = {}) =>
-    (span: Span, request: ClientRequest | IncomingMessage) => {
-      try {
-        const _options = setDefaultOptions(options)
-
-        if (!_options.captureBody && !_options.captureHeaders) {
-          return
-        }
-
-        const traceId = span.spanContext().traceId
-        const _request = request as IncomingMessage
-
-        if (_options.captureHeaders) {
-          let _headers = JSON.parse(JSON.stringify(_request.headers || {}))
-
-          if (_options.isMaskHeadersEnabled) {
-            _headers = _options.maskHeaders(_headers, span)
-          }
-
-          if (_options.headersToInclude) {
-            const filteredHeaders: any = {}
-            for (const headerName of _options.headersToInclude) {
-              filteredHeaders[headerName] = _headers[headerName]
-            }
-            _headers = filteredHeaders
-          }
-
-          if (_options.headersToExclude?.length) {
-            for (const headerName of _options.headersToExclude) {
-              delete _headers[headerName]
-            }
-          }
-
-          span.setAttribute(
-            ATTR_MULTIPLAYER_HTTP_REQUEST_HEADERS,
-            JSON.stringify(_headers),
-          )
-        }
-
-        const contentType = _request?.headers?.['content-type']
-        if (
-          _options.captureBody
-          && contentType?.includes('application/json')
-        ) {
-          let body = ''
-          _request.on('data', (chunk) => {
-            body += chunk
-          })
-          _request.on('end', () => {
-            try {
-              const requestBodySizeBytes = Buffer.byteLength(body, 'utf8')
-
-              if (
-                requestBodySizeBytes === 0
-                || requestBodySizeBytes > _options.maxPayloadSizeBytes
-              ) {
-                return
-              }
-
-              let requestBody = body
-              if (!requestBody) return
-
-              requestBody = JSON.parse(JSON.stringify(requestBody))
-
-              if (
-                traceId.startsWith(MULTIPLAYER_TRACE_DEBUG_PREFIX)
-                && _options.isMaskBodyEnabled
-              ) {
-                requestBody = _options.maskBody(requestBody, span)
-              } else if (typeof requestBody !== 'string') {
-                requestBody = JSON.stringify(requestBody)
-              }
-
-              if (requestBody?.length) {
-                span.setAttribute(
-                  ATTR_MULTIPLAYER_HTTP_REQUEST_BODY,
-                  requestBody,
-                )
-              }
-            } catch (err) {
-              // eslint-disable-next-line
-              console.error('[MULTIPLAYER-HTTP-REQ-HOOK] An error occured in multiplayer otlp http requestHook', err)
-            }
-          })
-        }
-
-      } catch (error) {
-        // eslint-disable-next-line
-        console.error('An error occured in multiplayer otlp http requestHook', error)
-      }
-    },
-}

package/src/instrumentations/index-node.ts

@@ -1 +0,0 @@
-export * from './SessionRecorderHttpInstrumentationHooksNode'

package/src/sdk/capture-exception.ts

@@ -1,102 +0,0 @@
-import { context, trace, SpanStatusCode } from '@opentelemetry/api'
-import {
-  ATTR_EXCEPTION_MESSAGE,
-  ATTR_EXCEPTION_STACKTRACE,
-  ATTR_EXCEPTION_TYPE
-} from '@opentelemetry/semantic-conventions'
-import { getResourceAttributes } from './set-resource-attributes'
-
-/**
- * @description Add error to current span
- * @param {Error} error
- * @returns {void}
- */
-export const captureException = (error: Error, errorInfo?: Record<string, any>) => {
-  if (!error || !shouldCaptureException(error)) {
-    return
-  }
-
-  const activeContext = context.active()
-
-  let span = trace.getSpan(activeContext)
-  let isNewSpan = false
-
-  if (!span || !span.isRecording()) {
-    span = trace.getTracer('exception').startSpan(error.name || 'Error', {
-      attributes: {
-        [ATTR_EXCEPTION_MESSAGE]: error.message,
-        [ATTR_EXCEPTION_STACKTRACE]: error.stack,
-        [ATTR_EXCEPTION_TYPE]: error.name,
-        ...getResourceAttributes()
-      }
-    })
-    trace.setSpan(activeContext, span)
-    isNewSpan = true
-  } else {
-    span.setAttributes({
-      [ATTR_EXCEPTION_MESSAGE]: error.message,
-      [ATTR_EXCEPTION_STACKTRACE]: error.stack,
-      [ATTR_EXCEPTION_TYPE]: error.name
-    })
-  }
-
-  if (errorInfo) {
-    Object.entries(errorInfo).forEach(([key, value]) => {
-      span.setAttribute(`error_info.${key}`, value)
-    })
-  }
-
-  span.recordException(error)
-  span.setStatus({
-    code: SpanStatusCode.ERROR,
-    message: error.message
-  })
-
-  if (isNewSpan) {
-    span.end()
-  }
-}
-
-/**
- * Best-effort deduplication of exceptions that fire multiple times
- * (e.g. framework handler + global handlers) within a short time window.
- */
-
-const exceptionDedupeWindowMs = 2000
-const recentExceptionFingerprints = new Map<string, number>()
-
-export const shouldCaptureException = (error: Error, _errorInfo?: Record<string, any>): boolean => {
-  if (!error) return false
-
-  const now = Date.now()
-
-  // Build a fingerprint that is stable enough across repeated emissions
-  // but not so broad that different errors collapse into one.
-  const keyParts: string[] = []
-  keyParts.push(error.name || 'Error')
-  keyParts.push(error.message || '')
-
-  // First stack line tends to include file/line where it originated.
-  if (typeof error.stack === 'string') {
-    const firstFrame = error.stack.split('\n')[1] || ''
-    keyParts.push(firstFrame.trim())
-  }
-
-  const fingerprint = keyParts.join('|').slice(0, 500)
-
-  const lastSeen = recentExceptionFingerprints.get(fingerprint)
-  if (lastSeen && now - lastSeen < exceptionDedupeWindowMs) {
-    return false
-  }
-
-  recentExceptionFingerprints.set(fingerprint, now)
-
-  // Cheap cleanup of old entries to avoid unbounded growth.
-  for (const [key, ts] of recentExceptionFingerprints) {
-    if (now - ts > exceptionDedupeWindowMs * 5) {
-      recentExceptionFingerprints.delete(key)
-    }
-  }
-
-  return true
-}

package/src/sdk/id-generator.ts

@@ -1,17 +0,0 @@
-const SHARED_CHAR_CODES_ARRAY = Array(32)
-
-export const getIdGenerator = (bytes: number) => {
-  return function generateId() {
-    for (let i = 0; i < bytes * 2; i++) {
-      SHARED_CHAR_CODES_ARRAY[i] = Math.floor(Math.random() * 16) + 48
-      // valid hex characters in the range 48-57 and 97-102
-      if (SHARED_CHAR_CODES_ARRAY[i] >= 58) {
-        SHARED_CHAR_CODES_ARRAY[i] += 39
-      }
-    }
-    return String.fromCharCode.apply(
-      null,
-      SHARED_CHAR_CODES_ARRAY.slice(0, bytes * 2),
-    )
-  }
-}

package/src/sdk/index.ts

@@ -1,8 +0,0 @@
-export { default as mask, sensitiveFields, sensitiveHeaders } from './mask'
-export { default as schemify } from './schemify'
-export * from './is-gzip'
-export * from './id-generator'
-export * from './capture-exception'
-export * from './set-attribute'
-export * from './save-continuous-deb-session'
-export * from './set-resource-attributes'

package/src/sdk/is-gzip.ts

@@ -1,7 +0,0 @@
-export const isGzip = (buf: Buffer | Uint8Array) => {
-  if (!buf || buf.length < 3) {
-    return false
-  }
-
-  return buf[0] === 0x1F && buf[1] === 0x8B && buf[2] === 0x08
-}

package/src/sdk/mask.ts

@@ -1,161 +0,0 @@
-import type { Span } from '@opentelemetry/api'
-import { MASK_PLACEHOLDER } from '../constants/constants.base'
-
-const MAX_DEPTH = 8
-export const sensitiveFields: string[] = [
-  'password',
-  'pass',
-  'passwd',
-  'pwd',
-  'token',
-  'access_token',
-  'accessToken',
-  'refresh_token',
-  'refreshToken',
-  'secret',
-  'api_key',
-  'apiKey',
-  'authorization',
-  'auth_token',
-  'authToken',
-  'jwt',
-  'session_id',
-  'sessionId',
-  'sessionToken',
-  'client_secret',
-  'clientSecret',
-  'private_key',
-  'privateKey',
-  'public_key',
-  'publicKey',
-  'key',
-  'encryption_key',
-  'encryptionKey',
-  'credit_card',
-  'creditCard',
-  'card_number',
-  'cardNumber',
-  'cvv',
-  'cvc',
-  'ssn',
-  'sin',
-  'pin',
-  'security_code',
-  'securityCode',
-  'bank_account',
-  'bankAccount',
-  'iban',
-  'swift',
-  'bic',
-  'routing_number',
-  'routingNumber',
-  'license_key',
-  'licenseKey',
-  'otp',
-  'mfa_code',
-  'mfaCode',
-  'phone_number',
-  'phoneNumber',
-  'email',
-  'address',
-  'dob',
-  'tax_id',
-  'taxId',
-  'passport_number',
-  'passportNumber',
-  'driver_license',
-  'driverLicense',
-
-  'set-cookie',
-  'cookie',
-  'authorization',
-  'proxyAuthorization',
-]
-
-export const sensitiveHeaders: string[] = [
-  'set-cookie',
-  'cookie',
-  'authorization',
-  'proxyAuthorization',
-]
-
-const maskAll = (value: any, depth = 0) => {
-  const type = typeof value
-  const isObject = type === 'object'
-  let isArray = false
-
-  if (Array.isArray(value)) {
-    isArray = true
-  }
-
-  if (depth > MAX_DEPTH && (isObject || isArray)) {
-    return undefined
-  }
-
-  if (isArray) {
-    return value.map((val: any) => maskAll(val, depth + 1), value)
-  }
-
-  if (isObject) {
-    for (const key in value) {
-      value[key] = maskAll(value[key], depth + 1)
-    }
-
-    return value
-  }
-
-  if (type === 'string') {
-    return MASK_PLACEHOLDER
-  }
-
-  return value
-}
-
-const maskSelected = (value: any, keysToMask: string[]): any => {
-  const type = typeof value
-  const isObject = type === 'object'
-
-  const _keysToMask = new Set(keysToMask)
-
-  if (Array.isArray(value)) {
-    return value.map((val: any) => maskSelected(val, keysToMask), value)
-  }
-
-  if (isObject) {
-    for (const key in value) {
-      if (_keysToMask.has(key)) {
-        value[key] = MASK_PLACEHOLDER
-      } else {
-        value[key] = maskSelected(value[key], keysToMask)
-      }
-    }
-
-    return value
-  }
-
-  if (type === 'string') {
-    return value
-  }
-
-  return value
-}
-
-export default (keysToMask: string[] = []) => (value: any, span?: Span): any => {
-  let payloadJson
-  try {
-    payloadJson = JSON.parse(value)
-  } catch {
-    payloadJson = value
-  }
-  let maskedData
-  if (keysToMask.length) {
-    maskedData = maskSelected(payloadJson, keysToMask)
-  } else {
-    maskedData = maskAll(payloadJson)
-  }
-  if (typeof maskedData !== 'string') {
-    maskedData = JSON.stringify(maskedData)
-  }
-
-  return maskedData
-}

package/src/sdk/save-continuous-deb-session.ts

@@ -1,28 +0,0 @@
-import { context, trace } from '@opentelemetry/api'
-import {
-  ATTR_MULTIPLAYER_CONTINUOUS_SESSION_AUTO_SAVE,
-  ATTR_MULTIPLAYER_CONTINUOUS_SESSION_AUTO_SAVE_REASON,
-} from '../constants/constants.base'
-/**
- * @description Set auto save attribute to span
- * @param {String} reason
- * @returns {void}
- */
-export const saveContinuousSession = (
-  reason?: string,
-) => {
-  const span = trace.getSpan(context.active())
-
-  if (!span) {
-    return
-    // create span
-  }
-
-  span?.setAttribute(ATTR_MULTIPLAYER_CONTINUOUS_SESSION_AUTO_SAVE, true)
-
-  if (reason?.length) {
-    span?.addEvent(ATTR_MULTIPLAYER_CONTINUOUS_SESSION_AUTO_SAVE_REASON, {
-      reason,
-    })
-  }
-}