refactor: cleanup prints and lint

fabriziodemaria · fabriziodemaria · commit e71d58ab5ff2 · 2025-11-11T16:56:04.000+01:00
Signed-off-by: Fabrizio Demaria &lt;fabrizio.f.demaria@gmail.com&gt;
diff --git a/Sources/OpenFeature/AsyncCoalescingSerialQueue.swift b/Sources/OpenFeature/AsyncCoalescingSerialQueue.swift
@@ -7,76 +7,27 @@ internal actor AsyncCoalescingSerialQueue {
     private var currentTask: Task<Void, Never>?
     private var pendingOperation: (() async -> Void)?
     private var pendingContinuations: [CheckedContinuation<Void, Never>] = []
-    private var operationCounter: Int = 0
-
-    /// Verbose mode controls whether debug logging is enabled
-    private let verbose: Bool
-
-    /// Initialize the queue with optional verbose logging
-    /// - Parameter verbose: If true, detailed debug logs will be printed with [ASQ] prefix
-    init(verbose: Bool = false) {
-        self.verbose = verbose
-    }
 
     /// Runs the given operation serially. If an operation is already running,
     /// this operation replaces any previously pending operation (which gets skipped).
     /// All callers whose operations were replaced will wait for the latest operation to complete.
     func run(_ operation: @Sendable @escaping () async -> Void) async {
         await withCheckedContinuation { continuation in
-            operationCounter += 1
-            let operationId = operationCounter
-
-            if verbose {
-                print("[ASQ] 🔵 run() called - Operation #\(operationId)")
-                print("[ASQ]   ├─ currentTask == nil: \(currentTask == nil)")
-                print("[ASQ]   ├─ pendingOperation == nil (before): \(pendingOperation == nil)")
-                print("[ASQ]   ├─ pendingContinuations.count (before): \(pendingContinuations.count)")
-            }
-
             // Replace any pending operation with this new one
-            let hadPendingOperation = pendingOperation != nil
             pendingOperation = operation
             pendingContinuations.append(continuation)
 
-            if verbose {
-                if hadPendingOperation {
-                    print("[ASQ]   ├─ ⚠️  REPLACED previous pending operation with Operation #\(operationId)")
-                } else {
-                    print("[ASQ]   ├─ ✓ Set Operation #\(operationId) as pending operation")
-                }
-                print("[ASQ]   ├─ pendingContinuations.count (after): \(pendingContinuations.count)")
-            }
-
             // If nothing is currently running, start processing
             if currentTask == nil {
-                if verbose {
-                    print("[ASQ]   └─ ▶️  No task running, calling processNext() for Operation #\(operationId)")
-                }
                 processNext()
-            } else {
-                if verbose {
-                    print("[ASQ]   └─ ⏸️  Task already running, Operation #\(operationId) will wait")
-                }
             }
         }
     }
 
     private func processNext() {
-        if verbose {
-            print("[ASQ] 🟢 processNext() called")
-            print("[ASQ]   ├─ pendingOperation == nil: \(pendingOperation == nil)")
-            print("[ASQ]   ├─ pendingContinuations.count: \(pendingContinuations.count)")
-        }
-
         guard let operation = pendingOperation else {
             // No pending work
-            if verbose {
-                print("[ASQ]   ├─ ⛔ No pending operation, cleaning up")
-            }
             currentTask = nil
-            if verbose {
-                print("[ASQ]   └─ ✓ currentTask set to nil, queue is now idle")
-            }
             return
         }
 
@@ -85,40 +36,16 @@ internal actor AsyncCoalescingSerialQueue {
         let continuations = pendingContinuations
         pendingContinuations = []
 
-        if verbose {
-            print("[ASQ]   ├─ ✓ Captured \(continuations.count) continuation(s) to resume")
-            print("[ASQ]   ├─ ✓ Cleared pendingOperation and pendingContinuations")
-            print("[ASQ]   └─ 🚀 Starting new Task to execute operation")
-        }
-
         // Start the task
-        currentTask = Task { [weak self, verbose] in
-            if verbose {
-                print("[ASQ]     🔄 Task execution started")
-            }
+        currentTask = Task { [weak self] in
             await operation()
-            if verbose {
-                print("[ASQ]     ✅ Task execution completed")
-            }
 
             // Resume all waiting callers
-            if verbose {
-                print("[ASQ]     📤 Resuming \(continuations.count) continuation(s)")
-            }
-            for (index, continuation) in continuations.enumerated() {
-                if verbose {
-                    print("[ASQ]       ├─ Resuming continuation #\(index + 1)")
-                }
+            for continuation in continuations {
                 continuation.resume()
             }
-            if verbose {
-                print("[ASQ]     ✓ All continuations resumed")
-            }
 
             // Process next operation if any arrived while we were running
-            if verbose {
-                print("[ASQ]     🔁 Checking for next operation...")
-            }
             await self?.processNext()
         }
     }
diff --git a/Sources/OpenFeature/OpenFeatureAPI.swift b/Sources/OpenFeature/OpenFeatureAPI.swift
@@ -17,9 +17,7 @@ public class OpenFeatureAPI {
     static public let shared = OpenFeatureAPI()
 
     public init() {
-        // Check for OPENFEATURE_ASQ_VERBOSE environment variable to enable verbose logging
-        let verboseMode = ProcessInfo.processInfo.environment["OPENFEATURE_ASQ_VERBOSE"] != nil
-        contextQueue = AsyncCoalescingSerialQueue(verbose: verboseMode)
+        contextQueue = AsyncCoalescingSerialQueue()
     }
 
     /**
diff --git a/Tests/OpenFeatureTests/AsyncSerialQueueTests.swift b/Tests/OpenFeatureTests/AsyncSerialQueueTests.swift
@@ -2,6 +2,7 @@ import XCTest
 import Combine
 @testable import OpenFeature
 
+// swiftlint:disable type_body_length file_length trailing_closure
 class AsyncCoalescingSerialQueueTests: XCTestCase {
     override func setUp() {
         super.setUp()
@@ -89,7 +90,10 @@ class AsyncCoalescingSerialQueueTests: XCTestCase {
 
         let finalState = OpenFeatureAPI.shared.getState()
         XCTAssertNotNil(finalState.provider, "Provider should not be nil after concurrent operations")
-        XCTAssertNotNil(finalState.evaluationContext, "Evaluation context should not be nil after concurrent operations")
+        XCTAssertNotNil(
+            finalState.evaluationContext,
+            "Evaluation context should not be nil after concurrent operations"
+        )
         XCTAssertTrue([.ready].contains(finalState.providerStatus), "Provider status should be in a valid final state")
 
         if let context = finalState.evaluationContext {
@@ -161,13 +165,17 @@ class AsyncCoalescingSerialQueueTests: XCTestCase {
 
             let contextMap = context?.asObjectMap() ?? [:]
             if contextMap.keys.contains("iteration") {
-                XCTAssertTrue(contextMap.keys.contains("timestamp"), "Context with iteration should also have timestamp")
+                XCTAssertTrue(
+                    contextMap.keys.contains("timestamp"),
+                    "Context with iteration should also have timestamp"
+                )
             }
         } else {
             XCTFail("Provider or Evaluation Context unexpectedly nil")
         }
     }
 
+    // swiftlint:disable:next function_body_length
     func testAsyncCoalescingSerialQueueCoalescence() async throws {
         // Track which operations actually executed
         actor ExecutionTracker {
@@ -186,7 +194,7 @@ class AsyncCoalescingSerialQueueTests: XCTestCase {
 
         // Create a provider with a slow onContextSet to ensure operations overlap
         let provider = MockProvider(
-            onContextSet: { oldContext, newContext in
+            onContextSet: { _, newContext in
                 // Add delay to simulate slow provider operation
                 // This ensures that when tasks 2 and 3 are queued, task 1 is still running
                 let targetingKey = newContext.getTargetingKey()
@@ -241,7 +249,10 @@ class AsyncCoalescingSerialQueueTests: XCTestCase {
         XCTAssertLessThanOrEqual(
             executedOperations.count,
             2,
-            "Should execute at most 2 operations due to coalescence (first + latest), but executed: \(executedOperations)"
+            """
+            Should execute at most 2 operations due to coalescence (first + latest), \
+            but executed: \(executedOperations)
+            """
         )
 
         // Verify user2 was NOT executed (it should be coalesced/skipped)
@@ -273,7 +284,7 @@ class AsyncCoalescingSerialQueueTests: XCTestCase {
 
         let tracker = ExecutionTracker()
         let provider = MockProvider(
-            onContextSet: { oldContext, newContext in
+            onContextSet: { _, newContext in
                 await tracker.recordExecution(newContext.getTargetingKey())
             }
         )
@@ -304,7 +315,7 @@ class AsyncCoalescingSerialQueueTests: XCTestCase {
 
         let tracker = ExecutionTracker()
         let provider = MockProvider(
-            onContextSet: { oldContext, newContext in
+            onContextSet: { _, newContext in
                 await tracker.recordExecution(newContext.getTargetingKey())
                 try await Task.sleep(nanoseconds: 10_000_000) // 10ms
             }
@@ -344,7 +355,7 @@ class AsyncCoalescingSerialQueueTests: XCTestCase {
 
         let tracker = ExecutionTracker()
         let provider = MockProvider(
-            onContextSet: { oldContext, newContext in
+            onContextSet: { _, newContext in
                 await tracker.recordExecution(newContext.getTargetingKey())
                 try await Task.sleep(nanoseconds: 100_000_000) // 100ms - long enough for many to queue
             }
@@ -395,7 +406,7 @@ class AsyncCoalescingSerialQueueTests: XCTestCase {
 
         let tracker = ExecutionTracker()
         let provider = MockProvider(
-            onContextSet: { oldContext, newContext in
+            onContextSet: { _, newContext in
                 await tracker.recordExecution(newContext.getTargetingKey())
             }
         )
@@ -464,7 +475,7 @@ class AsyncCoalescingSerialQueueTests: XCTestCase {
 
         let tracker = ExecutionTracker()
         let provider = MockProvider(
-            onContextSet: { oldContext, newContext in
+            onContextSet: { _, newContext in
                 let targetingKey = newContext.getTargetingKey()
                 await tracker.recordExecution(targetingKey)
 
@@ -543,7 +554,7 @@ class AsyncCoalescingSerialQueueTests: XCTestCase {
 
         let completionTracker = CompletionTracker()
         let provider = MockProvider(
-            onContextSet: { oldContext, newContext in
+            onContextSet: { _, _ in
                 try await Task.sleep(nanoseconds: 50_000_000) // 50ms
             }
         )
@@ -594,7 +605,7 @@ class AsyncCoalescingSerialQueueTests: XCTestCase {
 
         let tracker = ExecutionTracker()
         let provider = MockProvider(
-            onContextSet: { oldContext, newContext in
+            onContextSet: { _, newContext in
                 await tracker.recordExecution(newContext.getTargetingKey())
                 try await Task.sleep(nanoseconds: 20_000_000) // 20ms
             }
@@ -609,7 +620,10 @@ class AsyncCoalescingSerialQueueTests: XCTestCase {
                     group.addTask {
                         let ctx = ImmutableContext(
                             targetingKey: "wave\(wave)-user\(i)",
-                            structure: ImmutableStructure(attributes: ["wave": .integer(Int64(wave)), "id": .integer(Int64(i))])
+                            structure: ImmutableStructure(attributes: [
+                                "wave": .integer(Int64(wave)),
+                                "id": .integer(Int64(i)),
+                            ])
                         )
                         await OpenFeatureAPI.shared.setEvaluationContextAndWait(evaluationContext: ctx)
                     }
@@ -639,3 +653,4 @@ class AsyncCoalescingSerialQueueTests: XCTestCase {
         )
     }
 }
+// swiftlint:enable type_body_length file_length trailing_closure

Original file line number	Diff line number	Diff line change
`@@ -17,9 +17,7 @@ public class OpenFeatureAPI {`
`17`	`17`	`static public let shared = OpenFeatureAPI()`
`18`	`18`
`19`	`19`	`public init() {`
`20`		`- // Check for OPENFEATURE_ASQ_VERBOSE environment variable to enable verbose logging`
`21`		`- let verboseMode = ProcessInfo.processInfo.environment["OPENFEATURE_ASQ_VERBOSE"] != nil`
`22`		`- contextQueue = AsyncCoalescingSerialQueue(verbose: verboseMode)`
	`20`	`+ contextQueue = AsyncCoalescingSerialQueue()`
`23`	`21`	`}`
`24`	`22`
`25`	`23`	`/**`