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

package/src/exporters/SessionRecorderBrowserTraceExporter.ts

@@ -1,196 +0,0 @@
-import { ReadableSpan, SpanExporter } from '@opentelemetry/sdk-trace-base'
-
-import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http'
-import {
-  MULTIPLAYER_OTEL_DEFAULT_TRACES_EXPORTER_HTTP_URL,
-  MULTIPLAYER_TRACE_DEBUG_PREFIX,
-  MULTIPLAYER_TRACE_CONTINUOUS_DEBUG_PREFIX,
-  MULTIPLAYER_TRACE_SESSION_CACHE_PREFIX,
-} from '../constants/constants.base'
-
-export interface SessionRecorderBrowserTraceExporterConfig {
-  /** URL for the OTLP endpoint. Defaults to Multiplayer's default traces endpoint. */
-  url?: string
-  /** API key for authentication. Required. */
-  apiKey?: string
-  /** Additional headers to include in requests */
-  headers?: Record<string, string>
-  /** Request timeout in milliseconds */
-  timeoutMillis?: number
-  /** Whether to use keep-alive connections */
-  keepAlive?: boolean
-  /** Maximum number of concurrent requests */
-  concurrencyLimit?: number
-  /** Whether to use postMessage fallback for cross-origin requests */
-  usePostMessageFallback?: boolean
-  /** PostMessage type identifier */
-  postMessageType?: string
-  /** PostMessage target origin */
-  postMessageTargetOrigin?: string
-}
-
-/**
- * Browser-specific trace exporter for Session Recorder
- * Exports traces via HTTP to Multiplayer's OTLP endpoint with browser-specific optimizations
- * Only exports spans with trace IDs starting with Multiplayer prefixes
- */
-export class SessionRecorderBrowserTraceExporter implements SpanExporter {
-  private exporter: OTLPTraceExporter
-  private usePostMessage: boolean = false
-  private readonly postMessageType: string
-  private readonly postMessageTargetOrigin: string
-  private readonly config: SessionRecorderBrowserTraceExporterConfig
-
-  constructor(config: SessionRecorderBrowserTraceExporterConfig = {}) {
-    const {
-      url = MULTIPLAYER_OTEL_DEFAULT_TRACES_EXPORTER_HTTP_URL,
-      apiKey,
-      headers = {},
-      timeoutMillis = 30000,
-      keepAlive = true,
-      concurrencyLimit = 20,
-      postMessageType = 'MULTIPLAYER_SESSION_DEBUGGER_LIB',
-      postMessageTargetOrigin = '*',
-    } = config
-
-    this.config = {
-      ...config,
-      url,
-      apiKey,
-      headers,
-      keepAlive,
-      timeoutMillis,
-      concurrencyLimit,
-    }
-    this.postMessageType = postMessageType
-    this.postMessageTargetOrigin = postMessageTargetOrigin
-
-    this.exporter = this._createExporter()
-  }
-  _export(spans: ReadableSpan[], resultCallback: (result: { code: number }) => void): void {
-    // Only proceed if there are filtered spans
-    if (spans.length === 0) {
-      resultCallback({ code: 0 })
-      return
-    }
-
-    if (this.usePostMessage) {
-      this.exportViaPostMessage(spans, resultCallback)
-      return
-    }
-
-    this.exporter.export(spans, (result) => {
-      if (result.code === 0) {
-        resultCallback(result)
-      } else if (this.config.usePostMessageFallback) {
-        this.usePostMessage = true
-        this.exportViaPostMessage(spans, resultCallback)
-      } else {
-        resultCallback(result)
-      }
-    })
-  }
-
-  export(spans: ReadableSpan[], resultCallback: (result: { code: number }) => void): void {
-    // Filter spans to only include those with Multiplayer trace prefixes
-    const filteredSpans = spans.filter((span) => {
-      const traceId = span.spanContext().traceId
-      return (
-        traceId.startsWith(MULTIPLAYER_TRACE_DEBUG_PREFIX) ||
-        traceId.startsWith(MULTIPLAYER_TRACE_CONTINUOUS_DEBUG_PREFIX)
-      )
-    })
-    this._export(filteredSpans, resultCallback)
-  }
-
-  exportBuffer(spans: ReadableSpan[], resultCallback: (result: { code: number }) => void): void {
-    const filteredSpans = spans.filter((span) => {
-      const traceId = span.spanContext().traceId
-      return traceId.startsWith(MULTIPLAYER_TRACE_SESSION_CACHE_PREFIX)
-    })
-    this._export(filteredSpans, resultCallback)
-  }
-
-  shutdown(): Promise<void> {
-    return this.exporter.shutdown()
-  }
-
-  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 })
-    }
-  }
-
-  serializeSpan(span: ReadableSpan): any {
-    const spanContext = span.spanContext()
-    const instrumentationScope: any =
-      // OTel SDK (modern)
-      (span as any).instrumentationScope ||
-        // Older SDKs
-        (span as any).instrumentationLibrary || { name: 'unknown', version: undefined, schemaUrl: undefined }
-
-    const normalizedScope = {
-      name: instrumentationScope?.name || 'unknown',
-      version: instrumentationScope?.version,
-      schemaUrl: instrumentationScope?.schemaUrl,
-    }
-    return {
-      _spanContext: spanContext,
-      traceId: spanContext.traceId,
-      spanId: spanContext.spanId,
-      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.parentSpanContext?.spanId,
-      droppedAttributesCount: span.droppedAttributesCount,
-      droppedEventsCount: span.droppedEventsCount,
-      droppedLinksCount: span.droppedLinksCount,
-      instrumentationScope: normalizedScope,
-      resource: {
-        attributes: span.resource.attributes,
-        asyncAttributesPending: span.resource.asyncAttributesPending,
-      },
-    }
-  }
-
-  private _createExporter(): OTLPTraceExporter {
-    return new OTLPTraceExporter({
-      url: this.config.url,
-      headers: {
-        'Content-Type': 'application/json',
-        ...(this.config.apiKey ? { Authorization: this.config.apiKey } : {}),
-        ...(this.config.headers || {}),
-      },
-      timeoutMillis: this.config.timeoutMillis,
-      keepAlive: this.config.keepAlive,
-      concurrencyLimit: this.config.concurrencyLimit,
-    })
-  }
-
-  setApiKey(apiKey: string): void {
-    this.config.apiKey = apiKey
-    this.exporter = this._createExporter()
-  }
-}

