feat: Event queue early stop in buffer overflow (#118)

- drop events early (optimization)
- rethrow initialization error (fix oflline)

<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> Optimizes event batching and improves error handling.
> 
> - In `EventQueue`, introduce `SendResult` and change batch
`send([payloads])` to early-stop on total buffer overflow and skip
further items for exporters that hit per-exporter limits; `send(_:)` now
returns a result and triggers overflow notifications before stopping.
> - In `SessionReplayExporter`, rethrow initialization errors after
logging so callers can handle failures.
> 
> <sup>Written by [Cursor
Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit
f8ae091. This will update automatically
on new commits. Configure
[here](https://cursor.com/dashboard?tab=bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Author: abelonogov-ld

Sources/LaunchDarklyObservability/Transport/EventQueue.swift

@@ -51,6 +51,12 @@ public actor EventQueue: EventQueuing {
         let cost: Int
     }
 
+    private enum SendResult {
+        case success
+        case overflowedPartial(ObjectIdentifier)
+        case overflowedTotal
+    }
+    
     private var storage = [ObjectIdentifier: [EventQueueItem]]()
     private var lastEventTime: TimeInterval = 0
     private let limitSize: Int
@@ -73,29 +79,44 @@ public actor EventQueue: EventQueuing {
     }
 
     public func send(_ payloads: [EventQueueItemPayload]) async {
-        payloads.forEach {
-            send(EventQueueItem(payload: $0))
+        var overflowedExporters: Set<ObjectIdentifier> = []
+        for payload in payloads {
+            let item = EventQueueItem(payload: payload)
+            guard overflowedExporters.contains(item.exporterTypeId) == false else {
+                continue
+            }
+            
+            let result = send(item)
+            switch result {
+            case .success:
+                continue
+            case .overflowedPartial(let exporterId):
+                overflowedExporters.insert(exporterId)
+            case .overflowedTotal:
+                return
+            }
         }
     }
 
-    func send(_ item: EventQueueItem) {
+    private func send(_ item: EventQueueItem) -> SendResult {
         guard currentSize == 0 || currentSize + item.cost <= limitSize else {
             var exporterState = currentSizes[item.exporterTypeId, default: EventExporterState()]
             notifyOverflowIfNeeded(typeId: item.exporterTypeId, exporterState)
-            return
+            return .overflowedTotal
         }
 
         var exporterState = currentSizes[item.exporterTypeId, default: EventExporterState()]
         guard exporterState.size + item.cost <= exporterLimitSize else {
             notifyOverflowIfNeeded(typeId: item.exporterTypeId, exporterState)
-            return
+            return .overflowedPartial(item.exporterTypeId)
         }
 
         storage[item.exporterTypeId, default: []].append(item)
         lastEventTime = item.timestamp
         currentSize += item.cost
         exporterState.size += item.cost
         currentSizes[item.exporterTypeId] = exporterState
+        return .success
     }
 
     private func notify(typeId: ObjectIdentifier, _ status: EventStatus) {

Sources/LaunchDarklySessionReplay/Exporter/SessionReplayExporter.swift

@@ -77,6 +77,7 @@ actor SessionReplayExporter: EventExporting {
         } catch {
             initializedSession = nil
             os_log("%{public}@", log: log, type: .error, "Failed to initialize Session Replay:\n\(error)")
+            throw error
         }
     }