Add PSQLError debugDescription (#372)

gwynne · fabianfett · web-flow · commit 061a0836d7c1 · 2023-06-09T15:14:56.000+02:00
Co-authored-by: Fabian Fett &lt;fabianfett@apple.com&gt;
diff --git a/Sources/PostgresNIO/New/PSQLError.swift b/Sources/PostgresNIO/New/PSQLError.swift
@@ -190,21 +190,13 @@ public struct PSQLError: Error {
 
     private final class Backing {
         fileprivate var code: Code
-
         fileprivate var serverInfo: ServerInfo?
-
         fileprivate var underlying: Error?
-
         fileprivate var file: String?
-
         fileprivate var line: Int?
-
         fileprivate var query: PostgresQuery?
-
         fileprivate var backendMessage: PostgresBackendMessage?
-
         fileprivate var unsupportedAuthScheme: UnsupportedAuthScheme?
-
         fileprivate var invalidCommandTag: String?
 
         init(code: Code) {
@@ -224,10 +216,10 @@ public struct PSQLError: Error {
     }
 
     public struct ServerInfo {
-        public struct Field: Hashable, Sendable {
+        public struct Field: Hashable, Sendable, CustomStringConvertible {
             fileprivate let backing: PostgresBackendMessage.Field
 
-            private init(_ backing: PostgresBackendMessage.Field) {
+            fileprivate init(_ backing: PostgresBackendMessage.Field) {
                 self.backing = backing
             }
 
@@ -306,6 +298,47 @@ public struct PSQLError: Error {
 
             /// Routine: the name of the source-code routine reporting the error.
             public static let routine = Self(.routine)
+
+            public var description: String {
+                switch self.backing {
+                case .localizedSeverity:
+                    return "localizedSeverity"
+                case .severity:
+                    return "severity"
+                case .sqlState:
+                    return "sqlState"
+                case .message:
+                    return "message"
+                case .detail:
+                    return "detail"
+                case .hint:
+                    return "hint"
+                case .position:
+                    return "position"
+                case .internalPosition:
+                    return "internalPosition"
+                case .internalQuery:
+                    return "internalQuery"
+                case .locationContext:
+                    return "locationContext"
+                case .schemaName:
+                    return "schemaName"
+                case .tableName:
+                    return "tableName"
+                case .columnName:
+                    return "columnName"
+                case .dataTypeName:
+                    return "dataTypeName"
+                case .constraintName:
+                    return "constraintName"
+                case .file:
+                    return "file"
+                case .line:
+                    return "line"
+                case .routine:
+                    return "routine"
+                }
+            }
         }
 
         let underlying: PostgresBackendMessage.ErrorResponse
@@ -397,6 +430,65 @@ public struct PSQLError: Error {
     }
 }
 
+extension PSQLError: CustomStringConvertible {
+    public var description: String {
+        // This may seem very odd... But we are afraid that users might accidentally send the
+        // unfiltered errors out to end-users. This may leak security relevant information. For this
+        // reason we overwrite the error description by default to this generic "Database error"
+        """
+        PSQLError – Generic description to prevent accidental leakage of sensitive data. For debugging details, use `String(reflecting: error)`.
+        """
+    }
+}
+
+extension PSQLError: CustomDebugStringConvertible {
+    public var debugDescription: String {
+        var result = #"PSQLError(code: \#(self.code)"#
+
+        if let serverInfo = self.serverInfo?.underlying {
+            result.append(", serverInfo: [")
+            result.append(
+                serverInfo.fields
+                    .sorted(by: { $0.key.rawValue < $1.key.rawValue })
+                    .map { "\(PSQLError.ServerInfo.Field($0.0)): \($0.1)" }
+                    .joined(separator: ", ")
+            )
+            result.append("]")
+        }
+
+        if let backendMessage = self.backendMessage {
+            result.append(", backendMessage: \(String(reflecting: backendMessage))")
+        }
+
+        if let unsupportedAuthScheme = self.unsupportedAuthScheme {
+            result.append(", unsupportedAuthScheme: \(unsupportedAuthScheme)")
+        }
+
+        if let invalidCommandTag = self.invalidCommandTag {
+            result.append(", invalidCommandTag: \(invalidCommandTag)")
+        }
+
+        if let underlying = self.underlying {
+            result.append(", underlying: \(String(reflecting: underlying))")
+        }
+
+        if let file = self.file {
+            result.append(", triggeredFromRequestInFile: \(file)")
+            if let line = self.line {
+                result.append(", line: \(line)")
+            }
+        }
+
+        if let query = self.query {
+            result.append(", query: \(String(reflecting: query))")
+        }
+
+        result.append(")")
+
+        return result
+    }
+}
+
 /// An error that may happen when a ``PostgresRow`` or ``PostgresCell`` is decoded to native Swift types.
 public struct PostgresDecodingError: Error, Equatable {
     public struct Code: Hashable, Error, CustomStringConvertible {
@@ -490,7 +582,9 @@ extension PostgresDecodingError: CustomStringConvertible {
         // This may seem very odd... But we are afraid that users might accidentally send the
         // unfiltered errors out to end-users. This may leak security relevant information. For this
         // reason we overwrite the error description by default to this generic "Database error"
-        "Database error"
+        """
+        PostgresDecodingError – Generic description to prevent accidental leakage of sensitive data. For debugging details, use `String(reflecting: error)`.
+        """
     }
 }
 
@@ -504,7 +598,7 @@ extension PostgresDecodingError: CustomDebugStringConvertible {
         result.append(#", postgresType: \#(self.postgresType)"#)
         result.append(#", postgresFormat: \#(self.postgresFormat)"#)
         if let postgresData = self.postgresData {
-            result.append(#", postgresData: \#(postgresData.debugDescription)"#) // https://github.com/apple/swift-nio/pull/2418
+            result.append(#", postgresData: \#(String(reflecting: postgresData))"#)
         }
         result.append(#", file: \#(self.file)"#)
         result.append(#", line: \#(self.line)"#)
diff --git a/Sources/PostgresNIO/New/PostgresQuery.swift b/Sources/PostgresNIO/New/PostgresQuery.swift
@@ -95,6 +95,20 @@ extension PostgresQuery {
     }
 }
 
+extension PostgresQuery: CustomStringConvertible {
+    /// See ``Swift/CustomStringConvertible/description``.
+    public var description: String {
+        "\(self.sql) \(self.binds)"
+    }
+}
+
+extension PostgresQuery: CustomDebugStringConvertible {
+    /// See ``Swift/CustomDebugStringConvertible/debugDescription``.
+    public var debugDescription: String {
+        "PostgresQuery(sql: \(String(describing: self.sql)), binds: \(String(reflecting: self.binds)))"
+    }
+}
+
 struct PSQLExecuteStatement {
     /// The statements name
     var name: String
@@ -111,16 +125,19 @@ public struct PostgresBindings: Sendable, Hashable {
         var dataType: PostgresDataType
         @usableFromInline
         var format: PostgresFormat
+        @usableFromInline
+        var protected: Bool
 
         @inlinable
-        init(dataType: PostgresDataType, format: PostgresFormat) {
+        init(dataType: PostgresDataType, format: PostgresFormat, protected: Bool) {
             self.dataType = dataType
             self.format = format
+            self.protected = protected
         }
 
         @inlinable
-        init<Value: PostgresEncodable>(value: Value) {
-            self.init(dataType: Value.psqlType, format: Value.psqlFormat)
+        init<Value: PostgresEncodable>(value: Value, protected: Bool) {
+            self.init(dataType: Value.psqlType, format: Value.psqlFormat, protected: protected)
         }
     }
 
@@ -147,7 +164,7 @@ public struct PostgresBindings: Sendable, Hashable {
 
     public mutating func appendNull() {
         self.bytes.writeInteger(-1, as: Int32.self)
-        self.metadata.append(.init(dataType: .null, format: .binary))
+        self.metadata.append(.init(dataType: .null, format: .binary, protected: true))
     }
 
     @inlinable
@@ -156,7 +173,7 @@ public struct PostgresBindings: Sendable, Hashable {
         context: PostgresEncodingContext<JSONEncoder>
     ) throws {
         try value.encodeRaw(into: &self.bytes, context: context)
-        self.metadata.append(.init(value: value))
+        self.metadata.append(.init(value: value, protected: true))
     }
 
     @inlinable
@@ -165,7 +182,25 @@ public struct PostgresBindings: Sendable, Hashable {
         context: PostgresEncodingContext<JSONEncoder>
     ) {
         value.encodeRaw(into: &self.bytes, context: context)
-        self.metadata.append(.init(value: value))
+        self.metadata.append(.init(value: value, protected: true))
+    }
+
+    @inlinable
+    mutating func appendUnprotected<Value: PostgresEncodable, JSONEncoder: PostgresJSONEncoder>(
+        _ value: Value,
+        context: PostgresEncodingContext<JSONEncoder>
+    ) throws {
+        try value.encodeRaw(into: &self.bytes, context: context)
+        self.metadata.append(.init(value: value, protected: false))
+    }
+
+    @inlinable
+    mutating func appendUnprotected<Value: PostgresNonThrowingEncodable, JSONEncoder: PostgresJSONEncoder>(
+        _ value: Value,
+        context: PostgresEncodingContext<JSONEncoder>
+    ) {
+        value.encodeRaw(into: &self.bytes, context: context)
+        self.metadata.append(.init(value: value, protected: false))
     }
 
     public mutating func append(_ postgresData: PostgresData) {
@@ -176,6 +211,93 @@ public struct PostgresBindings: Sendable, Hashable {
             self.bytes.writeInteger(Int32(input.readableBytes))
             self.bytes.writeBuffer(&input)
         }
-        self.metadata.append(.init(dataType: postgresData.type, format: .binary))
+        self.metadata.append(.init(dataType: postgresData.type, format: .binary, protected: true))
+    }
+}
+
+extension PostgresBindings: CustomStringConvertible, CustomDebugStringConvertible {
+    /// See ``Swift/CustomStringConvertible/description``.
+    public var description: String {
+        """
+        [\(zip(self.metadata, BindingsReader(buffer: self.bytes))
+            .lazy.map({ Self.makeBindingPrintable(protected: $0.protected, type: $0.dataType, format: $0.format, buffer: $1) })
+            .joined(separator: ", "))]
+        """
+    }
+
+    /// See ``Swift/CustomDebugStringConvertible/description``.
+    public var debugDescription: String {
+        """
+        [\(zip(self.metadata, BindingsReader(buffer: self.bytes))
+            .lazy.map({ Self.makeDebugDescription(protected: $0.protected, type: $0.dataType, format: $0.format, buffer: $1) })
+            .joined(separator: ", "))]
+        """
+    }
+
+    private static func makeDebugDescription(protected: Bool, type: PostgresDataType, format: PostgresFormat, buffer: ByteBuffer?) -> String {
+        "(\(Self.makeBindingPrintable(protected: protected, type: type, format: format, buffer: buffer)); \(type); format: \(format))"
+    }
+
+    private static func makeBindingPrintable(protected: Bool, type: PostgresDataType, format: PostgresFormat, buffer: ByteBuffer?) -> String {
+        if protected {
+            return "****"
+        }
+
+        guard var buffer = buffer else {
+            return "null"
+        }
+
+        do {
+            switch (type, format) {
+            case (.int4, _), (.int2, _), (.int8, _):
+                let number = try Int64.init(from: &buffer, type: type, format: format, context: .default)
+                return String(describing: number)
+
+            case (.bool, _):
+                let bool = try Bool.init(from: &buffer, type: type, format: format, context: .default)
+                return String(describing: bool)
+
+            case (.varchar, _), (.bpchar, _), (.text, _), (.name, _):
+                let value = try String.init(from: &buffer, type: type, format: format, context: .default)
+                return String(reflecting: value) // adds quotes
+
+            default:
+                return "\(buffer.readableBytes) bytes"
+            }
+        } catch {
+            return "\(buffer.readableBytes) bytes"
+        }
+    }
+}
+
+/// A small helper to inspect encoded bindings
+private struct BindingsReader: Sequence {
+    typealias Element = Optional<ByteBuffer>
+
+    var buffer: ByteBuffer
+
+    struct Iterator: IteratorProtocol {
+        typealias Element = Optional<ByteBuffer>
+        private var buffer: ByteBuffer
+
+        init(buffer: ByteBuffer) {
+            self.buffer = buffer
+        }
+
+        mutating func next() -> Optional<Optional<ByteBuffer>> {
+            guard let length = self.buffer.readInteger(as: Int32.self) else {
+                return .none
+            }
+
+            if length < 0 {
+                return .some(.none)
+            }
+
+            return .some(self.buffer.readSlice(length: Int(length))!)
+        }
+    }
+
+    func makeIterator() -> Iterator {
+        Iterator(buffer: self.buffer)
     }
 }
diff --git a/Tests/IntegrationTests/AsyncTests.swift b/Tests/IntegrationTests/AsyncTests.swift
@@ -72,7 +72,7 @@ final class AsyncPostgresConnectionTests: XCTestCase {
             var counter = 0
 
             for try await element in rows.decode((Int, String, String, String, String?, Int, Date, Date, String, String).self) {
-                XCTAssertEqual(element.1, env("POSTGRES_DB") ?? "localhost")
+                XCTAssertEqual(element.1, env("POSTGRES_DB") ?? "test_database")
                 XCTAssertEqual(element.2, env("POSTGRES_USER") ?? "test_username")
 
                 XCTAssertEqual(element.8, query.sql)
@@ -106,8 +106,6 @@ final class AsyncPostgresConnectionTests: XCTestCase {
             } catch {
                 guard let error = error as? PSQLError else { return XCTFail("Unexpected error type") }
 
-                print(error)
-
                 XCTAssertEqual(error.code, .server)
                 XCTAssertEqual(error.serverInfo?[.severity], "ERROR")
             }
diff --git a/Tests/PostgresNIOTests/New/PostgresErrorTests.swift b/Tests/PostgresNIOTests/New/PostgresErrorTests.swift