package/src/exporters/SessionRecorderGrpcLogsExporter.ts

@@ -1,52 +0,0 @@
-import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-proto'
-import {
-  MULTIPLAYER_OTEL_DEFAULT_LOGS_EXPORTER_GRPC_URL,
-  MULTIPLAYER_TRACE_DEBUG_PREFIX,
-  MULTIPLAYER_TRACE_CONTINUOUS_DEBUG_PREFIX,
-} from '../constants/constants.base'
-
-export interface SessionRecorderGrpcLogsExporterConfig {
-  /** The URL to send logs to. Defaults to MULTIPLAYER_OTEL_DEFAULT_LOGS_EXPORTER_GRPC_URL */
-  url?: string
-  /** API key for authentication. Required. */
-  apiKey: string
-  /** Timeout for gRPC requests in milliseconds. Defaults to 30000 */
-  timeoutMillis?: number
-}
-
-/**
- * gRPC logs exporter for Session Recorder
- * Exports logs via gRPC to Multiplayer's OTLP endpoint
- * Only exports logs with trace IDs starting with Multiplayer prefixes
- * Note: API key authentication may need to be handled at the gRPC client level
- */
-export class SessionRecorderGrpcLogsExporter extends OTLPLogExporter {
-  constructor(config: SessionRecorderGrpcLogsExporterConfig) {
-    const {
-      url = MULTIPLAYER_OTEL_DEFAULT_LOGS_EXPORTER_GRPC_URL,
-      timeoutMillis = 30000,
-    } = config
-
-    super({
-      url,
-      timeoutMillis,
-    })
-  }
-
-  override export(logs: any[], resultCallback: (result: { code: number }) => void): void {
-    // Filter logs to only include those with Multiplayer trace prefixes
-    const filteredLogs = logs.filter(log => {
-      const traceId = log.spanContext?.traceId || log.traceId
-      return traceId && (traceId.startsWith(MULTIPLAYER_TRACE_DEBUG_PREFIX) ||
-        traceId.startsWith(MULTIPLAYER_TRACE_CONTINUOUS_DEBUG_PREFIX))
-    })
-
-    // Only proceed if there are filtered logs
-    if (filteredLogs.length === 0) {
-      resultCallback({ code: 0 })
-      return
-    }
-
-    super.export(filteredLogs, resultCallback)
-  }
-}

