Possible memory leak in SyncEngine?

[seanmrich]

After adding a SyncEngine to the bootstrap function in my app, I started getting "SQLite error 14: unable to open database" randomly scattered among my unit tests. I believe I've narrowed this down to the fact that SyncEngine isn't getting released so the file descriptors keep building up until the OS complains. The console output looks like this:

cannot open file at line 51043 of [f0ca7bba1c]
os_unix.c:51043: (24) open(/private/var/folders/7z/nbpvb51n2dg32m9wtsm61vpm0000gn/T/.603DC681-CE52-4F02-93BC-06FDB980F66F.metadata-iCloud.dev.sync-engine-bootstrap.sqlite) - Too many open files

Here's a simple one-file demo of the issue:

struct BootstrapTests {
  @Test func bootstrap() throws {
    for i in 0..<2000 {
      do {
        let database = try defaultDatabase()
        try migrate(database)
        _ = try SyncEngine(
          for: database,
          tables: BootstrapRecord.self,
          containerIdentifier: .containerIdentifier,
          startImmediately: false
        )
      } catch {
        print("Index \(i)")
        reportIssue(error)
        break
      }
    }
  }
}

func migrate(_ database: some DatabaseWriter) throws {
  var migrator = DatabaseMigrator()
  migrator.registerMigration("Create bootstrapRecords table") { db in
    try #sql(
      """
      CREATE TABLE "bootstrapRecords" (
        "id" TEXT PRIMARY KEY NOT NULL ON CONFLICT REPLACE DEFAULT (uuid()),
        "title" TEXT NOT NULL
      ) STRICT
      """
    )
    .execute(db)
  }
  try migrator.migrate(database)
}

extension String {
  static let containerIdentifier = "iCloud.dev.sync-engine-bootstrap"
}

@Table
struct BootstrapRecord: Equatable, Identifiable, Sendable {
  let id: UUID
  var title: String
}

Ideally the SyncEngine would be released at the end of each loop, but instead they pile up until the error is produced. You get the same result when you do this across a similar number of individual tests instead of in a loop (it's just much slower). I also wrote this test to check the release of the engine:

@Test func closeDb() throws {
  weak var weakSyncEngine: SyncEngine?
  do {
    let database = try defaultDatabase()
    try migrate(database)
    var syncEngine: SyncEngine? = try SyncEngine(
      for: database,
      tables: BootstrapRecord.self,
      containerIdentifier: .containerIdentifier,
      startImmediately: false
    )
    weakSyncEngine = syncEngine
    syncEngine = nil
    #expect(weakSyncEngine != nil)
    try database.close()
  }
  #expect(weakSyncEngine == nil)
}

In my testing, closeDb passes which means the sync engine is not released until the database is explicitly closed. Looking through the code it appears the leak may be related to the database functions registered in setUpSyncEngine(writableDB:). The sync engine retains the user database, the database retains the functions, and the functions capture self (the sync engine) giving you a retain cycle.

Tested using the main branch of SQLiteData using Xcode 26.3.

[mbrandonw]

Hi @seanmrich, surprisingly it seems that CKSyncEngine.Configuration's delegate is not weak, and so maybe that's the leak. SyncEngine strongly holds onto a CKSyncEngine, which in turns strongly holds onto SyncEngine as a delegate.

I'm not 100% certain of the fix right now.