fix: Otlp Trace Exporters to Event Exporter (#70)

Move Traces to LD buffering

Proof of testing:
<img width="733" height="468" alt="image"
src="https://github.com/user-attachments/assets/7e53fdde-f074-4534-beba-d6c9cc130901"
/>



<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> Route trace exporting through the LD event queue with a new OTLP trace
event exporter and processor, removing legacy sampling/stdout exporters.
> 
> - **Traces**:
> - Switch span exporting to LD event-queue pipeline: add
`EventSpanProcessor`, `OtlpTraceEventExporter`, and `SpanItem`.
> - Update `TracerDecorator` to use sampler + `EventQueue` (removes
`BatchSpanProcessor`/direct `SpanExporter` usage) and provide
start-with-time helper via `Tracer` extension.
> - Register trace event exporter in `ObservabilityClientFactory` via
`BatchWorker`.
> - Remove legacy exporters: `SamplingTraceExporter.swift`,
`SamplingLogExporter.swift`, `LDStdoutExporter.swift`.
> - **Metrics**:
> - Make `OtlpMetricEventExporter` and `OtlpMetricScheduleExporter`
internal and encapsulate properties (no functional change).
> - **TestApp**:
>   - Enable `.urlSession` in `autoInstrumentation` config.
> 
> <sup>Written by [Cursor
Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit
14ec46a. This will update automatically
on new commits. Configure
[here](https://cursor.com/dashboard?tab=bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Author: abelonogov-ld

Sources/Observability/Client/ObservabilityClientFactory.swift

@@ -74,14 +74,14 @@ public struct ObservabilityClientFactory {
         }
 
         if options.traces == .enabled {
-            let tracesExporter = SamplingTraceExporterDecorator(
-                exporter: OtlpHttpTraceExporter(
-                    endpoint: url,
-                    config: .init(headers: options.customHeaders.map({ ($0.key, $0.value) }))
-                ),
-                sampler: sampler
+            let traceEventExporter = OtlpTraceEventExporter(
+                endpoint: url,
+                config: .init(headers: options.customHeaders.map({ ($0.key, $0.value) }))
             )
-            let decorator = TracerDecorator(options: options, sessionManager: sessionManager, exporter: tracesExporter)
+            Task {
+                await batchWorker.addExporter(traceEventExporter)
+            }
+            let decorator = TracerDecorator(options: options, sessionManager: sessionManager, sampler: sampler, eventQueue: eventQueue)
             /// tracer is enabled
             if options.autoInstrumentation.contains(.urlSession) {
                 autoInstrumentation.append(NetworkInstrumentationManager(options: options, tracer: decorator, session: sessionManager))

Sources/Observability/Exporters/LDStdoutExporter.swift

@@ -3,33 +3,33 @@ import Common
 import Foundation
 import OpenTelemetryProtocolExporterCommon
 
-public final class OtlpMetricEventExporter: EventExporting {
-    let otlpHttpClient: OtlpHttpClient
+final class OtlpMetricEventExporter: EventExporting {
+    private let otlpHttpClient: OtlpHttpClient
 
-    public init(endpoint: URL,
-                config: OtlpConfiguration = OtlpConfiguration(),
-                useSession: URLSession? = nil,
-                envVarHeaders: [(String, String)]? = EnvVarHeaders.attributes) {
+    init(endpoint: URL,
+         config: OtlpConfiguration = OtlpConfiguration(),
+         useSession: URLSession? = nil,
+         envVarHeaders: [(String, String)]? = EnvVarHeaders.attributes) {
         self.otlpHttpClient = OtlpHttpClient(endpoint: endpoint,
                                              config: config,
                                              useSession: useSession,
                                              envVarHeaders: envVarHeaders)
     }
-
-    public func export(items: [EventQueueItem]) async throws {
+    
+    func export(items: [EventQueueItem]) async throws {
         let metricDatas: [OpenTelemetrySdk.MetricData] = items.compactMap { item in
             (item.payload as? MetricItem)?.metricData
         }
         guard metricDatas.isNotEmpty else {
             return
         }
+        
         try await export(metricDatas: metricDatas)
     }
 
     private func export(metricDatas: [MetricData],
                         explicitTimeout: TimeInterval? = nil) async throws {
-        let body =
-        Opentelemetry_Proto_Collector_Metrics_V1_ExportMetricsServiceRequest.with { request in
+        let body = Opentelemetry_Proto_Collector_Metrics_V1_ExportMetricsServiceRequest.with { request in
             request.resourceMetrics = MetricsAdapter.toProtoResourceMetrics(
                 metricData: metricDatas)
         }

Sources/Observability/Exporters/SamplingLogExporter.swift

@@ -3,9 +3,9 @@ import OpenTelemetryApi
 import OpenTelemetrySdk
 
 final class OtlpMetricScheduleExporter: MetricExporter {
-    let eventQueue: EventQueue
-    let aggregationTemporalitySelector: AggregationTemporalitySelector
-    let defaultAggregationSelector: DefaultAggregationSelector
+    private let eventQueue: EventQueue
+    private let aggregationTemporalitySelector: AggregationTemporalitySelector
+    private let defaultAggregationSelector: DefaultAggregationSelector
 
     init(eventQueue: EventQueue,
          aggregationTemporalitySelector: AggregationTemporalitySelector = AggregationTemporality.alwaysCumulative(),
@@ -33,17 +33,17 @@ final class OtlpMetricScheduleExporter: MetricExporter {
     }
 
     public func getAggregationTemporality(
-      for instrument: OpenTelemetrySdk.InstrumentType
+        for instrument: OpenTelemetrySdk.InstrumentType
     ) -> OpenTelemetrySdk.AggregationTemporality {
-      return aggregationTemporalitySelector.getAggregationTemporality(
-        for: instrument)
+        return aggregationTemporalitySelector.getAggregationTemporality(
+            for: instrument)
     }
-
+    
     // MARK: - DefaultAggregationSelector
-
+    
     public func getDefaultAggregation(
-      for instrument: OpenTelemetrySdk.InstrumentType
+        for instrument: OpenTelemetrySdk.InstrumentType
     ) -> OpenTelemetrySdk.Aggregation {
-      return defaultAggregationSelector.getDefaultAggregation(for: instrument)
+        return defaultAggregationSelector.getDefaultAggregation(for: instrument)
     }
 }

Sources/Observability/Exporters/SamplingTraceExporter.swift

@@ -0,0 +1,45 @@
+import Foundation
+import OpenTelemetryApi
+import OpenTelemetrySdk
+
+final class EventSpanProcessor: SpanProcessor {
+    private let eventQueue: EventQueue
+    private let sampler: ExportSampler
+    let isStartRequired = false
+    let isEndRequired = true
+    
+    init(eventQueue: EventQueue, sampler: ExportSampler) {
+        self.eventQueue = eventQueue
+        self.sampler = sampler
+    }
+    
+    func onStart(parentContext: OpenTelemetryApi.SpanContext?, span: any OpenTelemetrySdk.ReadableSpan) {
+        // No-op
+    }
+    
+    func onEnd(span: any OpenTelemetrySdk.ReadableSpan) {
+        if !span.context.traceFlags.sampled {
+          return
+        }
+        
+        let spanData = span.toSpanData()
+        let sampledItems = sampler.sampleSpans(items: [spanData])
+        guard !sampledItems.isEmpty else {
+            return
+        }
+        
+        Task {
+            await eventQueue.send(SpanItem(spanData: spanData))
+        }
+    }
+    
+    func shutdown(explicitTimeout: TimeInterval?) {
+        // No-op
+    }
+    
+    func forceFlush(timeout: TimeInterval?) {
+        // No-op
+    }
+    
+   
+}

Sources/Observability/Metrics/OtlpMetricEventExporter.swift

@@ -0,0 +1,39 @@
+import OpenTelemetrySdk
+import Common
+import Foundation
+import OpenTelemetryProtocolExporterCommon
+
+final class OtlpTraceEventExporter: EventExporting {
+    private let otlpHttpClient: OtlpHttpClient
+    
+    init(endpoint: URL,
+                config: OtlpConfiguration = OtlpConfiguration(),
+                useSession: URLSession? = nil,
+                envVarHeaders: [(String, String)]? = EnvVarHeaders.attributes) {
+        self.otlpHttpClient = OtlpHttpClient(endpoint: endpoint,
+                                             config: config,
+                                             useSession: useSession,
+                                             envVarHeaders: envVarHeaders)
+    }
+    
+    func export(items: [EventQueueItem]) async throws {
+        let spanDatas: [OpenTelemetrySdk.SpanData] = items.compactMap { item in
+            (item.payload as? SpanItem)?.spanData
+        }
+        guard spanDatas.isNotEmpty else {
+            return
+        }
+        try await export(spanDatas: spanDatas)
+    }
+    
+    private func export(spanDatas: [OpenTelemetrySdk.SpanData],
+                        explicitTimeout: TimeInterval? = nil) async throws {
+        let body =
+          Opentelemetry_Proto_Collector_Trace_V1_ExportTraceServiceRequest.with {
+            $0.resourceSpans = SpanAdapter.toProtoResourceSpans(
+              spanDataList: spanDatas)
+          }
+        
+        try await otlpHttpClient.send(body: body, explicitTimeout: explicitTimeout)
+    }
+}

Sources/Observability/Metrics/OtlpMetricScheduleExporter.swift

@@ -0,0 +1,20 @@
+import Foundation
+import OpenTelemetrySdk
+
+struct SpanItem: EventQueueItemPayload {
+    var exporterClass: AnyClass {
+        Observability.OtlpTraceEventExporter.self
+    }
+    
+    let spanData: SpanData
+    var timestamp: TimeInterval
+    
+    init(spanData: SpanData) {
+        self.spanData = spanData
+        self.timestamp = spanData.endTime.timeIntervalSince1970
+    }
+    
+    func cost() -> Int {
+        300 + spanData.events.count * 100 + spanData.attributes.count * 100
+    }
+}