package/src/exporters/SessionRecorderGrpcTraceExporter.ts

@@ -1,50 +0,0 @@
-import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-proto'
-import {
-  MULTIPLAYER_OTEL_DEFAULT_TRACES_EXPORTER_GRPC_URL,
-  MULTIPLAYER_TRACE_DEBUG_PREFIX,
-  MULTIPLAYER_TRACE_CONTINUOUS_DEBUG_PREFIX,
-} from '../constants/constants.base'
-
-export interface SessionRecorderGrpcTraceExporterConfig {
-  /** The URL to send traces to. Defaults to MULTIPLAYER_OTEL_DEFAULT_TRACES_EXPORTER_GRPC_URL */
-  url?: string
-  /** API key for authentication. Required. */
-  apiKey: string
-  /** Timeout for gRPC requests in milliseconds. Defaults to 30000 */
-  timeoutMillis?: number
-}
-
-/**
- * gRPC trace exporter for Session Recorder
- * Exports traces via gRPC to Multiplayer's OTLP endpoint
- * Only exports spans with trace IDs starting with Multiplayer prefixes
- * Note: API key authentication may need to be handled at the gRPC client level
- */
-export class SessionRecorderGrpcTraceExporter extends OTLPTraceExporter {
-  constructor(config: SessionRecorderGrpcTraceExporterConfig) {
-    const {
-      url = MULTIPLAYER_OTEL_DEFAULT_TRACES_EXPORTER_GRPC_URL,
-      timeoutMillis = 30000,
-    } = config
-
-    super({
-      url,
-      timeoutMillis,
-    })
-  }
-
-  override export(spans: any[], resultCallback: (result: { code: number }) => void): void {
-    const filteredSpans = spans.filter(span => {
-      const traceId = span.spanContext().traceId
-      return traceId.startsWith(MULTIPLAYER_TRACE_DEBUG_PREFIX) ||
-        traceId.startsWith(MULTIPLAYER_TRACE_CONTINUOUS_DEBUG_PREFIX)
-    })
-
-    if (filteredSpans.length === 0) {
-      resultCallback({ code: 0 })
-      return
-    }
-
-    super.export(filteredSpans, resultCallback)
-  }
-}

package/src/exporters/SessionRecorderHttpLogsExporter.ts

@@ -1,58 +0,0 @@
-import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http'
-import {
-  MULTIPLAYER_OTEL_DEFAULT_LOGS_EXPORTER_HTTP_URL,
-  MULTIPLAYER_TRACE_DEBUG_PREFIX,
-  MULTIPLAYER_TRACE_CONTINUOUS_DEBUG_PREFIX,
-} from '../constants/constants.base'
-
-export interface SessionRecorderHttpLogsExporterConfig {
-  /** The URL to send logs to. Defaults to MULTIPLAYER_OTEL_DEFAULT_LOGS_EXPORTER_HTTP_URL */
-  url?: string
-  /** API key for authentication. Required. */
-  apiKey: string
-  /** Timeout for HTTP requests in milliseconds. Defaults to 30000 */
-  timeoutMillis?: number
-  /** Whether to keep the connection alive. Defaults to true */
-  keepAlive?: boolean
-  /** Maximum number of concurrent requests. Defaults to 20 */
-  concurrencyLimit?: number
-}
-
-export class SessionRecorderHttpLogsExporter extends OTLPLogExporter {
-  constructor(config: SessionRecorderHttpLogsExporterConfig) {
-    const {
-      url = MULTIPLAYER_OTEL_DEFAULT_LOGS_EXPORTER_HTTP_URL,
-      apiKey,
-      timeoutMillis = 30000,
-      keepAlive = true,
-      concurrencyLimit = 20,
-    } = config
-
-    super({
-      url,
-      headers: {
-        'Content-Type': 'application/json',
-        'User-Agent': '@multiplayer-app/session-recorder-common/1.0.0',
-        'authorization': apiKey,
-      },
-      timeoutMillis,
-      keepAlive,
-      concurrencyLimit,
-    })
-  }
-
-  override export(logs: any[], resultCallback: (result: { code: number }) => void): void {
-    const filteredLogs = logs.filter(log => {
-      const traceId = log.spanContext?.traceId || log.traceId
-      return traceId && (traceId.startsWith(MULTIPLAYER_TRACE_DEBUG_PREFIX) ||
-        traceId.startsWith(MULTIPLAYER_TRACE_CONTINUOUS_DEBUG_PREFIX))
-    })
-
-    if (filteredLogs.length === 0) {
-      resultCallback({ code: 0 })
-      return
-    }
-
-    super.export(filteredLogs, resultCallback)
-  }
-}

