Use Codable for encoding/decoding payload

Author: Guilherme Souza

.gitignore

@@ -1,3 +1,5 @@
+Secrets.swift
+
 .DS_Store
 /.build
 /Packages

Package.swift

@@ -22,6 +22,7 @@ let package = Package(
       ]),
     .testTarget(
       name: "SupabaseLoggerTests",
-      dependencies: ["SupabaseLogger"]),
+      dependencies: ["SupabaseLogger"],
+      exclude: ["_Secrets.swift"]),
   ]
 )

Sources/SupabaseLogger/LogEntry.swift

@@ -0,0 +1,68 @@
+import Foundation
+import Logging
+
+struct LogEntry: Codable {
+  let label: String
+  let file: String
+  let line: String
+  let source: String
+  let function: String
+  let level: String
+  let message: String
+  let loggedAt: Date
+  let metadata: Logger.Metadata?
+}
+
+extension Logger.MetadataValue: Codable {
+
+  public init(from decoder: Decoder) throws {
+    if let string = try? decoder.singleValueContainer().decode(String.self) {
+      self = .string(string)
+    } else if let dictionary = try? decoder.singleValueContainer().decode(Logger.Metadata.self) {
+      self = .dictionary(dictionary)
+    } else if let array = try? decoder.singleValueContainer().decode([Logger.MetadataValue].self) {
+      self = .array(array)
+    } else {
+      throw DecodingError.dataCorrupted(
+        DecodingError.Context(
+          codingPath: decoder.codingPath,
+          debugDescription: "Unsupported \(Logger.MetadataValue.self) type."))
+    }
+  }
+
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.singleValueContainer()
+    switch self {
+    case .string(let value):
+      try container.encode(value)
+    case .stringConvertible(let value):
+      try container.encode(value.description)
+    case .dictionary(let value):
+      try container.encode(value)
+    case .array(let value):
+      try container.encode(value)
+    }
+  }
+}
+
+private let dateFormatter = { () -> DateFormatter in
+  let formatter = DateFormatter()
+  formatter.locale = Locale(identifier: "en_US_POSIX")
+  formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssZZZZZ"
+  formatter.timeZone = TimeZone(secondsFromGMT: 0)
+  return formatter
+}()
+
+let decoder = { () -> JSONDecoder in
+  let decoder = JSONDecoder()
+  decoder.dateDecodingStrategy = .formatted(dateFormatter)
+  decoder.keyDecodingStrategy = .convertFromSnakeCase
+  return decoder
+}()
+
+let encoder = { () -> JSONEncoder in
+  let encoder = JSONEncoder()
+  encoder.dateEncodingStrategy = .formatted(dateFormatter)
+  encoder.keyEncodingStrategy = .convertToSnakeCase
+  return encoder
+}()

Sources/SupabaseLogger/LogsCache.swift

@@ -1,23 +1,24 @@
 import Foundation
 
