Add network logging support

Author: stevensJourney

CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## 1.4.0
+
+* Added the ability to log PowerSync network requests.
+```swift
+struct InlineLogger: NetworkLogger {
+    func log(_ message: String) {
+        print("Network: \(message)")
+    }
+}
+
+try await db.connect(
+                connector: connector,
+                options: ConnectOptions(
+                    clientConfiguration: SyncClientConfiguration(
+                        networkLogger: NetworkLoggerConfig(
+                            logLevel: .headers,
+                            logger: InlineLogger()
+                        )
+                    )
+                )
+            )
+```
+
 ## 1.3.0
 
 * Use version `0.4.2` of the PowerSync core extension, which improves the reliability

Demo/PowerSyncExample/PowerSync/SystemManager.swift

@@ -13,6 +13,12 @@ func getAttachmentsDirectoryPath() throws -> String {
 
 let logTag = "SystemManager"
 
+struct InlineLogger: NetworkLogger {
+    func log(_ message: String) {
+        print("Network: \(message)")
+    }
+}
+
 @Observable
 class SystemManager {
     let connector = SupabaseConnector()
@@ -70,7 +76,17 @@ class SystemManager {
 
     func connect() async {
         do {
-            try await db.connect(connector: connector)
+            try await db.connect(
+                connector: connector,
+                options: ConnectOptions(
+                    clientConfiguration: SyncClientConfiguration(
+                        networkLogger: NetworkLoggerConfig(
+                            logLevel: .headers,
+                            logger: InlineLogger()
+                        )
+                    )
+                )
+            )
             try await attachments?.startSync()
         } catch {
             print("Unexpected error: \(error.localizedDescription)") // Catches any other error

Sources/PowerSync/Kotlin/KotlinNetworkLogger.swift

@@ -0,0 +1,29 @@
+import PowerSyncKotlin
+
+extension NetworkLogLevel {
+    func toKotlin() -> SwiftNetworkLogLevel {
+        switch self {
+            case .all:
+                return SwiftNetworkLogLevel.all
+            case .headers:
+                return SwiftNetworkLogLevel.headers
+            case .body:
+                return SwiftNetworkLogLevel.body
+            case .info:
+                return SwiftNetworkLogLevel.info
+            case .none:
+                return SwiftNetworkLogLevel.none
+        }
+    }
+}
+
+extension NetworkLoggerConfig {
+    func toKotlinConfig() -> SwiftNetworkLoggerConfig {
+        return SwiftNetworkLoggerConfig(
+            logLevel: self.logLevel.toKotlin(),
+            log: { [logger] message in
+                logger.log(message)
+            }
+        )
+    }
+}

Sources/PowerSync/Kotlin/KotlinPowerSyncDatabaseImpl.swift

@@ -52,10 +52,6 @@ final class KotlinPowerSyncDatabaseImpl: PowerSyncDatabaseProtocol {
         )
 
         let resolvedOptions = options ?? ConnectOptions()
-        let useWebsockets = switch (resolvedOptions.connectionMethod) {
-            case .http: false
-            case .webSocket: true
-        }
 
         try await kotlinDatabase.connect(
             connector: connectorAdapter,
@@ -64,8 +60,8 @@ final class KotlinPowerSyncDatabaseImpl: PowerSyncDatabaseProtocol {
             params: resolvedOptions.params.mapValues { $0.toKotlinMap() },
             options: createSyncOptions(
                 newClient: resolvedOptions.newClientImplementation,
-                webSocket: useWebsockets,
-                userAgent: "PowerSync Swift SDK"
+                userAgent: "PowerSync Swift SDK",
+                loggingConfig: resolvedOptions.clientConfiguration?.networkLogger?.toKotlinConfig()
             )
         )
     }

Sources/PowerSync/Protocol/NetworkLogger.swift

@@ -0,0 +1,54 @@
+/// A logger which handles PowerSync network request logs.
+///
+/// Implement this protocol to receive network logging messages at the level
+/// specified in `NetworkLoggerConfig`. The `log(_:)` method will be called
+/// for each network event that meets the configured logging criteria.
+public protocol NetworkLogger {
+    /// Logs a network-related message.
+    /// - Parameter message: The formatted log message to record
+    func log(_ message: String)
+}
+
+/// Level of logs to expose to a `NetworkLogger` handler.
+///
+/// Controls the verbosity of network logging for PowerSync HTTP requests.
+/// The log level is configured once during initialization and determines
+/// which network events will be logged throughout the session.
+public enum NetworkLogLevel {
+    /// Log all network activity including headers, body, and info
+    case all
+    /// Log only request/response headers
+    case headers
+    /// Log only request/response body content
+    case body
+    /// Log basic informational messages about requests
+    case info
+    /// Disable all network logging
+    case none
+}
+
+/// Configuration for PowerSync HTTP request logging.
+///
+/// This configuration is set once during initialization and used throughout
+/// the PowerSync session. The `logLevel` determines which network events
+/// are logged, while the `logger` handles the actual log output.
+///
+/// - Note: The log level cannot be changed after initialization. A new call to `PowerSyncDatabase.connect` is required to change the level.
+public struct NetworkLoggerConfig {
+    /// The logging level that determines which network events are logged.
+    /// Set once during initialization and used throughout the session.
+    public let logLevel: NetworkLogLevel
+    
+    /// The logger instance that receives network log messages.
+    /// Must conform to `NetworkLogger` protocol.
+    public let logger: NetworkLogger
+    
+    /// Creates a new network logger configuration.
+    /// - Parameters:
+    ///   - logLevel: The `NetworkLogLevel` to use for filtering log messages
+    ///   - logger: A `NetworkLogger` instance to handle log output
+    public init(logLevel: NetworkLogLevel, logger: NetworkLogger) {
+        self.logLevel = logLevel
+        self.logger = logger
+    }
+}

Sources/PowerSync/Protocol/PowerSyncDatabaseProtocol.swift

@@ -1,5 +1,28 @@
 import Foundation
 
+/// Configuration for the sync client used to connect to the PowerSync service.
+///
+/// Provides options to customize network behavior and logging for PowerSync
+/// HTTP requests and responses.
+public struct SyncClientConfiguration {
+    /// Optional configuration for logging PowerSync HTTP requests.
+    ///
+    /// When provided, network requests will be logged according to the
+    /// specified `NetworkLogLevel`. The `logLevel` is set during initialization
+    /// and remains constant throughout the PowerSync session.
+    ///
+    /// Set to `nil` to disable network logging entirely.
+    ///
+    /// - SeeAlso: `NetworkLoggerConfig` for configuration options
+    public let networkLogger: NetworkLoggerConfig?
+    
+    /// Creates a new sync client configuration.
+    /// - Parameter networkLogger: Optional network logger configuration
+    public init(networkLogger: NetworkLoggerConfig? = nil) {
+        self.networkLogger = networkLogger
+    }
+}
+
 /// Options for configuring a PowerSync connection.
 ///
 /// Provides optional parameters to customize sync behavior such as throttling and retry policies.
@@ -41,31 +64,37 @@ public struct ConnectOptions {
     /// We encourage interested users to try the new client.
     @_spi(PowerSyncExperimental)
     public var newClientImplementation: Bool
-
-    /// The connection method used to connect to the Powersync service.
+    
+    /// Configuration for the sync client used for PowerSync requests.
     ///
-    /// The default method is ``ConnectionMethod/http``. Using ``ConnectionMethod/webSocket(_:)`` can
-    /// improve performance as a more efficient binary protocol is used. However, using the websocket connection method
-    /// requires enabling ``ConnectOptions/newClientImplementation``.
-    @_spi(PowerSyncExperimental)
-    public var connectionMethod: ConnectionMethod
+    /// Provides options to customize network behavior including logging of HTTP
+    /// requests and responses. When `nil`, default HTTP client settings are used
+    /// with no network logging.
+    ///
+    /// Set this to configure network logging or other HTTP client behaviors
+    /// specific to PowerSync operations.
+    ///
+    /// - SeeAlso: `SyncClientConfiguration` for available configuration options
+    public var clientConfiguration: SyncClientConfiguration?
 
     /// Initializes a `ConnectOptions` instance with optional values.
     ///
     /// - Parameters:
     ///   - crudThrottle: TimeInterval between CRUD operations in milliseconds. Defaults to `1` second.
     ///   - retryDelay: Delay TimeInterval between retry attempts in milliseconds. Defaults to `5` seconds.
     ///   - params: Custom sync parameters to send to the server. Defaults to an empty dictionary.
+    ///   - clientConfiguration: Configuration for the HTTP client used to connect to PowerSync.
     public init(
         crudThrottle: TimeInterval = 1,
         retryDelay: TimeInterval = 5,
-        params: JsonParam = [:]
+        params: JsonParam = [:],
+        clientConfiguration: SyncClientConfiguration? = nil
     ) {
         self.crudThrottle = crudThrottle
         self.retryDelay = retryDelay
         self.params = params
         self.newClientImplementation = false
-        self.connectionMethod = .http
+        self.clientConfiguration = clientConfiguration
     }
 
     /// Initializes a ``ConnectOptions`` instance with optional values, including experimental options.
@@ -75,22 +104,16 @@ public struct ConnectOptions {
         retryDelay: TimeInterval = 5,
         params: JsonParam = [:],
         newClientImplementation: Bool = false,
-        connectionMethod: ConnectionMethod = .http
+        clientConfiguration: SyncClientConfiguration? = nil
     ) {
         self.crudThrottle = crudThrottle
         self.retryDelay = retryDelay
         self.params = params
         self.newClientImplementation = newClientImplementation
-        self.connectionMethod = connectionMethod
+        self.clientConfiguration = clientConfiguration
     }
 }
 
-@_spi(PowerSyncExperimental)
-public enum ConnectionMethod {
-    case http
-    case webSocket
-}
-
 /// A PowerSync managed database.
 ///
 /// Use one instance per database file.
@@ -108,7 +131,6 @@ public protocol PowerSyncDatabaseProtocol: Queries {
     /// Wait for the first sync to occur
     func waitForFirstSync() async throws
 
-
     /// Replace the schema with a new version. This is for advanced use cases - typically the schema
     /// should just be specified once in the constructor.
     ///
@@ -247,7 +269,7 @@ public extension PowerSyncDatabaseProtocol {
     }
 
     func disconnectAndClear(clearLocal: Bool = true) async throws {
-        try await self.disconnectAndClear(clearLocal: clearLocal)
+        try await disconnectAndClear(clearLocal: clearLocal)
     }
 
     func getCrudBatch(limit: Int32 = 100) async throws -> CrudBatch? {