Metrics: Generalize counters, ensure task counters are propagated to clients observing messages

mirza-garibovic · mirza-garibovic · commit e84ef2cb4b1e · 2025-09-10T15:43:02.000-07:00
diff --git a/Sources/SWBBuildService/BuildOperationMessages.swift b/Sources/SWBBuildService/BuildOperationMessages.swift
@@ -705,20 +705,8 @@ private final class TaskOutputHandler: TaskOutputDelegate {
         }
     }
 
-    func incrementClangCacheHit() {
-        self.counters[.clangCacheHits, default: 0] += 1
-    }
-
-    func incrementClangCacheMiss() {
-        self.counters[.clangCacheMisses, default: 0] += 1
-    }
-
-    func incrementSwiftCacheHit() {
-        self.counters[.swiftCacheHits, default: 0] += 1
-    }
-
-    func incrementSwiftCacheMiss() {
-        self.counters[.swiftCacheMisses, default: 0] += 1
+    func incrementCounter(_ counter: BuildOperationMetrics.Counter) {
+        self.counters[counter, default: 0] += 1
     }
 
     func incrementTaskCounter(_ counter: BuildOperationMetrics.TaskCounter) {
@@ -944,10 +932,7 @@ private final class DiscardingTaskOutputHandler: TaskOutputDelegate {
     func subtaskUpToDate(_ subtask: any ExecutableTask) {}
     func previouslyBatchedSubtaskUpToDate(signature: ByteString, target: ConfiguredTarget) {}
     func updateResult(_ result: TaskResult) {}
-    func incrementClangCacheHit() {}
-    func incrementClangCacheMiss() {}
-    func incrementSwiftCacheHit() {}
-    func incrementSwiftCacheMiss() {}
+    func incrementCounter(_ counter: BuildOperationMetrics.Counter) {}
     func incrementTaskCounter(_ counter: BuildOperationMetrics.TaskCounter) {}
 }
 
diff --git a/Sources/SWBBuildSystem/BuildOperation.swift b/Sources/SWBBuildSystem/BuildOperation.swift
@@ -806,7 +806,7 @@ package final class BuildOperation: BuildSystemOperation {
         }
 
         // `buildComplete()` should not run within `queue`, otherwise there can be a deadlock during cancelling.
-        return delegate.buildComplete(self, status: effectiveStatus, delegate: buildOutputDelegate, metrics: .init(counters: aggregatedCounters))
+        return delegate.buildComplete(self, status: effectiveStatus, delegate: buildOutputDelegate, metrics: .init(counters: aggregatedCounters, taskCounters: aggregatedTaskCounters))
     }
 
     func prepareForBuilding() async -> ([String], [String])? {
diff --git a/Sources/SWBProtocol/BuildOperationMessages.swift b/Sources/SWBProtocol/BuildOperationMessages.swift
@@ -500,8 +500,12 @@ public struct BuildOperationMetrics: Equatable, Codable, Sendable {
 
     public let counters: [Counter: Int]
 
-    public init(counters: [Counter : Int]) {
+    /// The key is the first component of task rule info, a.k.a. the rule info type
+    public let taskCounters: [String: [TaskCounter: Int]]
+
+    public init(counters: [Counter : Int], taskCounters: [String: [TaskCounter: Int]]) {
         self.counters = counters
+        self.taskCounters = taskCounters
     }
 }
 
diff --git a/Sources/SWBTaskExecution/Task.swift b/Sources/SWBTaskExecution/Task.swift
@@ -608,14 +608,7 @@ public protocol TaskOutputDelegate: DiagnosticProducingDelegate
     /// Report a task which was previously batched as up-to-date.
     func previouslyBatchedSubtaskUpToDate(signature: ByteString, target: ConfiguredTarget)
 
-    func incrementClangCacheHit()
-
-    func incrementClangCacheMiss()
-
-    func incrementSwiftCacheHit()
-
-    func incrementSwiftCacheMiss()
-
+    func incrementCounter(_ counter: BuildOperationMetrics.Counter)
     func incrementTaskCounter(_ counter: BuildOperationMetrics.TaskCounter)
 
     var counters: [BuildOperationMetrics.Counter: Int] { get }
diff --git a/Sources/SWBTaskExecution/TaskActions/ClangCompileTaskAction.swift b/Sources/SWBTaskExecution/TaskActions/ClangCompileTaskAction.swift
@@ -414,7 +414,7 @@ public final class ClangCompileTaskAction: TaskAction, BuildValueValidatingTaskA
             if enableDiagnosticRemarks {
                 outputDelegate.note("cache miss: \(cacheKey)")
             }
-            outputDelegate.incrementClangCacheMiss()
+            outputDelegate.incrementCounter(.clangCacheMisses)
             outputDelegate.incrementTaskCounter(.cacheMisses)
             outputDelegate.emitOutput("Cache miss\n")
             return false
@@ -427,7 +427,7 @@ public final class ClangCompileTaskAction: TaskAction, BuildValueValidatingTaskA
                     outputDelegate.note("missing CAS output \(output.name): \(output.casID)")
                     outputDelegate.note("cache miss: \(cacheKey)")
                 }
-                outputDelegate.incrementClangCacheMiss()
+                outputDelegate.incrementCounter(.clangCacheMisses)
                 outputDelegate.incrementTaskCounter(.cacheMisses)
                 outputDelegate.emitOutput("Cache miss\n")
                 return false
@@ -440,7 +440,7 @@ public final class ClangCompileTaskAction: TaskAction, BuildValueValidatingTaskA
                 outputDelegate.note("using CAS output \(output.name): \(output.casID)")
             }
         }
