@multiplayer-app/session-recorder-common 0.0.1

package/src/SessionRecorderHttpInstrumentationHooksNode.ts

@@ -0,0 +1,362 @@
+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.node'
+import {
+  mask,
+  schemify,
+  isGzip,
+} from './sdk'
+import {
+  sensitiveFields,
+  sensitiveHeaders
+} from './sdk/mask'
+
+interface HttpResponseHookOptions {
+  maxPayloadSizeBytes?: number
+  schemifyDocSpanPayload?: boolean
+  uncompressPayload?: boolean
+
+  captureHeaders?: boolean
+  captureBody?: boolean
+
+  isMaskingEnabled?: 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
+  schemifyDocSpanPayload?: boolean
+
+  captureHeaders?: boolean
+  captureBody?: boolean
+
+  isMaskingEnabled?: 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,
+    isMaskingEnabled: boolean,
+    schemifyDocSpanPayload: boolean,
+    uncompressPayload: boolean,
+    maxPayloadSizeBytes: number
+  } => {
+  options.captureHeaders = 'captureHeaders' in options
+    ? options.captureHeaders
+    : true
+  options.captureBody = 'captureBody' in options
+    ? options.captureBody
+    : true
+  options.isMaskingEnabled = 'isMaskingEnabled' in options
+    ? options.isMaskingEnabled
+    : true
+  options.schemifyDocSpanPayload = 'schemifyDocSpanPayload' in options
+    ? options.schemifyDocSpanPayload
+    : false
+  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,
+      isMaskingEnabled: boolean,
+      schemifyDocSpanPayload: 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]))
+            // eslint-disable-next-line
+            // @ts-ignore
+            oldWrite.apply(_response, restArgs)
+          }
+        }
+
+        // eslint-disable-next-line
+        // @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 (!skipResponseBodyModification) {
+              if (
+                traceId.startsWith(MULTIPLAYER_TRACE_DEBUG_PREFIX)
+                && _options.isMaskingEnabled
+              ) {
+                responseBody = _options.maskBody(responseBody, span)
+              } else if (_options.schemifyDocSpanPayload) {
+                responseBody = schemify(responseBody)
+              } else if (typeof responseBody !== 'string') {
+                responseBody = JSON.stringify(responseBody)
+              }
+            }
+
+            if (responseBody.length) {
+              span.setAttribute(
+                ATTR_MULTIPLAYER_HTTP_RESPONSE_BODY,
+                responseBody,
+              )
+            }
+          }
+
+          if (_options.captureHeaders) {
+            const headers = _options.maskHeaders(_response.getHeaders(), span)
+
+            let _headers: any = {}
+
+            if (
+              !_options.headersToInclude?.length
+              && !_options.headersToExclude?.length
+            ) {
+              _headers = JSON.parse(JSON.stringify(headers))
+            } else {
+              if (_options.headersToInclude) {
+                for (const headerName of _options.headersToInclude) {
+                  _headers[headerName] = headers[headerName]
+                }
+              }
+
+              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,
+              )
+            }
+          }
+
+          // eslint-disable-next-line
+          // @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: any = {}
+
+          if (
+            !_options.headersToInclude?.length
+            && !_options.headersToExclude?.length
+          ) {
+            _headers = JSON.parse(JSON.stringify(_request.headers))
+          } else {
+            if (_options.headersToInclude) {
+              for (const headerName of _options.headersToInclude) {
+                _headers[headerName] = _request.headers
+              }
+            }
+
+            if (_options.headersToExclude?.length) {
+              for (const headerName of _options.headersToExclude) {
+                delete _headers[headerName]
+              }
+            }
+          }
+
+          const headers = _options.maskHeaders(_headers, span)
+
+          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
+
+              if (
+                traceId.startsWith(MULTIPLAYER_TRACE_DEBUG_PREFIX)
+                && _options.isMaskingEnabled
+              ) {
+                requestBody = _options.maskBody(requestBody, span)
+              } else if (_options.schemifyDocSpanPayload) {
+                requestBody = schemify(requestBody)
+              } 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/SessionRecorderHttpTraceExporterBrowser.ts

