Structured Logs: Buffering & flushing of logs

CHANGELOG.md

@@ -4,7 +4,7 @@
 
 ### Features
 
-- Add experimental support for capturing structured logs via `SentrySDK.logger` (#5532)
+- Add experimental support for capturing structured logs via `SentrySDK.logger` (#5532, #5593)
 
 ### Improvements
 

Sources/Sentry/SentrySDK.m

@@ -118,14 +118,19 @@ + (SentryReplayApi *)replay
 
 + (SentryLogger *)logger
 {
+
     @synchronized(currentLoggerLock) {
         if (currentLogger == nil) {
+
             SentryLogBatcher *batcher;
             if (nil != currentHub.client && currentHub.client.options.experimental.enableLogs) {
-                batcher = [[SentryLogBatcher alloc] initWithClient:currentHub.client];
+                batcher = [[SentryLogBatcher alloc]
+                    initWithClient:currentHub.client
+                     dispatchQueue:SentryDependencyContainer.sharedInstance.dispatchQueueWrapper];
             } else {
                 batcher = nil;
             }
+
             currentLogger = [[SentryLogger alloc]
                  initWithHub:currentHub
                 dateProvider:SentryDependencyContainer.sharedInstance.dateProvider

Sources/Swift/Tools/SentryLogBatcher.swift

@@ -6,14 +6,92 @@ import Foundation
 @_spi(Private) public class SentryLogBatcher: NSObject {
 
     private let client: SentryClient
+    private let flushTimeout: TimeInterval
+    private let maxBufferSize: Int
+    private let dispatchQueue: SentryDispatchQueueWrapper
 
-    @_spi(Private) public init(client: SentryClient) {
+    private var logBuffer: [SentryLog] = []
+    private let logBufferLock = NSLock()
+    private var currentFlushId: UUID?
+
+    @_spi(Private) public init(
+        client: SentryClient,
+        flushTimeout: TimeInterval,
+        maxBufferSize: Int,
+        dispatchQueue: SentryDispatchQueueWrapper
+    ) {
         self.client = client
+        self.flushTimeout = flushTimeout
+        self.maxBufferSize = maxBufferSize
+        self.dispatchQueue = dispatchQueue
         super.init()
     }
 
+    @_spi(Private) public convenience init(client: SentryClient, dispatchQueue: SentryDispatchQueueWrapper) {
+        self.init(
+            client: client,
+            flushTimeout: 5,
+            maxBufferSize: 100,
+            dispatchQueue: dispatchQueue
+        )
+    }
+
     func add(_ log: SentryLog) {
-        dispatch(logs: [log])
+        cancelFlush()
+
+        let shouldFlush = logBufferLock.synchronized {
+            logBuffer.append(log)
+            return logBuffer.count >= maxBufferSize
+        }
+
+        if !shouldFlush {
+            scheduleFlush()
+        } else {
+            flush()
+        }
+    }
+
+    @objc
+    public func flush() {
+        cancelFlush()
+
+        let logs = logBufferLock.synchronized {
+            let logs = Array(logBuffer)
+            logBuffer.removeAll()
+            return logs
+        }
+
+        if !logs.isEmpty {
+            dispatch(logs: logs)
+        }
+    }
+
+    private func scheduleFlush() {
+        let flushId = UUID()
+
+        logBufferLock.synchronized {
+            currentFlushId = flushId
+        }
+
+        dispatchQueue.dispatch(after: flushTimeout) { [weak self] in
+            self?.executeFlushIfMatching(flushId: flushId)
+        }
+    }
+
+    private func executeFlushIfMatching(flushId: UUID) {
+        let shouldFlush = logBufferLock.synchronized {
+            return currentFlushId == flushId
+        }
+
+        if shouldFlush {
+            flush()
+        }
+    }
+
+    private func cancelFlush() {
+        logBufferLock.synchronized {
+            currentFlushId = nil
+        }
     }
 
     private func dispatch(logs: [SentryLog]) {