Implement log backup

Author: Guilherme Souza

Package.swift

@@ -5,7 +5,7 @@ import PackageDescription
 
 let package = Package(
   name: "swift-log-supabase",
-  platforms: [.iOS(.v13), .macOS(.v10_15)],
+  platforms: [.iOS(.v15), .macOS(.v12)],
   products: [
     .library(
       name: "SupabaseLogger",

Sources/SupabaseLogger/LogsCache.swift

@@ -0,0 +1,54 @@
+import Foundation
+
+actor LogsCache {
+
+  private let maximumNumberOfLogsToPopAtOnce = 100
+
+  private var cachedLogs: [[String: Any]] = []
+
+  func push(_ log: [String: Any]) {
+    cachedLogs.append(log)
+  }
+
+  func push(_ logs: [[String: Any]]) {
+    cachedLogs.append(contentsOf: logs)
+  }
+
+  func pop() -> [[String: Any]] {
+    let sliceSize = min(maximumNumberOfLogsToPopAtOnce, cachedLogs.count)
+    let poppedLogs = Array(cachedLogs[..<sliceSize])
+    cachedLogs.removeFirst(sliceSize)
+    return poppedLogs
+  }
+
+  func backupCache() {
+    do {
+      let data = try JSONSerialization.data(withJSONObject: cachedLogs)
+      try data.write(to: LogsCache.fileURL())
+      self.cachedLogs = []
+    } catch {
+      print("Error saving Logs cache.")
+    }
+  }
+
+  private static func fileURL() -> URL {
+    try! FileManager.default.url(
+      for: .cachesDirectory, in: .userDomainMask, appropriateFor: nil, create: false
+    )
+    .appendingPathComponent("supabase-log-cache")
+  }
+
+  static let shared = LogsCache()
+
+  private init() {
+    do {
+      let data = try Data(contentsOf: LogsCache.fileURL())
+      try FileManager.default.removeItem(at: LogsCache.fileURL())
+
+      let logs = try JSONSerialization.jsonObject(with: data) as? [[String: Any]] ?? []
+      self.cachedLogs = logs
+    } catch {
+      print("Error recovering logs from cache.")
+    }
+  }
+}

Sources/SupabaseLogger/SupabaseLogHandler.swift

@@ -1,6 +1,12 @@
 import Foundation
 import Logging
 
+#if os(iOS)
+  import UIKit
+#elseif os(macOS)
+  import AppKit
+#endif
+
 public struct SupabaseLogConfig {
   let supabaseURL: String
   let supabaseAnonKey: String
@@ -59,23 +65,40 @@ public struct SupabaseLogHandler: LogHandler {
 
 final class SupabaseLogManager {
 
-  let queue = DispatchQueue(label: "co.binaryscraping.supabase-log-manager", qos: .background)
-  var payloads: [[String: Any]] = []
+  let cache: LogsCache
   let config: SupabaseLogConfig
 
   init(config: SupabaseLogConfig) {
     self.config = config
+    self.cache = LogsCache.shared
+
+    #if os(macOS)
+      NotificationCenter.default.addObserver(
+        self, selector: #selector(appWillTerminate), name: NSApplication.willTerminateNotification,
+        object: nil)
+    #elseif os(iOS)
+      DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
+        // We need to use a delay with these type of notifications because they fire on app load which causes a double load of the cache from disk
+        NotificationCenter.default.addObserver(
+          self, selector: #selector(self.didEnterForeground),
+          name: UIApplication.willEnterForegroundNotification, object: nil)
+        NotificationCenter.default.addObserver(
+          self, selector: #selector(self.didEnterBackground),
+          name: UIApplication.didEnterBackgroundNotification, object: nil)
+      }
+    #endif
   }
 
   func log(_ payload: [String: Any]) {
-    queue.async {
-      self.payloads.append(payload)
-    }
+    Task { await cache.push(payload) }
   }
 
-  func uploadLogs() {
-    queue.async {
-      let data = try! JSONSerialization.data(withJSONObject: self.payloads)
+  private func checkForLogsAndSend() {
+    Task {
+      let logs = await cache.pop()
+      if logs.isEmpty { return }
+
+      let data = try! JSONSerialization.data(withJSONObject: logs)
       guard
         let url = URL(string: self.config.supabaseURL)?.appendingPathComponent(self.config.table)
       else {
@@ -86,14 +109,35 @@ final class SupabaseLogManager {
       request.httpMethod = "POST"
       request.httpBody = data
 
-      URLSession.shared.dataTask(with: request) { data, response, error in
-        if let error = error {
-          print(error)
-          return
-        }
+      do {
+        let (_, response) = try await URLSession.shared.data(for: request)
+        if let httpResponse = response as? HTTPURLResponse {
+          if 200..<300 ~= httpResponse.statusCode {
+            return
+          }
 
-        self.payloads = []
-      }.resume()
+          await cache.push(logs)
+        }
+      } catch {
+        await cache.push(logs)
+      }
     }
   }
 }
+
+extension SupabaseLogManager {
+  @objc func appWillTerminate() {
+    Task { await cache.backupCache() }
+  }
+
+  #if os(iOS)
+    @objc func didEnterForeground() {
+    }
+
+    @objc func didEnterBackground() {
+      Task {
+        await cache.backupCache()
+      }
+    }
+  #endif
+}