How to get notified on CKError.quotaExceeded

We would expect you to use NSPersistentCloudKitContainerEvent for this. You would observe event change notifications and see that the event failed with an error.

Thank you for your reply. I have tried something like the following, however the "quotaExceeded" never gets printed even though the above error message does. I can see also that the code enters the .partialFailure section of the if, however ckerror.partialErrorsByItemID is always nil or an empty list. Any suggests on how to unpack the error and get to the underlying .quotaExceeded?

class SyncMonitor {
    /// Where we store Combine cancellables for publishers we're listening to, e.g. NSPersistentCloudKitContainer's notifications.
    fileprivate var disposables = Set<AnyCancellable>()

    init() {
        NotificationCenter.default.publisher(for: NSPersistentCloudKitContainer.eventChangedNotification)
            .sink(receiveValue: { notification in
                
                print("notification: \(notification)")
                
                if let cloudEvent = notification.userInfo?[NSPersistentCloudKitContainer.eventNotificationUserInfoKey]
                    as? NSPersistentCloudKitContainer.Event {
                    // NSPersistentCloudKitContainer sends a notification when an event starts, and another when it
                    // ends. If it has an endDate, it means the event finished.
                    if cloudEvent.endDate == nil {
                        print("Starting an event...") // You could check the type, but I'm trying to keep this brief.
                    } else {
                        switch cloudEvent.type {
                        case .setup:
                            print("Setup finished!")
                        case .import:
                            print("An import finished!")
                        case .export:
                            print("An export finished!")
                        @unknown default:
                            assertionFailure("NSPersistentCloudKitContainer added a new event type.")
                        }

                        if cloudEvent.succeeded {
                            print("And it succeeded!")
                        } else {
                            print("But it failed!")
                        }

                        if let error = cloudEvent.error {
                            print("Error: \(error.localizedDescription)")
                            
                            guard let ckerror = error as? CKError else {
                                return
                            }

                            print("Error: code: \(ckerror.code), \(ckerror.localizedDescription)")
                            if ckerror.code == .partialFailure {
                                guard let errors = ckerror.partialErrorsByItemID else {
                                    return
                                }
                            
                                for (_, error) in errors {
                                    if let currentError = error as? CKError {
                                        print(currentError.localizedDescription)
                                    }
                                }
                            } else if ckerror.code == .quotaExceeded {
                                print("quotaExceeded")
                            }
                        }
                    }
                }
            })
            .store(in: &disposables)
    }
}

I am testing the same thing with a user that has a maxed out iCloud storage.

The eventChangedNotification received only mentions a partialFailure without any CKPartialErrorsByItemIDKey so there doesn't seem to be a way to come to the conclusion that the issue is with the storage quota being exceeded just by listening those notifications, is there? Is the only way trying to manually write to cloudkit and analysing the error received? If so, why is there a .quotaExceeded code for the notifications?

*** debugDescription print of the notification: NSPersistentCloudKitContainer.eventChangedNotification received: name = NSPersistentCloudKitContainerEventChangedNotification, object = Optional(<***>), userInfo = Optional([AnyHashable("event"): <NSPersistentCloudKitContainerEvent: 0x300d186e0> { type: Export store: C947EFBD-BE17-49EF-807B-087A62EBF0DE started: 2024-06-13 01:39:23 +0000 ended: 2024-06-13 01:39:28 +0000 succeeded: NO error: CKErrorDomain:2 }])

*** debug output from console: error: CoreData+CloudKit: -[NSCloudKitMirroringDelegate _recoverFromPartialError:forStore:inMonitor:] 2812: <NSCloudKitMirroringDelegate: 0x301114870>: Error recovery failed because the following fatal errors were found: { "<CKRecordID: 0x302e99dc0; recordName=61920C45-377E-4E1F-BD51-8E4E0D290B59, zoneID=com.apple.coredata.cloudkit.share.3DA846A5-15EC-409D-9160-E1764FFA74BC:defaultOwner>" = "<CKError 0x302090f90: "Quota Exceeded" (25/2035); server message = "Quota exceeded"; op = ADC86A29FF3777F8; uuid = 7C016545-FF26-4B11-B475-A15B770DDC25; Retry after 344.0 seconds; container ID = "xxxx">"; [...]

Any luck figuring this out? It seems very odd that there's no simple way to get a notification.

I'm seeing the same as the other engineers, this is shown in the Console:

error: CoreData+CloudKit: -[NSCloudKitMirroringDelegate _requestAbortedNotInitialized:](2191): <NSCloudKitMirroringDelegate: 0x28299c000> - Never successfully initialized and cannot execute request '<NSCloudKitMirroringExportRequest: 0x2835bc8c0> 5E186BF6-7A7E-49FE-9FBD-1FA163B49685' due to error: <CKError 0x281870fc0: "Partial Failure" (2/1011); "Failed to modify some records"; uuid = 279208A9-3E17-4B25-90AB-BBB4FD18ABDC; container ID = "iCloud.se.jagcesar.mat"; partial errors: {
	6106D943-E708-42F9-A661-A62AE82EBA86:(com.apple.coredata.cloudkit.zone:__defaultOwner__) = <CKError 0x281871620: "Quota Exceeded" (25/2035); server message = "Quota exceeded"; op = 72544197A933D70D; uuid = 279208A9-3E17-4B25-90AB-BBB4FD18ABDC; Retry after 343.0 seconds>
}>

This error says Quota Exceeded:

<CKError 0x281871620: "Quota Exceeded" (25/2035);

But we only receive an NSPersistentCloudKitContainerEvent with CKError 2

<NSPersistentCloudKitContainerEvent: 0x2835b6a30> { type: Export store: 4D7F0616-0DB0-44DB-B68B-EE4420E66B80 started: 2024-07-25 12:22:43 +0000 ended: 2024-07-25 12:22:44 +0000 succeeded: NO error: CKErrorDomain:2 }

We need to be able to inform our users that syncing isn't working because they're out of iCloud Storage.