package/src/exporters/SessionRecorderHttpTraceExporter.ts

@@ -1,68 +0,0 @@
-import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http'
-import {
-  MULTIPLAYER_OTEL_DEFAULT_TRACES_EXPORTER_HTTP_URL,
-  MULTIPLAYER_TRACE_DEBUG_PREFIX,
-  MULTIPLAYER_TRACE_CONTINUOUS_DEBUG_PREFIX,
-} from '../constants/constants.base'
-
-export interface SessionRecorderHttpTraceExporterConfig {
-  /** The URL to send traces to. Defaults to MULTIPLAYER_OTEL_DEFAULT_TRACES_EXPORTER_HTTP_URL */
-  url?: string
-  /** API key for authentication. Required. */
-  apiKey: string
-  /** Timeout for HTTP requests in milliseconds. Defaults to 30000 */
-  timeoutMillis?: number
-  /** Whether to keep the connection alive. Defaults to true */
-  keepAlive?: boolean
-  /** Maximum number of concurrent requests. Defaults to 20 */
-  concurrencyLimit?: number
-}
-
-/**
- * HTTP trace exporter for Session Recorder
- * Exports traces via HTTP to Multiplayer's OTLP endpoint
- * Only exports spans with trace IDs starting with Multiplayer prefixes
- */
-export class SessionRecorderHttpTraceExporter extends OTLPTraceExporter {
-  constructor(config: SessionRecorderHttpTraceExporterConfig) {
-    const {
-      url = MULTIPLAYER_OTEL_DEFAULT_TRACES_EXPORTER_HTTP_URL,
-      apiKey,
-      timeoutMillis = 30000,
-      keepAlive = true,
-      concurrencyLimit = 20,
-    } = config
-
-    super({
-      url,
-      headers: {
-        'Content-Type': 'application/json',
-        'User-Agent': '@multiplayer-app/session-recorder-common/1.0.0',
-        ...apiKey
-          ? { 'Authorization': apiKey }
-          : {},
-      },
-      timeoutMillis,
-      keepAlive,
-      concurrencyLimit,
-    })
-  }
-
-  override export(
-    spans: any[],
-    resultCallback: (result: { code: number }) => void,
-  ): void {
-    const filteredSpans = spans.filter(span => {
-      const traceId = span.spanContext().traceId
-      return traceId.startsWith(MULTIPLAYER_TRACE_DEBUG_PREFIX) ||
-        traceId.startsWith(MULTIPLAYER_TRACE_CONTINUOUS_DEBUG_PREFIX)
-    })
-
-    if (filteredSpans.length === 0) {
-      resultCallback({ code: 0 })
-      return
-    }
-
-    super.export(filteredSpans, resultCallback)
-  }
-}

package/src/exporters/SessionRecorderLogsExporterWrapper.ts

@@ -1,36 +0,0 @@
-import { SdkLogRecord, LogRecordExporter } from '@opentelemetry/sdk-logs'
-import {
-  MULTIPLAYER_TRACE_DEBUG_PREFIX,
-  MULTIPLAYER_TRACE_CONTINUOUS_DEBUG_PREFIX,
-} from '../constants/constants.base'
-
-export interface SessionRecorderLogsExporterWrapperConfig {
-  exporter: LogRecordExporter
-}
-
-export class SessionRecorderLogsExporterWrapper implements LogRecordExporter {
-  private readonly exporter: LogRecordExporter
-
-  constructor(config: SessionRecorderLogsExporterWrapperConfig) {
-    this.exporter = config.exporter
-  }
-
-  export(logs: SdkLogRecord[], resultCallback: (result: { code: number }) => void): void {
-    const filteredLogs = logs.filter(log => {
-      const traceId = log.spanContext?.traceId
-      return !traceId || (!traceId.startsWith(MULTIPLAYER_TRACE_DEBUG_PREFIX) &&
-        !traceId.startsWith(MULTIPLAYER_TRACE_CONTINUOUS_DEBUG_PREFIX))
-    })
-
-    if (filteredLogs.length === 0) {
-      resultCallback({ code: 0 })
-      return
-    }
-
-    this.exporter.export(filteredLogs, resultCallback)
-  }
-
-  shutdown(): Promise<void> {
-    return this.exporter.shutdown()
-  }
-}

