fix logging

Author: dankinsoid

Sources/SwiftAPIClient/APIClientCaller.swift

@@ -3,11 +3,12 @@ import Logging
 #if canImport(FoundationNetworking)
 import FoundationNetworking
 #endif
+import HTTPTypes
 
 /// A generic structure for handling network requests and their responses.
 public struct APIClientCaller<Response, Value, Result> {
 
-	var logRequestByItSelf = false
+	public var logRequestByItSelf = false
 	private let _call: (
 		UUID,
 		HTTPRequestComponents,
@@ -116,6 +117,17 @@ public extension APIClientCaller where Result == Value {
 	}
 }
 
+extension APIClientCaller {
+
+	func mock(_ response: Response) -> APIClientCaller {
+		APIClientCaller { [_mockResult] _, _, _, serialize in
+			try _mockResult(serialize(response) {})
+		} mockResult: { [_mockResult] value in
+			try _mockResult(value)
+		}
+	}
+}
+
 public extension APIClient {
 
 	/// Asynchronously performs a network call using the provided caller and serializer.
@@ -212,93 +224,71 @@ public extension APIClient {
 		line: UInt = #line
 	) throws -> Result {
 		let uuid = UUID()
+		let start = Date()
 		do {
 			return try withRequest { request, configs in
 				let fileIDLine = configs.fileIDLine ?? FileIDLine(fileID: fileID, line: line)
-				let configs = configs.with(\.fileIDLine, fileIDLine)
-
+				var configs = configs.with(\.fileIDLine, fileIDLine)
+				
 				if let mock = try configs.getMockIfNeeded(for: Value.self, serializer: serializer) {
-					#if canImport(Metrics)
-					configs.with(\.reportMetrics, false).logRequest(request, uuid: uuid)
-					#else
-					configs.logRequest(request, uuid: uuid)
-					#endif
+#if canImport(Metrics)
+					configs = configs.with(\.reportMetrics, false)
+#endif
+					configs.logRequestStarted(request, uuid: uuid)
 					let result = try caller.mockResult(for: mock)
-					configs.listener.onResponseSerialized(id: uuid, response: result, configs: configs)
+					configs.logRequestCompleted(request, response: nil, data: nil, uuid: uuid, start: start, result: result)
 					return result
 				}
 
 				try configs.requestValidator.validate(request, configs.with(\.requestValidator, .alwaysSuccess))
 				if !caller.logRequestByItSelf {
-					configs.logRequest(request, uuid: uuid)
+					configs.logRequestStarted(request, uuid: uuid)
 				}
 
 				return try caller.call(uuid: uuid, request: request, configs: configs) { response, validate in
+					let data = (response as? (Data, HTTPResponse))?.0 ?? (response as? Data)
 					do {
 						try validate()
 						let result = try serializer.serialize(response, configs)
-						#if canImport(Metrics)
-						if configs.reportMetrics {
-							updateTotalResponseMetrics(for: request, successful: true)
-						}
-						#endif
-						configs.listener.onResponseSerialized(id: uuid, response: result, configs: configs)
+						configs.logRequestCompleted(
+							request,
+							response: (response as? (Data, HTTPResponse))?.1,
+							data: data,
+							uuid: uuid,
+							start: start,
+							result: result
+						)
 						return result
 					} catch {
-						#if canImport(Metrics)
-						if configs.reportMetrics {
-							updateTotalResponseMetrics(for: request, successful: false)
+						var error = error
+						if let data, let failure = configs.errorDecoder.decodeError(data, configs) {
+							error = failure
 						}
-						#endif
-
-						let context = APIErrorContext(
-							request: request,
-							response: response as? Data,
-							fileIDLine: fileIDLine
+						throw	configs.logRequestFailed(
+							request,
+							response: (response as? (Data, HTTPResponse))?.1,
+							data: data,
+							start: start,
+							uuid: uuid,
+							error: error
 						)
-						do {
-							if let data = response as? Data, let failure = configs.errorDecoder.decodeError(data, configs) {
-								try configs.errorHandler(failure, configs, context)
-								throw failure
-							}
-							try configs.errorHandler(error, configs, context)
-							throw error
-						} catch {
-							configs.listener.onError(id: uuid, error: error, configs: configs)
-							throw error
-						}
 					}
 				}
 			}
 		} catch {
-			do {
-				try withConfigs { configs in
-					let fileIDLine = configs.fileIDLine ?? FileIDLine(fileID: fileID, line: line)
-					let configs = configs.with(\.fileIDLine, fileIDLine)
-					if !configs._errorLoggingComponents.isEmpty {
-						let message = configs._errorLoggingComponents.errorMessage(
-							uuid: uuid,
-							error: error,
-							maskedHeaders: configs.logMaskedHeaders,
-							fileIDLine: fileIDLine
-						)
-						configs.logger.log(level: configs._errorLogLevel, "\(message)")
-					}
-#if canImport(Metrics)
-					if configs.reportMetrics {
-						updateTotalErrorsMetrics(for: nil)
-					}
-#endif
-					let context = APIErrorContext(fileIDLine: fileIDLine)
-					try configs.errorHandler(error, configs, context)
-				}
-				throw error
-			} catch {
-				withConfigs { configs in
-					configs.listener.onError(id: uuid, error: error, configs: configs)
-				}
-				throw error
+			try withConfigs { configs in
+				let fileIDLine = configs.fileIDLine ?? FileIDLine(fileID: fileID, line: line)
+				let configs = configs.with(\.fileIDLine, fileIDLine)
+				throw configs.logRequestFailed(
+					nil,
+					response: nil,
+					data: nil,
+					start: start,
+					uuid: uuid,
+					error: error
+				)
 			}
+			throw error
 		}
 	}
 }

Sources/SwiftAPIClient/Clients/HTTPClient.swift

@@ -121,7 +121,7 @@ extension APIClientCaller where Result == AsyncThrowingValue<(Value, HTTPRespons
 				let requestWrapper = SendableValue(request)
 				do {
 					(value, response) = try await configs.httpClientMiddleware.execute(request: request, configs: configs) { request, configs in
-						configs.logRequest(request, uuid: uuid)
+						configs.logRequestStarted(request, uuid: uuid)
 						await requestWrapper.set(request)
 						let result = try await task(request, configs)
 						configs.listener.onResponseReceived(id: uuid, response: result, configs: configs)
@@ -130,92 +130,19 @@ extension APIClientCaller where Result == AsyncThrowingValue<(Value, HTTPRespons
 					}
 				} catch {
 					let request = await requestWrapper.value
-					let response = await responseWrapper.value
-					let duration = Date().timeIntervalSince(start)
-					if !configs._errorLoggingComponents.isEmpty {
-						let message = configs._errorLoggingComponents.errorMessage(
-							uuid: uuid,
-							error: error,
-							request: request,
-							duration: duration,
-							maskedHeaders: configs.logMaskedHeaders,
-							fileIDLine: configs.fileIDLine
-						)
-						configs.logger.log(level: configs._errorLogLevel, "\(message)")
-					}
-					#if canImport(Metrics)
-					if configs.reportMetrics {
-						updateHTTPMetrics(for: request, status: response?.1.status, duration: duration, successful: false)
-					}
-					#endif
-					do {
-						try configs.errorHandler(
-							error,
-							configs,
-							APIErrorContext(
-								request: request,
-								response: response.flatMap { data($0.0) },
-								status: response?.1.status,
-								fileIDLine: configs.fileIDLine ?? FileIDLine()
-							)
-						)
-						throw error
-					} catch {
-						configs.listener.onError(id: uuid, error: error, configs: configs)
-						throw error
-					}
+					throw configs.logRequestFailed(
+						request,
+						response: nil,
+						data: nil,
+						start: start,
+						uuid: uuid,
+						error: error
+					)
 				}
-				let request = await requestWrapper.value
-				let duration = Date().timeIntervalSince(start)
-				let data = data(value)
-				do {
-					let result = try serialize((value, response)) {
-						try validate(value, response, configs)
-					}
-					let isError = response.status.kind.isError
-					let logComponents = isError ? configs._errorLoggingComponents : configs.loggingComponents
-					if !logComponents.isEmpty {
-						let message = logComponents.responseMessage(
-							for: response,
-							uuid: uuid,
-							request: request,
-							data: data,
-							duration: duration,
-							maskedHeaders: configs.logMaskedHeaders,
-							fileIDLine: configs.fileIDLine
-						)
-						configs.logger.log(
-							level: isError ? configs._errorLogLevel : configs.logLevel,
-							"\(message)"
-						)
-					}
-					#if canImport(Metrics)
-					if configs.reportMetrics {
-						updateHTTPMetrics(for: request, status: response.status, duration: duration, successful: true)
-					}
-					#endif
-					return (result, response)
-				} catch {
-					if !configs._errorLoggingComponents.isEmpty {
-						let message = configs._errorLoggingComponents.responseMessage(
-							for: response,
-							uuid: uuid,
-							request: request,
-							data: data,
-							duration: duration,
-							error: error,
-							maskedHeaders: configs.logMaskedHeaders,
-							fileIDLine: configs.fileIDLine
-						)
-						configs.logger.log(level: configs._errorLogLevel, "\(message)")
-					}
-					#if canImport(Metrics)
-					if configs.reportMetrics {
-						updateHTTPMetrics(for: request, status: response.status, duration: duration, successful: false)
-					}
-					#endif
-					throw error
+				let result = try serialize((value, response)) {
+					try validate(value, response, configs)
 				}
+				return (result, response)
 			}
 		} mockResult: { value in
 			asyncWithResponse(value)

Sources/SwiftAPIClient/Modifiers/LoggingModifier.swift

@@ -1,6 +1,6 @@
 import Foundation
 import Logging
-import HTTPTypesFoundation
+import HTTPTypes
 
 public extension APIClient {
 
@@ -92,27 +92,99 @@ public extension APIClient.Configs {
 }
 
 extension APIClient.Configs {
-
+	
 	var _errorLogLevel: Logger.Level {
 		errorLogLevel ?? logLevel
 	}
-
+	
 	var _errorLoggingComponents: LoggingComponents {
 		errorLogginComponents ?? loggingComponents
 	}
-
-	func logRequest(_ request: HTTPRequestComponents, uuid: UUID) {
+	
+	public func logRequestStarted(_ request: HTTPRequestComponents, uuid: UUID) {
 		if loggingComponents.contains(.onRequest), loggingComponents != .onRequest {
 			let message = loggingComponents.requestMessage(for: request, uuid: uuid, maskedHeaders: logMaskedHeaders, fileIDLine: fileIDLine)
 			logger.log(level: logLevel, "\(message)")
 		}
-		#if canImport(Metrics)
+#if canImport(Metrics)
 		if reportMetrics {
 			updateTotalRequestsMetrics(for: request)
 		}
-		#endif
+#endif
 		listener.onRequestStarted(id: uuid, request: request, configs: self)
 	}
+	
+	public func logRequestFailed(
+		_ request: HTTPRequestComponents?,
+		response: HTTPResponse?,
+		data: Data?,
+		start: Date,
+		uuid: UUID,
+		error: Error
+	) -> Error {
+		let duration = Date().timeIntervalSince(start)
+		if !_errorLoggingComponents.isEmpty {
+			let message = _errorLoggingComponents.errorMessage(
+				uuid: uuid,
+				error: error,
+				request: request,
+				duration: duration,
+				maskedHeaders: logMaskedHeaders,
+				fileIDLine: fileIDLine
+			)
+			logger.log(level: _errorLogLevel, "\(message)")
+		}
+#if canImport(Metrics)
+		if reportMetrics {
+			updateHTTPMetrics(for: request, status: response?.status, duration: duration, successful: false)
+		}
+#endif
+		do {
+			try errorHandler(
+				error,
+				self,
+				APIErrorContext(
+					request: request,
+					response: data,
+					status: response?.status,
+					fileIDLine: fileIDLine ?? FileIDLine()
+				)
+			)
+			return error
+		} catch {
+			listener.onError(id: uuid, error: error, configs: self)
+			return error
+		}
+	}
+	
+	public func logRequestCompleted<T>(
+		_ request: HTTPRequestComponents,
+		response: HTTPResponse?,
+		data: Data?,
+		uuid: UUID,
+		start: Date,
+		result: T
+	) {
+		let duration = Date().timeIntervalSince(start)
+		if !loggingComponents.isEmpty {
+			let message = loggingComponents.responseMessage(
+				for: response,
+				uuid: uuid,
+				request: request,
+				data: data,
+				duration: duration,
+				maskedHeaders: logMaskedHeaders,
+				fileIDLine: fileIDLine
+			)
+			logger.log(level: logLevel, "\(message)")
+		}
+#if canImport(Metrics)
+		if reportMetrics {
+			updateHTTPMetrics(for: request, status: response?.status, duration: duration, successful: true)
+		}
+#endif
+		listener.onResponseSerialized(id: uuid, response: result, configs: self)
+	}
 }
 
 extension Set<HTTPField.Name> {