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

package/eslint.config.js

@@ -1,226 +0,0 @@
-import js from '@eslint/js'
-import globals from 'globals'
-import tseslint from '@typescript-eslint/eslint-plugin'
-import tsparser from '@typescript-eslint/parser'
-
-export default [
-  js.configs.recommended,
-  {
-    ignores: [
-      'node_modules/**',
-      'dist/**',
-      'build/**',
-      'coverage/**',
-      '*.min.js',
-      '*.bundle.js',
-    ],
-  },
-  {
-    files: ['**/*.ts', '**/*.tsx'],
-    languageOptions: {
-      parser: tsparser,
-      parserOptions: {
-        ecmaVersion: 'latest',
-        sourceType: 'module',
-      },
-      globals: {
-        ...globals.browser,
-        // Browser globals
-        window: 'readonly',
-        document: 'readonly',
-        navigator: 'readonly',
-        localStorage: 'readonly',
-        sessionStorage: 'readonly',
-        console: 'readonly',
-        setTimeout: 'readonly',
-        clearTimeout: 'readonly',
-        setInterval: 'readonly',
-        clearInterval: 'readonly',
-        requestAnimationFrame: 'readonly',
-        cancelAnimationFrame: 'readonly',
-        fetch: 'readonly',
-        Headers: 'readonly',
-        HeadersInit: 'readonly',
-        Request: 'readonly',
-        RequestInfo: 'readonly',
-        Response: 'readonly',
-        FormData: 'readonly',
-        File: 'readonly',
-        Blob: 'readonly',
-        URL: 'readonly',
-        URLSearchParams: 'readonly',
-        AbortController: 'readonly',
-        AbortSignal: 'readonly',
-        ReadableStream: 'readonly',
-        WritableStream: 'readonly',
-        TransformStream: 'readonly',
-        TextEncoder: 'readonly',
-        TextDecoder: 'readonly',
-        HTMLElement: 'readonly',
-        HTMLButtonElement: 'readonly',
-        HTMLInputElement: 'readonly',
-        HTMLTextAreaElement: 'readonly',
-        HTMLAnchorElement: 'readonly',
-        XMLHttpRequest: 'readonly',
-        XMLHttpRequestBodyInit: 'readonly',
-        MouseEvent: 'readonly',
-        InputEvent: 'readonly',
-        MessageEvent: 'readonly',
-        EventListener: 'readonly',
-        MutationObserver: 'readonly',
-        NodeJS: 'readonly',
-        Window: 'readonly',
-        Document: 'readonly',
-        IDBDatabase: 'readonly',
-        indexedDB: 'readonly',
-        // Node.js globals
-        process: 'readonly',
-        Buffer: 'readonly',
-        __dirname: 'readonly',
-        __filename: 'readonly',
-        global: 'readonly',
-        module: 'readonly',
-        require: 'readonly',
-        exports: 'readonly',
-      },
-    },
-    plugins: {
-      '@typescript-eslint': tseslint,
-    },
-    rules: {
-      // TypeScript specific rules
-      'no-namespace': 'off',
-      'no-useless-escape': 'off',
-      'no-self-assign': 'off',
-      'no-useless-catch': 'off',
-      'prefer-namespace-keyword': 'off',
-      'no-empty-function': 'off',
-      'no-unused-vars': 'off',
-      'no-explicit-any': 'off',
-      'ban-types': 'off',
-      'object-curly-spacing': ['error', 'always'],
-      'space-before-blocks': 'error',
-      'keyword-spacing': 'error',
-
-      // General rules
-      'prefer-const': 'error',
-      'block-spacing': ['error', 'always'],
-      'keyword-spacing': [
-        'error',
-        {
-          before: true,
-          after: true,
-        },
-      ],
-      'indent': ['error', 2, { SwitchCase: 1 }],
-      'linebreak-style': ['error', 'unix'],
-      'quotes': ['error', 'single'],
-      'semi': ['error', 'never'],
-      'comma-dangle': ['error', 'always-multiline'],
-      'no-console': 'warn',
-      'object-curly-spacing': ['error', 'always'],
-      'space-in-parens': ['error', 'never'],
-      'array-bracket-spacing': ['error', 'never'],
-      'no-trailing-spaces': 'error',
-      'no-multi-spaces': 'error',
-      'no-lonely-if': 'error',
-      'key-spacing': 'error',
-      'no-useless-escape': 'error',
-      'no-self-assign': 'error',
-    },
-  },
-  {
-    files: ['**/*.js', '**/*.mjs'],
-    languageOptions: {
-      ecmaVersion: 'latest',
-      sourceType: 'module',
-      globals: {
-        // Browser globals
-        window: 'readonly',
-        document: 'readonly',
-        navigator: 'readonly',
-        localStorage: 'readonly',
-        sessionStorage: 'readonly',
-        console: 'readonly',
-        setTimeout: 'readonly',
-        clearTimeout: 'readonly',
-        setInterval: 'readonly',
-        clearInterval: 'readonly',
-        requestAnimationFrame: 'readonly',
-        cancelAnimationFrame: 'readonly',
-        fetch: 'readonly',
-        Headers: 'readonly',
-        HeadersInit: 'readonly',
-        Request: 'readonly',
-        RequestInfo: 'readonly',
-        Response: 'readonly',
-        FormData: 'readonly',
-        File: 'readonly',
-        Blob: 'readonly',
-        URL: 'readonly',
-        URLSearchParams: 'readonly',
-        AbortController: 'readonly',
-        AbortSignal: 'readonly',
-        ReadableStream: 'readonly',
-        WritableStream: 'readonly',
-        TransformStream: 'readonly',
-        TextEncoder: 'readonly',
-        TextDecoder: 'readonly',
-        HTMLElement: 'readonly',
-        HTMLButtonElement: 'readonly',
-        HTMLInputElement: 'readonly',
-        HTMLTextAreaElement: 'readonly',
-        HTMLAnchorElement: 'readonly',
-        XMLHttpRequest: 'readonly',
-        XMLHttpRequestBodyInit: 'readonly',
-        MouseEvent: 'readonly',
-        InputEvent: 'readonly',
-        MessageEvent: 'readonly',
-        EventListener: 'readonly',
-        MutationObserver: 'readonly',
-        NodeJS: 'readonly',
-        Window: 'readonly',
-        Document: 'readonly',
-        IDBDatabase: 'readonly',
-        indexedDB: 'readonly',
-        // Node.js globals
-        process: 'readonly',
-        Buffer: 'readonly',
-        __dirname: 'readonly',
-        __filename: 'readonly',
-        global: 'readonly',
-        module: 'readonly',
-        require: 'readonly',
-        exports: 'readonly',
-      },
-    },
-    rules: {
-      'no-useless-escape': 'off',
-      'no-self-assign': 'off',
-      'prefer-const': 'error',
-      'block-spacing': ['error', 'always'],
-      'keyword-spacing': [
-        'error',
-        {
-          before: true,
-          after: true,
-        },
-      ],
-      'indent': ['error', 2, { SwitchCase: 1 }],
-      'linebreak-style': ['error', 'unix'],
-      'quotes': ['error', 'single'],
-      'semi': ['error', 'never'],
-      'comma-dangle': ['error', 'always-multiline'],
-      'no-console': 'warn',
-      'object-curly-spacing': ['error', 'always'],
-      'space-in-parens': ['error', 'never'],
-      'array-bracket-spacing': ['error', 'never'],
-      'no-trailing-spaces': 'error',
-      'no-multi-spaces': 'error',
-      'no-lonely-if': 'error',
-      'key-spacing': 'error',
-      'no-useless-escape': 'error',
-      'no-self-assign': 'error',
-    },
-  },
-]

