Refactor around logging and retrying

Author: Fernando Fernandes

Package.resolved

@@ -9,6 +9,7 @@ import Foundation
 #if canImport(FoundationNetworking)
 import FoundationNetworking
 #endif
+import Logging
 
 /// A **request** for an overview of a Kucoin Futures account.
 ///
@@ -19,11 +20,8 @@ public struct KucoinFuturesAccountOverviewRequest: NetworkRequest {
 
     public typealias DecodableModel = KucoinFuturesAccountOverview
 
-    public var logger: SwiftTraderLogger {
-        SwiftTraderLogger(
-            label: "swift-trader.account-overview",
-            isLoggingEnabled: settings.isLoggingEnable
-        )
+    public var logger: Logger {
+        NetworkRequestLogger().default
     }
 
     public var session: URLSession

Sources/SwiftTrader/Common/SwiftTraderLogger.swift

@@ -0,0 +1,23 @@
+//
+//  NetworkRequestLogger.swift
+//  
+//
+//  Created by Fernando Fernandes on 04.02.22.
+//
+
+import Foundation
+import Logging
+
+/// Logs information via Apple's `swift-log` package.
+public struct NetworkRequestLogger {
+    
+    // MARK: - Properties
+    
+    public let `default`: Logger
+    
+    // MARK: - Lifecycle
+    
+    public init(label: String = "com.backslash-f.network") {
+        self.default = Logger(label: label)
+    }
+}

Sources/SwiftTrader/Network/Kucoin/AccountOverview/KucoinFuturesAccountOverviewRequest.swift

@@ -17,43 +17,49 @@ public extension NetworkRequest {
 
     // MARK: - Default Execution
 
-    /// Executes the given request asynchronously (`async/await`) and returns the result.
+    /// Executes the `NetworkRequest.getter:request` asynchronously and returns the `NetworkRequestResult`.
+    ///
+    ///  Failed requests are to be retried `n` times, according to the `numberOfRetries` of `NetworkRequest.getter:settings`.
     ///
-    /// - Parameter request: `URLRequest` containing the target `URL`.
     /// - Returns: `NetworkRequestResult`.
-    func execute(attemptNumber: Int = 1) async -> NetworkRequestResult {
-        let req: URLRequest
+    func execute() async -> NetworkRequestResult {
+        let urlRequest: URLRequest
         do {
-            req = try request
+            urlRequest = try request
         } catch {
             return .failure(.invalidRequest(error: error))
         }
+        return await executeRetrying(request: urlRequest)
+    }
+}
+
+// MARK: - Private
+
+private extension NetworkRequest {
+    
+    func executeRetrying(request: URLRequest, attemptNumber: Int = 1) async -> NetworkRequestResult {
+        let result: NetworkRequestResult
 #if os(macOS) || os(iOS)
-        let result = await runOnApplePlatforms(request: req)
+        result = await runOnApplePlatforms(request: request)
+#elseif canImport(FoundationNetworking)
+        result = await runOnLinux(request: req)
+#endif
         switch result {
         case .success:
             return result
         case .failure:
             if attemptNumber <= settings.numberOfRetries {
-                logger.log(message: "Retrying... \(attemptNumber) of \(settings.numberOfRetries)")
+                log(message: "Retrying... \(attemptNumber) of \(settings.numberOfRetries)")
                 try? await Task.sleep(nanoseconds: 1_000_000_000 * settings.delayBetweenRetries)
-                return await execute(attemptNumber: attemptNumber + 1)
+                return await executeRetrying(request: request, attemptNumber: attemptNumber + 1)
             } else {
                 return result
             }
         }
-#elseif canImport(FoundationNetworking)
-        return await runOnLinux(request: req)
-#endif
     }
-}
-
-// MARK: - Private
-
-private extension NetworkRequest {
 
 #if os(macOS) || os(iOS)
-    /// macOS and iOS.
+    /// `async/await` can be simply called on macOS and iOS platforms; no further action is needed.
     func runOnApplePlatforms(request: URLRequest) async -> NetworkRequestResult {
         do {
             let (data, response) = try await session.data(for: request)
@@ -64,7 +70,7 @@ private extension NetworkRequest {
     }
 #endif
 
-    /// `async/await` isn't fully ported to Linux; use "withCheckedContinuation(function:_:)" instead.
+    /// `async/await` isn't fully ported to Linux; use "**withCheckedContinuation(function:_:)**" instead.
     func runOnLinux(request: URLRequest) async -> NetworkRequestResult {
         let (data, response, error) = await withCheckedContinuation { continuation in
             session.dataTask(with: request) { data, response, error in

Sources/SwiftTrader/Network/NetworkRequest/NetworkRequestLogger.swift

@@ -0,0 +1,20 @@
+//
+//  NetworkRequestProtocol+Logging.swift
+//  
+//
+//  Created by Fernando Fernandes on 04.02.22.
+//
+
+import Foundation
+import Logging
+
+/// Holds the default logging implementation.
+public extension NetworkRequest {
+    
+    func log(message: Logger.Message) {
+        guard settings.isLoggingEnable else {
+            return
+        }
+        logger.log(level: settings.logLevel, message)
+    }
+}

Sources/SwiftTrader/Network/NetworkRequest/NetworkRequestProtocol+Execution.swift

@@ -16,10 +16,11 @@ public typealias NetworkRequestResult = Result<Decodable, NetworkRequestError>
 /// Represents a generic network request composed by basic functions that make a network request possible.
 public protocol NetworkRequest {
     associatedtype DecodableModel: Decodable
-    var logger: SwiftTraderLogger { get }
+    var logger: Logger { get }
     var session: URLSession { get }
     var request: URLRequest { get throws }
     var settings: NetworkRequestSettings { get }
-    func execute(attemptNumber: Int) async -> NetworkRequestResult
+    func execute() async -> NetworkRequestResult
     func decode(_ data: Data) throws -> DecodableModel
+    func log(message: Logger.Message)
 }

Sources/SwiftTrader/Network/NetworkRequest/NetworkRequestProtocol+Logging.swift

@@ -6,13 +6,17 @@
 //
 
 import Foundation
+import Logging
 
 /// Conform to this protocol to provide/tweak default `NetworkRequest` settings.
 public protocol NetworkRequestSettings {
 
     /// `true` to enable logging of network requests.
     var isLoggingEnable: Bool { get }
 
+    /// The log level.
+    var logLevel: Logger.Level { get }
+    
     /// The number of retries of failed `NetworkRequest`s.
     var numberOfRetries: Int { get }
 
@@ -25,6 +29,7 @@ public struct DefaultNetworkRequestSettings: NetworkRequestSettings {
 
     // MARK: - Properties
 
+    public var logLevel: Logger.Level = .debug
     public var isLoggingEnable: Bool = true
     public var numberOfRetries: Int = 3
     public var delayBetweenRetries: UInt64 = 2