package/src/exporters/SessionRecorderTraceExporterWrapper.ts

@@ -1,36 +0,0 @@
-import { ReadableSpan, SpanExporter } from '@opentelemetry/sdk-trace-base'
-import {
-  MULTIPLAYER_TRACE_DEBUG_PREFIX,
-  MULTIPLAYER_TRACE_CONTINUOUS_DEBUG_PREFIX,
-} from '../constants/constants.base'
-
-export interface SessionRecorderTraceExporterWrapperConfig {
-  exporter: SpanExporter
-}
-
-export class SessionRecorderTraceExporterWrapper implements SpanExporter {
-  private readonly exporter: SpanExporter
-
-  constructor(config: SessionRecorderTraceExporterWrapperConfig) {
-    this.exporter = config.exporter
-  }
-
-  export(spans: ReadableSpan[], resultCallback: (result: { code: number }) => void): void {
-    const filteredSpans = spans.filter(span => {
-      const traceId = span.spanContext().traceId
-      return !traceId.startsWith(MULTIPLAYER_TRACE_DEBUG_PREFIX) &&
-        !traceId.startsWith(MULTIPLAYER_TRACE_CONTINUOUS_DEBUG_PREFIX)
-    })
-
-    if (filteredSpans.length === 0) {
-      resultCallback({ code: 0 })
-      return
-    }
-
-    this.exporter.export(filteredSpans, resultCallback)
-  }
-
-  shutdown(): Promise<void> {
-    return this.exporter.shutdown()
-  }
-}

package/src/exporters/index-browser.ts

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

package/src/exporters/index-node.ts

@@ -1,6 +0,0 @@
-export * from './SessionRecorderHttpTraceExporter'
-export * from './SessionRecorderHttpLogsExporter'
-export * from './SessionRecorderGrpcTraceExporter'
-export * from './SessionRecorderGrpcLogsExporter'
-export * from './SessionRecorderTraceExporterWrapper'
-export * from './SessionRecorderLogsExporterWrapper'

package/src/exporters/index.ts

@@ -1,7 +0,0 @@
-export * from './SessionRecorderHttpTraceExporter'
-export * from './SessionRecorderHttpLogsExporter'
-export * from './SessionRecorderGrpcTraceExporter'
-export * from './SessionRecorderGrpcLogsExporter'
-export * from './SessionRecorderBrowserTraceExporter'
-export * from './SessionRecorderTraceExporterWrapper'
-export * from './SessionRecorderLogsExporterWrapper'

package/src/index-browser.ts

@@ -1,6 +0,0 @@
-export * from './constants/constants.browser'
-export { SessionRecorderIdGenerator } from './SessionRecorderIdGenerator'
-export { SessionRecorderTraceIdRatioBasedSampler } from './SessionRecorderTraceIdRatioBasedSampler'
-export * as SessionRecorderSdk from './sdk'
-export * from './type'
-export * from './exporters/index-browser'

package/src/index-node.ts

@@ -1,7 +0,0 @@
-export * from './constants/constants.node'
-export { SessionRecorderHttpInstrumentationHooksNode } from './instrumentations/SessionRecorderHttpInstrumentationHooksNode'
-export { SessionRecorderIdGenerator } from './SessionRecorderIdGenerator'
-export { SessionRecorderTraceIdRatioBasedSampler } from './SessionRecorderTraceIdRatioBasedSampler'
-export * as SessionRecorderSdk from './sdk'
-export * from './type'
-export * from './exporters/index-node'

package/src/index.ts

@@ -1,7 +0,0 @@
-export * from './constants/constants.node'
-export { SessionRecorderIdGenerator } from './SessionRecorderIdGenerator'
-export { SessionRecorderTraceIdRatioBasedSampler } from './SessionRecorderTraceIdRatioBasedSampler'
-export * as SessionRecorderSdk from './sdk'
-export * from './type'
-export * from './exporters'
-export * from './instrumentations/index-node'