package/src/SessionRecorderIdGenerator.ts

@@ -1,70 +0,0 @@
-import { IdGenerator } from '@opentelemetry/sdk-trace-base'
-import { SessionType } from './type'
-import { getIdGenerator } from './sdk'
-import {
-  MULTIPLAYER_TRACE_PREFIX_MAP,
-} from './constants/constants.base'
-
-export class SessionRecorderIdGenerator implements IdGenerator {
-  sessionShortId: string
-  sessionType?: SessionType
-  clientId?: string
-  private generateLongId: () => string
-  private generateShortId: () => string
-
-  constructor() {
-    this.generateLongId = getIdGenerator(16)
-    this.generateShortId = getIdGenerator(8)
-    this.sessionShortId = ''
-    this.clientId = ''
-    this.sessionType
-  }
-
-  generateTraceId(): string {
-    const traceId = this.generateLongId()
-
-    if (
-      (
-        !this.sessionShortId
-        && !this.clientId
-      )
-      || !this.sessionType
-    ) {
-      return traceId
-    }
-
-    const sessionTypePrefix = MULTIPLAYER_TRACE_PREFIX_MAP[this.sessionType]
-    const prefix = `${sessionTypePrefix}${[SessionType.SESSION, SessionType.SESSION_CACHE].includes(this.sessionType) ? this.clientId : ''}${this.sessionShortId}`
-    const sessionTraceId = `${prefix}${traceId.substring(prefix.length, traceId.length)}`
-
-    return sessionTraceId
-  }
-
-  generateSpanId(): string {
-    return this.generateShortId()
-  }
-
-  setSessionId(
-    sessionShortId: string,
-    sessionType?: SessionType,
-    clientId?: string,
-  ) {
-    if (
-      sessionType
-      && !clientId
-      && [
-        SessionType.SESSION,
-        SessionType.SESSION_CACHE,
-      ].includes(sessionType)
-    ) {
-      throw new Error(`Client ID is required for ${[
-        SessionType.SESSION,
-        SessionType.SESSION_CACHE,
-      ].join(', ')} session types`)
-    }
-
-    this.sessionShortId = sessionShortId
-    this.sessionType = sessionType
-    this.clientId = clientId
-  }
-}

