feat: Swift error names

CHANGELOG.md

@@ -4,6 +4,24 @@
 
 ### Features
 
+- Swift Error Names (#2960)
+
+Instead of only the Swift error name and error code, the SDK now sends the Swift error name for enum-based errors.
+
+```Swift
+enum LoginError: Error {
+    case wrongUser
+    case wrongPassword
+}
+
+SentrySDK.capture(error: LoginError.wrongPassword)
+```
+
+Capturing the above Swift error will now result in the following error message in Sentry: `wrongPassword (Code: 1)` instead of only `(Code: 1)`.
+[Customized error descriptions](https://docs.sentry.io/platforms/apple/usage/#customizing-error-descriptions) have precedence over this feature.
+To avoid sending PII by accident, the SDK doesn't send the Swift error name for struct-based Swift errors, and the SDK drops the values of enums.
+This change has no impact on grouping of the issues in Sentry.
+
 - Create User and Breadcrumb from map (#2820)
 
 ### Fixes 

Samples/iOS-Swift/iOS-Swift/Tools/RandomErrors.swift

@@ -6,23 +6,6 @@ enum SampleError: Error {
     case awesomeCentaur
 }
 
-extension SampleError: CustomNSError {
-    var errorUserInfo: [String: Any] {
-        func getDebugDescription() -> String {
-            switch self {
-            case SampleError.bestDeveloper:
-                return  "bestDeveloper"
-            case .happyCustomer:
-                return  "happyCustomer"
-            case .awesomeCentaur:
-                return "awesomeCentaur"
-            }
-        }
-
-        return [NSDebugDescriptionErrorKey: getDebugDescription()]
-    }
-}
-
 class RandomErrorGenerator {
 
     static func generate() throws {

Sources/Sentry/SentryClient.m

@@ -35,6 +35,7 @@
 #import "SentrySDK+Private.h"
 #import "SentryScope+Private.h"
 #import "SentryStacktraceBuilder.h"
+#import "SentrySwift.h"
 #import "SentryThreadInspector.h"
 #import "SentryTraceContext.h"
 #import "SentryTracer.h"
@@ -248,9 +249,22 @@ - (SentryEvent *)buildErrorEvent:(NSError *)error
 
     // If the error has a debug description, use that.
     NSString *customExceptionValue = [[error userInfo] valueForKey:NSDebugDescriptionErrorKey];
+
+    NSString *swiftErrorDescription = nil;
+    // SwiftNativeNSError is the subclass of NSError used to represent bridged native Swift errors,
+    // see
+    // https://github.com/apple/swift/blob/067e4ec50147728f2cb990dbc7617d66692c1554/stdlib/public/runtime/ErrorObject.mm#L63-L73
+    NSString *errorClass = NSStringFromClass(error.class);
+    if ([errorClass containsString:@"SwiftNativeNSError"]) {
+        swiftErrorDescription = [SwiftDescriptor getSwiftErrorDescription:error];
+    }
+
     if (customExceptionValue != nil) {
         exceptionValue =
             [NSString stringWithFormat:@"%@ (Code: %ld)", customExceptionValue, (long)error.code];
+    } else if (swiftErrorDescription != nil) {
+        exceptionValue =
+            [NSString stringWithFormat:@"%@ (Code: %ld)", swiftErrorDescription, (long)error.code];
     } else {
         exceptionValue = [NSString stringWithFormat:@"Code: %ld", (long)error.code];
     }

Sources/Swift/SwiftDescriptor.swift

@@ -8,4 +8,20 @@ public class SwiftDescriptor: NSObject {
         return String(describing: type(of: object))
     }
 
+    @objc
+    public static func getSwiftErrorDescription(_ error: Error) -> String? {
+        let description = String(describing: error)
+
+        // We can't reliably detect what is PII in a struct and what is not.
+        // Furthermore, we can't detect which property contains the error enum.
+        if description.contains(":") || description.contains(",") {
+            return nil
+        }
+
+        // For error enums the description could contain PII in between (). Therefore,
+        // we strip the data.
+        let index = description.firstIndex(of: "(") ?? description.endIndex
+        return String(description[..<index])
+    }
+
 }

Tests/SentryTests/SentryClientTests.swift

@@ -415,7 +415,7 @@ class SentryClientTest: XCTestCase {
         eventId.assertIsNotEmpty()
         let error = TestError.invalidTest as NSError
         assertLastSentEvent { actual in
-            assertValidErrorEvent(actual, error)
+            assertValidErrorEvent(actual, error, exceptionValue: "invalidTest (Code: 0)")
         }
     }
 
@@ -456,6 +456,63 @@ class SentryClientTest: XCTestCase {
             }
         }
     }
+
+    func testCaptureSwiftError_UsesSwiftStringDescription() {
+        let eventId = fixture.getSut().capture(error: SentryClientError.someError)
+
+        eventId.assertIsNotEmpty()
+        assertLastSentEvent { actual in
+            do {
+                let exceptions = try XCTUnwrap(actual.exceptions)
+                XCTAssertEqual("someError (Code: 1)", try XCTUnwrap(exceptions.first).value)
+            } catch {
+                XCTFail("Exception expected but was nil")
+            }
+        }
+    }
+
+    func testCaptureSwiftErrorStruct_DoesNotUseDescriptionToAvoidPII() {
+        let eventId = fixture.getSut().capture(error: XMLParsingError(line: 10, column: 12, kind: .internalError))
+
+        eventId.assertIsNotEmpty()
+        assertLastSentEvent { actual in
+            do {
+                let exceptions = try XCTUnwrap(actual.exceptions)
+                XCTAssertEqual("Code: 1", try XCTUnwrap(exceptions.first).value)
+            } catch {
+                XCTFail("Exception expected but was nil")
+            }
+        }
+    }
+
+    func testCaptureSwiftErrorWithData_UsesSwiftStringDescriptionStripped() {
+        let eventId = fixture.getSut().capture(error: SentryClientError.invalidInput("hello"))
+
+        eventId.assertIsNotEmpty()
+        assertLastSentEvent { actual in
+            do {
+                let exceptions = try XCTUnwrap(actual.exceptions)
+                XCTAssertEqual("invalidInput (Code: 0)", try XCTUnwrap(exceptions.first).value)
+            } catch {
+                XCTFail("Exception expected but was nil")
+            }
+        }
+    }
+
+    func testCaptureSwiftErrorWithDebugDescription_UsesDebugDescription() {
+
+        let eventId = fixture.getSut().capture(error: SentryClientErrorWithDebugDescription.someError)
+
+        eventId.assertIsNotEmpty()
+        assertLastSentEvent { actual in
+            do {
+                let exceptions = try XCTUnwrap(actual.exceptions)
+                XCTAssertEqual("anotherError (Code: 0)", try XCTUnwrap(exceptions.first).value)
+            } catch {
+                XCTFail("Exception expected but was nil")
+            }
+        }
+    }
 
     func testCaptureErrorWithComplexUserInfo() {
         let url = URL(string: "https://github.com/getsentry")!
@@ -1464,7 +1521,7 @@ class SentryClientTest: XCTestCase {
         }
     }
 
-    private func assertValidErrorEvent(_ event: Event, _ error: NSError) {
+    private func assertValidErrorEvent(_ event: Event, _ error: NSError, exceptionValue: String? = nil) {
         XCTAssertEqual(SentryLevel.error, event.level)
         XCTAssertEqual(error, event.error as NSError?)
 
@@ -1475,7 +1532,7 @@ class SentryClientTest: XCTestCase {
         let exception = exceptions[0]
         XCTAssertEqual(error.domain, exception.type)
 
-        XCTAssertEqual("Code: \(error.code)", exception.value)
+        XCTAssertEqual(exceptionValue ?? "Code: \(error.code)", exception.value)
 
         XCTAssertNil(exception.threadId)
         XCTAssertNil(exception.stacktrace)
@@ -1565,4 +1622,26 @@ class SentryClientTest: XCTestCase {
 
 }
 
+enum SentryClientError: Error {
+    case someError
+    case invalidInput(String)
+}
+
+enum SentryClientErrorWithDebugDescription: Error {
+    case someError
+}
+
+extension SentryClientErrorWithDebugDescription: CustomNSError {
+    var errorUserInfo: [String: Any] {
+        func getDebugDescription() -> String {
+            switch self {
+            case .someError:
+                return  "anotherError"
+            }
+        }
+
+        return [NSDebugDescriptionErrorKey: getDebugDescription()]
+    }
+}
+
 // swiftlint:enable file_length

Tests/SentryTests/SwiftDescriptorTests.swift

@@ -28,7 +28,61 @@ class SwiftDescriptorTests: XCTestCase {
         XCTAssertEqual(name, "InnerClass")
     }
 
+    func testgetSwiftErrorDescription_EnumValue() {
+        let actual = SwiftDescriptor.getSwiftErrorDescription(SentryTestError.someError)
+        XCTAssertEqual("someError", actual)
+    }
+
+    func testgetSwiftErrorDescription_EnumValueWithData() {
+        let actual = SwiftDescriptor.getSwiftErrorDescription(SentryTestError.someOhterError(10))
+        XCTAssertEqual("someOhterError", actual)
+    }
+
+    func testgetSwiftErrorDescription_StructWithData() {
+        let actual = SwiftDescriptor.getSwiftErrorDescription(XMLParsingError(line: 10, column: 12, kind: .internalError))
+        XCTAssertNil(actual)
+
+        SentrySDK.capture(error: LoginError.wrongPassword)
+    }
+
+    func testgetSwiftErrorDescription_StructWithOneParam() {
+        let actual = SwiftDescriptor.getSwiftErrorDescription(StructWithOneParam(line: 10))
+        XCTAssertNil(actual)
+    }
+
     private func sanitize(_ name: AnyObject) -> String {
         return SwiftDescriptor.getObjectClassName(name)
     }
 }
+
+enum SentryTestError: Error {
+    case someError
+    case someOhterError(Int)
+}
+
+enum LoginError: Error {
+    case wrongUser
+    case wrongPassword
+}
+
+struct XMLParsingError: Error {
+    enum ErrorKind {
+        case invalidCharacter
+        case mismatchedTag
+        case internalError
+    }
+
+    let line: Int
+    let column: Int
+    let kind: ErrorKind
+}
+
+struct StructWithOneParam: Error {
+    enum ErrorKind {
+        case invalidCharacter
+        case mismatchedTag
+        case internalError
+    }
+
+    let line: Int
+}