@multiplayer-app/session-recorder-common 1.3.26 → 1.3.28

package/src/exporters/SessionRecorderBrowserTraceExporter.ts

@@ -1,11 +1,11 @@
 import { ReadableSpan, SpanExporter } from '@opentelemetry/sdk-trace-base'
-import { ExportResult } from '@opentelemetry/core'
 
 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 {
@@ -67,50 +67,52 @@ export class SessionRecorderBrowserTraceExporter implements SpanExporter {
 
     this.exporter = this._createExporter()
   }
-
-  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)
-      )
-    })
-
+  _export(spans: ReadableSpan[], resultCallback: (result: { code: number }) => void): void {
     // Only proceed if there are filtered spans
-    if (filteredSpans.length === 0) {
+    if (spans.length === 0) {
       resultCallback({ code: 0 })
       return
     }
 
     if (this.usePostMessage) {
-      this.exportViaPostMessage(filteredSpans, resultCallback)
+      this.exportViaPostMessage(spans, resultCallback)
       return
     }
 
-    this.exporter.export(filteredSpans, (result) => {
+    this.exporter.export(spans, (result) => {
       if (result.code === 0) {
         resultCallback(result)
       } else if (this.config.usePostMessageFallback) {
         this.usePostMessage = true
-        this.exportViaPostMessage(filteredSpans, resultCallback)
+        this.exportViaPostMessage(spans, resultCallback)
       } else {
         resultCallback(result)
       }
     })
   }
 
-  shutdown(): Promise<void> {
-    return this.exporter.shutdown()
+  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[]): Promise<ExportResult | undefined> {
-    return new Promise((resolve) => {
-      this.exporter.export(spans, (result) => {
-        resolve(result)
-      })
+  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 {
@@ -136,9 +138,40 @@ export class SessionRecorderBrowserTraceExporter implements SpanExporter {
 
   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 {
-      ...span,
       _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,
+      },
     }
   }
 

package/src/sdk/capture-exception.ts

@@ -1,19 +1,64 @@
 import { context, trace, SpanStatusCode } from '@opentelemetry/api'
+import {
+  ATTR_EXCEPTION_MESSAGE,
+  ATTR_EXCEPTION_STACKTRACE,
+  ATTR_EXCEPTION_TYPE,
+} from '@opentelemetry/semantic-conventions'
+import { getResourceAttributes } from './set-resource-attributes'
 
 /**
  * @description Add error to current span
  * @param {Error} error
  * @returns {void}
  */
-export const captureException = (error: Error) => {
-  if (!error) return
+export const captureException = (
+  error: Error,
+  errorInfo?: Record<string, any>,
+) => {
+  if (!error) {
+    return
+  }
 
-  const span = trace.getSpan(context.active())
-  if (!span) return
+  const activeContext = context.active()
+
+  let span = trace.getSpan(activeContext)
+  let isNewSpan = false
+
+  if (!span || !span.isRecording()) {
+    span = trace.getTracer('exception').startSpan(
+      error.name || 'Error',
+      {
+        attributes: {
+          [ATTR_EXCEPTION_MESSAGE]: error.message,
+          [ATTR_EXCEPTION_STACKTRACE]: error.stack,
+          [ATTR_EXCEPTION_TYPE]: error.name,
+          ...getResourceAttributes(),
+        },
+      },
+    )
+    trace.setSpan(activeContext, span)
+    isNewSpan = true
+  } else {
+    span.setAttributes({
+      [ATTR_EXCEPTION_MESSAGE]: error.message,
+      [ATTR_EXCEPTION_STACKTRACE]: error.stack,
+      [ATTR_EXCEPTION_TYPE]: error.name,
+    })
+  }
+
+  if (errorInfo) {
+    Object.entries(errorInfo).forEach(([key, value]) => {
+      span.setAttribute(`error_info.${key}`, value)
+    })
+  }
 
   span.recordException(error)
   span.setStatus({
     code: SpanStatusCode.ERROR,
     message: error.message,
   })
+
+  if (isNewSpan) {
+    span.end()
+  }
 }

package/src/sdk/index.ts

@@ -5,3 +5,4 @@ export * from './id-generator'
 export * from './capture-exception'
 export * from './set-attribute'
 export * from './save-continuous-deb-session'
+export * from './set-resource-attributes'

package/src/sdk/set-resource-attributes.ts

@@ -0,0 +1,9 @@
+let resourceAttributes: Record<string, any> = {}
+
+export const setResourceAttributes = (attributes: Record<string, any>) => {
+  resourceAttributes = attributes
+}
+
+export const getResourceAttributes = () => {
+  return resourceAttributes
+}