package/src/SessionRecorderTraceIdRatioBasedSampler.ts

@@ -1,89 +0,0 @@
-
-import {
-  isValidTraceId,
-  Context,
-  SpanKind,
-  Attributes,
-  Link,
-} from '@opentelemetry/api'
-import {
-  Sampler,
-  SamplingDecision,
-  SamplingResult,
-} from '@opentelemetry/sdk-trace-base'
-import {
-  ATTR_EXCEPTION_MESSAGE,
-  ATTR_EXCEPTION_STACKTRACE,
-  ATTR_EXCEPTION_TYPE,
-} from '@opentelemetry/semantic-conventions'
-import {
-  MULTIPLAYER_TRACE_DEBUG_PREFIX,
-  MULTIPLAYER_TRACE_CONTINUOUS_DEBUG_PREFIX,
-  MULTIPLAYER_TRACE_SESSION_CACHE_PREFIX,
-  // MULTIPLAYER_TRACE_CONTINUOUS_SESSION_CACHE_PREFIX,
-} from './constants/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: Context,
-    traceId: string,
-    spanName: string,
-    spanKind: SpanKind,
-    attributes: Attributes,
-    links: Link[],
-  ): SamplingResult {
-    if (attributes[ATTR_EXCEPTION_MESSAGE] || attributes[ATTR_EXCEPTION_STACKTRACE] || attributes[ATTR_EXCEPTION_TYPE]) {
-      return {
-        decision: SamplingDecision.RECORD_AND_SAMPLED,
-      }
-    }
-
-    if (
-      traceId.startsWith(MULTIPLAYER_TRACE_DEBUG_PREFIX)
-      || traceId.startsWith(MULTIPLAYER_TRACE_CONTINUOUS_DEBUG_PREFIX)
-      || traceId.startsWith(MULTIPLAYER_TRACE_SESSION_CACHE_PREFIX)
-      // || traceId.startsWith(MULTIPLAYER_TRACE_CONTINUOUS_SESSION_CACHE_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 `SessionRecorderTraceIdRatioBasedSampler{${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
-  }
-}

