Restored Gem Output

.github/workflows/swift.yml

@@ -11,20 +11,33 @@ jobs:
 
   Swift-Package:
     strategy:
+      fail-fast: false
       matrix:
-        os: [macos-15, ubuntu-latest]
+        os: [macos-26, ubuntu-latest]
 
     runs-on: ${{ matrix.os }}
 
     steps:
     - name: Checkout
-      uses: actions/checkout@v4
-
-    - name: Resolve Packages
+      uses: actions/checkout@v6
+
+    - name: Cache
+      uses: actions/cache@v5
+      with:
+        path: |
+          .build
+          ~/Library/Developer/Xcode/DerivedData/ModuleCache.noindex
+          ~/Library/Caches/org.swift.swiftpm
+          ~/Library/org.swift.swiftpm
+        key: ${{ runner.os }}-spm-${{ hashFiles('**/Package.resolved') }}
+        restore-keys: |
+          ${{ runner.os }}-spm-
+
+    - name: Package Resolution
       run: swift package resolve
 
-    - name: Compile Source
+    - name: Build
       run: swift build
 
-    - name: Run Tests
+    - name: Test
       run: swift test

Package.swift

@@ -1,4 +1,4 @@
-// swift-tools-version:5.9
+// swift-tools-version:6.2
 // The swift-tools-version declares the minimum version of Swift required to build this package.
 
 import PackageDescription
@@ -22,9 +22,11 @@ let package = Package(
     dependencies: [
         // Dependencies declare other packages that this package depends on.
         // .package(url: /* package url */, from: "1.0.0"),
-        .package(url: "https://github.com/apple/swift-log.git", .upToNextMajor(from: "1.6.4")),
-        .package(url: "https://github.com/richardpiazza/Statement.git", .upToNextMajor(from: "0.8.1")),
-        .package(url: "https://github.com/stephencelis/SQLite.swift.git", .upToNextMajor(from: "0.15.3")),
+        .package(url: "https://github.com/swiftlang/swift-toolchain-sqlite.git", from: "1.0.7"),
+        .package(url: "https://github.com/apple/swift-log.git", from: "1.9.1"),
+        .package(url: "https://github.com/richardpiazza/Statement.git", from: "0.8.1"),
+        .package(url: "https://github.com/stephencelis/SQLite.swift.git", from: "0.15.5", traits: ["SwiftToolchainCSQLite"]),
+        .package(url: "https://github.com/swhitty/swift-mutex.git", from: "0.0.6"),
     ],
     targets: [
         // Targets are the basic building blocks of a package. A target can define a module or a test suite.
@@ -36,10 +38,7 @@ let package = Package(
                 .product(name: "Statement", package: "Statement"),
                 .product(name: "StatementSQLite", package: "Statement"),
                 .product(name: "SQLite", package: "SQLite.swift"),
-            ],
-            swiftSettings: [
-                .enableExperimentalFeature("ExistentialAny"),
-                .enableExperimentalFeature("StrictConcurrency=complete"),
+                .product(name: "Mutex", package: "swift-mutex"),
             ]
         ),
         .testTarget(
@@ -51,3 +50,13 @@ let package = Package(
         ),
     ]
 )
+
+for target in package.targets {
+    var settings = target.swiftSettings ?? []
+    settings.append(contentsOf: [
+        .enableUpcomingFeature("ExistentialAny"),
+        .enableUpcomingFeature("MemberImportVisibility"),
+        .enableUpcomingFeature("StrictConcurrency=complete"),
+    ])
+    target.swiftSettings = settings
+}

Sources/Occurrence/CoreData/CoreDataLogProvider.swift

@@ -1,18 +1,14 @@
 import Foundation
 import Logging
+import Mutex
 #if canImport(CoreData)
 @preconcurrency import CoreData
 
