[#16044] Crashlytics Error Identity for Non-Fatals

Crashlytics/Crashlytics/FIRCrashlytics.m

@@ -432,8 +432,12 @@ - (void)recordError:(NSError *)error userInfo:(NSDictionary<NSString *, id> *)us
 
   NSString *rolloutsInfoJSON = [_remoteConfigManager getRolloutAssignmentsEncodedJsonString];
 
+  NSMutableDictionary *errorInfo = [userInfo mutableCopy] ?: [NSMutableDictionary dictionary];
+  NSString *swiftErrorIdentity = [FIRCLSErrorInspector getIdentityDescriptionForError:error];
+  if (swiftErrorIdentity) errorInfo[@"swift-error"] = swiftErrorIdentity;
+
   FIRCLSNonFatalError *nonFatalError = [[FIRCLSNonFatalError alloc] initWithError:error
-                                                                         userInfo:userInfo
+                                                                         userInfo:errorInfo
                                                                  rolloutsInfoJSON:rolloutsInfoJSON];
 
   [self waitForContextInit:@"recordError"

Crashlytics/Crashlytics/SwiftUtilities/ErrorInspector.swift

@@ -0,0 +1,73 @@
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import Foundation
+
+@objc(FIRCLSErrorInspector)
+public final class ErrorInspector: NSObject {
+  override private init() {
+    super.init()
+  }
+
+  /// Returns a short description of the error’s identity.
+  ///
+  /// The error identity is described as follows:
+  ///   * **True `NSError`s** and subclasses: `nil`
+  ///   (since we only describe the identity of errors declared as Swift types).
+  ///   * **Errors conforming to `CustomNSError`**: error domain + error code
+  ///   from protocol conformance (e.g. `CustomErrorDomain.123`).
+  ///   * Errors declared as **Swift enums**: type name + case name
+  ///   (e.g. `SomeErrorEnum.errorCase`); associated values are discarded.
+  ///   * Errors declared as **other Swift types**: type name + error code
+  ///   (e.g. `SomeErrorStruct.1`).
+  @objc(getIdentityDescriptionForError:)
+  public static func identityDescription(for error: any Error) -> String? {
+    let nsError = error as NSError
+    // Swift errors bridged to `NSError` have the `__SwiftNativeNSError` underlying type:
+    guard NSStringFromClass(type(of: nsError)).contains("SwiftNative") else {
+      // This is a true `NSError` (or its subclass), not a Swift error bridged to one.
+      // We only report the identity of errors declared as Swift types.
+      // See https://github.com/firebase/firebase-ios-sdk/pull/16045
+      return nil
+    }
+
+    // Always prioritize the custom domain and code if they’re available:
+    if let customNSError = error as? CustomNSError {
+      return "\(type(of: customNSError).errorDomain).\(customNSError.errorCode)"
+    }
+
+    // This is a Swift error bridged to `NSError`.
+    let typeLabel = String(describing: type(of: error))
+    let mirror = Mirror(reflecting: error)
+
+    guard mirror.displayStyle == .enum else {
+      // This error is not declared as an enum. We fall back onto the `NSError` bridge.
+      // `typeLabel` is used instead of `nsError.domain` for consistency
+      // (we only want the type name, not its parent types or module).
+      return "\(typeLabel).\(nsError.code)"
+    }
+
+    // The error is declared as an enum; we need to extract the case name.
+    if let caseLabel = mirror.children.first?.label {
+      // This enum case has an associated value. We don’t want it to affect the error’s identity:
+      // `someError(123)` and `someError(456)` should produce the same result `someError`.
+      // For enum cases with associated values, the bare case name is stored as the first child.
+      return "\(typeLabel).\(caseLabel)"
+    } else {
+      // For enum cases with no associated values, the `Mirror.children` array is empty;
+      // the case name can be retrieved using the synthesized `CustomStringConvertible` conformance.
+      return "\(typeLabel).\(error)"
+    }
+  }
+}

Crashlytics/UnitTestsSwift/ErrorInspectorTests.swift

@@ -0,0 +1,157 @@
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#if SWIFT_PACKAGE
+  @testable import FirebaseCrashlyticsSwift
+#else
+  @testable import FirebaseCrashlytics
+#endif
+
+import Foundation
+import Testing
+
+@Suite struct ErrorInspectorTests {
+  @Test(arguments: [
+    (.error1, "TestErrorEnum.error1"),
+    (.error2(999), "TestErrorEnum.error2"),
+    (.error3("TEST_AssociatedValue"), "TestErrorEnum.error3"),
+    (.error4(TestErrorClass()), "TestErrorEnum.error4"),
+    (.error5(1, "2", true), "TestErrorEnum.error5"),
+  ] as [(TestErrorEnum, String)]) func swiftEnumError(error: TestErrorEnum,
+                                                      expectedDescription: String) {
+    let description = ErrorInspector.identityDescription(for: error)
+
+    #expect(description == expectedDescription)
+  }
+
+  @Test(arguments: [
+    (.error1, "TEST_CustomErrorEnumDomain.987"),
+    (.error2(999), "TEST_CustomErrorEnumDomain.654"),
+  ] as [(TestCustomErrorEnum, String)]) func swiftCustomEnumError(error: TestCustomErrorEnum,
+                                                                  expectedDescription: String) {
+    let description = ErrorInspector.identityDescription(for: error)
+
+    #expect(description == expectedDescription)
+  }
+
+  @Test func swiftStructError() {
+    let description = ErrorInspector.identityDescription(
+      for: TestErrorStruct(value: 999)
+    )
+
+    #expect(description == "TestErrorStruct.1")
+  }
+
+  @Test func swiftClassError() {
+    let description = ErrorInspector.identityDescription(for: TestErrorClass())
+
+    #expect(description == "TEST_ErrorClassDomain.789")
+  }
+
+  @Test func nsError() {
+    let error = NSError(
+      domain: "TEST_NSError",
+      code: 123,
+      userInfo: [NSLocalizedDescriptionKey: "TEST_LocDesc"]
+    )
+
+    let description = ErrorInspector.identityDescription(for: error)
+
+    #expect(description == nil)
+  }
+
+  @Test func nsErrorSubclass() {
+    let error = TestNSError(
+      domain: "TEST_NSErrorSubclass",
+      code: 456,
+      userInfo: [NSLocalizedDescriptionKey: "TEST_LocDesc"]
+    )
+
+    let description = ErrorInspector.identityDescription(for: error)
+
+    #expect(description == nil)
+  }
+
+  // This is a known edge case. If an error inherits from `NSError`
+  // and at the same time uses `SwiftNative` in its class name,
+  // it will be treated as if it were a Swift `Error` bridged to `NSError`,
+  // i.e. the error’s identity will be based on its class name, not `domain`
+  // (but `domain` and all other properties remain intact and available).
+  @Test func nsErrorSubclassWithSpecialName() {
+    let error = TestSwiftNativeError(
+      domain: "TEST_NSErrorSubclass",
+      code: 789,
+      userInfo: [NSLocalizedDescriptionKey: "TEST_LocDesc"]
+    )
+
+    let description = ErrorInspector.identityDescription(for: error)
+
+    #expect(description == "TestSwiftNativeError.789")
+  }
+
+  // Error details from the `CustomNSError` conformance are always prioritized.
+  // Note that `NSError` doesn’t conform to `CustomNSError` out of the box.
+  @Test func nsErrorSubclassWithCustomNSErrorConformance() {
+    let error = TestNSErrorWithCustomNSError(
+      domain: "TEST_ErrorDomainFromInit",
+      code: 123,
+      userInfo: [NSLocalizedDescriptionKey: "TEST_LocDesc"]
+    )
+
+    let description = ErrorInspector.identityDescription(for: error)
+
+    #expect(description == nil)
+  }
+}
+
+enum TestErrorEnum: Error {
+  case error1
+  case error2(Int)
+  case error3(String)
+  case error4(Any)
+  case error5(Int, String, Bool)
+}
+
+enum TestCustomErrorEnum: CustomNSError {
+  case error1
+  case error2(Int)
+
+  static var errorDomain: String { "TEST_CustomErrorEnumDomain" }
+
+  var errorCode: Int {
+    switch self {
+    case .error1: 987
+    case .error2: 654
+    }
+  }
+}
+
+struct TestErrorStruct: Error {
+  let value: Int
+}
+
+class TestErrorClass: CustomNSError {
+  static var errorDomain: String { "TEST_ErrorClassDomain" }
+  var errorCode: Int { 789 }
+}
+
+class TestNSError: NSError, @unchecked Sendable {}
+
+// Having `SwiftNative` in the name is an edge case:
+class TestSwiftNativeError: NSError, @unchecked Sendable {}
+
+class TestNSErrorWithCustomNSError: NSError, CustomNSError, @unchecked Sendable {
+  static var errorDomain: String { "TEST_ErrorDomainFromProtocol" }
+  var errorCode: Int { 321 }
+}

Package.swift

@@ -580,7 +580,11 @@ func packageTargets() -> [Target] {
     .target(
       name: "FirebaseCrashlyticsSwift",
       dependencies: ["FirebaseRemoteConfigInterop"],
-      path: "Crashlytics/Crashlytics/Rollouts"
+      path: "Crashlytics/Crashlytics",
+      sources: [
+        "Rollouts",
+        "SwiftUtilities",
+      ]
     ),
     .testTarget(
       name: "FirebaseCrashlyticsSwiftUnit",
@@ -1416,6 +1420,7 @@ func firebaseCrashlyticsTarget() -> Target {
       "CrashlyticsInputFiles.xcfilelist",
       "third_party/libunwind/LICENSE",
       "Crashlytics/Rollouts",
+      "Crashlytics/SwiftUtilities",
     ],
     sources: [
       "Crashlytics",