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

onboarding playground event

grohith3276eae39329531
diff --git a/Sources/Fluid/Analytics/AnalyticsDatabase.swift b/Sources/Fluid/Analytics/AnalyticsDatabase.swift
index cedbe724..600db6d2 100644
--- a/Sources/Fluid/Analytics/AnalyticsDatabase.swift
+++ b/Sources/Fluid/Analytics/AnalyticsDatabase.swift
@@ -17,12 +17,20 @@ final class AnalyticsDatabase {
private let connection: OpaquePointer
private let distinctID: String
private let appVersion: String
+ private let systemConfiguration: AnalyticsSystemConfiguration
private let calendar: Calendar
private let iso8601 = ISO8601DateFormatter()
- init(url: URL, distinctID: String, appVersion: String, calendar: Calendar = .current) throws {
+ init(
+ url: URL,
+ distinctID: String,
+ appVersion: String,
+ systemConfiguration: AnalyticsSystemConfiguration = .current,
+ calendar: Calendar = .current
+ ) throws {
self.distinctID = distinctID
self.appVersion = appVersion
+ self.systemConfiguration = systemConfiguration
self.calendar = calendar
try FileManager.default.createDirectory(
@@ -133,6 +141,9 @@ final class AnalyticsDatabase {
) throws {
try self.transaction {
let flowID = try self.activeOnboardingFlow(origin: origin, at: date)
+ if step == .playground {
+ try self.ensureOnboardingTryoutState(flowID: flowID, enteredAt: date)
+ }
let key = "onboarding:\(flowID):viewed:\(step.rawValue)"
guard try self.insertDedupeKey(key, date: date) else { return }
try self.enqueue(.onboardingStepViewed, at: date, properties: [
@@ -143,6 +154,92 @@ final class AnalyticsDatabase {
}
}
+ func recordOnboardingTryoutAttemptStarted(
+ startMethod: AnalyticsOnboardingTryoutStartMethod,
+ origin: AnalyticsOnboardingOrigin,
+ at date: Date
+ ) throws {
+ try self.transaction {
+ let flowID = try self.activeOnboardingFlow(origin: origin, at: date)
+ try self.ensureOnboardingTryoutState(flowID: flowID, enteredAt: date)
+ try self.run(
+ "UPDATE onboarding_tryout_state SET attempt_count = attempt_count + 1, " +
+ "last_start_method = ?, last_outcome = NULL, last_failure_stage = NULL WHERE flow_id = ?",
+ bindings: [.text(startMethod.rawValue), .text(flowID)]
+ )
+ }
+ }
+
+ func recordOnboardingTryoutAttemptResult(
+ outcome: AnalyticsOnboardingTryoutOutcome,
+ failureStage: AnalyticsOnboardingTryoutFailureStage?,
+ origin: AnalyticsOnboardingOrigin,
+ at date: Date
+ ) throws {
+ try self.transaction {
+ let flowID = try self.activeOnboardingFlow(origin: origin, at: date)
+ try self.ensureOnboardingTryoutState(flowID: flowID, enteredAt: date)
+ try self.run(
+ "UPDATE onboarding_tryout_state SET last_outcome = ?, last_failure_stage = ? WHERE flow_id = ?",
+ bindings: [
+ .text(outcome.rawValue),
+ failureStage.map { .text($0.rawValue) } ?? .null,
+ .text(flowID),
+ ]
+ )
+ }
+ }
+
+ func finishOnboardingTryout(
+ outcome: AnalyticsOnboardingTryoutOutcome,
+ failureStage: AnalyticsOnboardingTryoutFailureStage?,
+ origin: AnalyticsOnboardingOrigin,
+ at date: Date
+ ) throws {
+ try self.transaction {
+ let flowID = try self.activeOnboardingFlow(origin: origin, at: date)
+ try self.ensureOnboardingTryoutState(flowID: flowID, enteredAt: date)
+ let state = try self.onboardingTryoutState(flowID: flowID)
+ guard try self.insertDedupeKey("onboarding:\(flowID):tryout_finished", date: date) else { return }
+
+ var properties: [String: Any] = [
+ "flow_id": flowID,
+ "origin": origin.rawValue,
+ "outcome": outcome.rawValue,
+ "duration_bucket": Self.onboardingTryoutDurationBucket(
+ date.timeIntervalSince1970 - state.enteredAt
+ ),
+ ]
+ if state.attemptCount > 0 {
+ properties["attempt_count_bucket"] = Self.onboardingTryoutAttemptCountBucket(state.attemptCount)
+ }
+ if let startMethod = state.lastStartMethod {
+ properties["start_method"] = startMethod
+ }
+ if let failureStage {
+ properties["failure_stage"] = failureStage.rawValue
+ } else if outcome == .skippedAfterAttempt, let lastFailureStage = state.lastFailureStage {
+ properties["failure_stage"] = lastFailureStage
+ }
+ try self.enqueue(.onboardingTryoutFinished, at: date, properties: properties)
+ }
+ }
+
+ func skipOnboardingTryout(origin: AnalyticsOnboardingOrigin, at date: Date) throws {
+ let flowID = try self.activeOnboardingFlow(origin: origin, at: date)
+ try self.ensureOnboardingTryoutState(flowID: flowID, enteredAt: date)
+ let state = try self.onboardingTryoutState(flowID: flowID)
+ let outcome: AnalyticsOnboardingTryoutOutcome = state.attemptCount == 0
+ ? .skippedBeforeAttempt
+ : .skippedAfterAttempt
+ try self.finishOnboardingTryout(
+ outcome: outcome,
+ failureStage: nil,
+ origin: origin,
+ at: date
+ )
+ }
+
func recordOnboardingStepCompleted(
_ step: AnalyticsOnboardingStep,
outcome: AnalyticsOnboardingOutcome,
@@ -378,6 +475,7 @@ final class AnalyticsDatabase {
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 onboarding_tryout_state")
try self.execute("DELETE FROM model_download_attempts")
}
try self.purgeDeletedPages()
@@ -439,6 +537,14 @@ final class AnalyticsDatabase {
created_at REAL NOT NULL,
completed INTEGER NOT NULL DEFAULT 0
);
+ CREATE TABLE IF NOT EXISTS onboarding_tryout_state (
+ flow_id TEXT PRIMARY KEY,
+ entered_at REAL NOT NULL,
+ attempt_count INTEGER NOT NULL DEFAULT 0,
+ last_start_method TEXT,
+ last_outcome TEXT,
+ last_failure_stage TEXT
+ );
CREATE TABLE IF NOT EXISTS model_download_attempts (
download_id TEXT PRIMARY KEY,
provider TEXT NOT NULL,
@@ -456,6 +562,12 @@ final class AnalyticsDatabase {
approvedProperties["platform"] = "macos"
approvedProperties["$os"] = "macOS"
approvedProperties["app_version"] = self.appVersion
+ approvedProperties["ram_gb"] = self.systemConfiguration.ramGB
+ approvedProperties["chip"] = self.systemConfiguration.chip
+ approvedProperties["$set"] = [
+ "ram_gb": self.systemConfiguration.ramGB,
+ "chip": self.systemConfiguration.chip,
+ ]
approvedProperties["schema_version"] = 2
let payload: [String: Any] = [
@@ -531,6 +643,55 @@ final class AnalyticsDatabase {
return flowID
}
+ private struct OnboardingTryoutState {
+ let enteredAt: TimeInterval
+ let attemptCount: Int
+ let lastStartMethod: String?
+ let lastFailureStage: String?
+ }
+
+ private func ensureOnboardingTryoutState(flowID: String, enteredAt: Date) throws {
+ try self.run(
+ "INSERT OR IGNORE INTO onboarding_tryout_state (flow_id, entered_at) VALUES (?, ?)",
+ bindings: [.text(flowID), .double(enteredAt.timeIntervalSince1970)]
+ )
+ }
+
+ private func onboardingTryoutState(flowID: String) throws -> OnboardingTryoutState {
+ let rows = try self.query(
+ "SELECT entered_at, attempt_count, COALESCE(last_start_method, ''), " +
+ "COALESCE(last_failure_stage, '') " +
+ "FROM onboarding_tryout_state WHERE flow_id = ?",
+ bindings: [.text(flowID)]
+ )
+ guard let row = rows.first, row.count == 4 else {
+ throw AnalyticsDatabaseError.sqlite("Missing onboarding tryout state")
+ }
+ return OnboardingTryoutState(
+ enteredAt: TimeInterval(row[0]) ?? 0,
+ attemptCount: Int(row[1]) ?? 0,
+ lastStartMethod: row[2].isEmpty ? nil : row[2],
+ lastFailureStage: row[3].isEmpty ? nil : row[3]
+ )
+ }
+
+ private static func onboardingTryoutAttemptCountBucket(_ count: Int) -> String {
+ switch count {
+ case 1: "1"
+ case 2: "2"
+ default: "3+"
+ }
+ }
+
+ private static func onboardingTryoutDurationBucket(_ duration: TimeInterval) -> String {
+ switch max(0, duration) {
+ case ..<30: "under_30s"
+ case ..<60: "30_to_59s"
+ case ..<180: "1_to_2m"
+ default: "3m_plus"
+ }
+ }
+
private func insertDedupeKey(_ key: String, date: Date) throws -> Bool {
try self.run(
"INSERT OR IGNORE INTO event_dedupe (dedupe_key, created_at) VALUES (?, ?)",
@@ -636,6 +797,8 @@ final class AnalyticsDatabase {
result = data.withUnsafeBytes { bytes in
sqlite3_bind_blob(statement, index, bytes.baseAddress, Int32(bytes.count), transient)
}
+ case .null:
+ result = sqlite3_bind_null(statement, index)
}
guard result == SQLITE_OK else { throw self.lastError() }
}
@@ -651,4 +814,5 @@ private enum SQLiteBinding {
case integer(Int)
case double(Double)
case blob(Data)
+ case null
}
diff --git a/Sources/Fluid/Analytics/AnalyticsEvent.swift b/Sources/Fluid/Analytics/AnalyticsEvent.swift
index 3e8e52ee..a4a8ab37 100644
--- a/Sources/Fluid/Analytics/AnalyticsEvent.swift
+++ b/Sources/Fluid/Analytics/AnalyticsEvent.swift
@@ -9,6 +9,7 @@ enum AnalyticsEvent: String {
case onboardingStepViewed = "onboarding_step_viewed"
case onboardingStepCompleted = "onboarding_step_completed"
case onboardingCompleted = "onboarding_completed"
+ case onboardingTryoutFinished = "onboarding_tryout_finished"
case modelDownloadStarted = "model_download_started"
case modelDownloadFinished = "model_download_finished"
}
@@ -69,6 +70,26 @@ enum AnalyticsOnboardingOutcome: String {
case openedSettings = "opened_settings"
}
+enum AnalyticsOnboardingTryoutOutcome: String {
+ case success
+ case empty
+ case error
+ case cancelled
+ case skippedBeforeAttempt = "skipped_before_attempt"
+ case skippedAfterAttempt = "skipped_after_attempt"
+}
+
+enum AnalyticsOnboardingTryoutStartMethod: String {
+ case hotkey
+ case button
+}
+
+enum AnalyticsOnboardingTryoutFailureStage: String {
+ case audioStart = "audio_start"
+ case transcription
+ case postProcessing = "post_processing"
+}
+
enum AnalyticsModelDownloadSource: String {
case onboarding
case settings
diff --git a/Sources/Fluid/Analytics/AnalyticsService.swift b/Sources/Fluid/Analytics/AnalyticsService.swift
index df063f77..bf9ef4c7 100644
--- a/Sources/Fluid/Analytics/AnalyticsService.swift
+++ b/Sources/Fluid/Analytics/AnalyticsService.swift
@@ -92,6 +92,53 @@ final class AnalyticsService {
}
}
+ func recordOnboardingTryoutAttemptStarted(startMethod: AnalyticsOnboardingTryoutStartMethod) {
+ let origin = SettingsStore.shared.analyticsOnboardingOrigin
+ self.submit { core, context in
+ await core.recordOnboardingTryoutAttemptStarted(
+ startMethod: startMethod,
+ origin: origin,
+ context: context
+ )
+ }
+ }
+
+ func recordOnboardingTryoutAttemptResult(
+ outcome: AnalyticsOnboardingTryoutOutcome,
+ failureStage: AnalyticsOnboardingTryoutFailureStage? = nil
+ ) {
+ let origin = SettingsStore.shared.analyticsOnboardingOrigin
+ self.submit { core, context in
+ await core.recordOnboardingTryoutAttemptResult(
+ outcome: outcome,
+ failureStage: failureStage,
+ origin: origin,
+ context: context
+ )
+ }
+ }
+
+ func finishOnboardingTryout(
+ outcome: AnalyticsOnboardingTryoutOutcome,
+ failureStage: AnalyticsOnboardingTryoutFailureStage? = nil
+ ) {
+ let origin = SettingsStore.shared.analyticsOnboardingOrigin
+ self.submit { core, context in
+ await core.finishOnboardingTryout(
+ outcome: outcome,
+ failureStage: failureStage,
+ origin: origin,
+ context: context
+ )
+ }
+ }
+
+ func skipOnboardingTryout(origin: AnalyticsOnboardingOrigin) {
+ self.submit { core, context in
+ await core.skipOnboardingTryout(origin: origin, context: context)
+ }
+ }
+
func recordModelDownloadStarted(
id: UUID,
descriptor: AnalyticsModelDescriptor,
@@ -288,6 +335,58 @@ private actor AnalyticsCore {
}
}
+ func recordOnboardingTryoutAttemptStarted(
+ startMethod: AnalyticsOnboardingTryoutStartMethod,
+ origin: AnalyticsOnboardingOrigin,
+ context: AnalyticsContext
+ ) async {
+ await self.writeDetailed(context: context) { database, date in
+ try database.recordOnboardingTryoutAttemptStarted(
+ startMethod: startMethod,
+ origin: origin,
+ at: date
+ )
+ }
+ }
+
+ func recordOnboardingTryoutAttemptResult(
+ outcome: AnalyticsOnboardingTryoutOutcome,
+ failureStage: AnalyticsOnboardingTryoutFailureStage?,
+ origin: AnalyticsOnboardingOrigin,
+ context: AnalyticsContext
+ ) async {
+ await self.writeDetailed(context: context) { database, date in
+ try database.recordOnboardingTryoutAttemptResult(
+ outcome: outcome,
+ failureStage: failureStage,
+ origin: origin,
+ at: date
+ )
+ }
+ }
+
+ func finishOnboardingTryout(
+ outcome: AnalyticsOnboardingTryoutOutcome,
+ failureStage: AnalyticsOnboardingTryoutFailureStage?,
+ origin: AnalyticsOnboardingOrigin,
+ context: AnalyticsContext
+ ) async {
+ await self.writeDetailed(context: context) { database, date in
+ try database.finishOnboardingTryout(
+ outcome: outcome,
+ failureStage: failureStage,
+ origin: origin,
+ at: date
+ )
+ }
+ }
+
+ func skipOnboardingTryout(origin: AnalyticsOnboardingOrigin, context: AnalyticsContext) async {
+ await self.writeDetailed(context: context) { database, date in
+ try database.skipOnboardingTryout(origin: origin, at: date)
+ }
+ }
+
func recordModelDownloadStarted(
id: String,
descriptor: AnalyticsModelDescriptor,
diff --git a/Sources/Fluid/Analytics/AnalyticsSystemConfiguration.swift b/Sources/Fluid/Analytics/AnalyticsSystemConfiguration.swift
new file mode 100644
index 00000000..f1fe3d7e
--- /dev/null
+++ b/Sources/Fluid/Analytics/AnalyticsSystemConfiguration.swift
@@ -0,0 +1,29 @@
+import Darwin
+import Foundation
+
+struct AnalyticsSystemConfiguration: Equatable {
+ let ramGB: Int
+ let chip: String
+
+ static let current = AnalyticsSystemConfiguration(
+ ramGB: Self.installedRAMInGigabytes,
+ chip: Self.sysctlString("machdep.cpu.brand_string") ?? "unknown"
+ )
+
+ private static var installedRAMInGigabytes: Int {
+ let bytesPerGigabyte: UInt64 = 1_073_741_824
+ let roundedBytes = ProcessInfo.processInfo.physicalMemory + (bytesPerGigabyte / 2)
+ return max(1, Int(roundedBytes / bytesPerGigabyte))
+ }
+
+ private static func sysctlString(_ name: String) -> String? {
+ var size = 0
+ guard sysctlbyname(name, nil, &size, nil, 0) == 0, size > 0 else { return nil }
+
+ var value = [CChar](repeating: 0, count: size)
+ guard sysctlbyname(name, &value, &size, nil, 0) == 0 else { return nil }
+
+ let result = String(cString: value).trimmingCharacters(in: .whitespacesAndNewlines)
+ return result.isEmpty ? nil : result
+ }
+}
diff --git a/Sources/Fluid/ContentView.swift b/Sources/Fluid/ContentView.swift
index 5e448b93..7eda4157 100644
--- a/Sources/Fluid/ContentView.swift
+++ b/Sources/Fluid/ContentView.swift
@@ -2093,6 +2093,7 @@ struct ContentView: View {
DebugLogger.shared.debug("stopAndProcessTranscription called", source: "ContentView")
DebugLogger.shared.info("Output route selected: \(route.rawValue)", source: "ContentView")
self.appBench("stop_path_enter route=\(route.rawValue)")
+ let isOnboardingTryout = route == .onboardingSandbox && self.isOnboardingVoicePlaygroundStepActive
// Check if we're in rewrite or command mode
let modeAtStop = self.activeRecordingMode
@@ -2157,6 +2158,16 @@ struct ContentView: View {
guard transcribedText.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty == false else {
DebugLogger.shared.debug("Transcription returned empty text", source: "ContentView")
+ if isOnboardingTryout {
+ if self.asr.lastStopOutcome == .failed {
+ AnalyticsService.shared.recordOnboardingTryoutAttemptResult(
+ outcome: .error,
+ failureStage: .transcription
+ )
+ } else {
+ AnalyticsService.shared.recordOnboardingTryoutAttemptResult(outcome: .empty)
+ }
+ }
// Finish the same short exit transition even when no text is emitted.
if !didRequestOverlayHideOnStop {
await self.menuBarManager.finishProcessingAndHideOverlay()
@@ -2358,6 +2369,10 @@ struct ContentView: View {
self.isOnboardingVoicePlaygroundStepActive,
!finalText.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
{
+ AnalyticsService.shared.finishOnboardingTryout(
+ outcome: .success,
+ failureStage: aiFallbackReason == nil ? nil : .postProcessing
+ )
self.settings.onboardingPlaygroundValidated = true
self.settings.playgroundUsed = true
self.playgroundUsed = true
@@ -3666,7 +3681,13 @@ struct ContentView: View {
if self.asr.isRunningOrStarting {
DebugLogger.shared.debug("Cancel shortcut: cancelling ASR recording", source: "ContentView")
- Task { await self.asr.stopWithoutTranscription() }
+ let isOnboardingTryout = self.isOnboardingVoicePlaygroundStepActive
+ Task {
+ await self.asr.stopWithoutTranscription()
+ if isOnboardingTryout {
+ AnalyticsService.shared.recordOnboardingTryoutAttemptResult(outcome: .cancelled)
+ }
+ }
self.cancelPrewarmDictationIfNeeded()
handled = true
}
@@ -3865,7 +3886,11 @@ extension ContentView {
}
}
- private func beginDictationRecording(for slot: SettingsStore.DictationShortcutSlot, mode: ActiveRecordingMode) {
+ private func beginDictationRecording(
+ for slot: SettingsStore.DictationShortcutSlot,
+ mode: ActiveRecordingMode,
+ startMethod: AnalyticsOnboardingTryoutStartMethod = .hotkey
+ ) {
DebugLogger.shared.debug("Begin dictation recording for slot \(slot.rawValue)", source: "ContentView")
self.appBench("begin_recording slot=\(slot.rawValue) mode=\(mode.rawValue)")
if self.isOnboardingVoicePlaygroundStepActive {
@@ -3883,6 +3908,10 @@ extension ContentView {
self.appBench("asr_start_skipped reason=already_running_or_starting")
return
}
+ let isOnboardingTryout = self.isOnboardingVoicePlaygroundStepActive && mode == .dictate
+ if isOnboardingTryout {
+ AnalyticsService.shared.recordOnboardingTryoutAttemptStarted(startMethod: startMethod)
+ }
self.advanceOverlayLifecycle()
if self.asr.micStatus == .authorized {
self.appBench("overlay_mode_request mode=Dictation")
@@ -3904,6 +3933,12 @@ extension ContentView {
})
if startOutcome == .failed {
self.menuBarManager.hideRecordingOverlayImmediately(reason: "asr_start_failed")
+ if isOnboardingTryout {
+ AnalyticsService.shared.recordOnboardingTryoutAttemptResult(
+ outcome: .error,
+ failureStage: .audioStart
+ )
+ }
}
DebugLogger.shared.benchmark(
"APP_BENCH",
diff --git a/Sources/Fluid/Services/ASRService.swift b/Sources/Fluid/Services/ASRService.swift
index 35fd26d8..96fc150a 100644
--- a/Sources/Fluid/Services/ASRService.swift
+++ b/Sources/Fluid/Services/ASRService.swift
@@ -54,6 +54,12 @@ enum AudioCaptureStartOutcome: Equatable {
case failed
}
+enum ASRStopOutcome: Equatable {
+ case success
+ case empty
+ case failed
+}
+
// swiftlint:disable file_length type_body_length
/// A comprehensive speech recognition service that handles real-time audio transcription.
///
@@ -192,6 +198,7 @@ final class ASRService: ObservableObject {
private var microphonePreviewOperationGeneration: UInt64 = 0
private var isMicrophonePreviewRequested = false
private(set) var lastDictionaryTrainingResult: ASRTranscriptionResult?
+ private(set) var lastStopOutcome: ASRStopOutcome = .empty
private(set) var dictionaryTrainingAudioGeneration = 0
@Published private(set) var isStarting: Bool = false // Guard against re-entrant start() calls
@@ -2319,6 +2326,7 @@ final class ASRService: ObservableObject {
forDictionaryTraining: Bool = false
) async -> String {
DebugLogger.shared.info("🛑 STOP() called - beginning shutdown sequence", source: "ASRService")
+ self.lastStopOutcome = .empty
if forDictionaryTraining || self.isDictionaryTrainingCaptureActive {
self.lastDictionaryTrainingResult = nil
}
@@ -2500,6 +2508,7 @@ final class ASRService: ObservableObject {
guard provider.isReady else {
DebugLogger.shared.error("Transcription provider is not ready", source: "ASRService")
+ self.lastStopOutcome = .failed
// Resume media playback if we paused it
if shouldResumeMedia {
await MediaPlaybackService.shared.resumeIfWePaused(true)
@@ -2583,8 +2592,12 @@ final class ASRService: ObservableObject {
DebugLogger.shared.info("🎵 Resumed system media after transcription", source: "ASRService")
}
+ self.lastStopOutcome = outputText.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+ ? .empty
+ : .success
return outputText
} catch {
+ self.lastStopOutcome = .failed
DebugLogger.shared.error("ASR transcription failed: \(error)", source: "ASRService")
DebugLogger.shared.error("Error details: \(error.localizedDescription)", source: "ASRService")
let nsError = error as NSError
diff --git a/Sources/Fluid/UI/WelcomeView.swift b/Sources/Fluid/UI/WelcomeView.swift
index 345c31aa..4118a911 100644
--- a/Sources/Fluid/UI/WelcomeView.swift
+++ b/Sources/Fluid/UI/WelcomeView.swift
@@ -1958,6 +1958,8 @@ struct OnboardingFlowView: View {
skipTitle: "Skip",
canSkip: !self.asr.isRunning && !self.isRecordingAnyShortcut,
skipAction: {
+ let origin = self.settings.analyticsOnboardingOrigin
+ AnalyticsService.shared.skipOnboardingTryout(origin: origin)
self.settings.onboardingPlaygroundSkipped = true
self.goNext(outcome: .skipped)
}
diff --git a/Tests/FluidDictationIntegrationTests/AnalyticsDatabaseTests.swift b/Tests/FluidDictationIntegrationTests/AnalyticsDatabaseTests.swift
index 9436b273..6d025af0 100644
--- a/Tests/FluidDictationIntegrationTests/AnalyticsDatabaseTests.swift
+++ b/Tests/FluidDictationIntegrationTests/AnalyticsDatabaseTests.swift
@@ -33,6 +33,12 @@ final class AnalyticsDatabaseTests: XCTestCase {
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)
+ XCTAssertEqual(usage.properties["ram_gb"] as? Int, 24)
+ XCTAssertEqual(usage.properties["chip"] as? String, "Apple M3 Pro")
+
+ let personProperties = try XCTUnwrap(usage.properties["$set"] as? [String: Any])
+ XCTAssertEqual(personProperties["ram_gb"] as? Int, 24)
+ XCTAssertEqual(personProperties["chip"] as? String, "Apple M3 Pro")
let model = try XCTUnwrap(events.first { $0.name == AnalyticsEvent.modelUsageDailySummary.rawValue })
XCTAssertEqual(model.properties["provider"] as? String, "fluid_audio")
@@ -128,6 +134,138 @@ final class AnalyticsDatabaseTests: XCTestCase {
XCTAssertEqual(finish.properties["duration_seconds"] as? Double, 25)
}
+ func testOnboardingTryoutTerminalEventAggregatesAttemptsAndDimensions() throws {
+ let database = try self.makeDatabase()
+ let enteredAt = Date(timeIntervalSince1970: 100)
+
+ try database.recordOnboardingStepViewed(.playground, origin: .firstRun, at: enteredAt)
+ try database.recordOnboardingTryoutAttemptStarted(
+ startMethod: .hotkey,
+ origin: .firstRun,
+ at: enteredAt.addingTimeInterval(5)
+ )
+ try database.recordOnboardingTryoutAttemptResult(
+ outcome: .empty,
+ failureStage: nil,
+ origin: .firstRun,
+ at: enteredAt.addingTimeInterval(20)
+ )
+ try database.recordOnboardingTryoutAttemptStarted(
+ startMethod: .button,
+ origin: .firstRun,
+ at: enteredAt.addingTimeInterval(35)
+ )
+ try database.finishOnboardingTryout(
+ outcome: .success,
+ failureStage: .postProcessing,
+ origin: .firstRun,
+ at: enteredAt.addingTimeInterval(75)
+ )
+ try database.finishOnboardingTryout(
+ outcome: .error,
+ failureStage: .transcription,
+ origin: .firstRun,
+ at: enteredAt.addingTimeInterval(80)
+ )
+
+ let events = try self.events(in: database)
+ let tryoutEvents = events.filter { $0.name == AnalyticsEvent.onboardingTryoutFinished.rawValue }
+ let tryout = try XCTUnwrap(tryoutEvents.first)
+ XCTAssertEqual(tryoutEvents.count, 1)
+ XCTAssertEqual(tryout.properties["outcome"] as? String, "success")
+ XCTAssertEqual(tryout.properties["attempt_count_bucket"] as? String, "2")
+ XCTAssertEqual(tryout.properties["duration_bucket"] as? String, "1_to_2m")
+ XCTAssertEqual(tryout.properties["start_method"] as? String, "button")
+ XCTAssertEqual(tryout.properties["failure_stage"] as? String, "post_processing")
+ XCTAssertEqual(tryout.properties["$os"] as? String, "macOS")
+ XCTAssertEqual(tryout.properties["ram_gb"] as? Int, 24)
+ XCTAssertEqual(tryout.properties["chip"] as? String, "Apple M3 Pro")
+ }
+
+ func testOnboardingTryoutSkipBeforeAttemptOmitsAttemptProperties() throws {
+ let database = try self.makeDatabase()
+ let enteredAt = Date(timeIntervalSince1970: 100)
+
+ try database.recordOnboardingStepViewed(.playground, origin: .firstRun, at: enteredAt)
+ try database.skipOnboardingTryout(origin: .firstRun, at: enteredAt.addingTimeInterval(10))
+
+ let tryout = try XCTUnwrap(
+ try self.events(in: database).first { $0.name == AnalyticsEvent.onboardingTryoutFinished.rawValue }
+ )
+ XCTAssertEqual(tryout.properties["outcome"] as? String, "skipped_before_attempt")
+ XCTAssertEqual(tryout.properties["duration_bucket"] as? String, "under_30s")
+ XCTAssertNil(tryout.properties["attempt_count_bucket"])
+ XCTAssertNil(tryout.properties["start_method"])
+ }
+
+ func testOnboardingTryoutSkipAfterFailureRetainsAttemptContext() throws {
+ let database = try self.makeDatabase()
+ let enteredAt = Date(timeIntervalSince1970: 100)
+
+ try database.recordOnboardingStepViewed(.playground, origin: .firstRun, at: enteredAt)
+ try database.recordOnboardingTryoutAttemptStarted(
+ startMethod: .hotkey,
+ origin: .firstRun,
+ at: enteredAt.addingTimeInterval(5)
+ )
+ try database.recordOnboardingTryoutAttemptResult(
+ outcome: .error,
+ failureStage: .transcription,
+ origin: .firstRun,
+ at: enteredAt.addingTimeInterval(15)
+ )
+ try database.skipOnboardingTryout(origin: .firstRun, at: enteredAt.addingTimeInterval(40))
+
+ let tryout = try XCTUnwrap(
+ try self.events(in: database).first { $0.name == AnalyticsEvent.onboardingTryoutFinished.rawValue }
+ )
+ XCTAssertEqual(tryout.properties["outcome"] as? String, "skipped_after_attempt")
+ XCTAssertEqual(tryout.properties["attempt_count_bucket"] as? String, "1")
+ XCTAssertEqual(tryout.properties["duration_bucket"] as? String, "30_to_59s")
+ XCTAssertEqual(tryout.properties["start_method"] as? String, "hotkey")
+ XCTAssertEqual(tryout.properties["failure_stage"] as? String, "transcription")
+ }
+
+ func testOnboardingTryoutAttemptStateSurvivesDatabaseReopen() throws {
+ let databaseURL = self.temporaryDirectory.appendingPathComponent("analytics.sqlite3")
+ let enteredAt = Date(timeIntervalSince1970: 100)
+
+ do {
+ let database = try self.makeDatabase(url: databaseURL)
+ try database.recordOnboardingStepViewed(.playground, origin: .firstRun, at: enteredAt)
+ try database.recordOnboardingTryoutAttemptStarted(
+ startMethod: .hotkey,
+ origin: .firstRun,
+ at: enteredAt.addingTimeInterval(5)
+ )
+ try database.recordOnboardingTryoutAttemptResult(
+ outcome: .empty,
+ failureStage: nil,
+ origin: .firstRun,
+ at: enteredAt.addingTimeInterval(15)
+ )
+ }
+
+ let reopened = try self.makeDatabase(url: databaseURL)
+ try reopened.recordOnboardingTryoutAttemptStarted(
+ startMethod: .hotkey,
+ origin: .firstRun,
+ at: enteredAt.addingTimeInterval(30)
+ )
+ try reopened.finishOnboardingTryout(
+ outcome: .success,
+ failureStage: nil,
+ origin: .firstRun,
+ at: enteredAt.addingTimeInterval(65)
+ )
+
+ let tryout = try XCTUnwrap(
+ try self.events(in: reopened).first { $0.name == AnalyticsEvent.onboardingTryoutFinished.rawValue }
+ )
+ XCTAssertEqual(tryout.properties["attempt_count_bucket"] as? String, "2")
+ XCTAssertEqual(tryout.properties["duration_bucket"] as? String, "1_to_2m")
+ }
+
func testDetailedConsentGateRejectsWorkQueuedBeforeOptOut() {
let gate = DetailedAnalyticsConsentGate()
let queuedGeneration = gate.currentGeneration
@@ -176,6 +314,7 @@ final class AnalyticsDatabaseTests: XCTestCase {
url: url ?? self.temporaryDirectory.appendingPathComponent("analytics.sqlite3"),
distinctID: "test-install-id",
appVersion: "test",
+ systemConfiguration: AnalyticsSystemConfiguration(ramGB: 24, chip: "Apple M3 Pro"),
calendar: calendar
)
}