🌕

Demo.swiftpm/Sources/AppModule/Demo.swift

@@ -26,7 +26,8 @@ extension TrackingEvent {
 }
 
 let logger = LoggerBundler.make(
-    components: [MyLogger()]
+    components: [MyLogger()],
+    loggingStrategy: RegularlyPollingScheduler(timeInterval: 5)
 )
 
 

Sources/Parchment/BufferedEventFlushScheduler.swift

@@ -7,15 +7,6 @@
 import Foundation
 
 public protocol BufferedEventFlushScheduler {
-    func schedule(with buffer: TrackingEventBufferAdapter, didFlush: @escaping ([BufferRecord])->())
-}
-
-extension BufferedEventFlushScheduler {
-    func schedule(with buffer: TrackingEventBufferAdapter) -> AsyncThrowingStream<[BufferRecord], Error> {
-        AsyncThrowingStream { continuation in
-            schedule(with: buffer) {
-                continuation.yield($0)
-            }
-        }
-    }
+    func schedule(with buffer: TrackingEventBufferAdapter) async -> AsyncThrowingStream<[BufferRecord], Error>
+    func cancel()
 }

Sources/Parchment/LoggerBundler.swift

@@ -22,6 +22,8 @@ public final class LoggerBundler {
     public var configMap: [LoggerComponentID: Configuration] = [:]
     public var mutations: [Mutation] = []
 
+    private var loggingTask: Task<(), Never>?
+
     public init(
         components: [LoggerComponent],
         buffer: TrackingEventBuffer,
@@ -90,13 +92,13 @@ public final class LoggerBundler {
     }
 
     public func startLogging() {
-        Task { [weak self] in
+        loggingTask = Task { [weak self] in
             guard let self = self else {
                 assertionIfDebugMode("LoggerBundler instance should been retained by any object due to log events definitely")
                 return
             }
             do {
-                for try await records in self.flushStrategy.schedule(with: self.buffer) {
+                for try await records in await self.flushStrategy.schedule(with: self.buffer) {
                     await self.bloadcast(records)
                 }
             } catch {
@@ -105,6 +107,10 @@ public final class LoggerBundler {
         }
     }
 
+    func cancell() {
+        loggingTask?.cancel()
+    }
+
     private func bloadcast(_ records: [BufferRecord]) async {
         let recordEachLogger = Dictionary(grouping: records) { record in
             record.destination

Sources/ParchmentDefault/RegularlyPollingScheduler.swift

@@ -16,7 +16,7 @@ public final class RegularlyPollingScheduler: BufferedEventFlushScheduler {
 
     var lastFlushedDate: Date = Date()
 
-    private var timer: Timer?
+    private weak var timer: Timer?
 
     public init(
         timeInterval: TimeInterval,
@@ -27,17 +27,24 @@ public final class RegularlyPollingScheduler: BufferedEventFlushScheduler {
         self.limitOnNumberOfEvent = limitOnNumberOfEvent
     }
 
-    public func schedule(with buffer: TrackingEventBufferAdapter, didFlush: @escaping ([BufferRecord])->()) {
-        DispatchQueue.main.async { [weak self] in
-            self?.timer = Timer.scheduledTimer(withTimeInterval: 1, repeats: true) { _ in
-                guard let self = self else { return }
-                Task {
-                    await self.tick(with: buffer, didFlush: didFlush)
+    public func schedule(with buffer: TrackingEventBufferAdapter) async -> AsyncThrowingStream<[BufferRecord], Error> {
+        return AsyncThrowingStream { continuation in
+            let timer = Timer(fire: .init(), interval: 1, repeats: true) { _ in
+                Task { [weak self] in
+                    await self?.tick(with: buffer) {
+                        continuation.yield($0)
+                    }
                 }
             }
+            RunLoop.main.add(timer, forMode: .common)
+            self.timer = timer
         }
     }
 
+    public func cancel() {
+        timer?.invalidate()
+    }
+
     private func tick(with buffer: TrackingEventBufferAdapter, didFlush: @escaping ([BufferRecord])->()) async {
         guard await buffer.count() > 0 else { return }
 

Tests/ParchmentDefaultTests/RegularlyPollingSchedulerTests.swift

@@ -43,17 +43,13 @@ class RegularlyPollingSchedulerTests: XCTestCase {
         let scheduler = RegularlyPollingScheduler(timeInterval: 0.1)
         let buffer = EventQueueMock()
         let event = TrackingEvent(eventName: "hoge", parameters: [:])
-        let exp = expectation(description: "wait")
 
-        var result: [BufferRecord] = []
-        scheduler.schedule(with: .init(buffer)) { record in
-            result = record
-            exp.fulfill()
+        Task {
+            for try await result in await scheduler.schedule(with: .init(buffer)) {
+                XCTAssertEqual(event.eventName, result.first?.eventName)
+                XCTAssertTrue(NSDictionary(dictionary: event.parameters).isEqual(to: result.first?.parameters ?? [:]))
+            }
         }
         buffer.save([.init(destination: "hoge", event: event, timestamp: Date())])
-
-        wait(for: [exp], timeout: 1.1)
-        XCTAssertEqual(event.eventName, result.first?.eventName)
-        XCTAssertTrue(NSDictionary(dictionary: event.parameters).isEqual(to: result.first?.parameters ?? [:]))
     }
 }

Tests/ParchmentTests/LoggerBundlerTests.swift

@@ -62,18 +62,24 @@ final class EventQueueMock: TrackingEventBuffer {
 }
 
 final class BufferedEventFlushStrategyMock: BufferedEventFlushScheduler {
-    private var didFlush: (([BufferRecord]) -> ())? = nil
     private var buffer: TrackingEventBufferAdapter?
 
-    func schedule(with buffer: TrackingEventBufferAdapter, didFlush: @escaping ([BufferRecord]) -> ()) {
-        self.didFlush = didFlush
+    private var continuation: AsyncThrowingStream<[BufferRecord], Error>.Continuation?
+
+    func schedule(with buffer: TrackingEventBufferAdapter) async -> AsyncThrowingStream<[BufferRecord], Error> {
         self.buffer = buffer
+        return .init { continuation in
+            self.continuation = continuation
+        }
     }
 
-    func flush() async {
-        await didFlush!(buffer!.load(limit: .max))
+    func cancel() {
 
     }
+
+    func flush() async {
+        await continuation?.yield(buffer!.load(limit: .max))
+    }
 }
 
 class LoggerBundlerTests: XCTestCase {