-class CoreDataLogProvider: LogProvider {
+final class CoreDataLogProvider: LogProvider {
 
     let storeUrl: URL
-    private var persistentContainer: NSPersistentContainer
-
-    private lazy var context: NSManagedObjectContext = {
-        let context = persistentContainer.newBackgroundContext()
-        context.automaticallyMergesChangesFromParent = true
-        return context
-    }()
+    private let persistentContainer: Mutex<NSPersistentContainer>
+    private let context: Mutex<NSManagedObjectContext>
 
     init(url: URL? = nil) throws {
         storeUrl = try url ?? FileManager.default.defaultDatabaseUrl()
@@ -38,11 +34,16 @@ class CoreDataLogProvider: LogProvider {
         }
 
         container.viewContext.automaticallyMergesChangesFromParent = true
-        persistentContainer = container
+        persistentContainer = Mutex(container)
+
+        let backgroundContext = container.newBackgroundContext()
+        backgroundContext.automaticallyMergesChangesFromParent = true
+        context = Mutex(backgroundContext)
     }
 
     deinit {
-        let context = persistentContainer.viewContext
+        let container = persistentContainer.withLock { $0 }
+        let context = container.viewContext
         context.performAndWait {
             if context.hasChanges {
                 do {
@@ -53,7 +54,7 @@ class CoreDataLogProvider: LogProvider {
             }
         }
 
-        let coordinator = persistentContainer.persistentStoreCoordinator
+        let coordinator = container.persistentStoreCoordinator
         let stores = coordinator.persistentStores
         do {
             for store in stores {
@@ -74,27 +75,30 @@ class CoreDataLogProvider: LogProvider {
         }
     }
 
-    public func log(_ entry: Logger.Entry) {
-        context.performAndWait {
+    func log(_ entry: Logger.Entry) {
+        let backgroundContext = context.withLock { $0 }
+        backgroundContext.performAndWait {
             do {
-                try ManagedEntry(context: context, entry: entry)
-                try context.save()
+                try ManagedEntry(context: backgroundContext, entry: entry)
+                try backgroundContext.save()
             } catch {
                 print(error)
             }
         }
     }
 
-    public func subsystems() -> [Logger.Subsystem] {
+    func subsystems() -> [Logger.Subsystem] {
         let request = NSFetchRequest<any NSFetchRequestResult>(entityName: ManagedEntry.fetchRequest().entityName ?? "ManagedEntry")
         request.resultType = .dictionaryResultType
         request.propertiesToFetch = [#keyPath(ManagedEntry.subsystem)]
         request.returnsDistinctResults = true
 
-        let subsystems = context.performAndWait {
+        let backgroundContext = context.withLock { $0 }
+
+        let subsystems = backgroundContext.performAndWait {
             var subsystems: Set<Logger.Subsystem> = [.occurrence]
             do {
-                let results = try context.fetch(request) as? [[String: String]]
+                let results = try backgroundContext.fetch(request) as? [[String: String]]
                 results?
                     .compactMap { $0[#keyPath(ManagedEntry.subsystem)] }
                     .map { Logger.Subsystem($0) }
@@ -110,7 +114,7 @@ class CoreDataLogProvider: LogProvider {
         return Array(subsystems)
     }
 
-    public func entries(matching filter: Logger.Filter?, ascending: Bool, limit: UInt) -> [Logger.Entry] {
+    func entries(matching filter: Logger.Filter?, ascending: Bool, limit: UInt) -> [Logger.Entry] {
         let request = ManagedEntry.fetchRequest()
         request.predicate = filter?.predicate
         request.sortDescriptors = [
@@ -120,10 +124,12 @@ class CoreDataLogProvider: LogProvider {
             request.fetchLimit = Int(limit)
         }
 
-        let results = context.performAndWait {
+        let backgroundContext = context.withLock { $0 }
+
+        let results = backgroundContext.performAndWait {
             var results: [Logger.Entry] = []
             do {
-                let entries = try context.fetch(request)
+                let entries = try backgroundContext.fetch(request)
                 results = entries.map(\.entry)
             } catch {
                 print(error)
@@ -134,18 +140,20 @@ class CoreDataLogProvider: LogProvider {
         return results
     }
 
-    public func purge(matching filter: Logger.Filter?) {
+    func purge(matching filter: Logger.Filter?) {
         let request = ManagedEntry.fetchRequest()
         request.predicate = filter?.predicate
 
-        context.performAndWait {
+        let backgroundContext = context.withLock { $0 }
+
+        backgroundContext.performAndWait {
             do {
-                let entities = try context.fetch(request)
+                let entities = try backgroundContext.fetch(request)
                 for entity in entities {
-                    context.delete(entity)
+                    backgroundContext.delete(entity)
                 }
-                if context.hasChanges {
-                    try context.save()
+                if backgroundContext.hasChanges {
+                    try backgroundContext.save()
                 }
             } catch {
                 print(error)

Sources/Occurrence/CoreData/LogModel.swift

@@ -1,11 +1,12 @@
 import Foundation
+import Mutex
 #if canImport(CoreData)
 import CoreData
 
 enum LogModel {
     case version_1_0_0
 
-    static var `default`: LogModel = .version_1_0_0
+    static var `default`: LogModel { .version_1_0_0 }
 
     var managedObjectModel: NSManagedObjectModel {
         switch self {
@@ -15,9 +16,12 @@ enum LogModel {
 }
 
 class Version_1_0_0: NSManagedObjectModel, NSSecureCoding {
+    private static let protectedState = Mutex(Version_1_0_0())
     /// Provide a singular instance of the model to be referenced. There is a known issue where when referencing
     /// a model in an app target, as well as unit tests, a model - and therefore its entities - can be loaded twice.
-    static let instance: Version_1_0_0 = Version_1_0_0()
+    static var instance: Version_1_0_0 {
+        protectedState.withLock { $0 }
+    }
 
     static var supportsSecureCoding: Bool { true }
 

Sources/Occurrence/Extensions/Logger+Entry.swift

@@ -74,7 +74,7 @@ extension Logger.Entry: CustomStringConvertible {
     public var description: String {
         let _date = Self.gmtDateFormatter.string(from: date)
         let sourceFile = [source, fileName].filter { !$0.isEmpty }.joined(separator: " ")
-        let output = "[\(_date) \(level) | \(subsystem) | \(sourceFile) | \(function) \(line)] \(message)"
+        let output = "[\(_date) \(level.fancyDescription) | \(subsystem) | \(sourceFile) | \(function) \(line)] \(message)"
         if let metadata {
             let sortedMetadata = metadata.sorted(by: { $0.key < $1.key })
             let values = sortedMetadata.map { "\($0.key): \($0.value)" }.joined(separator: ", ")

Sources/Occurrence/Extensions/Logger.Level+Occurrence.swift

@@ -20,18 +20,8 @@ public extension Logger.Level {
         let max = Logger.Level.allCases.map(\.rawValue.count).max() ?? rawValue.count
         return rawValue.padding(toLength: max, withPad: " ", startingAt: 0)
     }
-}
 
-#if hasFeature(RetroactiveAttribute)
-extension Logger.Level: @retroactive CustomStringConvertible {
-    public var description: String {
-        "\(gem) \(fixedWidthDescription.uppercased())"
-    }
-}
-#else
-extension Logger.Level: CustomStringConvertible {
-    public var description: String {
+    var fancyDescription: String {
         "\(gem) \(fixedWidthDescription.uppercased())"
     }
 }
-#endif

Sources/Occurrence/LogProvider.swift

@@ -2,7 +2,7 @@ import Foundation
 import Logging
 
 /// A source of logging data.
-public protocol LogProvider {
+public protocol LogProvider: Sendable {
     /// Consume a log entry.
     func log(_ entry: Logger.Entry)
 

Sources/Occurrence/LogStreamer.swift

@@ -1,22 +1,10 @@
 import Foundation
 import Logging
-#if canImport(Combine)
-import Combine
-#endif
 
-public protocol LogStreamer {
+public protocol LogStreamer: Sendable {
     /// `AsyncStream` which emits log entries.
-    ///
-    /// Due to limitations with the underlying `AsyncSequence` implementation, only a single receiver can await elements.
-    /// Each access will _finish_ an existing stream and return a fresh stream.
     var stream: AsyncStream<Logger.Entry> { get }
 
-    #if canImport(Combine)
-    /// Publisher which emits log entries.
-    @available(*, deprecated, message: "Use `AsyncStream` variant.")
-    var publisher: AnyPublisher<Logger.Entry, Never> { get }
-    #endif
-
     /// Consume a log entry.
     func log(_ entry: Logger.Entry)
 }