@@ -0,0 +1,123 @@
+import { ReadableSpan, SpanExporter } from '@opentelemetry/sdk-trace-base'
+import {
+  OTLPExporterConfigBase,
+  OTLPExporterBase,
+} from '@opentelemetry/otlp-exporter-base'
+import { createLegacyOtlpBrowserExportDelegate } from '@opentelemetry/otlp-exporter-base/browser-http'
+import { SessionRecorderJsonTraceSerializer } from './SessionRecorderJsonTraceSerializer'
+import { MULTIPLAYER_OTEL_DEFAULT_TRACES_EXPORTER_URL } from './constants.base'
+
+interface SessionRecorderExporterBrowserConfig
+  extends OTLPExporterConfigBase {
+  apiKey?: string
+  usePostMessageFallback?: boolean
+  postMessageType?: string
+  postMessageTargetOrigin?: string
+}
+
+/**
+ * Trace Exporters for Web with postMessage fallback
+ */
+export class SessionRecorderHttpTraceExporterBrowser
+  extends OTLPExporterBase<ReadableSpan[]>
+  implements SpanExporter {
+
+  private usePostMessage: boolean = false
+  private readonly postMessageType: string
+  private readonly postMessageTargetOrigin: string
+  private readonly config: SessionRecorderExporterBrowserConfig
+
+  constructor(config: SessionRecorderExporterBrowserConfig = {}) {
+    const _config = {
+      ...config,
+      url: config.url || MULTIPLAYER_OTEL_DEFAULT_TRACES_EXPORTER_URL,
+      headers: {
+        ...(config.headers || {}),
+        ...config.apiKey
+          ? { Authorization: config.apiKey }
+          : {},
+      },
+    }
+
+    super(
+      createLegacyOtlpBrowserExportDelegate(
+        _config,
+        SessionRecorderJsonTraceSerializer,
+        'v1/traces',
+        { 'Content-Type': 'application/json' },
+      ),
+    )
+
+    this.config = config
+    this.postMessageType = config.postMessageType || 'MULTIPLAYER_SESSION_DEBUGGER_LIB'
+    this.postMessageTargetOrigin = config.postMessageTargetOrigin || '*'
+  }
+
+  override export(spans: ReadableSpan[], resultCallback: (result: { code: number }) => void): void {
+    if (this.usePostMessage) {
+      this.exportViaPostMessage(spans, resultCallback)
+      return
+    }
+
+    super.export(spans, (result) => {
+      if (result.code === 0) {
+        resultCallback(result)
+      } else if (this.config.usePostMessageFallback) {
+        this.usePostMessage = true
+        this.exportViaPostMessage(spans, resultCallback)
+      } else {
+        resultCallback(result)
+      }
+    })
+  }
+
+  private exportViaPostMessage(spans: ReadableSpan[], resultCallback: (result: { code: number }) => void): void {
+    if (typeof window === 'undefined') {
+      resultCallback({ code: 1 })
+      return
+    }
+
+    try {
+      window.postMessage(
+        {
+          action: 'traces',
+          type: this.postMessageType,
+          payload: spans.map(span => this._serializeSpan(span)),
+        },
+        this.postMessageTargetOrigin,
+      )
+      resultCallback({ code: 0 })
+    } catch (e) {
+      resultCallback({ code: 1 })
+    }
+  }
+
+  private _serializeSpan(span: ReadableSpan): any {
+    return {
+      _spanContext: span.spanContext(),
+      name: span.name,
+      kind: span.kind,
+      links: span.links,
+      ended: span.ended,
+      events: span.events,
+      status: span.status,
+      endTime: span.endTime,
+      startTime: span.startTime,
+      duration: span.duration,
+      attributes: span.attributes,
+      parentSpanId: span.parentSpanId,
+      instrumentationLibrary: span.instrumentationLibrary,
+      droppedAttributesCount: span.droppedAttributesCount,
+      droppedEventsCount: span.droppedEventsCount,
+      droppedLinksCount: span.droppedLinksCount,
+      resource: {
+        attributes: span.resource.attributes,
+        asyncAttributesPending: span.resource.asyncAttributesPending,
+      },
+    }
+  }
+
+  getDefaultUrl(config: OTLPExporterConfigBase): string {
+    return config.url || MULTIPLAYER_OTEL_DEFAULT_TRACES_EXPORTER_URL
+  }
+}

package/src/SessionRecorderIdGenerator.ts

@@ -0,0 +1,72 @@
+import {
+  RandomIdGenerator,
+  SamplingDecision,
+} from '@opentelemetry/sdk-trace-base'
+import { SessionType } from './type'
+import {
+  SessionRecorderTraceIdRatioBasedSampler
+} from './SessionRecorderTraceIdRatioBasedSampler'
+import {
+  MULTIPLAYER_TRACE_DEBUG_PREFIX,
+  MULTIPLAYER_TRACE_DOC_PREFIX,
+  MULTIPLAYER_TRACE_CONTINUOUS_DEBUG_PREFIX,
+} from './constants.base'
+import { getIdGenerator } from './sdk'
+
+export class SessionRecorderIdGenerator extends RandomIdGenerator {
+  sessionShortId: string
+  sessionType: SessionType
+  docSpanSampler: SessionRecorderTraceIdRatioBasedSampler
+
+  generateLongId: () => string
+
+  constructor({ autoDocTracesRatio = 0 } = {}) {
+    super()
+
+    this.docSpanSampler = new SessionRecorderTraceIdRatioBasedSampler(autoDocTracesRatio)
+
+    this.generateLongId = getIdGenerator(16)
+    this.sessionShortId = ''
+    this.sessionType = SessionType.PLAIN
+
+    this.generateTraceId = () => {
+      const traceId = this.generateLongId()
+
+      if (this.sessionShortId) {
+        let sessionTypePrefix: string = ''
+        switch (this.sessionType) {
+          case SessionType.CONTINUOUS:
+            sessionTypePrefix = MULTIPLAYER_TRACE_CONTINUOUS_DEBUG_PREFIX
+            break
+          default:
+            sessionTypePrefix = MULTIPLAYER_TRACE_DEBUG_PREFIX
+        }
+
+        const prefix = `${sessionTypePrefix}${this.sessionShortId}`
+
+        const sessionTraceId = `${prefix}${traceId.substring(prefix.length, traceId.length)}`
+
+        return sessionTraceId
+      } else if (this._isDocTrace(traceId)) {
+        return `${MULTIPLAYER_TRACE_DOC_PREFIX}${traceId.slice(MULTIPLAYER_TRACE_DOC_PREFIX.length, traceId.length)}`
+      }
+
+      return traceId
+    }
+  }
+
+  setSessionId(
+    sessionShortId: string,
+    sessionType: SessionType = SessionType.PLAIN,
+  ) {
+    this.sessionShortId = sessionShortId
+    this.sessionType = sessionType
+  }
+
+  _isDocTrace(traceId: string) {
+    return this.docSpanSampler.shouldSample(
+      undefined,
+      traceId,
+    ).decision === SamplingDecision.RECORD_AND_SAMPLED
+  }
+}