-final class LogsCache {
+final class LogsCache<T: Codable> {
 
+  private let isDebug: Bool
   private let maximumNumberOfLogsToPopAtOnce = 100
 
   private let queue = DispatchQueue(
     label: "co.binaryscraping.supabase-log-cache", attributes: .concurrent)
-  private var cachedLogs: [[String: Any]] = []
+  private var cachedLogs: [T] = []
 
-  func push(_ log: [String: Any]) {
+  func push(_ log: T) {
     queue.sync { self.cachedLogs.append(log) }
   }
 
-  func push(_ logs: [[String: Any]]) {
+  func push(_ logs: [T]) {
     queue.sync { self.cachedLogs.append(contentsOf: logs) }
   }
 
-  func pop() -> [[String: Any]] {
-    var poppedLogs: [[String: Any]] = []
+  func pop() -> [T] {
+    var poppedLogs: [T] = []
     queue.sync(flags: .barrier) {
       let sliceSize = min(maximumNumberOfLogsToPopAtOnce, cachedLogs.count)
       poppedLogs = Array(cachedLogs[..<sliceSize])
@@ -33,27 +34,32 @@ final class LogsCache {
         try data.write(to: LogsCache.fileURL())
         self.cachedLogs = []
       } catch {
-        print("Error saving Logs cache.")
+        if isDebug {
+          print("Error saving Logs cache.")
+        }
       }
     }
   }
 
-  private static func fileURL() -> URL {
-    try! FileManager.default.url(
+  private static func fileURL() throws -> URL {
+    try FileManager.default.url(
       for: .cachesDirectory, in: .userDomainMask, appropriateFor: nil, create: false
     )
     .appendingPathComponent("supabase-log-cache")
   }
 
-  init() {
+  init(isDebug: Bool) {
+    self.isDebug = isDebug
     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]] ?? []
+      let logs = try decoder.decode([T].self, from: data)
       self.cachedLogs = logs
     } catch {
-      print("Error recovering logs from cache.")
+      if isDebug {
+        print("Error recovering logs from cache.")
+      }
     }
   }
 }

Sources/SupabaseLogger/SupabaseLogHandler.swift

@@ -32,47 +32,38 @@ public struct SupabaseLogConfig: Hashable {
 }
 
 public struct SupabaseLogHandler: LogHandler {
-
   public var metadata: Logger.Metadata = [:]
-
   public var logLevel: Logger.Level = .debug
 
   public subscript(metadataKey key: String) -> Logger.Metadata.Value? {
     get { metadata[key] }
     set { metadata[key] = newValue }
   }
 
+  private let label: String
   private let logManager: SupabaseLogManager
 
-  public init(config: SupabaseLogConfig) {
+  public init(label: String, config: SupabaseLogConfig) {
+    self.label = label
     logManager = SupabaseLogManager.shared(config)
   }
 
   public func log(
     level: Logger.Level, message: Logger.Message, metadata: Logger.Metadata?, source: String,
     file: String, function: String, line: UInt
   ) {
-    var parameters = self.metadata
-    if let metadata = metadata {
-      parameters.merge(metadata) { _, new in new }
-    }
-    parameters["file"] = .string(file)
-    parameters["line"] = .stringConvertible(line)
-    parameters["source"] = .string(source)
-    parameters["function"] = .string(function)
-
-    var payload: [String: Any] = [:]
-    payload["level"] = level.rawValue
-    payload["message"] = metadata?.description
-    payload["metadata"] = parameters.mapValues(\.description)
+    let entry = LogEntry(
+      label: label, file: file, line: "\(line)", source: source, function: function,
+      level: level.rawValue, message: message.description, loggedAt: Date(),
+      metadata: self.metadata.merging(metadata ?? [:]) { $1 })
 
-    logManager.log(payload)
+    logManager.log(entry)
   }
 }
 
 final class SupabaseLogManager {
 
-  let cache: LogsCache
+  let cache: LogsCache<LogEntry>
   let config: SupabaseLogConfig
 
   private let minimumWaitTimeBetweenRequests: TimeInterval = 10
@@ -96,7 +87,7 @@ final class SupabaseLogManager {
 
   private init(config: SupabaseLogConfig) {
     self.config = config
-    self.cache = LogsCache()
+    self.cache = LogsCache(isDebug: config.isDebug)
 
     #if os(macOS)
       NotificationCenter.default.addObserver(
@@ -127,7 +118,7 @@ final class SupabaseLogManager {
     checkForLogsAndSend()
   }
 
-  func log(_ payload: [String: Any]) {
+  func log(_ payload: LogEntry) {
     cache.push(payload)
   }
 
@@ -137,7 +128,7 @@ final class SupabaseLogManager {
 
     guard !logs.isEmpty else { return }
 
-    let data = try! JSONSerialization.data(withJSONObject: logs)
+    let data = try! encoder.encode(logs)
     guard
       let url = URL(string: self.config.supabaseURL)?.appendingPathComponent(self.config.table)
     else {
@@ -147,6 +138,8 @@ final class SupabaseLogManager {
     var request = URLRequest(url: url)
     request.httpMethod = "POST"
     request.addValue("application/json", forHTTPHeaderField: "Content-Type")
+    request.setValue(config.supabaseAnonKey, forHTTPHeaderField: "apikey")
+    request.setValue("Bearer \(config.supabaseAnonKey)", forHTTPHeaderField: "Authorization")
     request.httpBody = data
 
     let config = URLSessionConfiguration.default

Tests/SupabaseLoggerTests/SupabaseLogHandlerTests.swift

@@ -1,8 +1,48 @@
+import Logging
 import XCTest
 
 @testable import SupabaseLogger
 
 final class SupabaseLogHandlerTests: XCTestCase {
-  func testExample() throws {
+  func testLive() throws {
+    LoggingSystem.bootstrap { label in
+      MultiplexLogHandler(
+        [
+          StreamLogHandler.standardOutput(label: label),
+          SupabaseLogHandler(
+            label: label,
+            config: SupabaseLogConfig(
+              supabaseURL: Secrets.supabaseURL, supabaseAnonKey: Secrets.supabaseAnonKey,
+              isDebug: true)
+          ),
+        ]
+      )
+    }
+
+    let logger = Logger(label: "co.binaryscraping.supabase-log.tests")
+    let metadata: Logger.Metadata = [
+      "string": .string("string"),
+      "integer": .stringConvertible(1),
+      "array": .array([.string("a"), .string("b")]),
+      "dictionary": .dictionary([
+        "key": .string("value")
+      ]),
+    ]
+
+    logger.critical("This is a critical message", metadata: metadata)
+    logger.debug("This is a debug message", metadata: metadata)
+    logger.error("This is an error message", metadata: metadata)
+    logger.info("This is an info message", metadata: metadata)
+    logger.notice("This is a notice message", metadata: metadata)
+    logger.trace("This is a trace message", metadata: metadata)
+    logger.warning("This is a warning message", metadata: metadata)
+
+    let expectation = self.expectation(description: #function)
+
+    DispatchQueue.main.asyncAfter(deadline: .now() + 15) {
+      expectation.fulfill()
+    }
+
+    wait(for: [expectation], timeout: 20)
   }
 }

Tests/SupabaseLoggerTests/_Secrets.swift

@@ -0,0 +1,4 @@
+enum Secrets {
+  static let supabaseURL = "URL"
+  static let supabaseAnonKey = "KEY"
+}

supabase-init.sql

@@ -1,8 +1,13 @@
 create table logs (
     id uuid default uuid_generate_v4() not null primary key,
+    label text not null,
+    file text not null,
+    line text not null,
+    source text not null,
+    function text not null,
     level text not null,
-    message text,
+    message text not null,
     logged_at timestamp with time zone not null,
     received_at timestamp with time zone default timezone('utc'::text, now()) not null,
-    metadata jsonb not null
+    metadata jsonb
 );