-        outputDelegate.incrementClangCacheHit()
+        outputDelegate.incrementCounter(.clangCacheHits)
         outputDelegate.incrementTaskCounter(.cacheHits)
         outputDelegate.emitOutput("Cache hit\n")
         outputDelegate.emitOutput(ByteString(encodingAsUTF8: diagnosticText))
diff --git a/Sources/SWBTaskExecution/TaskActions/EmbedSwiftStdLibTaskAction.swift b/Sources/SWBTaskExecution/TaskActions/EmbedSwiftStdLibTaskAction.swift
@@ -472,15 +472,7 @@ public final class EmbedSwiftStdLibTaskAction: TaskAction {
             logV(args.joined(separator: " "))
 
             final class CapturingOutputDelegate: TaskOutputDelegate {
-                func incrementClangCacheHit() {
-                    // TBD
-                }
-
-                func incrementClangCacheMiss() {
-                    // TBD
-                }
-                func incrementSwiftCacheHit() {}
-                func incrementSwiftCacheMiss() {}
+                func incrementCounter(_ counter: BuildOperationMetrics.Counter) {}
                 func incrementTaskCounter(_ counter: BuildOperationMetrics.TaskCounter) {}
 
                 var counters: [BuildOperationMetrics.Counter : Int] = [:]
diff --git a/Sources/SWBTaskExecution/TaskActions/GenericCachingTaskAction.swift b/Sources/SWBTaskExecution/TaskActions/GenericCachingTaskAction.swift
@@ -404,20 +404,8 @@ fileprivate final class CapturingTaskOutputDelegate: TaskOutputDelegate {
         underlyingTaskOutputDelegate.previouslyBatchedSubtaskUpToDate(signature: signature, target: target)
     }
 
-    func incrementClangCacheHit() {
-        underlyingTaskOutputDelegate.incrementClangCacheHit()
-    }
-
-    func incrementClangCacheMiss() {
-        underlyingTaskOutputDelegate.incrementClangCacheMiss()
-    }
-
-    func incrementSwiftCacheHit() {
-        underlyingTaskOutputDelegate.incrementSwiftCacheHit()
-    }
-
-    func incrementSwiftCacheMiss() {
-        underlyingTaskOutputDelegate.incrementSwiftCacheMiss()
+    func incrementCounter(_ counter: BuildOperationMetrics.Counter) {
+        underlyingTaskOutputDelegate.incrementCounter(counter)
     }
 
     func incrementTaskCounter(_ counter: BuildOperationMetrics.TaskCounter) {
diff --git a/Sources/SWBTaskExecution/TaskActions/SwiftDriverJobTaskAction.swift b/Sources/SWBTaskExecution/TaskActions/SwiftDriverJobTaskAction.swift
@@ -670,11 +670,11 @@ public final class SwiftDriverJobTaskAction: TaskAction, BuildValueValidatingTas
             outputDelegate.note("replay cache \(result ? "hit" : "miss")")
         }
         if result {
-            outputDelegate.incrementSwiftCacheHit()
+            outputDelegate.incrementCounter(.swiftCacheHits)
             outputDelegate.incrementTaskCounter(.cacheHits)
             outputDelegate.emitOutput("Cache hit\n")
         } else {
-            outputDelegate.incrementSwiftCacheMiss()
+            outputDelegate.incrementCounter(.swiftCacheMisses)
             outputDelegate.incrementTaskCounter(.cacheMisses)
             outputDelegate.emitOutput("Cache miss\n")
         }
diff --git a/Sources/SWBTestSupport/BuildOperationTester.swift b/Sources/SWBTestSupport/BuildOperationTester.swift
@@ -1783,20 +1783,8 @@ private final class BuildOperationTesterDelegate: BuildOperationDelegate {
     }
 
     private class TesterTaskOutputDelegate: TaskOutputDelegate {
-        func incrementClangCacheHit() {
-            self.counters[.clangCacheHits, default: 0] += 1
-        }
-
-        func incrementClangCacheMiss() {
-            self.counters[.clangCacheMisses, default: 0] += 1
-        }
-
-        func incrementSwiftCacheHit() {
-            self.counters[.swiftCacheHits, default: 0] += 1
-        }
-
-        func incrementSwiftCacheMiss() {
-            self.counters[.swiftCacheMisses, default: 0] += 1
+        func incrementCounter(_ counter: BuildOperationMetrics.Counter) {
+            self.counters[counter, default: 0] += 1
         }
 
         func incrementTaskCounter(_ counter: BuildOperationMetrics.TaskCounter) {
diff --git a/Sources/SwiftBuild/ConsoleCommands/SWBServiceConsoleBuildCommandProtocol.swift b/Sources/SwiftBuild/ConsoleCommands/SWBServiceConsoleBuildCommandProtocol.swift
@@ -14,6 +14,7 @@
 
 public import Foundation
 public import SWBProjectModel
+public import SWBProtocol
 
 import SWBUtil
 
@@ -168,10 +169,10 @@ public enum SwiftBuildMessage {
     }
 
     public struct BuildOperationMetrics {
-        let clangCacheHits: Int
-        let clangCacheMisses: Int
-        let swiftCacheHits: Int
-        let swiftCacheMisses: Int
+        let counters: [SWBProtocol.BuildOperationMetrics.Counter: Int]
+
+        /// The key is the first component of task rule info, a.k.a. the rule info type
+        let taskCounters: [String: [SWBProtocol.BuildOperationMetrics.TaskCounter: Int]]
     }
 
     public struct BuildCompletedInfo {
diff --git a/Sources/SwiftBuild/SWBuildMessage+Protocol.swift b/Sources/SwiftBuild/SWBuildMessage+Protocol.swift
@@ -48,10 +48,7 @@ extension SwiftBuildMessage {
     init(_ message: BuildOperationEnded) {
         let metrics: BuildOperationMetrics?
         if let messageMetrics = message.metrics, !messageMetrics.counters.isEmpty {
-            metrics = .init(clangCacheHits: messageMetrics.counters[.clangCacheHits] ?? 0,
-                            clangCacheMisses: messageMetrics.counters[.clangCacheMisses] ?? 0,
-                            swiftCacheHits: messageMetrics.counters[.swiftCacheHits] ?? 0,
-                            swiftCacheMisses: messageMetrics.counters[.swiftCacheMisses] ?? 0)
+            metrics = .init(counters: messageMetrics.counters, taskCounters: messageMetrics.taskCounters)
         } else {
             metrics = nil
         }
diff --git a/Tests/SWBTaskExecutionTests/InProcessTaskTestSupport.swift b/Tests/SWBTaskExecutionTests/InProcessTaskTestSupport.swift
@@ -71,27 +71,9 @@ final class MockTaskOutputDelegate: TaskOutputDelegate {
 
     private let _diagnosticsEngine = DiagnosticsEngine()
 
-    func incrementClangCacheHit() {
+    func incrementCounter(_ counter: BuildOperationMetrics.Counter) {
         state.state.withLock { state in
-            state.counters[.clangCacheHits, default: 0] += 1
-        }
-    }
-
-    func incrementClangCacheMiss() {
-        state.state.withLock { state in
-            state.counters[.clangCacheMisses, default: 0] += 1
-        }
-    }
-
-    func incrementSwiftCacheHit() {
-        state.state.withLock { state in
-            state.counters[.swiftCacheHits, default: 0] += 1
-        }
-    }
-
-    func incrementSwiftCacheMiss() {
-        state.state.withLock { state in
-            state.counters[.swiftCacheMisses, default: 0] += 1
+            state.counters[counter, default: 0] += 1
         }
     }
 

Original file line number	Diff line number	Diff line change
`@@ -806,7 +806,7 @@ package final class BuildOperation: BuildSystemOperation {`
`806`	`806`	`}`
`807`	`807`
`808`	`808`	// `buildComplete()` should not run within `queue`, otherwise there can be a deadlock during cancelling.
`809`		`- return delegate.buildComplete(self, status: effectiveStatus, delegate: buildOutputDelegate, metrics: .init(counters: aggregatedCounters))`
	`809`	`+ return delegate.buildComplete(self, status: effectiveStatus, delegate: buildOutputDelegate, metrics: .init(counters: aggregatedCounters, taskCounters: aggregatedTaskCounters))`
`810`	`810`	`}`
`811`	`811`
`812`	`812`	`func prepareForBuilding() async -> ([String], [String])? {`
Original file line number	Diff line number	Diff line change
`@@ -500,8 +500,12 @@ public struct BuildOperationMetrics: Equatable, Codable, Sendable {`
`500`	`500`
`501`	`501`	`public let counters: [Counter: Int]`
`502`	`502`
`503`		`- public init(counters: [Counter : Int]) {`
	`503`	`+ /// The key is the first component of task rule info, a.k.a. the rule info type`
	`504`	`+ public let taskCounters: [String: [TaskCounter: Int]]`
	`505`	`+`
	`506`	`+ public init(counters: [Counter : Int], taskCounters: [String: [TaskCounter: Int]]) {`
`504`	`507`	`self.counters = counters`
	`508`	`+ self.taskCounters = taskCounters`
`505`	`509`	`}`
`506`	`510`	`}`
`507`	`511`
Original file line number	Diff line number	Diff line change
`@@ -670,11 +670,11 @@ public final class SwiftDriverJobTaskAction: TaskAction, BuildValueValidatingTas`
`670`	`670`	`outputDelegate.note("replay cache \(result ? "hit" : "miss")")`
`671`	`671`	`}`
`672`	`672`	`if result {`
`673`		`- outputDelegate.incrementSwiftCacheHit()`
	`673`	`+ outputDelegate.incrementCounter(.swiftCacheHits)`
`674`	`674`	`outputDelegate.incrementTaskCounter(.cacheHits)`
`675`	`675`	`outputDelegate.emitOutput("Cache hit\n")`
`676`	`676`	`} else {`
`677`		`- outputDelegate.incrementSwiftCacheMiss()`
	`677`	`+ outputDelegate.incrementCounter(.swiftCacheMisses)`
`678`	`678`	`outputDelegate.incrementTaskCounter(.cacheMisses)`
`679`	`679`	`outputDelegate.emitOutput("Cache miss\n")`
`680`	`680`	`}`