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

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

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