AsyncOperationTracer

Package.swift

@@ -1,4 +1,4 @@
-// swift-tools-version:5.8
+// swift-tools-version:5.10
 // The swift-tools-version declares the minimum version of Swift required to build this package.
 
 import PackageDescription
@@ -8,8 +8,6 @@ let package = Package(
     platforms: [
         .iOS(.v15),
         .macOS(.v13),
-        .tvOS(.v14),
-        .watchOS(.v7)
     ],
     products: [
         .library(

Sources/BSWInterfaceKit/Model/Photo.swift

@@ -169,3 +169,8 @@ extension CGSize: Hashable { // For some reason `CGSize` isn't `Hashable`
 extension Photo: Equatable, Hashable {}
 extension Photo.Kind: Equatable, Hashable {}
 extension Photo.PlaceholderImage: Equatable, Hashable {}
+
+
+#if canImport(AppKit)
+extension PlatformImage: @unchecked Sendable {}
+#endif

Sources/BSWInterfaceKit/SwiftUI/Tracking/AsyncOperationTracer.swift

@@ -0,0 +1,58 @@
+
+/// Hook this up in in `AppDelegate.didFinishLaunching`
+/// to your preferred tacking framework in order to trace Async operations
+public enum AsyncOperationTracer {
+
+    public static nonisolated func setOperationDidBegin(_ op: @escaping OperationHandler) {
+        Task { @AsyncOperationTracerStorageActor in
+            AsyncOperationTracer.operationDidBegin = op
+        }
+    }
+
+    public static nonisolated func setOperationDidEnd(_ op: @escaping OperationHandler) {
+        Task { @AsyncOperationTracerStorageActor in
+            AsyncOperationTracer.operationDidEnd = op
+        }
+    }
+
+    public static nonisolated func setOperationDidFail(_ op: @escaping OperationFailedHandler) {
+        Task { @AsyncOperationTracerStorageActor in
+            AsyncOperationTracer.operationDidFail = op
+        }
+    }
+
+    public typealias OperationHandler = @Sendable (Operation) async -> ()
+    public typealias OperationFailedHandler = @Sendable (Operation, any Error) async -> ()
+
+    public struct Operation: Sendable {
+
+        public let kind: Kind
+        public let id: any (Equatable & Sendable)
+
+        public enum Kind: Sendable {
+            case viewLoading
+            case buttonAction
+        }
+
+        public var traceValue: String {
+            switch self.kind {
+            case .buttonAction:
+                return "async-button-\(self.id)"
+            case .viewLoading:
+                return "async-view-\(self.id)"
+            }
+        }
+    }
+
+    @AsyncOperationTracerStorageActor
+    static var operationDidBegin: OperationHandler = { _ in }
+    @AsyncOperationTracerStorageActor
+    static var operationDidEnd: OperationHandler = { _ in }
+
+    @AsyncOperationTracerStorageActor
+    static var operationDidFail: OperationFailedHandler = { _, _ in }
+}
+
+@globalActor actor AsyncOperationTracerStorageActor: GlobalActor {
+    static let shared = AsyncOperationTracerStorageActor()
+}

Sources/BSWInterfaceKit/SwiftUI/Views/AsyncButton.swift

@@ -62,10 +62,20 @@ public struct AsyncButton<Label: View>: View {
         }
         #endif
         let result: Swift.Result<Void, Swift.Error> = await {
+            if let operation = operation {
+                await AsyncOperationTracer.operationDidBegin(operation)
+            }
             do {
                 try await action()
+                if let operation = operation {
+                    await AsyncOperationTracer.operationDidEnd(operation)
+                }
                 return .success(())
             } catch {
+                if let operation = operation {
+                    await AsyncOperationTracer.operationDidEnd(operation)
+                    await AsyncOperationTracer.operationDidFail(operation, error)
+                }
                 return .failure(error)
             }
         }()
@@ -125,6 +135,16 @@ public struct AsyncButton<Label: View>: View {
             .ignoresSafeArea()
         }
     }
+
+    @Environment(\.asyncButtonOperationIdentifierKey)
+    private var operationKey
+
+    private var operation: AsyncOperationTracer.Operation? {
+        guard let operationKey else {
+            return nil
+        }
+        return .init(kind: .buttonAction, id: operationKey)
+    }
 
 #if canImport(UIKit)
     @MainActor
@@ -205,18 +225,31 @@ public extension View {
     func asyncButtonLoadingConfiguration(message: String? = nil, style: AsyncButtonLoadingConfiguration.Style = .nonblocking) -> some View {
         self.environment(\.asyncButtonLoadingConfiguration, .init(message: message, style: style))
     }
+
+    func asyncButtonOperationIdentifierKey(_ key: String) -> some View {
+        self.environment(\.asyncButtonOperationIdentifierKey, key)
+    }
 }
 
 private struct AsyncButtonLoadingStyleEnvironmentKey: EnvironmentKey {
     static let defaultValue: AsyncButtonLoadingConfiguration = .init()
 }
 
+private struct AsyncButtonOperationIdentifierKey: EnvironmentKey {
+    static let defaultValue: String? = nil
+}
+
 private extension EnvironmentValues {
 
     var asyncButtonLoadingConfiguration: AsyncButtonLoadingConfiguration {
         get { self[AsyncButtonLoadingStyleEnvironmentKey.self] }
         set { self[AsyncButtonLoadingStyleEnvironmentKey.self] = newValue }
     }
+
+    var asyncButtonOperationIdentifierKey: String? {
+        get { self[AsyncButtonOperationIdentifierKey.self] }
+        set { self[AsyncButtonOperationIdentifierKey.self] = newValue }
+    }
 }
 
 private extension Swift.Result where Failure == Error {

Sources/BSWInterfaceKit/SwiftUI/Views/AsyncView.swift

@@ -57,7 +57,7 @@ struct RecipeListView: View, PlaceholderDataProvider {
 /// To do so, implement `generatePlaceholderData()` from `PlaceholderDataProvider` protocol
 ///
 @MainActor
-public struct AsyncView<Data: Sendable, HostedView: View, ErrorView: View, LoadingView: View, ID: Equatable>: View {
+public struct AsyncView<Data: Sendable, HostedView: View, ErrorView: View, LoadingView: View, ID: Equatable & Sendable>: View {
 
     /// Represents the state of this view
     struct Operation {
@@ -165,6 +165,9 @@ public struct AsyncView<Data: Sendable, HostedView: View, ErrorView: View, Loadi
         withAnimation {
             currentOperation.phase = .loading
         }
+
+        let operation = AsyncOperationTracer.Operation(kind: .viewLoading, id: id)
+        await AsyncOperationTracer.operationDidBegin(operation)
         do {
             let finalData = try await dataGenerator()
             withAnimation {
@@ -175,10 +178,12 @@ public struct AsyncView<Data: Sendable, HostedView: View, ErrorView: View, Loadi
         } catch let error where error.isURLCancelled {
             /// Do nothing as we handle this `.task`
         } catch {
+            await AsyncOperationTracer.operationDidFail(operation, error)
             withAnimation {
                 currentOperation.phase = .error(error)
             }
         }
+        await AsyncOperationTracer.operationDidEnd(operation)
     }
 }
 

Tests/BSWInterfaceKitTests/Errors.swift

@@ -0,0 +1,8 @@
+
+import Foundation
+
+struct SomeError: LocalizedError {
+    var errorDescription: String? {
+        return "Some Error"
+    }
+}

Tests/BSWInterfaceKitTests/Suite/UIViewControllerTaskTests.swift

@@ -55,7 +55,7 @@ class UIViewControllerTaskTests: BSWSnapshotTest {
     }
 
     func testTaskErrorView() {
-        let vc = MockVC(taskGenerator: { throw "Some Error" })
+        let vc = MockVC(taskGenerator: { throw SomeError() })
         waitABitAndVerify(viewController: vc, testDarkMode: false)
     }
 

Tests/BSWInterfaceKitTests/Suite/UIViewControllerTests.swift

@@ -71,7 +71,7 @@ class UIViewControllerTests: BSWSnapshotTest {
         let vc = TestViewController()
         var buttonConfig = UIButton.Configuration.plain()
         buttonConfig.title = "Retry"
-        vc.showErrorMessage("Something Failed", error: "Some Error", retryButton: buttonConfig)
+        vc.showErrorMessage("Something Failed", error: SomeError(), retryButton: buttonConfig)
         waitABitAndVerify(viewController: vc, testDarkMode: false)
     }
 
@@ -192,8 +192,4 @@ private class ContentVC: UIViewController {
     }
 }
 
-extension String: LocalizedError {
-
-}
-
 #endif