@multiplayer-app/session-recorder-common 0.0.12 → 1.0.1-alpha.0

package/src/exporters/SessionRecorderBrowserTraceExporter.ts

@@ -0,0 +1,212 @@
+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 {
+  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 {
+  /** API key for authentication. Required. */
+  apiKey: string
+  /** 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
+  extends OTLPExporterBase<ReadableSpan[]>
+  implements SpanExporter {
+
+  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 = {},
+      postMessageType = 'MULTIPLAYER_SESSION_DEBUGGER_LIB',
+      postMessageTargetOrigin = '*',
+      ...restConfig
+    } = config
+
+    const _config = {
+      ...restConfig,
+      url,
+      headers: {
+        'Content-Type': 'application/x-protobuf',
+        'User-Agent': '@multiplayer-app/session-recorder-common/1.0.0',
+        'Authorization': apiKey,
+        ...headers,
+      },
+    }
+
+    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
+  }
+
+  override 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)
+    })
+
+    // Only proceed if there are filtered spans
+    if (filteredSpans.length === 0) {
+      resultCallback({ code: 0 })
+      return
+    }
+
+    if (this.usePostMessage) {
+      this.exportViaPostMessage(filteredSpans, resultCallback)
+      return
+    }
+
+    super.export(filteredSpans, (result) => {
+      if (result.code === 0) {
+        resultCallback(result)
+      } else if (this.config.usePostMessageFallback) {
+        this.usePostMessage = true
+        this.exportViaPostMessage(filteredSpans, resultCallback)
+      } else {
+        resultCallback(result)
+      }
+    })
+  }
+
+  override shutdown(): Promise<void> {
+    return Promise.resolve()
+  }
+
+  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 })
+    }
+  }
+
+  private _serializeSpan(span: ReadableSpan): any {
+    const spanContext = span.spanContext()
+    return {
+      _spanContext: spanContext,
+      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: spanContext.spanId, // Using spanId as parentSpanId is not available in newer versions
+      droppedAttributesCount: span.droppedAttributesCount,
+      droppedEventsCount: span.droppedEventsCount,
+      droppedLinksCount: span.droppedLinksCount,
+      resource: {
+        attributes: span.resource.attributes,
+        asyncAttributesPending: span.resource.asyncAttributesPending,
+      },
+    }
+  }
+}

package/src/exporters/SessionRecorderGrpcLogsExporter.ts

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,50 @@
+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

@@ -0,0 +1,58 @@
+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/x-protobuf',
+        '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

@@ -0,0 +1,65 @@
+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/x-protobuf',
+        'User-Agent': '@multiplayer-app/session-recorder-common/1.0.0',
+        'authorization': apiKey,
+      },
+      timeoutMillis,
+      keepAlive,
+      concurrencyLimit,
+    })
+  }
+
+  override export(spans: any[], 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)
+    })
+
+    // Only proceed if there are filtered spans
+    if (filteredSpans.length === 0) {
+      resultCallback({ code: 0 })
+      return
+    }
+
+    super.export(filteredSpans, resultCallback)
+  }
+}

package/src/exporters/SessionRecorderLogsExporterWrapper.ts

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,36 @@
+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

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

package/src/exporters/index-node.ts

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

package/src/exporters/index.ts

@@ -0,0 +1,7 @@
+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,7 +1,7 @@
-export * from './constants.browser'
-export { SessionRecorderHttpTraceExporterBrowser } from './SessionRecorderHttpTraceExporterBrowser'
+export * from './constants/constants.browser'
 export { SessionRecorderIdGenerator } from './SessionRecorderIdGenerator'
 export { SessionRecorderJsonTraceSerializer } from './SessionRecorderJsonTraceSerializer'
 export { SessionRecorderTraceIdRatioBasedSampler } from './SessionRecorderTraceIdRatioBasedSampler'
 export * as SessionRecorderSdk from './sdk'
 export * from './type'
+export * from './exporters/index-browser'

package/src/index-node.ts

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

package/src/index.ts

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

package/src/{SessionRecorderHttpInstrumentationHooksNode.ts → instrumentations/SessionRecorderHttpInstrumentationHooksNode.ts}

@@ -13,17 +13,17 @@ import {
   MULTIPLAYER_MAX_HTTP_REQUEST_RESPONSE_SIZE,
   ATTR_MULTIPLAYER_HTTP_RESPONSE_BODY_ENCODING,
   MULTIPLAYER_TRACE_DEBUG_PREFIX,
-  MULTIPLAYER_TRACE_DOC_PREFIX
-} from './constants.node'
+  MULTIPLAYER_TRACE_DOC_PREFIX,
+} from '../constants/constants.node'
 import {
   mask,
   schemify,
   isGzip,
-} from './sdk'
+} from '../sdk'
 import {
   sensitiveFields,
-  sensitiveHeaders
-} from './sdk/mask'
+  sensitiveHeaders,
+} from '../sdk/mask'
 
 interface HttpResponseHookOptions {
   maxPayloadSizeBytes?: number
@@ -67,7 +67,7 @@ interface HttpRequestHookOptions {
 }
 
 const setDefaultOptions = (
-  options: HttpResponseHookOptions | HttpResponseHookOptions
+  options: HttpResponseHookOptions | HttpResponseHookOptions,
 ): Omit<HttpResponseHookOptions & HttpResponseHookOptions, 'maskBody' | 'maskHeaders'>
   & {
     maskBody: (arg: any, span: Span) => any
@@ -157,18 +157,18 @@ export const SessionRecorderHttpInstrumentationHooksNode = {
 
         const [oldWrite, oldEnd] = [_response.write, _response.end]
 
-        const chunks: Buffer[] = [];
+        const chunks: Buffer[] = []
 
         if (_options.captureBody) {
           (_response.write as unknown) = function (...restArgs: any[]) {
             chunks.push(Buffer.from(restArgs[0]))
-            // eslint-disable-next-line
+
             // @ts-ignore
             oldWrite.apply(_response, restArgs)
           }
         }
 
-        // eslint-disable-next-line
+
         // @ts-ignore
         _response.end = async function (...restArgs) {
           if (_options.captureBody && restArgs[0]) {
@@ -267,7 +267,7 @@ export const SessionRecorderHttpInstrumentationHooksNode = {
             }
           }
 
-          // eslint-disable-next-line
+
           // @ts-ignore
           return oldEnd.apply(_response, restArgs)
         }

package/src/instrumentations/index-node.ts

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

package/src/sdk/capture-exception.ts

@@ -2,14 +2,14 @@ import { context, trace, SpanStatusCode } from '@opentelemetry/api'
 
 /**
  * @description Add error to current span
- * @param {Error} error 
+ * @param {Error} error
  * @returns {void}
  */
 export const captureException = (error: Error) => {
-  if (!error) return;
+  if (!error) return
 
   const span = trace.getSpan(context.active())
-  if (!span) return;
+  if (!span) return
 
   span.recordException(error)
   span.setStatus({