package/src/constants/constants.base.ts

@@ -1,111 +0,0 @@
-import { SessionType } from '../type'
-
-/**
- * @deprecated
- */
-export const MULTIPLAYER_TRACE_DOC_PREFIX = 'd0cd0c'
-
-export const MULTIPLAYER_TRACE_DEBUG_PREFIX = 'debdeb'
-
-export const MULTIPLAYER_TRACE_CONTINUOUS_DEBUG_PREFIX = 'cdbcdb'
-
-export const MULTIPLAYER_TRACE_SESSION_PREFIX = 'cdbcac'
-
-export const MULTIPLAYER_TRACE_SESSION_CACHE_PREFIX = 'debcdb'
-
-export const MULTIPLAYER_TRACE_PREFIX_MAP = {
-  [SessionType.CONTINUOUS]: MULTIPLAYER_TRACE_CONTINUOUS_DEBUG_PREFIX,
-  [SessionType.SESSION_CACHE]: MULTIPLAYER_TRACE_SESSION_CACHE_PREFIX,
-  [SessionType.SESSION]: MULTIPLAYER_TRACE_SESSION_PREFIX,
-  [SessionType.MANUAL]: MULTIPLAYER_TRACE_DEBUG_PREFIX,
-} as Record<SessionType, string>
-
-export const MULTIPLAYER_TRACE_DEBUG_SESSION_SHORT_ID_LENGTH = 8
-
-export const MULTIPLAYER_TRACE_CLIENT_ID_LENGTH = 4
-
-/**
- * @deprecated Use MULTIPLAYER_OTEL_DEFAULT_TRACES_EXPORTER_HTTP_URL instead
- */
-export const MULTIPLAYER_OTEL_DEFAULT_TRACES_EXPORTER_URL = 'https://api.multiplayer.app/v1/traces'
-
-/**
- * @deprecated Use MULTIPLAYER_OTEL_DEFAULT_LOGS_EXPORTER_HTTP_URL instead
- */
-export const MULTIPLAYER_OTEL_DEFAULT_LOGS_EXPORTER_URL = 'https://api.multiplayer.app/v1/logs'
-
-export const MULTIPLAYER_OTEL_DEFAULT_TRACES_EXPORTER_HTTP_URL = 'https://otlp.multiplayer.app/v1/traces'
-
-export const MULTIPLAYER_OTEL_DEFAULT_LOGS_EXPORTER_HTTP_URL = 'https://otlp.multiplayer.app/v1/logs'
-
-export const MULTIPLAYER_OTEL_DEFAULT_TRACES_EXPORTER_GRPC_URL = 'https://otlp.multiplayer.app:4317/v1/traces'
-
-export const MULTIPLAYER_OTEL_DEFAULT_LOGS_EXPORTER_GRPC_URL = 'https://otlp.multiplayer.app:4317/v1/logs'
-
-export const MULTIPLAYER_BASE_API_URL = 'https://api.multiplayer.app'
-
-export const MULTIPLAYER_ATTRIBUTE_PREFIX = 'multiplayer.'
-
-export const ATTR_MULTIPLAYER_WORKSPACE_ID = 'multiplayer.workspace.id'
-
-export const ATTR_MULTIPLAYER_PROJECT_ID = 'multiplayer.project.id'
-
-export const ATTR_MULTIPLAYER_PLATFORM_ID = 'multiplayer.platform.id'
-
-export const ATTR_MULTIPLAYER_CONTINUOUS_SESSION_AUTO_SAVE = 'multiplayer.session.auto-save'
-
-export const ATTR_MULTIPLAYER_CONTINUOUS_SESSION_AUTO_SAVE_REASON = 'multiplayer.session.auto-save.reason'
-
-export const ATTR_MULTIPLAYER_PLATFORM_NAME = 'multiplayer.platform.name'
-
-export const ATTR_MULTIPLAYER_CLIENT_ID = 'multiplayer.client.id'
-
-export const ATTR_MULTIPLAYER_INTEGRATION_ID = 'multiplayer.integration.id'
-
-export const ATTR_MULTIPLAYER_SESSION_ID = 'multiplayer.session.id'
-
-export const ATTR_MULTIPLAYER_SESSION_CLIENT_ID = 'multiplayer.session.client.id'
-
-export const ATTR_MULTIPLAYER_HTTP_PROXY = 'multiplayer.http.proxy'
-
-export const ATTR_MULTIPLAYER_HTTP_PROXY_TYPE = 'multiplayer.http.proxy.type'
-
-export const ATTR_MULTIPLAYER_HTTP_REQUEST_BODY = 'multiplayer.http.request.body'
-
-export const ATTR_MULTIPLAYER_HTTP_RESPONSE_BODY = 'multiplayer.http.response.body'
-
-export const ATTR_MULTIPLAYER_HTTP_REQUEST_HEADERS = 'multiplayer.http.request.headers'
-
-export const ATTR_MULTIPLAYER_HTTP_RESPONSE_HEADERS = 'multiplayer.http.response.headers'
-
-export const ATTR_MULTIPLAYER_HTTP_RESPONSE_BODY_ENCODING = 'multiplayer.http.response.body.encoding'
-
-export const ATTR_MULTIPLAYER_RPC_REQUEST_MESSAGE = 'multiplayer.rpc.request.message'
-
-export const ATTR_MULTIPLAYER_RPC_REQUEST_MESSAGE_ENCODING = 'multiplayer.rpc.request.message.encoding'
-
-export const ATTR_MULTIPLAYER_RPC_RESPONSE_MESSAGE = 'multiplayer.rpc.response.message'
-
-export const ATTR_MULTIPLAYER_GRPC_REQUEST_MESSAGE = 'multiplayer.rpc.grpc.request.message'
-
-export const ATTR_MULTIPLAYER_GRPC_REQUEST_MESSAGE_ENCODING = 'multiplayer.rpc.request.message.encoding'
-
-export const ATTR_MULTIPLAYER_GRPC_RESPONSE_MESSAGE = 'multiplayer.rpc.grpc.response.message'
-
-export const ATTR_MULTIPLAYER_MESSAGING_MESSAGE_BODY = 'multiplayer.messaging.message.body'
-
-export const ATTR_MULTIPLAYER_MESSAGING_MESSAGE_BODY_ENCODING = 'multiplayer.messaging.message.body.encoding'
-
-export const ATTR_MULTIPLAYER_SESSION_RECORDER_VERSION = 'multiplayer.session-recorder.version'
-
-export const ATTR_MULTIPLAYER_ISSUE_CUSTOM_HASH = 'multiplayer.issue.custom-hash'
-
-export const ATTR_MULTIPLAYER_ISSUE_HASH = 'multiplayer.issue.hash'
-
-export const ATTR_MULTIPLAYER_ISSUE_COMPONENT_HASH = 'multiplayer.issue.component-hash'
-
-export const ATTR_MULTIPLAYER_ISSUE_TITLE_HASH = 'multiplayer.issue.title-hash'
-
-export const ATTR_MULTIPLAYER_USER_HASH = 'multiplayer.user.hash'
-
-export const MASK_PLACEHOLDER = '***MASKED***'

package/src/constants/constants.browser.ts

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

package/src/constants/constants.node.ts

@@ -1,5 +0,0 @@
-export * from './constants.base'
-
-export const MULTIPLAYER_MAX_HTTP_REQUEST_RESPONSE_SIZE = process.env.MULTIPLAYER_MAX_HTTP_REQUEST_RESPONSE_SIZE
-  ? Number(process.env.MULTIPLAYER_MAX_HTTP_REQUEST_RESPONSE_SIZE)
-  : 500000

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()
-  }
-}