package/src/SessionRecorderJsonTraceSerializer.ts

@@ -0,0 +1,43 @@
+import { ReadableSpan } from '@opentelemetry/sdk-trace-base'
+import {
+  IExportTraceServiceResponse,
+  createExportTraceServiceRequest,
+  ISerializer,
+} from '@opentelemetry/otlp-transformer'
+import {
+  MULTIPLAYER_TRACE_DEBUG_PREFIX,
+  MULTIPLAYER_TRACE_DOC_PREFIX,
+  MULTIPLAYER_TRACE_CONTINUOUS_DEBUG_PREFIX,
+} from './constants.base'
+
+export const SessionRecorderJsonTraceSerializer: ISerializer<
+ReadableSpan[],
+IExportTraceServiceResponse
+> = {
+  serializeRequest: (arg: ReadableSpan[]) => {
+    const filteredArg = arg.filter(span => {
+      const traceId = span.spanContext().traceId
+
+      if (
+        traceId.startsWith(MULTIPLAYER_TRACE_DEBUG_PREFIX)
+        || traceId.startsWith(MULTIPLAYER_TRACE_DOC_PREFIX)
+        || traceId.startsWith(MULTIPLAYER_TRACE_CONTINUOUS_DEBUG_PREFIX)
+      ) {
+        return true
+      }
+
+      return false
+    })
+
+    const request = createExportTraceServiceRequest(filteredArg, {
+      useHex: true,
+      useLongBits: false,
+    })
+    const encoder = new TextEncoder()
+    return encoder.encode(JSON.stringify(request))
+  },
+  deserializeResponse: (arg: Uint8Array) => {
+    const decoder = new TextDecoder()
+    return JSON.parse(decoder.decode(arg)) as IExportTraceServiceResponse
+  },
+}

package/src/SessionRecorderTraceIdRatioBasedSampler.ts

@@ -0,0 +1,57 @@
+import { isValidTraceId } from '@opentelemetry/api'
+import {
+  Sampler,
+  SamplingDecision,
+  SamplingResult,
+} from '@opentelemetry/sdk-trace-base'
+import { MULTIPLAYER_TRACE_DEBUG_PREFIX } from './constants.base'
+
+export class SessionRecorderTraceIdRatioBasedSampler implements Sampler {
+  private _upperBound: number
+
+  constructor(private readonly _ratio: number = 0) {
+    this._ratio = this._normalize(_ratio)
+    this._upperBound = Math.floor(this._ratio * 0xffffffff)
+  }
+
+  shouldSample(context: unknown, traceId: string): SamplingResult {
+    if (
+      this._ratio > 0
+      && traceId.startsWith(MULTIPLAYER_TRACE_DEBUG_PREFIX)
+    ) {
+      return {
+        decision: SamplingDecision.RECORD_AND_SAMPLED,
+      }
+    }
+
+    let decision: SamplingDecision = SamplingDecision.NOT_RECORD
+
+    if (
+      isValidTraceId(traceId)
+      && this._accumulate(traceId) < this._upperBound
+    ) {
+      decision = SamplingDecision.RECORD_AND_SAMPLED
+    }
+
+    return { decision }
+  }
+
+  toString(): string {
+    return `MultiplayerTraceIdRatioBasedSampler{${this._ratio}}`
+  }
+
+  private _normalize(ratio: number): number {
+    if (typeof ratio !== 'number' || isNaN(ratio)) return 0
+    return ratio >= 1 ? 1 : ratio <= 0 ? 0 : ratio
+  }
+
+  private _accumulate(traceId: string): number {
+    let accumulation = 0
+    for (let i = 0; i < traceId.length / 8; i++) {
+      const pos = i * 8
+      const part = parseInt(traceId.slice(pos, pos + 8), 16)
+      accumulation = (accumulation ^ part) >>> 0
+    }
+    return accumulation
+  }
+}