Skip to content

Fastest and only macOS Dictation app with on-device STT and custom trained AI enhancement model. Windows, iOS testflight! Android, Linux waitlist open! A local Wispr Flow alternative. Follow https://x.com/fluidvoiceapp for more

Reduce PH events

grohith327586335cab7fa
diff --git a/Fluid.xcodeproj/project.pbxproj b/Fluid.xcodeproj/project.pbxproj
index f281dd4c..5da00c24 100644
--- a/Fluid.xcodeproj/project.pbxproj
+++ b/Fluid.xcodeproj/project.pbxproj
@@ -17,6 +17,7 @@
7CDB0A2E2F3C4D5600FB7CAD /* AudioFixtureLoader.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7CDB0A2A2F3C4D5600FB7CAD /* AudioFixtureLoader.swift */; };
86CAA2D4EF18433096185602 /* LLMClientRequestBodyTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 343B29013F4441D6A797D12D /* LLMClientRequestBodyTests.swift */; };
272BFB5CB271489892CAE50C /* TemperatureSupportTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 980330F3CE464336ADCE3E23 /* TemperatureSupportTests.swift */; };
+ A11A00000000000000000002 /* AnalyticsDatabaseTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = A11A00000000000000000001 /* AnalyticsDatabaseTests.swift */; };
A62300000000000000000002 /* AudioBufferConverterTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = A62300000000000000000001 /* AudioBufferConverterTests.swift */; };
D1A600000000000000000202 /* SpeakerTurnMergingTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D1A600000000000000000201 /* SpeakerTurnMergingTests.swift */; };
C0DE63600000000000000002 /* AudioEngineRetirementDrainTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = C0DE63600000000000000001 /* AudioEngineRetirementDrainTests.swift */; };
@@ -55,6 +56,7 @@
/* Begin PBXFileReference section */
343B29013F4441D6A797D12D /* LLMClientRequestBodyTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = LLMClientRequestBodyTests.swift; sourceTree = "<group>"; };
980330F3CE464336ADCE3E23 /* TemperatureSupportTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = TemperatureSupportTests.swift; sourceTree = "<group>"; };
+ A11A00000000000000000001 /* AnalyticsDatabaseTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AnalyticsDatabaseTests.swift; sourceTree = "<group>"; };
A62300000000000000000001 /* AudioBufferConverterTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AudioBufferConverterTests.swift; sourceTree = "<group>"; };
D1A600000000000000000201 /* SpeakerTurnMergingTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SpeakerTurnMergingTests.swift; sourceTree = "<group>"; };
C0DE63600000000000000001 /* AudioEngineRetirementDrainTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AudioEngineRetirementDrainTests.swift; sourceTree = "<group>"; };
@@ -136,6 +138,7 @@
7C91B0022F42AA0100C0DEF0 /* HotkeyShortcutTests.swift */,
343B29013F4441D6A797D12D /* LLMClientRequestBodyTests.swift */,
980330F3CE464336ADCE3E23 /* TemperatureSupportTests.swift */,
+ A11A00000000000000000001 /* AnalyticsDatabaseTests.swift */,
A62300000000000000000001 /* AudioBufferConverterTests.swift */,
D1A600000000000000000201 /* SpeakerTurnMergingTests.swift */,
C0DE63600000000000000001 /* AudioEngineRetirementDrainTests.swift */,
@@ -298,6 +301,7 @@
7C91B0012F42AA0100C0DEF0 /* HotkeyShortcutTests.swift in Sources */,
86CAA2D4EF18433096185602 /* LLMClientRequestBodyTests.swift in Sources */,
272BFB5CB271489892CAE50C /* TemperatureSupportTests.swift in Sources */,
+ A11A00000000000000000002 /* AnalyticsDatabaseTests.swift in Sources */,
A62300000000000000000002 /* AudioBufferConverterTests.swift in Sources */,
D1A600000000000000000202 /* SpeakerTurnMergingTests.swift in Sources */,
C0DE63600000000000000002 /* AudioEngineRetirementDrainTests.swift in Sources */,
diff --git a/Package.resolved b/Package.resolved
index d9e9053e..5011ae15 100644
--- a/Package.resolved
+++ b/Package.resolved
@@ -54,15 +54,6 @@
"version" : "1.4.1"
}
},
- {
- "identity" : "posthog-ios",
- "kind" : "remoteSourceControl",
- "location" : "https://github.com/PostHog/posthog-ios.git",
- "state" : {
- "revision" : "1ba3e8636d4f1ad9f18f5a4273e88d39a162466b",
- "version" : "3.41.1"
- }
- },
{
"identity" : "promisekit",
"kind" : "remoteSourceControl",
diff --git a/Package.swift b/Package.swift
index a680e275..dd761847 100644
--- a/Package.swift
+++ b/Package.swift
@@ -14,7 +14,6 @@ let package = Package(
.package(url: "https://github.com/mxcl/PromiseKit", from: "6.0.0"),
.package(url: "https://github.com/altic-dev/DynamicNotchKit.git", branch: "main"),
.package(url: "https://github.com/altic-dev/transcribe-cpp-swift.git", exact: "0.1.2"),
- .package(url: "https://github.com/PostHog/posthog-ios.git", from: "3.0.0"),
],
targets: [
.target(
@@ -33,7 +32,9 @@ let package = Package(
"PromiseKit",
"DynamicNotchKit",
.product(name: "TranscribeCpp", package: "transcribe-cpp-swift"),
- .product(name: "PostHog", package: "posthog-ios"),
+ ],
+ linkerSettings: [
+ .linkedLibrary("sqlite3"),
]
),
]
diff --git a/Sources/Fluid/Analytics/AnalyticsBuckets.swift b/Sources/Fluid/Analytics/AnalyticsBuckets.swift
deleted file mode 100644
index 11b7e1f0..00000000
--- a/Sources/Fluid/Analytics/AnalyticsBuckets.swift
+++ /dev/null
@@ -1,45 +0,0 @@
-import Foundation
-
-enum AnalyticsBuckets {
- nonisolated static func wordCount(in text: String) -> Int {
- let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
- guard !trimmed.isEmpty else { return 0 }
- return trimmed
- .split(whereSeparator: { $0.isWhitespace || $0.isNewline })
- .count
- }
-
- nonisolated static func bucketWords(_ count: Int) -> String {
- switch count {
- case ...0: return "0"
- case 1...5: return "1-5"
- case 6...20: return "6-20"
- case 21...50: return "21-50"
- case 51...100: return "51-100"
- case 101...300: return "101-300"
- default: return "301+"
- }
- }
-
- nonisolated static func bucketSeconds(_ seconds: Double) -> String {
- switch seconds {
- case ..<0.5: return "<0.5s"
- case 0.5..<2: return "0.5-2s"
- case 2..<5: return "2-5s"
- case 5..<15: return "5-15s"
- case 15..<60: return "15-60s"
- default: return "60s+"
- }
- }
-
- nonisolated static func bucketMs(_ ms: Double) -> String {
- switch ms {
- case ..<100: return "<100ms"
- case 100..<300: return "100-300ms"
- case 300..<1000: return "300ms-1s"
- case 1000..<3000: return "1-3s"
- case 3000..<10_000: return "3-10s"
- default: return "10s+"
- }
- }
-}
diff --git a/Sources/Fluid/Analytics/AnalyticsConfig.swift b/Sources/Fluid/Analytics/AnalyticsConfig.swift
index a937e0be..50b07aa4 100644
--- a/Sources/Fluid/Analytics/AnalyticsConfig.swift
+++ b/Sources/Fluid/Analytics/AnalyticsConfig.swift
@@ -14,5 +14,7 @@ struct AnalyticsConfig {
return AnalyticsConfig(postHogApiKey: key, postHogHost: host.isEmpty ? AnalyticsConfig.defaultEUHost : host)
}
- nonisolated var isConfigured: Bool { !self.postHogApiKey.isEmpty }
+ nonisolated var isConfigured: Bool {
+ !self.postHogApiKey.isEmpty
+ }
}
diff --git a/Sources/Fluid/Analytics/AnalyticsDatabase.swift b/Sources/Fluid/Analytics/AnalyticsDatabase.swift
new file mode 100644
index 00000000..e9ba54a8
--- /dev/null
+++ b/Sources/Fluid/Analytics/AnalyticsDatabase.swift
@@ -0,0 +1,623 @@
+import Foundation
+import SQLite3
+
+struct AnalyticsOutboxItem {
+ let id: String
+ let payload: Data
+}
+
+enum AnalyticsDatabaseError: Error {
+ case open(String)
+ case sqlite(String)
+ case invalidPayload
+}
+
+/// SQLite aggregates and crash-safe upload outbox.
+final class AnalyticsDatabase {
+ private let connection: OpaquePointer
+ private let distinctID: String
+ private let appVersion: String
+ private let calendar: Calendar
+ private let iso8601 = ISO8601DateFormatter()
+
+ init(url: URL, distinctID: String, appVersion: String, calendar: Calendar = .current) throws {
+ self.distinctID = distinctID
+ self.appVersion = appVersion
+ self.calendar = calendar
+
+ try FileManager.default.createDirectory(
+ at: url.deletingLastPathComponent(),
+ withIntermediateDirectories: true
+ )
+
+ var database: OpaquePointer?
+ let result = sqlite3_open_v2(
+ url.path,
+ &database,
+ SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE | SQLITE_OPEN_FULLMUTEX,
+ nil
+ )
+ guard result == SQLITE_OK, let database else {
+ let message = database.map { String(cString: sqlite3_errmsg($0)) } ?? "unknown error"
+ if let database { sqlite3_close(database) }
+ throw AnalyticsDatabaseError.open(message)
+ }
+ self.connection = database
+
+ do {
+ try self.execute("PRAGMA journal_mode=WAL")
+ try self.execute("PRAGMA synchronous=FULL")
+ try self.execute("PRAGMA secure_delete=ON")
+ try self.execute("PRAGMA auto_vacuum=INCREMENTAL")
+ try self.execute("PRAGMA busy_timeout=3000")
+ try self.createSchema()
+ } catch {
+ sqlite3_close(database)
+ throw error
+ }
+ }
+
+ deinit {
+ sqlite3_close(self.connection)
+ }
+
+ func recordActivity(_ kind: AnalyticsActivityKind, at date: Date) throws {
+ try self.finalizeDays(before: date)
+ try self.transaction {
+ try self.enqueueActivityIfNeeded(kind, at: date)
+ }
+ }
+
+ func recordUsage(
+ mode: AnalyticsUsageMode,
+ transcriptionModel: AnalyticsModelDescriptor?,
+ aiModel: AnalyticsModelDescriptor?,
+ at date: Date
+ ) throws {
+ try self.finalizeDays(before: date)
+ let day = self.dayString(date)
+ try self.transaction {
+ try self.upsertDailyUsage(day: day, mode: mode)
+ if let transcriptionModel {
+ try self.upsertDailyModelUsage(
+ day: day,
+ role: .transcription,
+ mode: mode,
+ descriptor: transcriptionModel
+ )
+ }
+ if let aiModel {
+ try self.upsertDailyModelUsage(
+ day: day,
+ role: .aiPostProcessing,
+ mode: mode,
+ descriptor: aiModel
+ )
+ }
+ try self.enqueueActivityIfNeeded(.coreAction, at: date)
+ }
+ }
+
+ func recordModelUsage(
+ role: AnalyticsModelRole,
+ mode: AnalyticsUsageMode,
+ descriptor: AnalyticsModelDescriptor,
+ at date: Date
+ ) throws {
+ try self.finalizeDays(before: date)
+ try self.transaction {
+ try self.upsertDailyModelUsage(day: self.dayString(date), role: role, mode: mode, descriptor: descriptor)
+ try self.enqueueActivityIfNeeded(.coreAction, at: date)
+ }
+ }
+
+ func recordOnboardingStarted(origin: AnalyticsOnboardingOrigin, at date: Date) throws {
+ try self.finalizeDays(before: date)
+ try self.transaction {
+ let flowID = try self.activeOnboardingFlow(origin: origin, at: date)
+ let key = "onboarding:\(flowID):started"
+ if try self.insertDedupeKey(key, date: date) {
+ try self.enqueue(.onboardingStarted, at: date, properties: [
+ "flow_id": flowID,
+ "origin": origin.rawValue,
+ ])
+ }
+ try self.enqueueActivityIfNeeded(.app, at: date)
+ }
+ }
+
+ func recordOnboardingStepViewed(
+ _ step: AnalyticsOnboardingStep,
+ origin: AnalyticsOnboardingOrigin,
+ at date: Date
+ ) throws {
+ try self.transaction {
+ let flowID = try self.activeOnboardingFlow(origin: origin, at: date)
+ let key = "onboarding:\(flowID):viewed:\(step.rawValue)"
+ guard try self.insertDedupeKey(key, date: date) else { return }
+ try self.enqueue(.onboardingStepViewed, at: date, properties: [
+ "flow_id": flowID,
+ "origin": origin.rawValue,
+ "step": step.rawValue,
+ ])
+ }
+ }
+
+ func recordOnboardingStepCompleted(
+ _ step: AnalyticsOnboardingStep,
+ outcome: AnalyticsOnboardingOutcome,
+ origin: AnalyticsOnboardingOrigin,
+ completesFlow: Bool,
+ at date: Date
+ ) throws {
+ try self.transaction {
+ let flowID = try self.activeOnboardingFlow(origin: origin, at: date)
+ let key = "onboarding:\(flowID):completed:\(step.rawValue)"
+ if try self.insertDedupeKey(key, date: date) {
+ try self.enqueue(.onboardingStepCompleted, at: date, properties: [
+ "flow_id": flowID,
+ "origin": origin.rawValue,
+ "step": step.rawValue,
+ "outcome": outcome.rawValue,
+ ])
+ }
+ if completesFlow {
+ let completionKey = "onboarding:\(flowID):flow_completed"
+ if try self.insertDedupeKey(completionKey, date: date) {
+ try self.enqueue(.onboardingCompleted, at: date, properties: [
+ "flow_id": flowID,
+ "origin": origin.rawValue,
+ ])
+ }
+ try self.run(
+ "UPDATE onboarding_flows SET completed = 1 WHERE flow_id = ?",
+ bindings: [.text(flowID)]
+ )
+ }
+ }
+ }
+
+ func recordModelDownloadStarted(
+ id: String,
+ descriptor: AnalyticsModelDescriptor,
+ source: AnalyticsModelDownloadSource,
+ at date: Date
+ ) throws {
+ try self.finalizeDays(before: date)
+ try self.transaction {
+ let finishKey = "download:\(id):finished"
+ if try !self.dedupeKeyExists(finishKey),
+ try self.insertDedupeKey("download:\(id):started", date: date)
+ {
+ try self.run(
+ "INSERT OR IGNORE INTO model_download_attempts " +
+ "(download_id, provider, model, source, started_at) VALUES (?, ?, ?, ?, ?)",
+ bindings: [
+ .text(id), .text(descriptor.provider), .text(descriptor.model),
+ .text(source.rawValue), .double(date.timeIntervalSince1970),
+ ]
+ )
+ try self.enqueue(.modelDownloadStarted, at: date, properties: [
+ "download_id": id,
+ "provider": descriptor.provider,
+ "model": descriptor.model,
+ "source": source.rawValue,
+ ])
+ }
+ try self.enqueueActivityIfNeeded(.coreAction, at: date)
+ }
+ }
+
+ func recordModelDownloadFinished(
+ id: String,
+ descriptor: AnalyticsModelDescriptor,
+ source: AnalyticsModelDownloadSource,
+ outcome: AnalyticsModelDownloadOutcome,
+ duration: TimeInterval?,
+ at date: Date
+ ) throws {
+ try self.transaction {
+ guard try self.insertDedupeKey("download:\(id):finished", date: date) else { return }
+ if try !self.modelDownloadExists(id: id) {
+ let inferredStart = duration.map { date.addingTimeInterval(-max(0, $0)) } ?? date
+ _ = try self.insertDedupeKey("download:\(id):started", date: inferredStart)
+ try self.enqueue(.modelDownloadStarted, at: inferredStart, properties: [
+ "download_id": id,
+ "provider": descriptor.provider,
+ "model": descriptor.model,
+ "source": source.rawValue,
+ ])
+ }
+ var properties: [String: Any] = [
+ "download_id": id,
+ "provider": descriptor.provider,
+ "model": descriptor.model,
+ "source": source.rawValue,
+ "outcome": outcome.rawValue,
+ ]
+ if let duration, duration >= 0 {
+ properties["duration_seconds"] = (duration * 10).rounded() / 10
+ }
+ try self.enqueue(.modelDownloadFinished, at: date, properties: properties)
+ try self.run("DELETE FROM model_download_attempts WHERE download_id = ?", bindings: [.text(id)])
+ }
+ }
+
+ func recoverInterruptedModelDownloads(at date: Date) throws {
+ let rows = try self.query(
+ "SELECT download_id, provider, model, source FROM model_download_attempts",
+ bindings: []
+ )
+ for row in rows {
+ guard row.count == 4 else { continue }
+ try self.recordModelDownloadFinished(
+ id: row[0],
+ descriptor: AnalyticsModelDescriptor(provider: row[1], model: row[2]),
+ source: AnalyticsModelDownloadSource(rawValue: row[3]) ?? .automatic,
+ outcome: .interrupted,
+ duration: nil,
+ at: date
+ )
+ }
+ }
+
+ func finalizeDays(before date: Date) throws {
+ let today = self.dayString(date)
+ let usageRows = try self.query(
+ "SELECT day, dictation_count, command_count, edit_count, meeting_count " +
+ "FROM daily_usage WHERE day < ? ORDER BY day",
+ bindings: [.text(today)]
+ )
+ let modelRows = try self.query(
+ "SELECT day, role, mode, provider, model, use_count FROM daily_model_usage " +
+ "WHERE day < ? ORDER BY day, role, mode, provider, model",
+ bindings: [.text(today)]
+ )
+
+ guard !usageRows.isEmpty || !modelRows.isEmpty else { return }
+ try self.transaction {
+ for row in usageRows where row.count == 5 {
+ try self.enqueue(.usageDailySummary, at: date, properties: [
+ "usage_date": row[0],
+ "dictation_count": Int(row[1]) ?? 0,
+ "command_count": Int(row[2]) ?? 0,
+ "edit_count": Int(row[3]) ?? 0,
+ "meeting_count": Int(row[4]) ?? 0,
+ ])
+ }
+ for row in modelRows where row.count == 6 {
+ try self.enqueue(.modelUsageDailySummary, at: date, properties: [
+ "usage_date": row[0],
+ "role": row[1],
+ "mode": row[2],
+ "provider": row[3],
+ "model": row[4],
+ "use_count": Int(row[5]) ?? 0,
+ ])
+ }
+ try self.run("DELETE FROM daily_usage WHERE day < ?", bindings: [.text(today)])
+ try self.run("DELETE FROM daily_model_usage WHERE day < ?", bindings: [.text(today)])
+ }
+ }
+
+ func readyOutbox(limit: Int, at date: Date) throws -> [AnalyticsOutboxItem] {
+ var statement: OpaquePointer?
+ try self.prepare(
+ "SELECT event_id, payload FROM outbox " +
+ "WHERE next_retry_at <= ? ORDER BY created_at LIMIT ?",
+ into: &statement
+ )
+ defer { sqlite3_finalize(statement) }
+ try self.bind([.double(date.timeIntervalSince1970), .integer(limit)], to: statement)
+
+ var items: [AnalyticsOutboxItem] = []
+ while sqlite3_step(statement) == SQLITE_ROW {
+ guard let idText = sqlite3_column_text(statement, 0) else { continue }
+ let id = String(cString: idText)
+ let byteCount = Int(sqlite3_column_bytes(statement, 1))
+ guard let bytes = sqlite3_column_blob(statement, 1), byteCount > 0 else { continue }
+ let payload = Data(bytes: bytes, count: byteCount)
+ items.append(AnalyticsOutboxItem(id: id, payload: payload))
+ }
+ return items
+ }
+
+ /// Deletes uploaded events and reclaims their SQLite pages.
+ func acknowledgeUploaded(ids: [String], at date: Date) throws {
+ guard !ids.isEmpty else { return }
+ try self.transaction {
+ for id in ids {
+ try self.run("DELETE FROM outbox WHERE event_id = ?", bindings: [.text(id)])
+ }
+ let retentionCutoff = date.addingTimeInterval(-45 * 24 * 60 * 60).timeIntervalSince1970
+ try self.run("DELETE FROM event_dedupe WHERE created_at < ?", bindings: [.double(retentionCutoff)])
+ }
+ try self.purgeDeletedPages()
+ }
+
+ func retry(ids: [String], at date: Date) throws {
+ for id in ids {
+ let attempt = try self.integer(
+ "SELECT attempt_count FROM outbox WHERE event_id = ?",
+ bindings: [.text(id)]
+ ) ?? 0
+ let nextAttempt = attempt + 1
+ let delay = min(pow(2, Double(min(nextAttempt, 10))) * 5, 60 * 60)
+ try self.run(
+ "UPDATE outbox SET attempt_count = ?, next_retry_at = ? WHERE event_id = ?",
+ bindings: [.integer(nextAttempt), .double(date.timeIntervalSince1970 + delay), .text(id)]
+ )
+ }
+ }
+
+ func discardPermanently(ids: [String]) throws {
+ try self.transaction {
+ for id in ids {
+ try self.run("DELETE FROM outbox WHERE event_id = ?", bindings: [.text(id)])
+ }
+ }
+ try self.purgeDeletedPages()
+ }
+
+ func purgeAll() throws {
+ try self.transaction {
+ try self.execute("DELETE FROM outbox")
+ try self.execute("DELETE FROM daily_usage")
+ try self.execute("DELETE FROM daily_model_usage")
+ try self.execute("DELETE FROM event_dedupe")
+ try self.execute("DELETE FROM onboarding_flows")
+ try self.execute("DELETE FROM model_download_attempts")
+ }
+ try self.purgeDeletedPages()
+ }
+
+ private func createSchema() throws {
+ try self.execute("""
+ CREATE TABLE IF NOT EXISTS outbox (
+ event_id TEXT PRIMARY KEY,
+ event_name TEXT NOT NULL,
+ payload BLOB NOT NULL,
+ attempt_count INTEGER NOT NULL DEFAULT 0,
+ next_retry_at REAL NOT NULL DEFAULT 0,
+ created_at REAL NOT NULL
+ );
+ CREATE INDEX IF NOT EXISTS outbox_ready ON outbox(next_retry_at, created_at);
+ CREATE TABLE IF NOT EXISTS daily_usage (
+ day TEXT PRIMARY KEY,
+ dictation_count INTEGER NOT NULL DEFAULT 0,
+ command_count INTEGER NOT NULL DEFAULT 0,
+ edit_count INTEGER NOT NULL DEFAULT 0,
+ meeting_count INTEGER NOT NULL DEFAULT 0
+ );
+ CREATE TABLE IF NOT EXISTS daily_model_usage (
+ day TEXT NOT NULL,
+ role TEXT NOT NULL,
+ mode TEXT NOT NULL,
+ provider TEXT NOT NULL,
+ model TEXT NOT NULL,
+ use_count INTEGER NOT NULL DEFAULT 0,
+ PRIMARY KEY(day, role, mode, provider, model)
+ );
+ CREATE TABLE IF NOT EXISTS event_dedupe (
+ dedupe_key TEXT PRIMARY KEY,
+ created_at REAL NOT NULL
+ );
+ CREATE TABLE IF NOT EXISTS onboarding_flows (
+ flow_id TEXT PRIMARY KEY,
+ origin TEXT NOT NULL,
+ created_at REAL NOT NULL,
+ completed INTEGER NOT NULL DEFAULT 0
+ );
+ CREATE TABLE IF NOT EXISTS model_download_attempts (
+ download_id TEXT PRIMARY KEY,
+ provider TEXT NOT NULL,
+ model TEXT NOT NULL,
+ source TEXT NOT NULL,
+ started_at REAL NOT NULL
+ );
+ """)
+ }
+
+ private func enqueue(_ event: AnalyticsEvent, at date: Date, properties: [String: Any]) throws {
+ let eventID = UUID().uuidString.lowercased()
+ var approvedProperties = properties
+ approvedProperties["distinct_id"] = self.distinctID
+ approvedProperties["platform"] = "macos"
+ approvedProperties["$os"] = "macOS"
+ approvedProperties["app_version"] = self.appVersion
+ approvedProperties["schema_version"] = 2
+
+ let payload: [String: Any] = [
+ "uuid": eventID,
+ "event": event.rawValue,
+ "timestamp": self.iso8601.string(from: date),
+ "properties": approvedProperties,
+ ]
+ guard JSONSerialization.isValidJSONObject(payload) else {
+ throw AnalyticsDatabaseError.invalidPayload
+ }
+ let data = try JSONSerialization.data(withJSONObject: payload)
+ try self.run(
+ "INSERT INTO outbox (event_id, event_name, payload, created_at) VALUES (?, ?, ?, ?)",
+ bindings: [.text(eventID), .text(event.rawValue), .blob(data), .double(date.timeIntervalSince1970)]
+ )
+ }
+
+ private func enqueueActivityIfNeeded(_ kind: AnalyticsActivityKind, at date: Date) throws {
+ let day = self.dayString(date)
+ guard try self.insertDedupeKey("activity:\(day)", date: date) else { return }
+ try self.enqueue(.activeUser, at: date, properties: [
+ "activity_kind": kind.rawValue,
+ "activity_date": day,
+ ])
+ }
+
+ private func upsertDailyUsage(day: String, mode: AnalyticsUsageMode) throws {
+ let column: String
+ switch mode {
+ case .dictation: column = "dictation_count"
+ case .command: column = "command_count"
+ case .edit: column = "edit_count"
+ case .meeting: column = "meeting_count"
+ }
+ try self.run(
+ "INSERT INTO daily_usage (day, \(column)) VALUES (?, 1) " +
+ "ON CONFLICT(day) DO UPDATE SET \(column) = \(column) + 1",
+ bindings: [.text(day)]
+ )
+ }
+
+ private func upsertDailyModelUsage(
+ day: String,
+ role: AnalyticsModelRole,
+ mode: AnalyticsUsageMode,
+ descriptor: AnalyticsModelDescriptor
+ ) throws {
+ try self.run(
+ "INSERT INTO daily_model_usage (day, role, mode, provider, model, use_count) " +
+ "VALUES (?, ?, ?, ?, ?, 1) ON CONFLICT(day, role, mode, provider, model) " +
+ "DO UPDATE SET use_count = use_count + 1",
+ bindings: [
+ .text(day), .text(role.rawValue), .text(mode.rawValue),
+ .text(descriptor.provider), .text(descriptor.model),
+ ]
+ )
+ }
+
+ private func activeOnboardingFlow(origin: AnalyticsOnboardingOrigin, at date: Date) throws -> String {
+ if let existing = try self.string(
+ "SELECT flow_id FROM onboarding_flows WHERE completed = 0 AND origin = ? " +
+ "ORDER BY created_at DESC LIMIT 1",
+ bindings: [.text(origin.rawValue)]
+ ) {
+ return existing
+ }
+ let flowID = UUID().uuidString.lowercased()
+ try self.run(
+ "INSERT INTO onboarding_flows (flow_id, origin, created_at) VALUES (?, ?, ?)",
+ bindings: [.text(flowID), .text(origin.rawValue), .double(date.timeIntervalSince1970)]
+ )
+ return flowID
+ }
+
+ private func insertDedupeKey(_ key: String, date: Date) throws -> Bool {
+ try self.run(
+ "INSERT OR IGNORE INTO event_dedupe (dedupe_key, created_at) VALUES (?, ?)",
+ bindings: [.text(key), .double(date.timeIntervalSince1970)]
+ ) > 0
+ }
+
+ private func dedupeKeyExists(_ key: String) throws -> Bool {
+ try self.integer(
+ "SELECT COUNT(*) FROM event_dedupe WHERE dedupe_key = ?",
+ bindings: [.text(key)]
+ ) == 1
+ }
+
+ private func modelDownloadExists(id: String) throws -> Bool {
+ try self.integer(
+ "SELECT COUNT(*) FROM model_download_attempts WHERE download_id = ?",
+ bindings: [.text(id)]
+ ) == 1
+ }
+
+ private func dayString(_ date: Date) -> String {
+ let components = self.calendar.dateComponents([.year, .month, .day], from: date)
+ return String(format: "%04d-%02d-%02d", components.year ?? 0, components.month ?? 0, components.day ?? 0)
+ }
+
+ private func purgeDeletedPages() throws {
+ try self.execute("PRAGMA incremental_vacuum")
+ try self.execute("PRAGMA wal_checkpoint(TRUNCATE)")
+ }
+
+ private func transaction(_ body: () throws -> Void) throws {
+ try self.execute("BEGIN IMMEDIATE")
+ do {
+ try body()
+ try self.execute("COMMIT")
+ } catch {
+ try? self.execute("ROLLBACK")
+ throw error
+ }
+ }
+
+ @discardableResult
+ private func run(_ sql: String, bindings: [SQLiteBinding] = []) throws -> Int {
+ var statement: OpaquePointer?
+ try self.prepare(sql, into: &statement)
+ defer { sqlite3_finalize(statement) }
+ try self.bind(bindings, to: statement)
+ guard sqlite3_step(statement) == SQLITE_DONE else { throw self.lastError() }
+ return Int(sqlite3_changes(self.connection))
+ }
+
+ private func execute(_ sql: String) throws {
+ var errorMessage: UnsafeMutablePointer<CChar>?
+ guard sqlite3_exec(self.connection, sql, nil, nil, &errorMessage) == SQLITE_OK else {
+ let message = errorMessage.map { String(cString: $0) } ?? "unknown SQLite error"
+ sqlite3_free(errorMessage)
+ throw AnalyticsDatabaseError.sqlite(message)
+ }
+ }
+
+ private func query(_ sql: String, bindings: [SQLiteBinding]) throws -> [[String]] {
+ var statement: OpaquePointer?
+ try self.prepare(sql, into: &statement)
+ defer { sqlite3_finalize(statement) }
+ try self.bind(bindings, to: statement)
+ var rows: [[String]] = []
+ while sqlite3_step(statement) == SQLITE_ROW {
+ rows.append((0..<sqlite3_column_count(statement)).map { index in
+ sqlite3_column_text(statement, index).map { String(cString: $0) } ?? ""
+ })
+ }
+ return rows
+ }
+
+ private func string(_ sql: String, bindings: [SQLiteBinding]) throws -> String? {
+ try self.query(sql, bindings: bindings).first?.first
+ }
+
+ private func integer(_ sql: String, bindings: [SQLiteBinding]) throws -> Int? {
+ try self.string(sql, bindings: bindings).flatMap(Int.init)
+ }
+
+ private func prepare(_ sql: String, into statement: inout OpaquePointer?) throws {
+ guard sqlite3_prepare_v2(self.connection, sql, -1, &statement, nil) == SQLITE_OK else {
+ throw self.lastError()
+ }
+ }
+
+ private func bind(_ bindings: [SQLiteBinding], to statement: OpaquePointer?) throws {
+ let transient = unsafeBitCast(-1, to: sqlite3_destructor_type.self)
+ for (offset, binding) in bindings.enumerated() {
+ let index = Int32(offset + 1)
+ let result: Int32
+ switch binding {
+ case let .text(value):
+ result = sqlite3_bind_text(statement, index, value, -1, transient)
+ case let .integer(value):
+ result = sqlite3_bind_int64(statement, index, sqlite3_int64(value))
+ case let .double(value):
+ result = sqlite3_bind_double(statement, index, value)
+ case let .blob(data):
+ result = data.withUnsafeBytes { bytes in
+ sqlite3_bind_blob(statement, index, bytes.baseAddress, Int32(bytes.count), transient)
+ }
+ }
+ guard result == SQLITE_OK else { throw self.lastError() }
+ }
+ }
+
+ private func lastError() -> AnalyticsDatabaseError {
+ AnalyticsDatabaseError.sqlite(String(cString: sqlite3_errmsg(self.connection)))
+ }
+}
+
+private enum SQLiteBinding {
+ case text(String)
+ case integer(Int)
+ case double(Double)
+ case blob(Data)
+}
diff --git a/Sources/Fluid/Analytics/AnalyticsEvent.swift b/Sources/Fluid/Analytics/AnalyticsEvent.swift
index e02767b2..3e8e52ee 100644
--- a/Sources/Fluid/Analytics/AnalyticsEvent.swift
+++ b/Sources/Fluid/Analytics/AnalyticsEvent.swift
@@ -1,55 +1,83 @@
import Foundation
-/// Typed analytics events to avoid typos and enforce a low-cardinality schema.
+/// Allowed analytics event names.
enum AnalyticsEvent: String {
- // App lifecycle
- case appFirstOpen = "app_first_open"
- case appOpen = "app_open"
+ case activeUser = "active_user"
+ case usageDailySummary = "usage_daily_summary"
+ case modelUsageDailySummary = "model_usage_daily_summary"
+ case onboardingStarted = "onboarding_started"
+ case onboardingStepViewed = "onboarding_step_viewed"
+ case onboardingStepCompleted = "onboarding_step_completed"
+ case onboardingCompleted = "onboarding_completed"
+ case modelDownloadStarted = "model_download_started"
+ case modelDownloadFinished = "model_download_finished"
+}
- // Consent
- case analyticsConsentChanged = "analytics_consent_changed"
+enum AnalyticsActivityKind: String {
+ case app
+ case coreAction = "core_action"
+}
- // Dictation
- case transcriptionCompleted = "transcription_completed"
- case transcriptionChunkProcessed = "transcription_chunk_processed"
- case dictationPostProcessingCompleted = "dictation_post_processing_completed"
- case outputDelivered = "output_delivered"
- case postTranscriptionEdit = "post_transcription_edit"
+enum AnalyticsUsageMode: String {
+ case dictation
+ case command
+ case edit
+ case meeting
+}
- // Command mode
- case commandModeRunCompleted = "command_mode_run_completed"
+enum AnalyticsModelRole: String {
+ case transcription
+ case aiPostProcessing = "ai_post_processing"
+}
- // Write/Rewrite
- case rewriteRunCompleted = "rewrite_run_completed"
+struct AnalyticsModelDescriptor: Equatable {
+ let provider: String
+ let model: String
- // Meeting transcription
- case meetingTranscriptionCompleted = "meeting_transcription_completed"
+ init(provider: String, model: String) {
+ self.provider = Self.normalized(provider)
+ self.model = Self.normalized(model)
+ }
- // Prompts
- case customPromptUsed = "custom_prompt_used"
+ private static func normalized(_ value: String) -> String {
+ let normalized = value
+ .trimmingCharacters(in: .whitespacesAndNewlines)
+ .lowercased()
+ .replacingOccurrences(of: " ", with: "_")
+ return normalized.isEmpty ? "unknown" : normalized
+ }
+}
- // Errors
- case errorOccurred = "error_occurred"
+enum AnalyticsOnboardingStep: String {
+ case welcome
+ case language
+ case voiceModel = "voice_model"
+ case permissions
+ case playground
+ case aiEnhancement = "ai_enhancement"
}
-enum AnalyticsMode: String {
- case dictation
- case command
- case rewrite
- case meeting
+enum AnalyticsOnboardingOrigin: String {
+ case firstRun = "first_run"
+ case manualRestart = "manual_restart"
+}
+
+enum AnalyticsOnboardingOutcome: String {
+ case continued
+ case skipped
+ case completed
+ case openedSettings = "opened_settings"
}
-enum AnalyticsOutputMethod: String {
- case typed
- case clipboard
- case historyOnly = "history_only"
+enum AnalyticsModelDownloadSource: String {
+ case onboarding
+ case settings
+ case automatic
}
-enum AnalyticsErrorDomain: String {
- case asr
- case llm
- case typing
- case hotkey
- case update
- case other
+enum AnalyticsModelDownloadOutcome: String {
+ case succeeded
+ case failed
+ case cancelled
+ case interrupted
}
diff --git a/Sources/Fluid/Analytics/AnalyticsIdentityStore.swift b/Sources/Fluid/Analytics/AnalyticsIdentityStore.swift
index a52c7224..47516329 100644
--- a/Sources/Fluid/Analytics/AnalyticsIdentityStore.swift
+++ b/Sources/Fluid/Analytics/AnalyticsIdentityStore.swift
@@ -1,6 +1,6 @@
import Foundation
-/// Stores anonymous analytics identifiers. This is intentionally NOT tied to any user identity.
+/// Persists the anonymous analytics ID across app updates.
final class AnalyticsIdentityStore {
nonisolated static let shared = AnalyticsIdentityStore()
@@ -14,7 +14,7 @@ final class AnalyticsIdentityStore {
private init() {}
nonisolated var anonymousInstallID: String {
- if let existing = defaults.string(forKey: Keys.anonymousInstallID), existing.isEmpty == false {
+ if let existing = defaults.string(forKey: Keys.anonymousInstallID), !existing.isEmpty {
return existing
}
let newID = UUID().uuidString
@@ -22,7 +22,7 @@ final class AnalyticsIdentityStore {
return newID
}
- /// Returns true if this is the first time we've ever recorded an app open on this install.
+ /// Returns whether this is the first recorded launch.
@discardableResult
nonisolated func ensureFirstOpenRecorded() -> Bool {
if self.defaults.object(forKey: Keys.firstOpenAt) == nil {
@@ -33,8 +33,7 @@ final class AnalyticsIdentityStore {
}
nonisolated var firstOpenAt: Date? {
- let ts = self.defaults.double(forKey: Keys.firstOpenAt)
- if ts <= 0 { return nil }
- return Date(timeIntervalSince1970: ts)
+ let timestamp = self.defaults.double(forKey: Keys.firstOpenAt)
+ return timestamp > 0 ? Date(timeIntervalSince1970: timestamp) : nil
}
}
diff --git a/Sources/Fluid/Analytics/AnalyticsModelResolver.swift b/Sources/Fluid/Analytics/AnalyticsModelResolver.swift
new file mode 100644
index 00000000..9cc427b3
--- /dev/null
+++ b/Sources/Fluid/Analytics/AnalyticsModelResolver.swift
@@ -0,0 +1,23 @@
+import Foundation
+
+extension SettingsStore.SpeechModel {
+ var analyticsDescriptor: AnalyticsModelDescriptor {
+ let resolvedModel: SettingsStore.SpeechModel
+ switch self {
+ case .appleSpeechAnalyzer:
+ if #available(macOS 26.0, *) {
+ resolvedModel = self
+ } else {
+ resolvedModel = .appleSpeech
+ }
+ case .qwen3Asr:
+ resolvedModel = .parakeetTDT
+ default:
+ resolvedModel = self
+ }
+ return AnalyticsModelDescriptor(
+ provider: resolvedModel.provider.rawValue,
+ model: resolvedModel.rawValue
+ )
+ }
+}
diff --git a/Sources/Fluid/Analytics/AnalyticsService.swift b/Sources/Fluid/Analytics/AnalyticsService.swift
index 30e7b032..036be0e5 100644
--- a/Sources/Fluid/Analytics/AnalyticsService.swift
+++ b/Sources/Fluid/Analytics/AnalyticsService.swift
@@ -1,315 +1,414 @@
-import Darwin
import Foundation
-/// Lightweight analytics pipeline:
-/// - bounded in-memory queue (drops oldest)
-/// - periodic background flush
-/// - fire-and-forget publishing (does not await responses)
+/// Typed API for low-volume analytics.
final class AnalyticsService {
static let shared = AnalyticsService()
private let core = AnalyticsCore()
- private static let hardwarePropertiesSnapshot = AnalyticsService.buildHardwareProperties()
private init() {}
- /// Call once at startup. Cheap and does not start networking unless configured + enabled.
func bootstrap() {
- let enabled = SettingsStore.shared.shareAnonymousAnalytics
- let config = AnalyticsConfig.fromBundle()
- Task.detached(priority: .background) { [core] in
- await core.bootstrap(enabled: enabled, config: config)
+ self.submit { core, context in
+ await core.bootstrap(context: context)
}
}
func setEnabled(_ enabled: Bool) {
- let config = AnalyticsConfig.fromBundle()
+ let context = Self.context(enabled: enabled)
Task.detached(priority: .background) { [core] in
- await core.setEnabled(enabled, config: config)
+ await core.setEnabled(enabled, context: context)
}
}
- func capture(_ event: AnalyticsEvent, properties: [String: Any] = [:]) {
- // Capture should be as close to O(1) as possible on the caller thread.
- // We compute common properties quickly (no heavy work, no content).
- let common = AnalyticsService.commonProperties()
- let merged = common.merging(properties) { _, new in new }
-
- let enabled = SettingsStore.shared.shareAnonymousAnalytics
- let config = AnalyticsConfig.fromBundle()
- let distinctID = AnalyticsIdentityStore.shared.anonymousInstallID
+ /// Records one active-user event per local day.
+ func recordAppActivity() {
+ self.submit { core, context in
+ await core.recordActivity(.app, context: context)
+ }
+ }
- Task.detached(priority: .background) { [core] in
- await core.capture(
- eventName: event.rawValue,
- distinctID: distinctID,
- enabled: enabled,
- config: config,
- properties: merged
+ /// Counts accepted usage and attempted AI requests.
+ func recordUsage(
+ mode: AnalyticsUsageMode,
+ transcriptionModel: AnalyticsModelDescriptor? = nil,
+ aiModel: AnalyticsModelDescriptor? = nil
+ ) {
+ self.submit { core, context in
+ await core.recordUsage(
+ mode: mode,
+ transcriptionModel: transcriptionModel,
+ aiModel: aiModel,
+ context: context
)
}
}
- // MARK: - Common props (low-cardinality only)
-
- private static func commonProperties() -> [String: Any] {
- let info = Bundle.main.infoDictionary
- let version = info?["CFBundleShortVersionString"] as? String ?? "unknown"
- let build = info?["CFBundleVersion"] as? String ?? "unknown"
-
- let os = ProcessInfo.processInfo.operatingSystemVersion
- let osVersion = "\(os.majorVersion).\(os.minorVersion).\(os.patchVersion)"
-
- #if arch(arm64)
- let arch = "arm64"
- #else
- let arch = "x86_64"
- #endif
-
- #if DEBUG
- let environment = "debug"
- #else
- let environment = "release"
- #endif
-
- let settings = SettingsStore.shared
-
- let anyDictationShortcutUsesAI =
- settings.dictationPromptSelection(for: .primary) != .off ||
- settings.dictationPromptSelection(for: .secondary) != .off
-
- var properties: [String: Any] = [
- "app_version": version,
- "app_build": build,
- "os_version": osVersion,
- "arch": arch,
- "environment": environment,
-
- // Low-cardinality settings snapshot
- "ai_processing_enabled": anyDictationShortcutUsesAI,
- "streaming_preview_enabled": settings.enableStreamingPreview,
- "press_and_hold_mode": settings.pressAndHoldMode,
- "hotkey_activation_mode": settings.hotkeyMode.rawValue,
- "copy_to_clipboard_enabled": settings.copyTranscriptionToClipboard,
- ]
-
- for (key, value) in Self.hardwarePropertiesSnapshot {
- properties[key] = value
+ func recordModelUsage(
+ role: AnalyticsModelRole,
+ mode: AnalyticsUsageMode,
+ descriptor: AnalyticsModelDescriptor
+ ) {
+ self.submit { core, context in
+ await core.recordModelUsage(role: role, mode: mode, descriptor: descriptor, context: context)
}
-
- return properties
}
- private static func buildHardwareProperties() -> [String: Any] {
- let architectureFamily = CPUArchitecture.isAppleSilicon ? "apple_silicon" : "intel"
- let cpuBrand = self.sysctlString("machdep.cpu.brand_string") ?? "unknown"
- let hardwareModel = self.sysctlString("hw.model") ?? "unknown"
- let chipFamily = self.normalizedChipFamily(cpuBrand: cpuBrand, architectureFamily: architectureFamily)
-
- return [
- "hardware_arch_family": architectureFamily,
- "hardware_chip_family": chipFamily,
- "hardware_model": hardwareModel,
- ]
+ func recordOnboardingStarted(origin: AnalyticsOnboardingOrigin) {
+ self.submit { core, context in
+ await core.recordOnboardingStarted(origin: origin, context: context)
+ }
}
- private static func normalizedChipFamily(cpuBrand: String, architectureFamily: String) -> String {
- let normalizedBrand = cpuBrand.lowercased()
- let tokenized = normalizedBrand
- .split(whereSeparator: { $0.isWhitespace })
- .map { token in
- String(token.unicodeScalars.filter { CharacterSet.alphanumerics.contains($0) })
- }
- .filter { !$0.isEmpty }
-
- if architectureFamily == "apple_silicon" {
- if let familyTokenIndex = tokenized.firstIndex(where: { self.isAppleMSeriesToken($0) }) {
- let family = tokenized[familyTokenIndex]
- let tiers = Set(["pro", "max", "ultra"])
- if familyTokenIndex + 1 < tokenized.count {
- let tier = tokenized[familyTokenIndex + 1]
- if tiers.contains(tier) {
- return "\(family)_\(tier)"
- }
- }
- return family
- }
- return "apple_silicon_other"
+ func recordOnboardingStepViewed(_ step: AnalyticsOnboardingStep, origin: AnalyticsOnboardingOrigin) {
+ self.submit { core, context in
+ await core.recordOnboardingStepViewed(step, origin: origin, context: context)
}
+ }
- if let intelTier = ["i9", "i7", "i5", "i3"].first(where: { tier in
- tokenized.contains(where: { $0.hasPrefix(tier) })
- }) {
- return "intel_\(intelTier)"
- }
- if tokenized.contains(where: { $0.contains("xeon") }) {
- return "intel_xeon"
+ func recordOnboardingStepCompleted(
+ _ step: AnalyticsOnboardingStep,
+ outcome: AnalyticsOnboardingOutcome,
+ origin: AnalyticsOnboardingOrigin,
+ completesFlow: Bool = false
+ ) {
+ self.submit { core, context in
+ await core.recordOnboardingStepCompleted(
+ step,
+ outcome: outcome,
+ origin: origin,
+ completesFlow: completesFlow,
+ context: context
+ )
}
- return "intel_other"
}
- private static func isAppleMSeriesToken(_ token: String) -> Bool {
- guard token.hasPrefix("m"), token.count > 1 else { return false }
- return token.dropFirst().allSatisfy(\.isNumber)
+ func recordModelDownloadStarted(
+ id: UUID,
+ descriptor: AnalyticsModelDescriptor,
+ source: AnalyticsModelDownloadSource
+ ) {
+ self.submit { core, context in
+ await core.recordModelDownloadStarted(
+ id: id.uuidString.lowercased(),
+ descriptor: descriptor,
+ source: source,
+ context: context
+ )
+ }
}
- private static func sysctlString(_ name: String) -> String? {
- var size: size_t = 0
- guard sysctlbyname(name, nil, &size, nil, 0) == 0, size > 0 else { return nil }
+ func recordModelDownloadFinished(
+ id: UUID,
+ descriptor: AnalyticsModelDescriptor,
+ source: AnalyticsModelDownloadSource,
+ outcome: AnalyticsModelDownloadOutcome,
+ duration: TimeInterval?
+ ) {
+ self.submit { core, context in
+ await core.recordModelDownloadFinished(
+ id: id.uuidString.lowercased(),
+ descriptor: descriptor,
+ source: source,
+ outcome: outcome,
+ duration: duration,
+ context: context
+ )
+ }
+ }
- var buffer = [CChar](repeating: 0, count: size)
- guard sysctlbyname(name, &buffer, &size, nil, 0) == 0 else { return nil }
+ private func submit(
+ _ operation: @escaping @Sendable (AnalyticsCore, AnalyticsContext) async -> Void
+ ) {
+ let context = Self.context(enabled: SettingsStore.shared.shareAnonymousAnalytics)
+ Task.detached(priority: .background) { [core] in
+ await operation(core, context)
+ }
+ }
- let value = String(cString: buffer).trimmingCharacters(in: .whitespacesAndNewlines)
- return value.isEmpty ? nil : value
+ private static func context(enabled: Bool) -> AnalyticsContext {
+ let version = Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? "unknown"
+ return AnalyticsContext(
+ enabled: enabled,
+ config: AnalyticsConfig.fromBundle(),
+ distinctID: AnalyticsIdentityStore.shared.anonymousInstallID,
+ appVersion: version
+ )
}
}
-// MARK: - Core (actor)
+private struct AnalyticsContext {
+ let enabled: Bool
+ let config: AnalyticsConfig
+ let distinctID: String
+ let appVersion: String
+}
private actor AnalyticsCore {
- private var enabled: Bool = true
- private var config: AnalyticsConfig = .fromBundle()
-
- // Bounded queue to protect memory.
- private var queue: [[String: Any]] = []
- private let maxQueuedEvents: Int = 200
-
- // Flush tuning.
- private let flushAt: Int = 20
- private let flushIntervalSeconds: UInt64 = 30
-
+ private var context: AnalyticsContext?
+ private var database: AnalyticsDatabase?
private var flushTask: Task<Void, Never>?
- private var isFlushing: Bool = false
-
- func bootstrap(enabled: Bool, config: AnalyticsConfig) async {
- self.enabled = enabled
- self.config = config
+ private var isFlushing = false
- // Record first open timestamp (used for retention-style calculations).
- _ = AnalyticsIdentityStore.shared.ensureFirstOpenRecorded()
+ private let batchSize = 50
- self.startFlushLoopIfNeeded()
+ func bootstrap(context: AnalyticsContext) async {
+ self.context = context
+ guard context.enabled else {
+ try? self.purgeStoredAnalyticsIfPresent(context: context)
+ return
+ }
+ guard context.config.isConfigured else { return }
+ do {
+ let database = try self.database(for: context)
+ try database.finalizeDays(before: Date())
+ try database.recoverInterruptedModelDownloads(at: Date())
+ self.startFlushLoopIfNeeded()
+ await self.flushIfNeeded()
+ } catch {
+ self.stopFlushLoop()
+ }
}
- func setEnabled(_ enabled: Bool, config: AnalyticsConfig) async {
- self.enabled = enabled
- self.config = config
-
+ func setEnabled(_ enabled: Bool, context: AnalyticsContext) async {
+ self.context = context
if !enabled {
- // Drop any pending events to honor opt-out immediately.
- self.queue.removeAll(keepingCapacity: true)
+ self.stopFlushLoop()
+ try? self.purgeStoredAnalyticsIfPresent(context: context)
+ return
}
+ await self.bootstrap(context: context)
+ }
- self.startFlushLoopIfNeeded()
+ func recordActivity(_ kind: AnalyticsActivityKind, context: AnalyticsContext) async {
+ await self.write(context: context) { database, date in
+ try database.recordActivity(kind, at: date)
+ }
}
- func capture(
- eventName: String,
- distinctID: String,
- enabled: Bool,
- config: AnalyticsConfig,
- properties: [String: Any]
+ func recordUsage(
+ mode: AnalyticsUsageMode,
+ transcriptionModel: AnalyticsModelDescriptor?,
+ aiModel: AnalyticsModelDescriptor?,
+ context: AnalyticsContext
) async {
- // Use latest values passed by caller to avoid cross-actor UserDefaults reads.
- self.enabled = enabled
- self.config = config
+ await self.write(context: context) { database, date in
+ try database.recordUsage(
+ mode: mode,
+ transcriptionModel: transcriptionModel,
+ aiModel: aiModel,
+ at: date
+ )
+ }
+ }
- guard self.enabled, self.config.isConfigured else { return }
+ func recordModelUsage(
+ role: AnalyticsModelRole,
+ mode: AnalyticsUsageMode,
+ descriptor: AnalyticsModelDescriptor,
+ context: AnalyticsContext
+ ) async {
+ await self.write(context: context) { database, date in
+ try database.recordModelUsage(role: role, mode: mode, descriptor: descriptor, at: date)
+ }
+ }
- var event: [String: Any] = [:]
- event["event"] = eventName
- event["timestamp"] = ISO8601DateFormatter().string(from: Date())
+ func recordOnboardingStarted(origin: AnalyticsOnboardingOrigin, context: AnalyticsContext) async {
+ await self.write(context: context) { database, date in
+ try database.recordOnboardingStarted(origin: origin, at: date)
+ }
+ }
- // PostHog expects distinct_id inside properties.
- var props = properties
- props["distinct_id"] = distinctID
- props["$lib"] = "FluidVoice"
- props["$lib_version"] = "1"
- event["properties"] = props
+ func recordOnboardingStepViewed(
+ _ step: AnalyticsOnboardingStep,
+ origin: AnalyticsOnboardingOrigin,
+ context: AnalyticsContext
+ ) async {
+ await self.write(context: context) { database, date in
+ try database.recordOnboardingStepViewed(step, origin: origin, at: date)
+ }
+ }
- self.enqueue(event)
+ func recordOnboardingStepCompleted(
+ _ step: AnalyticsOnboardingStep,
+ outcome: AnalyticsOnboardingOutcome,
+ origin: AnalyticsOnboardingOrigin,
+ completesFlow: Bool,
+ context: AnalyticsContext
+ ) async {
+ await self.write(context: context) { database, date in
+ try database.recordOnboardingStepCompleted(
+ step,
+ outcome: outcome,
+ origin: origin,
+ completesFlow: completesFlow,
+ at: date
+ )
+ }
+ }
- if self.queue.count >= self.flushAt {
- await self.flushIfNeeded()
+ func recordModelDownloadStarted(
+ id: String,
+ descriptor: AnalyticsModelDescriptor,
+ source: AnalyticsModelDownloadSource,
+ context: AnalyticsContext
+ ) async {
+ await self.write(context: context) { database, date in
+ try database.recordModelDownloadStarted(id: id, descriptor: descriptor, source: source, at: date)
}
}
- private func enqueue(_ event: [String: Any]) {
- self.queue.append(event)
- if self.queue.count > self.maxQueuedEvents {
- // Drop oldest.
- self.queue.removeFirst(self.queue.count - self.maxQueuedEvents)
+ func recordModelDownloadFinished(
+ id: String,
+ descriptor: AnalyticsModelDescriptor,
+ source: AnalyticsModelDownloadSource,
+ outcome: AnalyticsModelDownloadOutcome,
+ duration: TimeInterval?,
+ context: AnalyticsContext
+ ) async {
+ await self.write(context: context) { database, date in
+ try database.recordModelDownloadFinished(
+ id: id,
+ descriptor: descriptor,
+ source: source,
+ outcome: outcome,
+ duration: duration,
+ at: date
+ )
}
}
- private func startFlushLoopIfNeeded() {
- // Only run a background flush loop when enabled and configured.
- guard self.enabled, self.config.isConfigured else {
- self.flushTask?.cancel()
- self.flushTask = nil
+ private func write(
+ context: AnalyticsContext,
+ operation: (AnalyticsDatabase, Date) throws -> Void
+ ) async {
+ self.context = context
+ guard context.enabled, context.config.isConfigured else { return }
+ do {
+ let database = try self.database(for: context)
+ try operation(database, Date())
+ self.startFlushLoopIfNeeded()
+ } catch {
return
}
+ }
- guard self.flushTask == nil else { return }
+ private func database(for context: AnalyticsContext) throws -> AnalyticsDatabase {
+ if let database { return database }
+ let url = try self.databaseURL()
+ let database = try AnalyticsDatabase(
+ url: url,
+ distinctID: context.distinctID,
+ appVersion: context.appVersion
+ )
+ self.database = database
+ return database
+ }
+
+ private func databaseURL() throws -> URL {
+ let applicationSupport = try FileManager.default.url(
+ for: .applicationSupportDirectory,
+ in: .userDomainMask,
+ appropriateFor: nil,
+ create: true
+ )
+ let directoryName = Bundle.main.bundleIdentifier ?? "FluidVoice"
+ return applicationSupport
+ .appendingPathComponent(directoryName, isDirectory: true)
+ .appendingPathComponent("Analytics", isDirectory: true)
+ .appendingPathComponent("analytics-v2.sqlite3")
+ }
+
+ private func purgeStoredAnalyticsIfPresent(context: AnalyticsContext) throws {
+ if let database {
+ try database.purgeAll()
+ return
+ }
+ let url = try self.databaseURL()
+ guard FileManager.default.fileExists(atPath: url.path) else { return }
+ let existingDatabase = try AnalyticsDatabase(
+ url: url,
+ distinctID: context.distinctID,
+ appVersion: context.appVersion
+ )
+ try existingDatabase.purgeAll()
+ }
- self.flushTask = Task.detached(priority: .background) { [weak self] in
- guard let self else { return }
+ private func startFlushLoopIfNeeded() {
+ guard self.flushTask == nil, let context, context.enabled, context.config.isConfigured else { return }
+ self.flushTask = Task { [weak self] in
while !Task.isCancelled {
- try? await Task.sleep(nanoseconds: self.flushIntervalSeconds * 1_000_000_000)
- await self.flushIfNeeded()
+ try? await Task.sleep(for: .seconds(30))
+ guard !Task.isCancelled else { return }
+ await self?.flushIfNeeded()
}
}
}
+ private func stopFlushLoop() {
+ self.flushTask?.cancel()
+ self.flushTask = nil
+ }
+
private func flushIfNeeded() async {
- guard self.enabled, self.config.isConfigured else { return }
- guard !self.queue.isEmpty else { return }
- guard !self.isFlushing else { return }
+ guard !self.isFlushing,
+ let context,
+ context.enabled,
+ context.config.isConfigured,
+ let database
+ else { return }
self.isFlushing = true
defer { self.isFlushing = false }
- // Drain up to max batch size.
- let batchCount = min(self.queue.count, self.maxQueuedEvents)
- let batch = Array(self.queue.prefix(batchCount))
- self.queue.removeFirst(batchCount)
-
- await self.sendBatch(batch)
- }
-
- private func sendBatch(_ batch: [[String: Any]]) async {
- // Fire-and-forget network request; do not await response.
- let host = self.config.postHogHost
- let apiKey = self.config.postHogApiKey
-
- guard let url = URL(string: host)?.appendingPathComponent("batch") else { return }
-
- var payload: [String: Any] = [
- "api_key": apiKey,
- "batch": batch,
- ]
-
- // Ensure payload is JSON serializable.
- guard JSONSerialization.isValidJSONObject(payload) else { return }
+ let items: [AnalyticsOutboxItem]
+ do {
+ try database.finalizeDays(before: Date())
+ items = try database.readyOutbox(limit: self.batchSize, at: Date())
+ } catch {
+ return
+ }
+ guard !items.isEmpty else { return }
- let data: Data
+ let ids = items.map(\.id)
+ let status: Int
do {
- data = try JSONSerialization.data(withJSONObject: payload, options: [])
+ status = try await self.send(items: items, config: context.config)
} catch {
+ try? database.retry(ids: ids, at: Date())
return
}
+ switch status {
+ case 200..<300:
+ try? database.acknowledgeUploaded(ids: ids, at: Date())
+ case 408, 429, 500...599:
+ try? database.retry(ids: ids, at: Date())
+ default:
+ try? database.discardPermanently(ids: ids)
+ }
+ }
+
+ private func send(items: [AnalyticsOutboxItem], config: AnalyticsConfig) async throws -> Int {
+ guard let url = URL(string: config.postHogHost)?.appendingPathComponent("batch") else {
+ throw URLError(.badURL)
+ }
+ let batch = try items.map { item -> Any in
+ try JSONSerialization.jsonObject(with: item.payload)
+ }
+ let body: [String: Any] = ["api_key": config.postHogApiKey, "batch": batch]
+ let data = try JSONSerialization.data(withJSONObject: body)
+
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.httpBody = data
+ request.timeoutInterval = 10
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
- request.timeoutInterval = 8
- // Detached task ensures we never block the actor while URLSession does its work.
- Task.detached(priority: .background) {
- let session = URLSession.shared
- _ = try? await session.data(for: request)
+ let (_, response) = try await URLSession.shared.data(for: request)
+ guard let httpResponse = response as? HTTPURLResponse else {
+ throw URLError(.badServerResponse)
}
+ return httpResponse.statusCode
}
}
diff --git a/Sources/Fluid/Analytics/PostTranscriptionEditTracker.swift b/Sources/Fluid/Analytics/PostTranscriptionEditTracker.swift
deleted file mode 100644
index 63cd2ddd..00000000
--- a/Sources/Fluid/Analytics/PostTranscriptionEditTracker.swift
+++ /dev/null
@@ -1,114 +0,0 @@
-import AppKit
-import Foundation
-
-/// Tracks whether the user immediately edits freshly-typed dictation output (Backspace / Cmd+A).
-/// Privacy: stores only low-cardinality metadata; never stores transcript content.
-actor PostTranscriptionEditTracker {
- static let shared = PostTranscriptionEditTracker()
-
- private init() {}
-
- // MARK: - State
-
- private struct ActiveWindow {
- let completedAt: Date
- let wordsBucket: String
- let xSeconds: Int
- let aiUsed: Bool
- let aiModel: String?
- let aiProvider: String?
- let mode: String
- let outputMethod: String
- }
-
- private var active: ActiveWindow?
-
- // MARK: - Public API
-
- func markTranscriptionCompleted(
- mode: String,
- outputMethod: String,
- wordsBucket: String,
- aiUsed: Bool,
- aiModel: String?,
- aiProvider: String?
- ) {
- let x = Self.xSeconds(forWordsBucket: wordsBucket)
- guard x > 0 else {
- self.active = nil
- return
- }
-
- self.active = ActiveWindow(
- completedAt: Date(),
- wordsBucket: wordsBucket,
- xSeconds: x,
- aiUsed: aiUsed,
- aiModel: aiUsed ? aiModel : nil,
- aiProvider: aiUsed ? aiProvider : nil,
- mode: mode,
- outputMethod: outputMethod
- )
- }
-
- func handleKeyDown(keyCode: UInt16, modifiers: NSEvent.ModifierFlags) async {
- guard let active else { return }
-
- let elapsed = Date().timeIntervalSince(active.completedAt)
- if elapsed < 0 || elapsed > Double(active.xSeconds) {
- self.active = nil
- return
- }
-
- let action: String?
- if keyCode == 51 { // Backspace (delete)
- action = "backspace"
- } else if keyCode == 0, modifiers.contains(.command) { // Cmd + A
- action = "cmd_a"
- } else {
- action = nil
- }
-
- guard let action else { return }
-
- var props: [String: Any] = [
- "mode": active.mode,
- "edit_action": action,
- "words_bucket": active.wordsBucket,
- "x_seconds": active.xSeconds,
- "time_since_completion_bucket": AnalyticsBuckets.bucketSeconds(elapsed),
- "ai_used": active.aiUsed,
- "output_method": active.outputMethod,
- ]
-
- if let model = active.aiModel {
- props["ai_model"] = model
- }
- if let provider = active.aiProvider {
- props["ai_provider"] = provider
- }
-
- let properties = props
- await MainActor.run {
- AnalyticsService.shared.capture(.postTranscriptionEdit, properties: properties)
- }
-
- // Single-fire per transcription window.
- self.active = nil
- }
-
- // MARK: - Window mapping
-
- private static func xSeconds(forWordsBucket bucket: String) -> Int {
- switch bucket {
- case "0": return 0
- case "1-5": return 2
- case "6-20": return 3
- case "21-50": return 5
- case "51-100": return 8
- case "101-300": return 12
- case "301+": return 15
- default: return 5
- }
- }
-}
diff --git a/Sources/Fluid/AppDelegate.swift b/Sources/Fluid/AppDelegate.swift
index 77c9a444..3e22814f 100644
--- a/Sources/Fluid/AppDelegate.swift
+++ b/Sources/Fluid/AppDelegate.swift
@@ -17,6 +17,7 @@ class AppDelegate: NSObject, NSApplicationDelegate, UNUserNotificationCenterDele
private var didRequestMainWindowReopen = false
private var shouldSuppressNextReopenActivation = false
private var wasLaunchedAsLoginItem = false
+ private var analyticsActivationSuppressionDeadline: Date?
private var hasDeferredMLXUpgradeOffer = false
var shouldPresentStartupMicrophoneNotice: Bool {
@@ -29,6 +30,9 @@ class AppDelegate: NSObject, NSApplicationDelegate, UNUserNotificationCenterDele
// Must be read during the launch callback - the current Apple Event identifies
// login-item launches (used to optionally start silently, see issue #369).
self.wasLaunchedAsLoginItem = Self.detectLoginItemLaunch()
+ if self.wasLaunchedAsLoginItem {
+ self.analyticsActivationSuppressionDeadline = Date().addingTimeInterval(3)
+ }
DebugLogger.shared.info(
"Application launched [loginItemLaunch=\(self.wasLaunchedAsLoginItem)]",
source: "AppDelegate"
@@ -47,14 +51,6 @@ class AppDelegate: NSObject, NSApplicationDelegate, UNUserNotificationCenterDele
AnalyticsService.shared.bootstrap()
- if isTrueFirstOpen {
- AnalyticsService.shared.capture(.appFirstOpen)
- }
- AnalyticsService.shared.capture(
- .appOpen,
- properties: ["accessibility_trusted": AXIsProcessTrusted()]
- )
-
// Check for updates automatically if enabled (initial check on launch)
self.checkForUpdatesAutomatically()
@@ -139,9 +135,16 @@ class AppDelegate: NSObject, NSApplicationDelegate, UNUserNotificationCenterDele
}
func applicationDidBecomeActive(_ notification: Notification) {
- guard self.hasDeferredMLXUpgradeOffer else { return }
- self.hasDeferredMLXUpgradeOffer = false
- self.scheduleMLXUpgradeOffer()
+ if let deadline = self.analyticsActivationSuppressionDeadline, Date() <= deadline {
+ self.analyticsActivationSuppressionDeadline = nil
+ } else {
+ self.analyticsActivationSuppressionDeadline = nil
+ AnalyticsService.shared.recordAppActivity()
+ }
+ if self.hasDeferredMLXUpgradeOffer {
+ self.hasDeferredMLXUpgradeOffer = false
+ self.scheduleMLXUpgradeOffer()
+ }
}
func userNotificationCenter(
diff --git a/Sources/Fluid/ContentView.swift b/Sources/Fluid/ContentView.swift
index a3cacb21..a95f8e4b 100644
--- a/Sources/Fluid/ContentView.swift
+++ b/Sources/Fluid/ContentView.swift
@@ -2148,31 +2148,25 @@ struct ContentView: View {
// If this was a rewrite recording, process the rewrite instead of typing
if wasRewriteMode {
DebugLogger.shared.info("Processing rewrite with instruction: \(transcribedText)", source: "ContentView")
+ AnalyticsService.shared.recordModelUsage(
+ role: .transcription,
+ mode: .edit,
+ descriptor: self.settings.selectedSpeechModel.analyticsDescriptor
+ )
let appInfo = self.recordingAppInfo ?? self.getCurrentAppInfo()
await self.processRewriteWithVoiceInstruction(transcribedText, appInfo: appInfo)
- AnalyticsService.shared.capture(
- .transcriptionCompleted,
- properties: [
- "mode": AnalyticsMode.rewrite.rawValue,
- "words_bucket": AnalyticsBuckets.bucketWords(AnalyticsBuckets.wordCount(in: transcribedText)),
- "ai_used": true,
- ]
- )
return
}
// If this was a command recording, process the command
if wasCommandMode {
DebugLogger.shared.info("Processing command: \(transcribedText)", source: "ContentView")
- await self.processCommandWithVoice(transcribedText)
- AnalyticsService.shared.capture(
- .transcriptionCompleted,
- properties: [
- "mode": AnalyticsMode.command.rawValue,
- "words_bucket": AnalyticsBuckets.bucketWords(AnalyticsBuckets.wordCount(in: transcribedText)),
- "ai_used": true,
- ]
+ AnalyticsService.shared.recordModelUsage(
+ role: .transcription,
+ mode: .command,
+ descriptor: self.settings.selectedSpeechModel.analyticsDescriptor
)
+ await self.processCommandWithVoice(transcribedText)
return
}
@@ -2191,13 +2185,21 @@ struct ContentView: View {
DictationAIPostProcessingGate.isConfigured(for: $0, appBundleID: appInfo.bundleId)
} ?? DictationAIPostProcessingGate.isConfigured(for: .primary, appBundleID: appInfo.bundleId)
let transcriptionModelInfo = self.currentTranscriptionModelInfo()
+ let postProcessingModelInfo = self.currentDictationAIModelInfo(
+ dictationSlot: activeDictationSlot,
+ appBundleID: appInfo.bundleId
+ )
+ AnalyticsService.shared.recordUsage(
+ mode: .dictation,
+ transcriptionModel: self.settings.selectedSpeechModel.analyticsDescriptor,
+ aiModel: shouldUseAI ? AnalyticsModelDescriptor(
+ provider: postProcessingModelInfo.provider ?? "unknown",
+ model: postProcessingModelInfo.model ?? "unknown"
+ ) : nil
+ )
if shouldUseAI {
DebugLogger.shared.debug("Routing transcription through AI post-processing", source: "ContentView")
- let postProcessingModelInfo = self.currentDictationAIModelInfo(
- dictationSlot: activeDictationSlot,
- appBundleID: appInfo.bundleId
- )
postProcessingModel = postProcessingModelInfo.model
let postProcessingInputChars = normalizedTranscribedText.count
let postProcessingStart = Date()
@@ -2255,18 +2257,6 @@ struct ContentView: View {
+ "inputChars=\(postProcessingInputChars) fallback=\(aiFallbackReason != nil)",
source: "ContentView"
)
- AnalyticsService.shared.capture(
- .dictationPostProcessingCompleted,
- properties: [
- "latency_ms": postProcessingLatencyMs,
- "input_chars": postProcessingInputChars,
- "post_processing_provider": postProcessingModelInfo.provider ?? "unknown",
- "post_processing_model": postProcessingModelInfo.model ?? "unknown",
- "transcription_provider": transcriptionModelInfo.provider,
- "transcription_model": transcriptionModelInfo.model,
- ]
- )
-
// Clear transient status text before leaving processing state to avoid
// a brief non-shimmer "Refining..." preview flash.
NotchOverlayManager.shared.updateTranscriptionText("")
@@ -2316,18 +2306,6 @@ struct ContentView: View {
self.appBench("transcription_finalized chars=\(finalText.count)")
self.appBench("text_ready chars=\(finalText.count)")
- AnalyticsService.shared.capture(
- .transcriptionCompleted,
- properties: [
- "mode": AnalyticsMode.dictation.rawValue,
- "words_bucket": AnalyticsBuckets.bucketWords(AnalyticsBuckets.wordCount(in: finalText)),
- "ai_used": shouldUseAI,
- "ai_changed_text": transcribedText != finalText,
- "transcription_provider": transcriptionModelInfo.provider,
- "transcription_model": transcriptionModelInfo.model,
- ]
- )
-
let shouldPersistOutputs = route == .normal
if !shouldPersistOutputs {
DebugLogger.shared.info(
@@ -2379,13 +2357,6 @@ struct ContentView: View {
if shouldCopyToClipboard {
ClipboardService.copyToClipboard(finalText)
- AnalyticsService.shared.capture(
- .outputDelivered,
- properties: [
- "mode": AnalyticsMode.dictation.rawValue,
- "method": AnalyticsOutputMethod.clipboard.rawValue,
- ]
- )
}
var didTypeExternally = false
@@ -2418,42 +2389,6 @@ struct ContentView: View {
}
}
- if didTypeExternally {
- AnalyticsService.shared.capture(
- .outputDelivered,
- properties: [
- "mode": AnalyticsMode.dictation.rawValue,
- "method": AnalyticsOutputMethod.typed.rawValue,
- ]
- )
-
- // Register the post-transcription edit observation after insertion is dispatched.
- let wordsBucket = AnalyticsBuckets.bucketWords(AnalyticsBuckets.wordCount(in: finalText))
- let modelInfo = self.currentDictationAIModelInfo(
- dictationSlot: activeDictationSlot,
- appBundleID: appInfo.bundleId
- )
- await PostTranscriptionEditTracker.shared.markTranscriptionCompleted(
- mode: AnalyticsMode.dictation.rawValue,
- outputMethod: AnalyticsOutputMethod.typed.rawValue,
- wordsBucket: wordsBucket,
- aiUsed: shouldUseAI,
- aiModel: modelInfo.model,
- aiProvider: modelInfo.provider
- )
- } else if shouldPersistOutputs,
- SettingsStore.shared.copyTranscriptionToClipboard == false,
- SettingsStore.shared.saveTranscriptionHistory
- {
- AnalyticsService.shared.capture(
- .outputDelivered,
- properties: [
- "mode": AnalyticsMode.dictation.rawValue,
- "method": AnalyticsOutputMethod.historyOnly.rawValue,
- ]
- )
- }
-
if !didTypeExternally, !shouldShowAIProcessingFailure, !didRequestOverlayHideOnStop {
self.hideOverlayAfterOutput()
}
@@ -2950,13 +2885,6 @@ struct ContentView: View {
// Copy to clipboard as backup
if SettingsStore.shared.copyTranscriptionToClipboard {
ClipboardService.copyToClipboard(self.rewriteModeService.rewrittenText)
- AnalyticsService.shared.capture(
- .outputDelivered,
- properties: [
- "mode": AnalyticsMode.rewrite.rawValue,
- "method": AnalyticsOutputMethod.clipboard.rawValue,
- ]
- )
}
// Type the rewritten text
@@ -2968,27 +2896,12 @@ struct ContentView: View {
self.rewriteModeService.rewrittenText,
preferredTargetPID: typingTarget.pid
)
- AnalyticsService.shared.capture(
- .outputDelivered,
- properties: [
- "mode": AnalyticsMode.rewrite.rawValue,
- "method": AnalyticsOutputMethod.typed.rawValue,
- ]
- )
-
// Clear the rewrite service state for next use
self.rewriteModeService.clearState()
self.hideOverlayAfterOutput()
} else {
await self.menuBarManager.finishProcessingAndHideOverlay()
DebugLogger.shared.error("Rewrite failed - no result", source: "ContentView")
- AnalyticsService.shared.capture(
- .errorOccurred,
- properties: [
- "domain": AnalyticsErrorDomain.llm.rawValue,
- "category": "rewrite_no_result",
- ]
- )
}
}
diff --git a/Sources/Fluid/Persistence/SettingsStore.swift b/Sources/Fluid/Persistence/SettingsStore.swift
index 50b378d4..89bf20de 100644
--- a/Sources/Fluid/Persistence/SettingsStore.swift
+++ b/Sources/Fluid/Persistence/SettingsStore.swift
@@ -2586,6 +2586,10 @@ final class SettingsStore: ObservableObject {
!self.onboardingCompleted
}
+ var analyticsOnboardingOrigin: AnalyticsOnboardingOrigin {
+ self.defaults.bool(forKey: Keys.manualOnboardingResetRequested) ? .manualRestart : .firstRun
+ }
+
var shouldPromptAccessibilityOnLaunch: Bool {
!self.shouldShowOnboarding
}
@@ -3851,6 +3855,24 @@ final class SettingsStore: ObservableObject {
return ModelRepository.shared.defaultModels(for: providerID).first
}
+ func analyticsAIModelDescriptor(for mode: AnalyticsUsageMode) -> AnalyticsModelDescriptor? {
+ let providerID: String
+ let selectedModel: String?
+ switch mode {
+ case .edit:
+ providerID = self.rewriteModeLinkedToGlobal ? self.selectedProviderID : self.rewriteModeSelectedProviderID
+ selectedModel = self.rewriteModeLinkedToGlobal ? self.modelSelection(for: providerID) : self.rewriteModeSelectedModel
+ case .command:
+ providerID = self.commandModeLinkedToGlobal ? self.selectedProviderID : self.commandModeSelectedProviderID
+ selectedModel = self.commandModeLinkedToGlobal ? self.modelSelection(for: providerID) : self.commandModeSelectedModel
+ case .dictation, .meeting:
+ providerID = self.selectedProviderID
+ selectedModel = self.modelSelection(for: providerID)
+ }
+ guard !providerID.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else { return nil }
+ return AnalyticsModelDescriptor(provider: providerID, model: selectedModel ?? "unknown")
+ }
+
private func availableSelectedProviderID(for rawValue: String?) -> String {
let trimmed = rawValue?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
guard !trimmed.isEmpty else { return "" }
diff --git a/Sources/Fluid/Services/ASRService.swift b/Sources/Fluid/Services/ASRService.swift
index 200e5297..9557ea92 100644
--- a/Sources/Fluid/Services/ASRService.swift
+++ b/Sources/Fluid/Services/ASRService.swift
@@ -271,6 +271,7 @@ final class ASRService: ObservableObject {
private var ensureReadyOperationID: UUID?
private var modelDownloadTask: Task<Void, Error>?
private var modelDownloadOperationID: UUID?
+ private var modelDownloadAnalyticsStates: [UUID: ModelDownloadAnalyticsState] = [:]
private var modelExistenceCheckID: UUID?
var hasActiveModelPreparation: Bool {
@@ -473,77 +474,6 @@ final class ASRService: ObservableObject {
DebugLogger.shared.benchmark("ASR_BENCH", message: "session=\(self.benchmarkSessionID) \(message)", source: "ASRBenchmark")
}
- private func streamingChunkErrorCategory(for error: Error) -> String {
- if error is CancellationError {
- return "cancelled"
- }
-
- let nsError = error as NSError
- switch nsError.domain {
- case AVFoundationErrorDomain:
- return "avfoundation"
- case NSOSStatusErrorDomain:
- return "osstatus"
- case NSCocoaErrorDomain:
- return "cocoa"
- default:
- return "other"
- }
- }
-
- private func shouldCaptureStreamingChunkAnalytics(success: Bool) -> Bool {
- if success {
- self.streamingChunkAnalyticsSuccessCount += 1
- if self.streamingChunkAnalyticsSuccessCount == 1 {
- return true
- }
- return self.streamingChunkAnalyticsSuccessCount % self.streamingChunkAnalyticsSuccessSampleRate == 0
- }
-
- let now = Date()
- guard let lastFailureCaptureAt = self.lastStreamingChunkFailureAnalyticsAt else {
- self.lastStreamingChunkFailureAnalyticsAt = now
- return true
- }
-
- guard now.timeIntervalSince(lastFailureCaptureAt) >= self.streamingChunkFailureMinIntervalSeconds else {
- return false
- }
-
- self.lastStreamingChunkFailureAnalyticsAt = now
- return true
- }
-
- private func captureStreamingChunkAnalytics(
- success: Bool,
- chunkSampleCount: Int,
- latencyMs: Int,
- error: Error? = nil
- ) {
- guard self.shouldCaptureStreamingChunkAnalytics(success: success) else { return }
-
- let dims = self.currentTranscriptionAnalyticsDimensions()
- var properties: [String: Any] = [
- "success": success,
- "latency_ms": latencyMs,
- "chunk_samples": chunkSampleCount,
- "chunk_audio_seconds": Double(chunkSampleCount) / 16_000.0,
- "transcription_provider": dims.provider,
- "transcription_model": dims.model,
- "success_sample_rate_chunks": self.streamingChunkAnalyticsSuccessSampleRate,
- "failure_min_interval_seconds": self.streamingChunkFailureMinIntervalSeconds,
- ]
-
- if let error {
- properties["error_category"] = self.streamingChunkErrorCategory(for: error)
- }
-
- AnalyticsService.shared.capture(
- .transcriptionChunkProcessed,
- properties: properties
- )
- }
-
/// Gets a provider for a specific model (without changing the active selection)
/// Used for downloading models without switching the active model.
private func getProvider(for model: SettingsStore.SpeechModel) -> TranscriptionProvider {
@@ -578,7 +508,11 @@ final class ASRService: ObservableObject {
/// - Parameters:
/// - model: The model to download
/// - progressHandler: Optional callback for download progress (0.0 to 1.0)
- func downloadModel(_ model: SettingsStore.SpeechModel, progressHandler: ((Double) -> Void)?) async throws {
+ func downloadModel(
+ _ model: SettingsStore.SpeechModel,
+ source: AnalyticsModelDownloadSource = .settings,
+ progressHandler: ((Double) -> Void)?
+ ) async throws {
guard self.modelDownloadTask == nil, self.ensureReadyTask == nil else {
throw NSError(
domain: "ASRService",
@@ -610,7 +544,10 @@ final class ASRService: ObservableObject {
self.applyModelPreparationProgress(
progress,
updatesActiveModelState: false,
- externalProgressHandler: progressHandler
+ externalProgressHandler: progressHandler,
+ analyticsOperationID: operationID,
+ analyticsDescriptor: model.analyticsDescriptor,
+ analyticsSource: source
)
}
})
@@ -643,10 +580,19 @@ final class ASRService: ObservableObject {
}
}
- try await withTaskCancellationHandler {
- try await task.value
- } onCancel: {
- task.cancel()
+ do {
+ try await withTaskCancellationHandler {
+ try await task.value
+ } onCancel: {
+ task.cancel()
+ }
+ self.finishModelDownloadAnalytics(operationID: operationID, outcome: .succeeded)
+ } catch is CancellationError {
+ self.finishModelDownloadAnalytics(operationID: operationID, outcome: .cancelled)
+ throw CancellationError()
+ } catch {
+ self.finishModelDownloadAnalytics(operationID: operationID, outcome: .failed)
+ throw error
}
}
@@ -1111,10 +1057,6 @@ final class ASRService: ObservableObject {
private var benchmarkStreamingChunkIndex: Int = 0
private var benchmarkCompletedStreamingChunks: Int = 0
private var benchmarkLastChunkSampleCount: Int = 0
- private let streamingChunkAnalyticsSuccessSampleRate: Int = 50
- private let streamingChunkFailureMinIntervalSeconds: TimeInterval = 15
- private var streamingChunkAnalyticsSuccessCount: Int = 0
- private var lastStreamingChunkFailureAnalyticsAt: Date?
private let transcriptionExecutor = TranscriptionExecutor() // Serializes all CoreML access
private var providerResetDrain: (id: UUID, task: Task<Void, Never>)?
private var engineConfigurationChangeObserver: NSObjectProtocol?
@@ -1764,8 +1706,6 @@ final class ASRService: ObservableObject {
self.benchmarkStreamingChunkIndex = 0
self.benchmarkCompletedStreamingChunks = 0
self.benchmarkLastChunkSampleCount = 0
- self.streamingChunkAnalyticsSuccessCount = 0
- self.lastStreamingChunkFailureAnalyticsAt = nil
(self.transcriptionProvider as? FluidAudioProvider)?.resetStreamingPreviewCache()
self.audioCapturePipeline.setRecordingEnabled(
true,
@@ -2228,8 +2168,6 @@ final class ASRService: ObservableObject {
self.isProcessingChunk = false
self.skipNextChunk = false
self.previousFullTranscription.removeAll()
- self.streamingChunkAnalyticsSuccessCount = 0
- self.lastStreamingChunkFailureAnalyticsAt = nil
// NOW it's safe to access the buffer - all pending tasks have completed
// Thread-safe copy of recorded audio
@@ -2571,8 +2509,6 @@ final class ASRService: ObservableObject {
self.lastProcessedSampleCount = 0
self.isProcessingChunk = false
self.skipNextChunk = false
- self.streamingChunkAnalyticsSuccessCount = 0
- self.lastStreamingChunkFailureAnalyticsAt = nil
self.refreshWordBoostStatus()
// Resume media playback if we paused it
@@ -3860,10 +3796,17 @@ final class ASRService: ObservableObject {
// Audio tap processing is handled by AudioCapturePipeline (thread-safe).
func ensureAsrReady() async throws {
- try await self.ensureAsrReady(progressHandler: nil)
+ try await self.ensureAsrReady(source: .automatic, progressHandler: nil)
}
func ensureAsrReady(progressHandler: ((Double) -> Void)?) async throws {
+ try await self.ensureAsrReady(source: .automatic, progressHandler: progressHandler)
+ }
+
+ func ensureAsrReady(
+ source: AnalyticsModelDownloadSource,
+ progressHandler: ((Double) -> Void)? = nil
+ ) async throws {
guard self.modelDownloadTask == nil else {
throw NSError(
domain: "ASRService",
@@ -3917,6 +3860,7 @@ final class ASRService: ObservableObject {
try await self.performEnsureAsrReady(
provider: provider,
operationID: operationID,
+ analyticsSource: source,
externalProgressHandler: progressHandler
)
}
@@ -3948,6 +3892,7 @@ final class ASRService: ObservableObject {
private func performEnsureAsrReady(
provider: TranscriptionProvider,
operationID: UUID,
+ analyticsSource: AnalyticsModelDownloadSource,
externalProgressHandler: ((Double) -> Void)? = nil
) async throws {
guard self.ensureReadyOperationID == operationID else { throw CancellationError() }
@@ -4038,7 +3983,10 @@ final class ASRService: ObservableObject {
self.applyModelPreparationProgress(
progress,
updatesActiveModelState: true,
- externalProgressHandler: externalProgressHandler
+ externalProgressHandler: externalProgressHandler,
+ analyticsOperationID: operationID,
+ analyticsDescriptor: SettingsStore.shared.selectedSpeechModel.analyticsDescriptor,
+ analyticsSource: analyticsSource
)
}
}
@@ -4068,7 +4016,9 @@ final class ASRService: ObservableObject {
self.isAsrReady = true
self.isCancellingModelPreparation = false
self.refreshWordBoostStatus()
+ self.finishModelDownloadAnalytics(operationID: operationID, outcome: .succeeded)
} catch is CancellationError {
+ self.finishModelDownloadAnalytics(operationID: operationID, outcome: .cancelled)
DebugLogger.shared.info("ASR initialization cancelled", source: "ASRService")
if provider.shouldClearCacheAfterCancellation,
provider.modelsExistOnDisk() == false
@@ -4093,6 +4043,7 @@ final class ASRService: ObservableObject {
throw CancellationError()
} catch {
if Task.isCancelled || Self.isModelPreparationCancellation(error) {
+ self.finishModelDownloadAnalytics(operationID: operationID, outcome: .cancelled)
if provider.shouldClearCacheAfterCancellation,
provider.modelsExistOnDisk() == false
{
@@ -4108,6 +4059,7 @@ final class ASRService: ObservableObject {
}
throw CancellationError()
}
+ self.finishModelDownloadAnalytics(operationID: operationID, outcome: .failed)
DebugLogger.shared.error("ASR initialization failed with error: \(error)", source: "ASRService")
DebugLogger.shared.error("Error details: \(error.localizedDescription)", source: "ASRService")
if self.ensureReadyOperationID == operationID {
@@ -4123,7 +4075,10 @@ final class ASRService: ObservableObject {
private func applyModelPreparationProgress(
_ progress: ModelPreparationProgress,
updatesActiveModelState: Bool,
- externalProgressHandler: ((Double) -> Void)?
+ externalProgressHandler: ((Double) -> Void)?,
+ analyticsOperationID: UUID? = nil,
+ analyticsDescriptor: AnalyticsModelDescriptor? = nil,
+ analyticsSource: AnalyticsModelDownloadSource = .automatic
) {
switch progress.phase {
case .preparingDownload:
@@ -4133,6 +4088,13 @@ final class ASRService: ObservableObject {
self.isLoadingModel = false
}
case .downloading:
+ if let analyticsOperationID, let analyticsDescriptor {
+ self.beginModelDownloadAnalytics(
+ operationID: analyticsOperationID,
+ descriptor: analyticsDescriptor,
+ source: analyticsSource
+ )
+ }
self.downloadProgress = progress.fractionCompleted
if updatesActiveModelState {
self.isDownloadingModel = true
@@ -4142,12 +4104,18 @@ final class ASRService: ObservableObject {
externalProgressHandler?(fraction)
}
case .optimizing:
+ if let analyticsOperationID {
+ self.finishModelDownloadAnalytics(operationID: analyticsOperationID, outcome: .succeeded)
+ }
self.downloadProgress = nil
if updatesActiveModelState {
self.isDownloadingModel = true
self.isLoadingModel = false
}
case .loading:
+ if let analyticsOperationID {
+ self.finishModelDownloadAnalytics(operationID: analyticsOperationID, outcome: .succeeded)
+ }
self.downloadProgress = nil
if updatesActiveModelState {
self.isDownloadingModel = false
@@ -4158,6 +4126,44 @@ final class ASRService: ObservableObject {
self.modelPreparationPhase = progress.phase
}
+ private struct ModelDownloadAnalyticsState {
+ let descriptor: AnalyticsModelDescriptor
+ let source: AnalyticsModelDownloadSource
+ let startedAt: Date
+ }
+
+ private func beginModelDownloadAnalytics(
+ operationID: UUID,
+ descriptor: AnalyticsModelDescriptor,
+ source: AnalyticsModelDownloadSource
+ ) {
+ guard self.modelDownloadAnalyticsStates[operationID] == nil else { return }
+ self.modelDownloadAnalyticsStates[operationID] = ModelDownloadAnalyticsState(
+ descriptor: descriptor,
+ source: source,
+ startedAt: Date()
+ )
+ AnalyticsService.shared.recordModelDownloadStarted(
+ id: operationID,
+ descriptor: descriptor,
+ source: source
+ )
+ }
+
+ private func finishModelDownloadAnalytics(
+ operationID: UUID,
+ outcome: AnalyticsModelDownloadOutcome
+ ) {
+ guard let state = self.modelDownloadAnalyticsStates.removeValue(forKey: operationID) else { return }
+ AnalyticsService.shared.recordModelDownloadFinished(
+ id: operationID,
+ descriptor: state.descriptor,
+ source: state.source,
+ outcome: outcome,
+ duration: Date().timeIntervalSince(state.startedAt)
+ )
+ }
+
private func prepareProviderWithRecovery(
provider: TranscriptionProvider,
modelsAlreadyCached: Bool,
@@ -4416,12 +4422,6 @@ final class ASRService: ObservableObject {
}
let duration = Date().timeIntervalSince(startTime)
- let latencyMs = Int((duration * 1000).rounded())
- self.captureStreamingChunkAnalytics(
- success: true,
- chunkSampleCount: chunk.count,
- latencyMs: latencyMs
- )
DebugLogger.shared.debug(
"Streaming chunk transcription finished in \(String(format: "%.2f", duration))s",
source: "ASRService"
@@ -4469,14 +4469,6 @@ final class ASRService: ObservableObject {
self.skipNextChunk = true
}
} catch {
- let duration = Date().timeIntervalSince(startTime)
- let latencyMs = Int((duration * 1000).rounded())
- self.captureStreamingChunkAnalytics(
- success: false,
- chunkSampleCount: chunk.count,
- latencyMs: latencyMs,
- error: error
- )
DebugLogger.shared.error("❌ Streaming failed: \(error)", source: "ASRService")
self.benchmarkLog("chunk_fail index=\(chunkIndex) elapsedMs=\(self.elapsedMilliseconds(since: startedAt)) samples=\(chunk.count) error=\(error.localizedDescription)")
self.skipNextChunk = true
diff --git a/Sources/Fluid/Services/CommandModeService.swift b/Sources/Fluid/Services/CommandModeService.swift
index b356788c..5e624894 100644
--- a/Sources/Fluid/Services/CommandModeService.swift
+++ b/Sources/Fluid/Services/CommandModeService.swift
@@ -15,7 +15,6 @@ final class CommandModeService: ObservableObject {
private let chatStore = ChatHistoryStore.shared
private var currentTurnCount = 0
private let maxTurns = 20
- private var didRequireConfirmationThisRun: Bool = false
// Flag to enable notch output display
var enableNotchOutput: Bool = true
@@ -307,9 +306,13 @@ final class CommandModeService: ObservableObject {
func processUserCommand(_ text: String, notifyInvalidRequest: Bool = false) async {
guard !text.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else { return }
+ AnalyticsService.shared.recordUsage(
+ mode: .command,
+ aiModel: SettingsStore.shared.analyticsAIModelDescriptor(for: .command)
+ )
+
self.isProcessing = true
self.currentTurnCount = 0
- self.didRequireConfirmationThisRun = false
self.conversationHistory.append(Message(role: .user, content: text))
// Auto-save after adding user message
@@ -328,6 +331,11 @@ final class CommandModeService: ObservableObject {
func processFollowUpCommand(_ text: String) async {
guard !text.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else { return }
+ AnalyticsService.shared.recordUsage(
+ mode: .command,
+ aiModel: SettingsStore.shared.analyticsAIModelDescriptor(for: .command)
+ )
+
// Add to both histories
self.conversationHistory.append(Message(role: .user, content: text))
if self.shouldSyncCommandNotchState {
@@ -338,7 +346,6 @@ final class CommandModeService: ObservableObject {
self.saveCurrentChat()
self.isProcessing = true
- self.didRequireConfirmationThisRun = false
if self.shouldSyncCommandNotchState {
NotchContentState.shared.setCommandProcessing(true)
}
@@ -383,8 +390,6 @@ final class CommandModeService: ObservableObject {
// Auto-save on completion
self.saveCurrentChat()
- self.captureCommandRunCompleted(success: false)
-
// Push to notch
if self.shouldSyncCommandNotchState {
NotchContentState.shared.addCommandMessage(role: .assistant, content: errorMsg)
@@ -433,7 +438,6 @@ final class CommandModeService: ObservableObject {
// Check if we need confirmation for destructive commands
if SettingsStore.shared.commandModeConfirmBeforeExecute, self.isDestructiveCommand(tc.command) {
- self.didRequireConfirmationThisRun = true
self.pendingCommand = PendingCommand(
id: tc.id,
command: tc.command,
@@ -473,8 +477,6 @@ final class CommandModeService: ObservableObject {
// Auto-save on completion
self.saveCurrentChat()
- self.captureCommandRunCompleted(success: isFinal)
-
// Push final response to notch and show expanded view
if self.shouldSyncCommandNotchState {
NotchContentState.shared.updateCommandStreamingText("") // Clear streaming
@@ -506,8 +508,6 @@ final class CommandModeService: ObservableObject {
// Auto-save on error
self.saveCurrentChat()
- self.captureCommandRunCompleted(success: false)
-
// Push error to notch
if self.shouldSyncCommandNotchState {
NotchContentState.shared.addCommandMessage(role: .assistant, content: errorMsg)
@@ -517,38 +517,6 @@ final class CommandModeService: ObservableObject {
}
}
- private func captureCommandRunCompleted(success: Bool) {
- let toolCalls = self.conversationHistory.compactMap { $0.toolCall }.count
- let turns = self.currentTurnCount
-
- let turnsBucket: String
- switch turns {
- case ...1: turnsBucket = "1"
- case 2...3: turnsBucket = "2-3"
- case 4...7: turnsBucket = "4-7"
- case 8...20: turnsBucket = "8-20"
- default: turnsBucket = "20+"
- }
-
- let toolCallsBucket: String
- switch toolCalls {
- case 0: toolCallsBucket = "0"
- case 1...2: toolCallsBucket = "1-2"
- case 3...5: toolCallsBucket = "3-5"
- default: toolCallsBucket = "6+"
- }
-
- AnalyticsService.shared.capture(
- .commandModeRunCompleted,
- properties: [
- "success": success,
- "turns_bucket": turnsBucket,
- "tool_calls_bucket": toolCallsBucket,
- "confirmation_needed": self.didRequireConfirmationThisRun,
- ]
- )
- }
-
/// Show expanded notch output if there's content to display
private func showExpandedNotchIfNeeded() {
guard self.shouldSyncCommandNotchState else { return }
diff --git a/Sources/Fluid/Services/GlobalHotkeyManager.swift b/Sources/Fluid/Services/GlobalHotkeyManager.swift
index ff952d88..7eadbf0b 100644
--- a/Sources/Fluid/Services/GlobalHotkeyManager.swift
+++ b/Sources/Fluid/Services/GlobalHotkeyManager.swift
@@ -801,11 +801,6 @@ final class GlobalHotkeyManager: NSObject {
case .keyDown:
self.markOtherInputDuringModifierOnly()
- // Observe post-transcription edits (do not consume the event).
- Task {
- await PostTranscriptionEditTracker.shared.handleKeyDown(keyCode: keyCode, modifiers: eventModifiers)
- }
-
// Check the configured cancel shortcut first.
if SettingsStore.shared.cancelRecordingHotkeyShortcut.matches(keyCode: keyCode, modifiers: eventModifiers) {
var handled = false
diff --git a/Sources/Fluid/Services/MeetingTranscriptionService.swift b/Sources/Fluid/Services/MeetingTranscriptionService.swift
index 905af5fd..227ffa85 100644
--- a/Sources/Fluid/Services/MeetingTranscriptionService.swift
+++ b/Sources/Fluid/Services/MeetingTranscriptionService.swift
@@ -158,26 +158,6 @@ final class MeetingTranscriptionService: ObservableObject {
}
}
- private func errorCategory(for error: Error) -> String {
- guard let transcriptionError = error as? TranscriptionError else {
- return "unknownError"
- }
- return self.errorCategory(for: transcriptionError)
- }
-
- private func errorCategory(for error: TranscriptionError) -> String {
- switch error {
- case .modelLoadFailed:
- return "modelLoadFailed"
- case .audioConversionFailed:
- return "audioConversionFailed"
- case .transcriptionFailed:
- return "transcriptionFailed"
- case .fileNotSupported:
- return "fileNotSupported"
- }
- }
-
/// Initialize the ASR models (reuses models from ASRService - no duplicate download!)
func initializeModels() async throws {
guard !self.asrService.isAsrReady else { return }
@@ -230,6 +210,11 @@ final class MeetingTranscriptionService: ObservableObject {
.fileNotSupported("Format .\(fileExtension) not supported. \(Self.supportedFormatsDescription)")
}
+ AnalyticsService.shared.recordUsage(
+ mode: .meeting,
+ transcriptionModel: SettingsStore.shared.selectedSpeechModel.analyticsDescriptor
+ )
+
// Get audio duration for progress display
self.currentStatus = "Analyzing audio file..."
self.progress = 0.2
@@ -297,16 +282,6 @@ final class MeetingTranscriptionService: ObservableObject {
self.currentStatus = "Complete!"
self.progress = 1.0
- AnalyticsService.shared.capture(
- .meetingTranscriptionCompleted,
- properties: [
- "success": true,
- "file_type": fileURL.pathExtension.lowercased(),
- "audio_duration_bucket": AnalyticsBuckets.bucketSeconds(duration),
- "processing_time_bucket": AnalyticsBuckets.bucketSeconds(processingTime),
- ]
- )
-
self.result = result
FileTranscriptionHistoryStore.shared.addEntry(result)
return result
@@ -427,42 +402,16 @@ final class MeetingTranscriptionService: ObservableObject {
fileName: fileURL.lastPathComponent
)
- AnalyticsService.shared.capture(
- .meetingTranscriptionCompleted,
- properties: [
- "success": true,
- "file_type": fileURL.pathExtension.lowercased(),
- "audio_duration_bucket": AnalyticsBuckets.bucketSeconds(duration),
- "processing_time_bucket": AnalyticsBuckets.bucketSeconds(processingTime),
- ]
- )
-
self.result = result
FileTranscriptionHistoryStore.shared.addEntry(result)
return result
} catch let error as TranscriptionError {
self.error = error.localizedDescription
- AnalyticsService.shared.capture(
- .meetingTranscriptionCompleted,
- properties: [
- "success": false,
- "file_type": fileURL.pathExtension.lowercased(),
- "category": errorCategory(for: error),
- ]
- )
throw error
} catch {
let wrappedError = TranscriptionError.transcriptionFailed(error.localizedDescription)
self.error = wrappedError.localizedDescription
- AnalyticsService.shared.capture(
- .meetingTranscriptionCompleted,
- properties: [
- "success": false,
- "file_type": fileURL.pathExtension.lowercased(),
- "category": self.errorCategory(for: wrappedError),
- ]
- )
throw wrappedError
}
}
@@ -619,18 +568,6 @@ final class MeetingTranscriptionService: ObservableObject {
self.currentStatus = "Complete!"
self.progress = 1.0
- AnalyticsService.shared.capture(
- .meetingTranscriptionCompleted,
- properties: [
- "success": true,
- "file_type": fileURL.pathExtension.lowercased(),
- "audio_duration_bucket": AnalyticsBuckets.bucketSeconds(duration),
- "processing_time_bucket": AnalyticsBuckets.bucketSeconds(processingTime),
- "speaker_labels": true,
- "speaker_count": Set(segments.map(\.speaker)).count,
- ]
- )
-
self.result = result
FileTranscriptionHistoryStore.shared.addEntry(result)
return result
diff --git a/Sources/Fluid/Services/MenuBarManager.swift b/Sources/Fluid/Services/MenuBarManager.swift
index 4d331d2c..32c5073a 100644
--- a/Sources/Fluid/Services/MenuBarManager.swift
+++ b/Sources/Fluid/Services/MenuBarManager.swift
@@ -593,6 +593,7 @@ final class MenuBarManager: NSObject, ObservableObject, NSMenuDelegate {
func menuWillOpen(_ menu: NSMenu) {
if menu === self.menu {
+ AnalyticsService.shared.recordAppActivity()
self.updateMenuItemsText()
self.refreshMicrophoneMenu()
}
diff --git a/Sources/Fluid/Services/RewriteModeService.swift b/Sources/Fluid/Services/RewriteModeService.swift
index d476a25d..fd17ad39 100644
--- a/Sources/Fluid/Services/RewriteModeService.swift
+++ b/Sources/Fluid/Services/RewriteModeService.swift
@@ -83,6 +83,10 @@ final class RewriteModeService: ObservableObject {
func processRewriteRequest(_ prompt: String) async {
let startTime = Date()
+ AnalyticsService.shared.recordUsage(
+ mode: .edit,
+ aiModel: SettingsStore.shared.analyticsAIModelDescriptor(for: .edit)
+ )
self.appendDiagnosticLog(
"processRewriteRequest start | promptChars=\(prompt.count) | hadOriginal=\(!self.originalText.isEmpty) | contextChars=\(self.selectedContextText.count)"
)
@@ -133,14 +137,6 @@ final class RewriteModeService: ObservableObject {
"processRewriteRequest success | writeMode=\(self.isWriteMode) | outputChars=\(response.count) | latency=\(String(format: "%.2fs", Date().timeIntervalSince(startTime)))"
)
- AnalyticsService.shared.capture(
- .rewriteRunCompleted,
- properties: [
- "write_mode": self.isWriteMode,
- "success": true,
- "latency_bucket": AnalyticsBuckets.bucketSeconds(Date().timeIntervalSince(startTime)),
- ]
- )
} catch {
self.conversationHistory.append(Message(role: .assistant, content: "Error: \(error.localizedDescription)"))
self.isProcessing = false
@@ -148,14 +144,6 @@ final class RewriteModeService: ObservableObject {
"processRewriteRequest failure | writeMode=\(self.isWriteMode) | error=\(error.localizedDescription)"
)
- AnalyticsService.shared.capture(
- .rewriteRunCompleted,
- properties: [
- "write_mode": self.isWriteMode,
- "success": false,
- "latency_bucket": AnalyticsBuckets.bucketSeconds(Date().timeIntervalSince(startTime)),
- ]
- )
}
}
@@ -164,13 +152,6 @@ final class RewriteModeService: ObservableObject {
NSApp.hide(nil) // Restore focus to the previous app
self.typingService.typeTextInstantly(self.rewrittenText)
- AnalyticsService.shared.capture(
- .outputDelivered,
- properties: [
- "mode": AnalyticsMode.rewrite.rawValue,
- "method": AnalyticsOutputMethod.typed.rawValue,
- ]
- )
}
func clearState() {
diff --git a/Sources/Fluid/UI/AISettings/VoiceEngineSettingsViewModel.swift b/Sources/Fluid/UI/AISettings/VoiceEngineSettingsViewModel.swift
index bd561f02..8ca7b4f1 100644
--- a/Sources/Fluid/UI/AISettings/VoiceEngineSettingsViewModel.swift
+++ b/Sources/Fluid/UI/AISettings/VoiceEngineSettingsViewModel.swift
@@ -131,7 +131,7 @@ final class VoiceEngineSettingsViewModel: ObservableObject {
self.asr.resetTranscriptionProvider()
Task {
do {
- try await self.asr.ensureAsrReady()
+ try await self.asr.ensureAsrReady(source: .settings)
} catch is CancellationError {
DebugLogger.shared.info("Model activation cancelled: \(model.displayName)", source: "AISettingsView")
} catch {
@@ -233,7 +233,7 @@ final class VoiceEngineSettingsViewModel: ObservableObject {
func downloadModels() async {
do {
- try await self.asr.ensureAsrReady()
+ try await self.asr.ensureAsrReady(source: .settings)
} catch is CancellationError {
DebugLogger.shared.info("Model download cancelled", source: "AISettingsView")
} catch {
diff --git a/Sources/Fluid/UI/AnalyticsPrivacyView.swift b/Sources/Fluid/UI/AnalyticsPrivacyView.swift
index 0221ae72..08dad9dc 100644
--- a/Sources/Fluid/UI/AnalyticsPrivacyView.swift
+++ b/Sources/Fluid/UI/AnalyticsPrivacyView.swift
@@ -30,24 +30,26 @@ struct AnalyticsPrivacyView: View {
ScrollView {
VStack(alignment: .leading, spacing: 14) {
self.sectionTitle("We collect")
- self.bullet("Basic app/device info (app version, macOS version, CPU family/chip class, etc.)")
- self.bullet("Which features were used (for example: dictation, Command Mode etc.)")
- self.bullet("Performance metrics such as transcription chunk latency and AI post-processing latency (milliseconds).")
- self.bullet("Model/provider metadata and post-processing input length (character count only, not text content).")
- self.bullet("Whether something worked and high-level error info.")
+ self.bullet("A random installation ID, app version, and the operating-system label macOS.")
+ self.bullet("One daily active-use signal after you interact with the app.")
+ self.bullet("Daily totals for Dictation, Command Mode, Edit Mode, and meeting transcription.")
+ self.bullet("Onboarding steps viewed and completed, including skips.")
+ self.bullet("Transcription and AI provider/model identifiers, counted as daily totals.")
+ self.bullet("Model download source, outcome, and download duration.")
self.sectionTitle("We do NOT collect")
self.bullet("Any transcription text or audio.")
self.bullet("Selected text, rewrite prompts, or AI responses.")
self.bullet("Terminal commands or outputs from Command Mode.")
self.bullet("Window titles, app names, file names/paths, clipboard contents, or anything you type.")
+ self.bullet("Hardware identifiers, CPU/chip details, performance timings, or individual transcription events.")
self.sectionTitle("How it’s used")
- self.bullet("To understand which features are being used and where reliability/performance can be improved.")
- self.bullet("To measure product health (e.g., active devices, retention) without requiring accounts.")
+ self.bullet("To understand feature adoption, onboarding completion, model usage, active installations, and retention without requiring accounts.")
self.sectionTitle("Control")
self.bullet("You can disable analytics anytime in Settings → Share Anonymous Analytics.")
+ self.bullet("Disabling analytics securely removes all queued and aggregated analytics stored on this Mac.")
}
.padding(.vertical, 6)
}
diff --git a/Sources/Fluid/UI/SettingsView.swift b/Sources/Fluid/UI/SettingsView.swift
index fbd91b5d..77178bf3 100644
--- a/Sources/Fluid/UI/SettingsView.swift
+++ b/Sources/Fluid/UI/SettingsView.swift
@@ -1002,7 +1002,7 @@ struct SettingsView: View {
self.optionToggleRow(
title: "Share Anonymous Analytics",
- description: "Send anonymous usage and performance metrics to help improve FluidVoice. Never includes transcription text or prompts.",
+ description: "Send lean, anonymous daily usage, onboarding, retention, and model metrics. Never includes transcription text or prompts.",
isOn: self.analyticsToggleBinding
)
@@ -1769,7 +1769,6 @@ struct SettingsView: View {
private func applyAnalyticsConsentChange(_ enabled: Bool) {
SettingsStore.shared.shareAnonymousAnalytics = enabled
AnalyticsService.shared.setEnabled(enabled)
- AnalyticsService.shared.capture(.analyticsConsentChanged, properties: ["enabled": enabled])
}
// MARK: - Helper Views
diff --git a/Sources/Fluid/UI/WelcomeView.swift b/Sources/Fluid/UI/WelcomeView.swift
index fb4b5b11..4419c0fe 100644
--- a/Sources/Fluid/UI/WelcomeView.swift
+++ b/Sources/Fluid/UI/WelcomeView.swift
@@ -703,6 +703,17 @@ struct OnboardingFlowView: View {
case playground = 4
case aiEnhancement = 5
+ var analyticsStep: AnalyticsOnboardingStep {
+ switch self {
+ case .landing: .welcome
+ case .language: .language
+ case .voiceModel: .voiceModel
+ case .permissions: .permissions
+ case .playground: .playground
+ case .aiEnhancement: .aiEnhancement
+ }
+ }
+
var title: String {
switch self {
case .landing:
@@ -946,6 +957,9 @@ struct OnboardingFlowView: View {
self.syncOnboardingSelectionFromSettings()
self.playLandingWelcomeSoundIfNeeded()
self.refreshOnboardingMicrophoneAuthorization(checkModels: true)
+ let origin = self.settings.analyticsOnboardingOrigin
+ AnalyticsService.shared.recordOnboardingStarted(origin: origin)
+ AnalyticsService.shared.recordOnboardingStepViewed(self.step.analyticsStep, origin: origin)
}
.onChange(of: self.currentStep) { _, _ in
if self.step != .voiceModel {
@@ -957,6 +971,10 @@ struct OnboardingFlowView: View {
self.stopOnboardingMicrophonePreview()
}
self.playLandingWelcomeSoundIfNeeded()
+ AnalyticsService.shared.recordOnboardingStepViewed(
+ self.step.analyticsStep,
+ origin: self.settings.analyticsOnboardingOrigin
+ )
}
.onChange(of: self.isMicrophoneReady) { _, isReady in
guard self.step == .permissions else { return }
@@ -1854,11 +1872,33 @@ struct OnboardingFlowView: View {
onGlowExit: self.resetLandingGlow,
onBack: self.goBack,
onSkip: {
+ let origin = self.settings.analyticsOnboardingOrigin
self.markAISkipped()
self.finishOnboardingAtGettingStarted()
+ self.completeCurrentStep(
+ outcome: .skipped,
+ origin: origin,
+ completesFlow: self.settings.onboardingCompleted
+ )
+ },
+ onUseAIProvider: {
+ let origin = self.settings.analyticsOnboardingOrigin
+ self.openAIEnhancementSettingsFromOnboarding()
+ self.completeCurrentStep(
+ outcome: .openedSettings,
+ origin: origin,
+ completesFlow: self.settings.onboardingCompleted
+ )
},
- onUseAIProvider: self.openAIEnhancementSettingsFromOnboarding,
- onFinishSetup: self.finishOnboardingAtGettingStarted
+ onFinishSetup: {
+ let origin = self.settings.analyticsOnboardingOrigin
+ self.finishOnboardingAtGettingStarted()
+ self.completeCurrentStep(
+ outcome: .completed,
+ origin: origin,
+ completesFlow: self.settings.onboardingCompleted
+ )
+ }
)
}
@@ -1919,7 +1959,7 @@ struct OnboardingFlowView: View {
canSkip: !self.asr.isRunning && !self.isRecordingAnyShortcut,
skipAction: {
self.settings.onboardingPlaygroundSkipped = true
- self.goNext()
+ self.goNext(outcome: .skipped)
}
)
}
@@ -2063,7 +2103,7 @@ struct OnboardingFlowView: View {
}
do {
- try await self.asr.ensureAsrReady()
+ try await self.asr.ensureAsrReady(source: .onboarding)
} catch is CancellationError {
DebugLogger.shared.info("Cancelled onboarding voice model setup for \(route.model.displayName)", source: "OnboardingFlowView")
} catch {
@@ -2788,7 +2828,8 @@ struct OnboardingFlowView: View {
self.currentStep = max(0, self.currentStep - 1)
}
- private func goNext() {
+ private func goNext(outcome: AnalyticsOnboardingOutcome = .continued) {
+ self.completeCurrentStep(outcome: outcome)
self.activeShortcutRecordingTarget = nil
self.shortcutRecordingMessage = nil
self.currentStep = min(Step.allCases.count - 1, self.currentStep + 1)
@@ -2805,11 +2846,30 @@ struct OnboardingFlowView: View {
if self.step == .aiEnhancement {
guard self.isAIReady else { return }
+ let origin = self.settings.analyticsOnboardingOrigin
self.finishOnboarding()
+ self.completeCurrentStep(
+ outcome: .completed,
+ origin: origin,
+ completesFlow: self.settings.onboardingCompleted
+ )
return
}
self.goNext()
}
+
+ private func completeCurrentStep(
+ outcome: AnalyticsOnboardingOutcome,
+ origin: AnalyticsOnboardingOrigin? = nil,
+ completesFlow: Bool = false
+ ) {
+ AnalyticsService.shared.recordOnboardingStepCompleted(
+ self.step.analyticsStep,
+ outcome: outcome,
+ origin: origin ?? self.settings.analyticsOnboardingOrigin,
+ completesFlow: completesFlow
+ )
+ }
}
private extension OnboardingFlowView {
diff --git a/Tests/FluidDictationIntegrationTests/AnalyticsDatabaseTests.swift b/Tests/FluidDictationIntegrationTests/AnalyticsDatabaseTests.swift
new file mode 100644
index 00000000..f4d710a4
--- /dev/null
+++ b/Tests/FluidDictationIntegrationTests/AnalyticsDatabaseTests.swift
@@ -0,0 +1,131 @@
+@testable import FluidVoice_Debug
+import Foundation
+import XCTest
+
+final class AnalyticsDatabaseTests: XCTestCase {
+ private var temporaryDirectory: URL!
+
+ override func setUpWithError() throws {
+ self.temporaryDirectory = FileManager.default.temporaryDirectory
+ .appendingPathComponent("FluidVoiceAnalyticsTests-\(UUID().uuidString)", isDirectory: true)
+ try FileManager.default.createDirectory(at: self.temporaryDirectory, withIntermediateDirectories: true)
+ }
+
+ override func tearDownWithError() throws {
+ try? FileManager.default.removeItem(at: self.temporaryDirectory)
+ }
+
+ func testActivityIsDeduplicatedAndUsageIsAggregatedByDay() throws {
+ let database = try self.makeDatabase()
+ let firstDay = Date(timeIntervalSince1970: 1_735_689_600) // 2025-01-01 UTC
+ let secondDay = firstDay.addingTimeInterval(24 * 60 * 60)
+ let descriptor = AnalyticsModelDescriptor(provider: "Fluid Audio", model: "Parakeet TDT")
+
+ try database.recordActivity(.app, at: firstDay)
+ try database.recordActivity(.app, at: firstDay.addingTimeInterval(60))
+ try database.recordUsage(mode: .dictation, transcriptionModel: descriptor, aiModel: nil, at: firstDay)
+ try database.recordUsage(mode: .dictation, transcriptionModel: descriptor, aiModel: nil, at: firstDay)
+ try database.finalizeDays(before: secondDay)
+
+ let events = try self.events(in: database)
+ XCTAssertEqual(events.filter { $0.name == AnalyticsEvent.activeUser.rawValue }.count, 1)
+
+ let usage = try XCTUnwrap(events.first { $0.name == AnalyticsEvent.usageDailySummary.rawValue })
+ XCTAssertEqual(usage.properties["dictation_count"] as? Int, 2)
+ XCTAssertEqual(usage.properties["command_count"] as? Int, 0)
+
+ let model = try XCTUnwrap(events.first { $0.name == AnalyticsEvent.modelUsageDailySummary.rawValue })
+ XCTAssertEqual(model.properties["provider"] as? String, "fluid_audio")
+ XCTAssertEqual(model.properties["model"] as? String, "parakeet_tdt")
+ XCTAssertEqual(model.properties["use_count"] as? Int, 2)
+ }
+
+ func testAcknowledgementPurgesOutboxAndTruncatesWAL() throws {
+ let databaseURL = self.temporaryDirectory.appendingPathComponent("analytics.sqlite3")
+ let database = try self.makeDatabase(url: databaseURL)
+ try database.recordActivity(.app, at: Date())
+ let items = try database.readyOutbox(limit: 50, at: Date())
+ XCTAssertEqual(items.count, 1)
+
+ try database.acknowledgeUploaded(ids: items.map(\.id), at: Date())
+
+ XCTAssertTrue(try database.readyOutbox(limit: 50, at: Date()).isEmpty)
+ let walURL = URL(fileURLWithPath: databaseURL.path + "-wal")
+ if FileManager.default.fileExists(atPath: walURL.path) {
+ let attributes = try FileManager.default.attributesOfItem(atPath: walURL.path)
+ XCTAssertEqual(attributes[.size] as? UInt64, 0)
+ }
+ }
+
+ func testInterruptedDownloadIsRecoveredWithoutDuration() throws {
+ let databaseURL = self.temporaryDirectory.appendingPathComponent("analytics.sqlite3")
+ let id = UUID().uuidString.lowercased()
+ let descriptor = AnalyticsModelDescriptor(provider: "whisper", model: "large")
+
+ do {
+ let database = try self.makeDatabase(url: databaseURL)
+ try database.recordModelDownloadStarted(
+ id: id,
+ descriptor: descriptor,
+ source: .settings,
+ at: Date(timeIntervalSince1970: 100)
+ )
+ }
+
+ let recovered = try self.makeDatabase(url: databaseURL)
+ try recovered.recoverInterruptedModelDownloads(at: Date(timeIntervalSince1970: 200))
+ let finish = try XCTUnwrap(
+ try self.events(in: recovered).first { $0.name == AnalyticsEvent.modelDownloadFinished.rawValue }
+ )
+ XCTAssertEqual(finish.properties["outcome"] as? String, "interrupted")
+ XCTAssertNil(finish.properties["duration_seconds"])
+ }
+
+ func testDownloadFinishBeforeStartStillProducesOneCompletePair() throws {
+ let database = try self.makeDatabase()
+ let id = UUID().uuidString.lowercased()
+ let descriptor = AnalyticsModelDescriptor(provider: "whisper", model: "large")
+ let finishedAt = Date(timeIntervalSince1970: 200)
+
+ try database.recordModelDownloadFinished(
+ id: id,
+ descriptor: descriptor,
+ source: .settings,
+ outcome: .succeeded,
+ duration: 25,
+ at: finishedAt
+ )
+ try database.recordModelDownloadStarted(
+ id: id,
+ descriptor: descriptor,
+ source: .settings,
+ at: finishedAt.addingTimeInterval(1)
+ )
+
+ let events = try self.events(in: database)
+ XCTAssertEqual(events.filter { $0.name == AnalyticsEvent.modelDownloadStarted.rawValue }.count, 1)
+ XCTAssertEqual(events.filter { $0.name == AnalyticsEvent.modelDownloadFinished.rawValue }.count, 1)
+ let finish = try XCTUnwrap(events.first { $0.name == AnalyticsEvent.modelDownloadFinished.rawValue })
+ XCTAssertEqual(finish.properties["duration_seconds"] as? Double, 25)
+ }
+
+ private func makeDatabase(url: URL? = nil) throws -> AnalyticsDatabase {
+ var calendar = Calendar(identifier: .gregorian)
+ calendar.timeZone = try XCTUnwrap(TimeZone(secondsFromGMT: 0))
+ return try AnalyticsDatabase(
+ url: url ?? self.temporaryDirectory.appendingPathComponent("analytics.sqlite3"),
+ distinctID: "test-install-id",
+ appVersion: "test",
+ calendar: calendar
+ )
+ }
+
+ private func events(in database: AnalyticsDatabase) throws -> [(name: String, properties: [String: Any])] {
+ try database.readyOutbox(limit: 100, at: Date.distantFuture).map { item in
+ let object = try XCTUnwrap(JSONSerialization.jsonObject(with: item.payload) as? [String: Any])
+ let name = try XCTUnwrap(object["event"] as? String)
+ let properties = try XCTUnwrap(object["properties"] as? [String: Any])
+ return (name, properties)
+ }
+ }
+}