sitepong 0.2.8 → 0.2.9

package/ios/WatchtowerCore/StructuralRecorder.swift

@@ -31,6 +31,14 @@ public final class SitePongStructuralCapture {
     private var flushTimer: Timer?
     private var running = false
 
+    // Incremental delivery: count of events CONFIRMED stored (== next seq_start).
+    // The device ships only the delta each flush and clears its buffer, so memory
+    // stays bounded and the uplink never re-sends the whole session. Node ids
+    // (`ids`/`nextId`) stay PERSISTENT across flushes — the server stitches the
+    // deltas by id, so resetting them would corrupt the tree.
+    private var flushedEventCount = 0
+    private var sending = false
+
     private func now() -> Int { Int(Date().timeIntervalSince(startedAt) * 1000) }
 
     /// Start capturing. `endpoint` is the ingest base URL (e.g.
@@ -57,6 +65,17 @@ public final class SitePongStructuralCapture {
         }
         sampleTimer = Timer.scheduledTimer(withTimeInterval: 0.12, repeats: true) { [weak self] _ in self?.sample() }
         flushTimer = Timer.scheduledTimer(withTimeInterval: 4.0, repeats: true) { [weak self] _ in self?.flush() }
+
+        // Flush on background so the tail isn't stranded when timers suspend.
+        NotificationCenter.default.addObserver(
+            self, selector: #selector(onBackground),
+            name: UIApplication.didEnterBackgroundNotification, object: nil
+        )
+    }
+
+    @objc private func onBackground() {
+        guard running else { return }
+        flush()
     }
 
     public func setScreen(_ name: String) {
@@ -71,6 +90,9 @@ public final class SitePongStructuralCapture {
         running = false
         sampleTimer?.invalidate(); sampleTimer = nil
         flushTimer?.invalidate(); flushTimer = nil
+        NotificationCenter.default.removeObserver(
+            self, name: UIApplication.didEnterBackgroundNotification, object: nil
+        )
         flush()
     }
 
@@ -171,23 +193,60 @@ public final class SitePongStructuralCapture {
         return v
     }
 
+    /// Ship the pending event delta (only what's accumulated since the last
+    /// confirmed flush), then clear the device buffer. The batch carries its
+    /// `seq_start` so the server dedups retries; a failed batch is re-queued so
+    /// nothing is lost offline. All buffer mutation stays on the main thread.
     private func flush() {
-        guard !endpoint.isEmpty, !events.isEmpty, let w = keyWindow() else { return }
+        guard !endpoint.isEmpty, !sending, !events.isEmpty, let w = keyWindow() else { return }
+        let batch = events
+        let seqStart = flushedEventCount
+        events.removeAll(keepingCapacity: true) // drain the device buffer
+        sending = true
+        post(batch: batch, seqStart: seqStart,
+             viewport: (Int(w.bounds.width), Int(w.bounds.height)), attempt: 0)
+    }
+
+    private func post(batch: [[String: Any]], seqStart: Int, viewport: (Int, Int), attempt: Int) {
         let payload: [String: Any] = [
             "session_id": sessionId,
             "platform": platform,
-            "viewport": ["w": Int(w.bounds.width), "h": Int(w.bounds.height)],
-            "events": events,
+            "viewport": ["w": viewport.0, "h": viewport.1],
+            "seq_start": seqStart,
+            "events": batch,
         ]
         guard let body = try? JSONSerialization.data(withJSONObject: payload),
-              let url = URL(string: "\(endpoint)/api/replay-stream/native") else { return }
+              let url = URL(string: "\(endpoint)/api/replay-stream/native") else {
+            DispatchQueue.main.async { self.sending = false }
+            return
+        }
         var req = URLRequest(url: url)
         req.httpMethod = "POST"
         req.setValue("application/json", forHTTPHeaderField: "Content-Type")
         req.setValue(apiKey, forHTTPHeaderField: "X-API-Key")
         if let pid = projectId { req.setValue(pid, forHTTPHeaderField: "X-Project-ID") }
         req.httpBody = body
-        URLSession.shared.dataTask(with: req).resume()
+
+        URLSession.shared.dataTask(with: req) { [weak self] _, resp, err in
+            guard let self = self else { return }
+            let ok = (resp as? HTTPURLResponse).map { (200..<300).contains($0.statusCode) } ?? false
+            DispatchQueue.main.async {
+                if ok && err == nil {
+                    self.flushedEventCount = seqStart + batch.count
+                    self.sending = false
+                } else if attempt < 3 {
+                    let delay = pow(2.0, Double(attempt)) // 1,2,4s
+                    DispatchQueue.main.asyncAfter(deadline: .now() + delay) {
+                        self.post(batch: batch, seqStart: seqStart, viewport: viewport, attempt: attempt + 1)
+                    }
+                } else {
+                    // Give up on this attempt: re-queue at the front so the seq
+                    // stays contiguous and the delta re-sends on the next flush.
+                    self.events.insert(contentsOf: batch, at: 0)
+                    self.sending = false
+                }
+            }
+        }.resume()
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sitepong",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "description": "Official SitePong SDK for error tracking and monitoring",
   "main": "dist/index.js",
   "module": "dist/index.mjs",