refactor: migrate latency tracking to TelemetryDeck floatValue

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: ZhaoChaoqun

Sources/ASREngineFactory.swift

@@ -63,13 +63,12 @@ enum ASREngineFactory {
         let success = engine != nil
         var params: [String: String] = [
             "engine": modelType.rawValue,
-            "latencyMs": "\(loadMs)",
             "success": "\(success)",
         ]
         if !success {
             params["errorType"] = "load_failed"
         }
-        AnalyticsService.track("Model.LoadCompleted", parameters: params)
+        AnalyticsService.track("Model.LoadCompleted", parameters: params, floatValue: Double(loadMs))
 
         return Result(engine: engine)
     }

Sources/AnalyticsService.swift

@@ -49,7 +49,11 @@ enum AnalyticsService {
     }
 
     /// Track an analytics event with optional parameters.
-    static func track(_ event: String, parameters: [String: String] = [:]) {
+    /// - Parameters:
+    ///   - event: Event name (e.g. "ASR.FlushCompleted").
+    ///   - parameters: String key-value metadata (for filtering and breakdown).
+    ///   - floatValue: Optional numeric value for aggregation (avg/min/max) in TelemetryDeck.
+    static func track(_ event: String, parameters: [String: String] = [:], floatValue: Double? = nil) {
         guard isEnabled else { return }
 
         // Attach default parameters
@@ -58,7 +62,7 @@ enum AnalyticsService {
         params["selectedEngine"] = UserDefaults.standard.string(forKey: "selectedASRModel") ?? "streamingParaformer"
         params["cloudRewriteEnabled"] = "\(hasCloudRewriteAPIKey)"
 
-        TelemetryDeck.signal(event, parameters: params)
+        TelemetryDeck.signal(event, parameters: params, floatValue: floatValue)
     }
 
     // MARK: - Timing Helpers
@@ -78,17 +82,6 @@ enum AnalyticsService {
 
     // MARK: - Bucketing Helpers
 
-    /// Map millisecond latency to a privacy-safe bucket string.
-    static func latencyBucket(ms: Int) -> String {
-        switch ms {
-        case ..<500: return "0-500ms"
-        case 500..<1000: return "500-1000ms"
-        case 1000..<1500: return "1000-1500ms"
-        case 1500..<2000: return "1500-2000ms"
-        default: return "2000ms+"
-        }
-    }
-
     /// Map recording duration (seconds) to a privacy-safe bucket.
     static func durationBucket(seconds: Double) -> String {
         switch seconds {

Sources/CloudRewriteService.swift

@@ -149,17 +149,15 @@ final class CloudRewriteService {
             let resolvedModel = await modelProbeTask.value
             AnalyticsService.track("CloudRewrite.Completed", parameters: [
                 "outcome": "rewritten",
-                "latencyBucket": AnalyticsService.latencyBucket(ms: elapsedMs),
                 "model": resolvedModel,
                 "changed": "\(result != text)",
                 "inputLengthBucket": AnalyticsService.lengthBucket(count: text.count),
-            ])
+            ], floatValue: Double(elapsedMs))
             return result
         } catch is RewriteTimeoutError {
             cloudRewriteLogger.warning("Cloud rewrite timed out (\(Self.rewriteTimeout, privacy: .public)), using original text (\(text.count, privacy: .public) chars)")
             AnalyticsService.track("CloudRewrite.Completed", parameters: [
                 "outcome": "timeout",
-                "latencyBucket": "timeout",
                 "inputLengthBucket": AnalyticsService.lengthBucket(count: text.count),
             ])
             return text
@@ -171,30 +169,27 @@ final class CloudRewriteService {
             let elapsedMs = Int(startTime.duration(to: .now).components.seconds * 1000)
             AnalyticsService.track("CloudRewrite.Completed", parameters: [
                 "outcome": "error",
-                "latencyBucket": AnalyticsService.latencyBucket(ms: elapsedMs),
                 "errorType": "network_\(error.code.rawValue)",
                 "inputLengthBucket": AnalyticsService.lengthBucket(count: text.count),
-            ])
+            ], floatValue: Double(elapsedMs))
             return text
         } catch let error as CloudRewriteError {
             cloudRewriteLogger.warning("Cloud rewrite service error: \(error.logDescription, privacy: .public). Fallback to original text")
             let elapsedMs = Int(startTime.duration(to: .now).components.seconds * 1000)
             AnalyticsService.track("CloudRewrite.Completed", parameters: [
                 "outcome": "error",
-                "latencyBucket": AnalyticsService.latencyBucket(ms: elapsedMs),
                 "errorType": error.logDescription,
                 "inputLengthBucket": AnalyticsService.lengthBucket(count: text.count),
-            ])
+            ], floatValue: Double(elapsedMs))
             return text
         } catch {
             cloudRewriteLogger.warning("Cloud rewrite unknown error: \(error.localizedDescription, privacy: .public). Fallback to original text")
             let elapsedMs = Int(startTime.duration(to: .now).components.seconds * 1000)
             AnalyticsService.track("CloudRewrite.Completed", parameters: [
                 "outcome": "error",
-                "latencyBucket": AnalyticsService.latencyBucket(ms: elapsedMs),
                 "errorType": "unknown",
                 "inputLengthBucket": AnalyticsService.lengthBucket(count: text.count),
-            ])
+            ], floatValue: Double(elapsedMs))
             return text
         }
     }

Sources/PostProcessingPipeline.swift

@@ -165,13 +165,12 @@ final class PostProcessingPipeline {
             "itnApplied": "\(itnApplied)",
             "cscApplied": "\(cscApplied)",
             "punctuationApplied": "\(punctuationApplied)",
-            "totalLatencyMs": "\(totalMs)",
             "termNormLatencyMs": "\(termNormMs)",
             "itnLatencyMs": "\(itnMs)",
             "cscLatencyMs": "\(cscMs)",
             "punctLatencyMs": "\(punctMs)",
             "cloudRewriteLatencyMs": "\(cloudRewriteMs)",
             "termNormChanged": "\(termNormChanged)",
-        ])
+        ], floatValue: Double(totalMs))
     }
 }

Sources/RecordingManager.swift

@@ -158,7 +158,7 @@ class RecordingManager {
                         "durationBucket": AnalyticsService.durationBucket(seconds: durationSeconds),
                         "hasResult": "\(finalText != nil && !(finalText?.isEmpty ?? true))",
                         "resultLengthBucket": AnalyticsService.lengthBucket(count: finalText?.count ?? 0),
-                    ])
+                    ], floatValue: durationSeconds)
                     self.sessionStartTime = nil
                 }
                 DispatchQueue.main.async { self.onFinalResult?(finalText) }
@@ -208,10 +208,9 @@ class RecordingManager {
             let text = rawText.isEmpty ? fallbackText : rawText
             AnalyticsService.track("ASR.FlushCompleted", parameters: [
                 "engine": self.currentModel.rawValue,
-                "latencyMs": "\(flushMs)",
                 "success": "\(!rawText.isEmpty)",
                 "rawTextLengthBucket": AnalyticsService.lengthBucket(count: text.count),
-            ])
+            ], floatValue: Double(flushMs))
             self.handleEvent(.flushComplete(rawText: text))
         }
     }