@multiplayer-app/session-recorder-common 1.0.1-alpha.1 → 1.0.1-alpha.3

package/src/exporters/SessionRecorderBrowserTraceExporter.ts

@@ -1,21 +1,24 @@
 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 { 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 SessionRecorderBrowserTraceExporterConfig
-  extends OTLPExporterConfigBase {
+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 */
@@ -29,10 +32,8 @@ export interface SessionRecorderBrowserTraceExporterConfig
  * 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
-  extends OTLPExporterBase<ReadableSpan[]>
-  implements SpanExporter {
-
+export class SessionRecorderBrowserTraceExporter implements SpanExporter {
+  private exporter: OTLPTraceExporter
   private usePostMessage: boolean = false
   private readonly postMessageType: string
   private readonly postMessageTargetOrigin: string
@@ -43,93 +44,32 @@ export class SessionRecorderBrowserTraceExporter
       url = MULTIPLAYER_OTEL_DEFAULT_TRACES_EXPORTER_HTTP_URL,
       apiKey,
       headers = {},
+      timeoutMillis = 30000,
+      keepAlive = true,
+      concurrencyLimit = 20,
       postMessageType = 'MULTIPLAYER_SESSION_DEBUGGER_LIB',
       postMessageTargetOrigin = '*',
-      ...restConfig
     } = config
 
-    const _config = {
-      ...restConfig,
+    this.config = {
+      ...config,
       url,
-      headers: {
-        'Content-Type': 'application/x-protobuf',
-        'User-Agent': '@multiplayer-app/session-recorder-common/1.0.0',
-        'Authorization': apiKey,
-        ...headers,
-      },
+      apiKey,
+      headers,
+      timeoutMillis,
+      keepAlive,
+      concurrencyLimit,
     }
-
-    super(
-      createLegacyOtlpBrowserExportDelegate(
-        _config,
-        {
-          serializeRequest: (spans: ReadableSpan[]) => {
-            // Create a simple trace service request structure
-            const request = {
-              resourceSpans: spans.map(span => ({
-                resource: {
-                  attributes: Object.entries(span.resource.attributes).map(([key, value]) => ({
-                    key,
-                    value: { stringValue: String(value) },
-                  })),
-                },
-                scopeSpans: [{
-                  spans: [{
-                    traceId: span.spanContext().traceId,
-                    spanId: span.spanContext().spanId,
-                    parentSpanId: span.spanContext().spanId, // Using spanId as fallback
-                    name: span.name,
-                    kind: span.kind,
-                    startTimeUnixNano: span.startTime[0] * 1e9 + span.startTime[1],
-                    endTimeUnixNano: span.endTime ? span.endTime[0] * 1e9 + span.endTime[1] : undefined,
-                    attributes: Object.entries(span.attributes).map(([key, value]) => ({
-                      key,
-                      value: { stringValue: String(value) },
-                    })),
-                    events: span.events.map(event => ({
-                      timeUnixNano: event.time[0] * 1e9 + event.time[1],
-                      name: event.name,
-                      attributes: Object.entries(event.attributes || {}).map(([key, value]) => ({
-                        key,
-                        value: { stringValue: String(value) },
-                      })),
-                    })),
-                    links: span.links.map(link => ({
-                      traceId: link.context.traceId,
-                      spanId: link.context.spanId,
-                      attributes: Object.entries(link.attributes || {}).map(([key, value]) => ({
-                        key,
-                        value: { stringValue: String(value) },
-                      })),
-                    })),
-                    status: {
-                      code: span.status.code,
-                      message: span.status.message || '',
-                    },
-                  }],
-                }],
-              })),
-            }
-
-            const encoder = new TextEncoder()
-            return encoder.encode(JSON.stringify(request))
-          },
-          deserializeResponse: (arg: Uint8Array) => {
-            const decoder = new TextDecoder()
-            return JSON.parse(decoder.decode(arg))
-          },
-        },
-        'v1/traces',
-        { 'Content-Type': 'application/json' },
-      ),
-    )
-
-    this.config = config
     this.postMessageType = postMessageType
     this.postMessageTargetOrigin = postMessageTargetOrigin
+
+    this.exporter = this._createExporter()
   }
 
-  override export(spans: ReadableSpan[], resultCallback: (result: { code: number }) => void): void {
+  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
@@ -148,7 +88,7 @@ export class SessionRecorderBrowserTraceExporter
       return
     }
 
-    super.export(filteredSpans, (result) => {
+    this.exporter.export(filteredSpans, (result) => {
       if (result.code === 0) {
         resultCallback(result)
       } else if (this.config.usePostMessageFallback) {
@@ -160,8 +100,8 @@ export class SessionRecorderBrowserTraceExporter
     })
   }
 
-  override shutdown(): Promise<void> {
-    return Promise.resolve()
+  shutdown(): Promise<void> {
+    return this.exporter.shutdown()
   }
 
   private exportViaPostMessage(spans: ReadableSpan[], resultCallback: (result: { code: number }) => void): void {
@@ -199,7 +139,7 @@ export class SessionRecorderBrowserTraceExporter
       startTime: span.startTime,
       duration: span.duration,
       attributes: span.attributes,
-      parentSpanId: spanContext.spanId, // Using spanId as parentSpanId is not available in newer versions
+      parentSpanId: span.parentSpanContext?.spanId,
       droppedAttributesCount: span.droppedAttributesCount,
       droppedEventsCount: span.droppedEventsCount,
       droppedLinksCount: span.droppedLinksCount,
@@ -209,4 +149,25 @@ export class SessionRecorderBrowserTraceExporter
       },
     }
   }
+
+  private _createExporter(): OTLPTraceExporter {
+    return new OTLPTraceExporter({
+      url: this.config.url,
+      headers: {
+        'Content-Type': 'application/x-protobuf',
+        'User-Agent': '@multiplayer-app/session-recorder-common/1.0.0',
+        '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()
+  }
 }