Improve loggers

Author: stevensJourney

Sources/PowerSync/Kotlin/DatabaseLogger.swift

@@ -1,57 +1,17 @@
 import PowerSyncKotlin
 
-/// Maps a Kermit `Severity` level to a local `LogSeverity`.
-///
-/// - Parameter severity: The Kermit log severity value from Kotlin.
-/// - Returns: The corresponding `LogSeverity` used in Swift.
-private func mapKermitSeverity(_ severity: PowerSyncKotlin.Kermit_coreSeverity) -> LogSeverity {
-    switch severity {
-        case PowerSyncKotlin.Kermit_coreSeverity.verbose:
-            return LogSeverity.debug
-        case PowerSyncKotlin.Kermit_coreSeverity.debug:
-            return LogSeverity.debug
-        case PowerSyncKotlin.Kermit_coreSeverity.info:
-            return LogSeverity.info
-        case PowerSyncKotlin.Kermit_coreSeverity.warn:
-            return LogSeverity.warning
-        case PowerSyncKotlin.Kermit_coreSeverity.error:
-            return LogSeverity.error
-        case PowerSyncKotlin.Kermit_coreSeverity.assert:
-            return LogSeverity.fault
-    }
-}
-
-/// Maps a local `LogSeverity` to a Kermit-compatible `Kermit_coreSeverity`.
-///
-/// - Parameter severity: The Swift-side `LogSeverity`.
-/// - Returns: The equivalent Kermit log severity.
-private func mapSeverity(_ severity: LogSeverity) -> PowerSyncKotlin.Kermit_coreSeverity {
-    switch severity {
-        case .debug:
-            return PowerSyncKotlin.Kermit_coreSeverity.debug
-        case .info:
-            return PowerSyncKotlin.Kermit_coreSeverity.info
-        case .warning:
-            return PowerSyncKotlin.Kermit_coreSeverity.warn
-        case .error:
-            return PowerSyncKotlin.Kermit_coreSeverity.error
-        case .fault:
-            return PowerSyncKotlin.Kermit_coreSeverity.assert
-    }
-}
-
-/// Adapts a Swift `LogWritterProtocol` to Kermit's `LogWriter` interface.
+/// Adapts a Swift `LoggerProtocol` to Kermit's `LogWriter` interface.
 ///
 /// This allows Kotlin logging (via Kermit) to call into the Swift logging implementation.
 private class KermitLogWriterAdapter: Kermit_coreLogWriter {
     /// The underlying Swift log writer to forward log messages to.
-    var adapter: LogWriterProtocol
+    let logger: any LoggerProtocol
 
     /// Initializes a new adapter.
     ///
     /// - Parameter adapter: A Swift log writer that will handle log output.
-    init(adapter: LogWriterProtocol) {
-        self.adapter = adapter
+    init(logger: any LoggerProtocol) {
+        self.logger = logger
         super.init()
     }
 
@@ -63,27 +23,42 @@ private class KermitLogWriterAdapter: Kermit_coreLogWriter {
     ///   - tag: An optional string categorizing the log.
     ///   - throwable: An optional Kotlin exception (ignored here).
     override func log(severity: Kermit_coreSeverity, message: String, tag: String, throwable: KotlinThrowable?) {
-        adapter.log(
-            severity: mapKermitSeverity(severity),
-            message: message,
-            tag: tag
-        )
+        switch severity {
+        case PowerSyncKotlin.Kermit_coreSeverity.verbose:
+            return logger.debug(message, tag: tag)
+        case PowerSyncKotlin.Kermit_coreSeverity.debug:
+            return logger.debug(message, tag: tag)
+        case PowerSyncKotlin.Kermit_coreSeverity.info:
+            return logger.info(message, tag: tag)
+        case PowerSyncKotlin.Kermit_coreSeverity.warn:
+            return logger.warning(message, tag: tag)
+        case PowerSyncKotlin.Kermit_coreSeverity.error:
+            return logger.error(message, tag: tag)
+        case PowerSyncKotlin.Kermit_coreSeverity.assert:
+            return logger.fault(message, tag: tag)
+        }
     }
 }
 
 /// A logger implementation that integrates with PowerSync's Kotlin backend using Kermit.
 ///
 /// This class bridges Swift log writers with the Kotlin logging system and supports
 /// runtime configuration of severity levels and writer lists.
-public class DatabaseLogger: LoggerProtocol {
+internal class DatabaseLogger: LoggerProtocol {
     /// The underlying Kermit logger instance provided by the PowerSyncKotlin SDK.
-    internal let kLogger = PowerSyncKotlin.generateLogger(logger: nil)
+    public let kLogger = PowerSyncKotlin.generateLogger(logger: nil)
+    public let logger: any LoggerProtocol
 
     /// Initializes a new logger with an optional list of writers.
     ///
     /// - Parameter writers: An array of Swift log writers. Defaults to an empty array.
-    init(writers: [any LogWriterProtocol] = []) {
-        setWriters(writers)
+    init(_ logger: any LoggerProtocol) {
+        self.logger = logger
+        // Set to the lowest severity. The adapter downstream logger should filter by severity
+        kLogger.mutableConfig.setMinSeverity(Kermit_coreSeverity.verbose)
+        kLogger.mutableConfig.setLogWriterList(
+            [KermitLogWriterAdapter(logger: logger)]
+        )
     }
 
     /// Sets the minimum severity level that will be logged.
@@ -92,9 +67,7 @@ public class DatabaseLogger: LoggerProtocol {
     ///
     /// - Parameter severity: The minimum `LogSeverity` to allow through.
     public func setMinSeverity(_ severity: LogSeverity) {
-        kLogger.mutableConfig.setMinSeverity(
-            mapSeverity(severity)
-        )
+        logger.setMinSeverity(severity)
     }
 
     /// Sets the list of log writers that will receive log messages.
@@ -103,33 +76,31 @@ public class DatabaseLogger: LoggerProtocol {
     ///
     /// - Parameter writers: An array of Swift `LogWritterProtocol` implementations.
     public func setWriters(_ writers: [any LogWriterProtocol]) {
-        kLogger.mutableConfig.setLogWriterList(
-            writers.map { item in KermitLogWriterAdapter(adapter: item) }
-        )
+        logger.setWriters(writers)
     }
 
     /// Logs a debug-level message.
     public func debug(_ message: String, tag: String) {
-        kLogger.d(messageString: message, throwable: nil, tag: tag)
+        logger.debug(message, tag: tag)
     }
 
     /// Logs an info-level message.
     public func info(_ message: String, tag: String) {
-        kLogger.i(messageString: message, throwable: nil, tag: tag)
+        logger.info(message, tag: tag)
     }
 
     /// Logs a warning-level message.
     public func warning(_ message: String, tag: String) {
-        kLogger.w(messageString: message, throwable: nil, tag: tag)
+        logger.warning(message, tag: tag)
     }
 
     /// Logs an error-level message.
     public func error(_ message: String, tag: String) {
-        kLogger.e(messageString: message, throwable: nil, tag: tag)
+        logger.error(message, tag: tag)
     }
 
     /// Logs a fault (assert-level) message, typically used for critical issues.
     public func fault(_ message: String, tag: String) {
-        kLogger.a(messageString: message, throwable: nil, tag: tag)
+        logger.fault(message, tag: tag)
     }
 }

Sources/PowerSync/Logger.swift

@@ -1,10 +1,9 @@
 import OSLog
 
-/// A log writer that bridges custom `LogSeverity` levels to Apple's unified `Logger` framework.
+/// A log writer which prints to the standard output
 ///
 /// This writer uses `os.Logger` on iOS 14+ and falls back to `print` for earlier versions.
-/// Tags are optionally prefixed to messages in square brackets.
-public class SwiftLogWriter: LogWriterProtocol {
+public class PrintLogWriter: LogWriterProtocol {
 
     /// Logs a message with a given severity and optional tag.
        ///
@@ -39,14 +38,54 @@ public class SwiftLogWriter: LogWriterProtocol {
 /// A default logger configuration that uses `SwiftLogWritter` and filters messages by minimum severity.
 ///
 /// This logger integrates with your custom logging system and uses `os.Logger` under the hood.
-public class DefaultLogger: DatabaseLogger {
+public class DefaultLogger: LoggerProtocol {
+    public var minSeverirty: LogSeverity
+    public var writers: [any LogWriterProtocol]
 
     /// Initializes the default logger with an optional minimum severity level.
     ///
     /// - Parameter minSeverity: The minimum severity level to log. Defaults to `.debug`.
-    public init(minSeverity: LogSeverity = .debug) {
-        super.init()
-        setMinSeverity(minSeverity)
-        setWriters([SwiftLogWriter()])
+    public init(minSeverity: LogSeverity = .debug, writers: [any LogWriterProtocol]? = nil ) {
+        self.writers = writers ?? [ PrintLogWriter() ]
+        self.minSeverirty = minSeverity
+    }
+    
+    public func setWriters(_ writters: [any LogWriterProtocol]) {
+        self.writers = writters
+    }
+    
+    public func setMinSeverity(_ severity: LogSeverity) {
+        self.minSeverirty = severity
+    }
+    
+    
+    public func debug(_ message: String, tag: String) {
+        self.writeLog(message, tag: tag, severity: LogSeverity.debug)
+    }
+    
+    public func error(_ message: String, tag: String) {
+        self.writeLog(message, tag: tag, severity: LogSeverity.error)
+    }
+    
+    public func info(_ message: String, tag: String) {
+        self.writeLog(message, tag: tag, severity: LogSeverity.info)
+    }
+    
+    public func warning(_ message: String, tag: String) {
+        self.writeLog(message, tag: tag, severity: LogSeverity.warning)
+    }
+    
+    public func fault(_ message: String, tag: String) {
+        self.writeLog(message, tag: tag, severity: LogSeverity.fault)
+    }
+    
+    private func writeLog(_ message: String, tag: String, severity: LogSeverity) {
+        if (severity.rawValue < self.minSeverirty.rawValue) {
+            return
+        }
+        
+        for writer in self.writers {
+            writer.log(severity: severity, message: message, tag: tag)
+        }
     }
 }

Sources/PowerSync/LoggerProtocol.swift

@@ -1,19 +1,34 @@
-/// Represents the severity level of a log message.
-public enum LogSeverity: String, CaseIterable {
-    /// Informational messages that highlight the progress of the application.
-    case info = "INFO"
-    
-    /// Error events that might still allow the application to continue running.
-    case error = "ERROR"
-    
+public enum LogSeverity: Int, CaseIterable {
     /// Detailed information typically used for debugging.
-    case debug = "DEBUG"
-    
+    case debug = 0
+
+    /// Informational messages that highlight the progress of the application.
+    case info = 1
+
     /// Potentially harmful situations that are not necessarily errors.
-    case warning = "WARNING"
-    
+    case warning = 2
+
+    /// Error events that might still allow the application to continue running.
+    case error = 3
+
     /// Serious errors indicating critical failures, often unrecoverable.
-    case fault = "FAULT"
+    case fault = 4
+
+    /// Map severity to its string representation
+    public var stringValue: String {
+        switch self {
+        case .debug: return "DEBUG"
+        case .info: return "INFO"
+        case .warning: return "WARNING"
+        case .error: return "ERROR"
+        case .fault: return "FAULT"
+        }
+    }
+
+    /// Convert Int to String representation
+    public static func string(from intValue: Int) -> String? {
+        return LogSeverity(rawValue: intValue)?.stringValue
+    }
 }
 
 /// A protocol for writing log messages to a specific backend or output.

Sources/PowerSync/PowerSyncDatabase.swift

@@ -12,12 +12,12 @@ public let DEFAULT_DB_FILENAME = "powersync.db"
 public func PowerSyncDatabase(
     schema: Schema,
     dbFilename: String = DEFAULT_DB_FILENAME,
-    logger: DatabaseLogger = DefaultLogger()
+    logger: (any LoggerProtocol)? = nil
 ) -> PowerSyncDatabaseProtocol {
 
     return KotlinPowerSyncDatabaseImpl(
         schema: schema,
         dbFilename: dbFilename,
-        logger: logger
+        logger: logger != nil ? DatabaseLogger(logger!) : nil
     )
 }

Tests/PowerSyncTests/Kotlin/KotlinPowerSyncDatabaseImplTests.swift

@@ -17,7 +17,7 @@ final class KotlinPowerSyncDatabaseImplTests: XCTestCase {
         database = KotlinPowerSyncDatabaseImpl(
             schema: schema,
             dbFilename: ":memory:",
-            logger: DefaultLogger()
+            logger: DatabaseLogger(DefaultLogger())
         )
         try await database.disconnectAndClear()
     }
@@ -472,17 +472,18 @@ final class KotlinPowerSyncDatabaseImplTests: XCTestCase {
     }
 
     func testCustomLogger() async throws {
-        let logger = TestLogger()
+        let testWriter = TestLogWriterAdapter()
+        let logger = DefaultLogger(minSeverity: LogSeverity.debug, writers: [testWriter])
 
         let db2 = KotlinPowerSyncDatabaseImpl(
             schema: schema,
             dbFilename: ":memory:",
-            logger: logger
+            logger: DatabaseLogger(logger)
         )
 
         try await db2.close()
 
-        let warningIndex = logger.logs.firstIndex(
+        let warningIndex = testWriter.logs.firstIndex(
             where: { value in
                 value.contains("warning: Multiple PowerSync instances for the same database have been detected")
             }
@@ -492,17 +493,18 @@ final class KotlinPowerSyncDatabaseImplTests: XCTestCase {
     }
 
     func testMinimumSeverity() async throws {
-        let logger = TestLogger(minSeverity: .error)
+        let testWriter = TestLogWriterAdapter()
+        let logger = DefaultLogger(minSeverity: LogSeverity.error, writers: [testWriter])
 
         let db2 = KotlinPowerSyncDatabaseImpl(
             schema: schema,
             dbFilename: ":memory:",
-            logger: logger
+            logger: DatabaseLogger(logger)
         )
 
         try await db2.close()
 
-        let warningIndex = logger.logs.firstIndex(
+        let warningIndex = testWriter.logs.firstIndex(
             where: { value in
                 value.contains("warning: Multiple PowerSync instances for the same database have been detected")
             }

Tests/PowerSyncTests/Kotlin/TestLogger.swift

@@ -9,15 +9,3 @@ class TestLogWriterAdapter: LogWriterProtocol {
     }
 }
 
-class TestLogger: DefaultLogger {
-    let writer = TestLogWriterAdapter()
-    
-    public var logs: [String] {
-            return writer.logs
-    }
-    
-    override init(minSeverity: LogSeverity = .debug) {
-        super.init(minSeverity: minSeverity)
-        setWriters([writer])
-    }
-}