From 273791174f582302195bf3fda15c0e8973aa168b Mon Sep 17 00:00:00 2001
From: Owen McGirr <o.a.mcgirr@gmail.com>
Date: Mon, 13 Jul 2026 22:04:54 +0100
Subject: [PATCH] Add opt-in Timberlogs diagnostics

---
 .github/workflows/release.yml                 |   8 +
 src/SwitchifyPc.App/App.xaml.cs               | 109 ++++++++-
 .../DiagnosticsConsentWindow.xaml             |  29 +++
 .../DiagnosticsConsentWindow.xaml.cs          |  26 ++
 src/SwitchifyPc.App/SettingsWindow.xaml       |  30 +++
 src/SwitchifyPc.App/SettingsWindow.xaml.cs    |  22 ++
 src/SwitchifyPc.App/SetupGuideWindow.xaml     |  24 ++
 src/SwitchifyPc.App/SetupGuideWindow.xaml.cs  |  17 +-
 src/SwitchifyPc.App/SwitchifyPc.App.csproj    |   6 +-
 .../Diagnostics/TelemetryReporter.cs          | 230 ++++++++++++++++++
 .../Diagnostics/TelemetrySanitizer.cs         |  36 +++
 .../Diagnostics/TelemetrySettings.cs          |  72 ++++++
 src/SwitchifyPc.Core/Ui/SettingsController.cs |  18 +-
 src/SwitchifyPc.Core/Ui/SettingsViewModel.cs  |  10 +
 .../Ui/SetupGuideViewModel.cs                 |  26 +-
 .../SetupGuideViewModelTests.cs               |  10 +-
 .../SetupGuideWindowTests.cs                  |   4 +-
 src/SwitchifyPc.Tests/TelemetryTests.cs       | 144 +++++++++++
 18 files changed, 808 insertions(+), 13 deletions(-)
 create mode 100644 src/SwitchifyPc.App/DiagnosticsConsentWindow.xaml
 create mode 100644 src/SwitchifyPc.App/DiagnosticsConsentWindow.xaml.cs
 create mode 100644 src/SwitchifyPc.Core/Diagnostics/TelemetryReporter.cs
 create mode 100644 src/SwitchifyPc.Core/Diagnostics/TelemetrySanitizer.cs
 create mode 100644 src/SwitchifyPc.Core/Diagnostics/TelemetrySettings.cs
 create mode 100644 src/SwitchifyPc.Tests/TelemetryTests.cs

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index b758d8c..4ca9017 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -26,6 +26,7 @@ jobs:
       SWITCHIFY_SIGNING_MODE: certum-simplysign
       SWITCHIFY_CERTUM_CERT_THUMBPRINT: ${{ vars.CERTUM_CERT_THUMBPRINT }}
       SWITCHIFY_CERTUM_TIMESTAMP_URL: http://time.certum.pl
+      TIMBERLOGS_API_KEY: ${{ secrets.TIMBERLOGS_API_KEY }}
 
     steps:
       - name: Resolve release tag
@@ -55,6 +56,13 @@ jobs:
       - name: Restore
         run: dotnet restore src/SwitchifyPc.sln
 
+      - name: Verify Timberlogs configuration
+        shell: powershell
+        run: |
+          if ([string]::IsNullOrWhiteSpace($env:TIMBERLOGS_API_KEY)) {
+            throw 'TIMBERLOGS_API_KEY secret is not available to the release workflow.'
+          }
+
       - name: Build
         run: dotnet build src/SwitchifyPc.sln -c Release --no-restore
 
diff --git a/src/SwitchifyPc.App/App.xaml.cs b/src/SwitchifyPc.App/App.xaml.cs
index 235f2ca..e1ca353 100644
--- a/src/SwitchifyPc.App/App.xaml.cs
+++ b/src/SwitchifyPc.App/App.xaml.cs
@@ -52,7 +52,13 @@ public partial class App : System.Windows.Application
     private readonly object bluetoothConnectionSync = new();
     private readonly HashSet<string> authenticatedBluetoothConnections = new(StringComparer.Ordinal);
     private DispatcherTimer? pairingExpiryTimer;
+    private DispatcherTimer? telemetryFlushTimer;
     private AppThemeManager? themeManager;
+    private JsonTelemetrySettingsStore? telemetrySettingsStore;
+    private ITelemetryReporter? telemetryReporter;
+    private readonly HashSet<Exception> reportedExceptions = new(ReferenceEqualityComparer.Instance);
+    private readonly object reportedExceptionsSync = new();
+    private bool diagnosticsConsentShown;
     private string? lastLoggedUpdateCheckStatus;
     private string? lastLoggedUpdateDownloadStatus;
     private bool isQuitting;
@@ -82,6 +88,8 @@ protected override void OnStartup(StartupEventArgs e)
             return;
         }
 
+        InitializeTelemetry();
+
         existingInstanceSignal = new WindowsExistingInstanceSignal();
         existingInstanceSignal.Start(
             () => Dispatcher.BeginInvoke(ShowMainWindow),
@@ -94,6 +102,8 @@ protected override void OnStartup(StartupEventArgs e)
         RefreshPairingApprovals();
         updateService.StartAutomaticUpdateChecks();
         StartPairingExpiryTimer();
+        StartTelemetryFlushTimer();
+        _ = telemetryReporter?.FlushAsync();
         _ = StartBluetoothAsync();
         _ = InitializeStartupRegistrationAsync(e.Args, launchOptions.StartHidden);
         trayIcon = new NativeTrayIcon(
@@ -123,6 +133,8 @@ protected override void OnExit(ExitEventArgs e)
         updateService = null;
         pairingExpiryTimer?.Stop();
         pairingExpiryTimer = null;
+        telemetryFlushTimer?.Stop();
+        telemetryFlushTimer = null;
         mouseRepeatController?.StopAllAsync().GetAwaiter().GetResult();
         mouseRepeatController = null;
         bluetoothServer?.Dispose();
@@ -145,6 +157,9 @@ protected override void OnExit(ExitEventArgs e)
         trayIcon = null;
         settingsWindow = null;
         setupGuideWindow = null;
+        telemetryReporter?.Dispose();
+        telemetryReporter = null;
+        telemetrySettingsStore = null;
         base.OnExit(e);
     }
 
@@ -236,7 +251,9 @@ private SetupGuideWindow CreateSetupGuideWindow()
             AcceptPairingApprovalAsync,
             RejectPairingApproval,
             SetSetupStartWithSystemAsync,
-            CompleteSetupGuide);
+            CompleteSetupGuide,
+            () => Dispatcher.BeginInvoke(ShowDiagnosticsConsentIfNeeded),
+            setShareDiagnosticData: SetShareDiagnosticData);
         window.Closing += (_, eventArgs) =>
         {
             if (isQuitting) return;
@@ -276,7 +293,9 @@ private SettingsController CreateSettingsController()
             new JsonMouseRepeatSettingsStore(Path.Combine(userDataDirectory, "mouse-repeat-settings.json")),
             new JsonCursorOverlaySettingsStore(Path.Combine(userDataDirectory, "cursor-overlay-settings.json")),
             updateService ?? CreateUpdateService(),
-            new JsonPairingStore(Path.Combine(userDataDirectory, "pairing-state.json")));
+            new JsonPairingStore(Path.Combine(userDataDirectory, "pairing-state.json")),
+            telemetrySettingsStore ?? CreateTelemetrySettingsStore(),
+            telemetryReporter ?? CreateDisabledTelemetryReporter());
     }
 
     private SystemStartupService CreateStartupService()
@@ -367,6 +386,7 @@ private async Task StartBluetoothAsync()
         {
             bluetoothStatusTracker?.SetError(error.Message);
             RecordRuntimeDiagnostic("bluetooth.start.failed", reason: "startup_failed");
+            ReportException(error, "bluetooth");
         }
     }
 
@@ -551,6 +571,10 @@ await Dispatcher.BeginInvoke(() =>
                 MarkSetupGuideShown();
                 ShowSetupGuideWindowCore();
             }
+            else
+            {
+                ShowDiagnosticsConsentIfNeeded();
+            }
         });
     }
 
@@ -594,6 +618,70 @@ private void CompleteSetupGuide()
         store.Save(SetupGuidePrompt.MarkCompleted(settings));
     }
 
+    private JsonTelemetrySettingsStore CreateTelemetrySettingsStore()
+    {
+        return new JsonTelemetrySettingsStore(Path.Combine(UserDataDirectory(), "telemetry-settings.json"));
+    }
+
+    private ITelemetryReporter CreateDisabledTelemetryReporter()
+    {
+        return new TelemetryReporter(CreateTelemetrySettingsStore(), new HttpClient(), string.Empty, CurrentVersion,
+            Path.Combine(UserDataDirectory(), "telemetry-queue.json"));
+    }
+
+    private void InitializeTelemetry()
+    {
+        telemetrySettingsStore = CreateTelemetrySettingsStore();
+        string apiKey = typeof(App).Assembly.GetCustomAttributes<AssemblyMetadataAttribute>()
+            .FirstOrDefault(attribute => attribute.Key == "TimberlogsApiKey")?.Value ?? string.Empty;
+        telemetryReporter = new TelemetryReporter(
+            telemetrySettingsStore,
+            new HttpClient(),
+            apiKey,
+            CurrentVersion,
+            Path.Combine(UserDataDirectory(), "telemetry-queue.json"));
+
+        DispatcherUnhandledException += (_, args) => ReportException(args.Exception, "dispatcher");
+        AppDomain.CurrentDomain.UnhandledException += (_, args) =>
+        {
+            if (args.ExceptionObject is Exception error) ReportException(error, "appdomain");
+        };
+        TaskScheduler.UnobservedTaskException += (_, args) => ReportException(args.Exception, "task");
+    }
+
+    private void SetShareDiagnosticData(bool enabled)
+    {
+        telemetryReporter?.SetEnabled(enabled);
+        setupGuideViewModel.SetShareDiagnosticData(enabled);
+        if (enabled) _ = telemetryReporter?.FlushAsync();
+    }
+
+    private void ShowDiagnosticsConsentIfNeeded()
+    {
+        if (diagnosticsConsentShown || telemetrySettingsStore?.Load().ConsentRecorded != false || MainWindow is null) return;
+        diagnosticsConsentShown = true;
+        DiagnosticsConsentWindow prompt = new() { Owner = MainWindow };
+        prompt.ShowDialog();
+        SetShareDiagnosticData(prompt.Choice == true);
+    }
+
+    private void ReportException(Exception error, string dataset)
+    {
+        lock (reportedExceptionsSync)
+        {
+            if (!reportedExceptions.Add(error)) return;
+            if (reportedExceptions.Count > 100) reportedExceptions.Clear();
+        }
+        _ = telemetryReporter?.ReportExceptionAsync(error, dataset);
+    }
+
+    private void StartTelemetryFlushTimer()
+    {
+        telemetryFlushTimer = new DispatcherTimer { Interval = TimeSpan.FromMinutes(5) };
+        telemetryFlushTimer.Tick += (_, _) => _ = telemetryReporter?.FlushAsync();
+        telemetryFlushTimer.Start();
+    }
+
     private void StartPairingExpiryTimer()
     {
         pairingExpiryTimer = new DispatcherTimer
@@ -727,6 +815,23 @@ private void RecordRuntimeDiagnostic(
                 Status: SafeDiagnosticText(status),
                 Reason: SafeDiagnosticText(reason),
                 Message: SafeDiagnosticText(message)));
+
+        telemetryReporter?.RecordBreadcrumb(eventName);
+        if (IsRemoteHealthEvent(eventName))
+        {
+            Dictionary<string, string> data = [];
+            if (!string.IsNullOrWhiteSpace(status)) data["status"] = status;
+            if (!string.IsNullOrWhiteSpace(reason)) data["reason"] = reason;
+            _ = telemetryReporter?.ReportHealthAsync(eventName, data);
+        }
+    }
+
+    private static bool IsRemoteHealthEvent(string eventName)
+    {
+        return eventName is "app.startup.completed" or "app.exit" or "bluetooth.ready" or
+            "bluetooth.unavailable" or "bluetooth.connected" or "bluetooth.disconnected" or
+            "bluetooth.error" or "bluetooth.start.failed" or "cursor.overlay.disabled" or
+            "startup.registration.repair.failed" or "update.state.changed";
     }
 
     private static string? SafeDiagnosticText(string? value)
diff --git a/src/SwitchifyPc.App/DiagnosticsConsentWindow.xaml b/src/SwitchifyPc.App/DiagnosticsConsentWindow.xaml
new file mode 100644
index 0000000..619cf12
--- /dev/null
+++ b/src/SwitchifyPc.App/DiagnosticsConsentWindow.xaml
@@ -0,0 +1,29 @@
+<Window x:Class="SwitchifyPc.App.DiagnosticsConsentWindow"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        Title="Switchify PC privacy"
+        Width="520" Height="330"
+        ResizeMode="NoResize"
+        WindowStartupLocation="CenterOwner"
+        Background="{DynamicResource AppBackground}"
+        Foreground="{DynamicResource Text}"
+        FontFamily="Segoe UI"
+        Icon="Assets/icon.ico">
+    <Grid Margin="28">
+        <Grid.RowDefinitions>
+            <RowDefinition Height="*" />
+            <RowDefinition Height="Auto" />
+        </Grid.RowDefinitions>
+        <StackPanel>
+            <TextBlock Text="Help improve Switchify PC" FontSize="22" FontWeight="Bold" />
+            <TextBlock Margin="0,14,0,0" TextWrapping="Wrap" LineHeight="21"
+                       Text="May Switchify PC send sanitized crashes, exceptions, and app health events? Reports use a random identifier for this installation." />
+            <TextBlock Margin="0,12,0,0" TextWrapping="Wrap" Foreground="{DynamicResource TextMuted}"
+                       Text="Typed text, commands, pairing secrets, device names, and full file paths are never included. You can change this later in Settings > Privacy." />
+        </StackPanel>
+        <StackPanel Grid.Row="1" HorizontalAlignment="Right" Orientation="Horizontal">
+            <Button MinWidth="110" MinHeight="38" Content="No thanks" Click="Decline_Click" />
+            <Button Margin="10,0,0,0" MinWidth="170" MinHeight="38" Content="Share diagnostic data" Click="Accept_Click" />
+        </StackPanel>
+    </Grid>
+</Window>
diff --git a/src/SwitchifyPc.App/DiagnosticsConsentWindow.xaml.cs b/src/SwitchifyPc.App/DiagnosticsConsentWindow.xaml.cs
new file mode 100644
index 0000000..70ae11d
--- /dev/null
+++ b/src/SwitchifyPc.App/DiagnosticsConsentWindow.xaml.cs
@@ -0,0 +1,26 @@
+using System.Windows;
+
+namespace SwitchifyPc.App;
+
+public partial class DiagnosticsConsentWindow : Window
+{
+    public DiagnosticsConsentWindow()
+    {
+        InitializeComponent();
+        Closing += (_, _) => Choice ??= false;
+    }
+
+    public bool? Choice { get; private set; }
+
+    private void Accept_Click(object sender, RoutedEventArgs e)
+    {
+        Choice = true;
+        DialogResult = true;
+    }
+
+    private void Decline_Click(object sender, RoutedEventArgs e)
+    {
+        Choice = false;
+        DialogResult = false;
+    }
+}
diff --git a/src/SwitchifyPc.App/SettingsWindow.xaml b/src/SwitchifyPc.App/SettingsWindow.xaml
index 8db78ee..79c3599 100644
--- a/src/SwitchifyPc.App/SettingsWindow.xaml
+++ b/src/SwitchifyPc.App/SettingsWindow.xaml
@@ -295,6 +295,11 @@
                                  Style="{StaticResource NavRadio}"
                                  Tag="updates"
                                  Checked="SectionNav_Checked" />
+                    <RadioButton Content="Privacy"
+                                 GroupName="SettingsSections"
+                                 Style="{StaticResource NavRadio}"
+                                 Tag="privacy"
+                                 Checked="SectionNav_Checked" />
                 </StackPanel>
             </Border>
 
@@ -757,6 +762,31 @@
                             </StackPanel>
                         </Border>
                     </StackPanel>
+
+                    <StackPanel x:Name="PrivacyPanel" Visibility="Collapsed">
+                        <Border Style="{StaticResource PanelBorder}">
+                            <StackPanel>
+                                <TextBlock Text="Privacy" Style="{StaticResource SectionTitle}" />
+                                <TextBlock Margin="0,6,0,0"
+                                           Text="Choose whether Switchify PC may send diagnostic information."
+                                           Style="{StaticResource MutedText}" />
+                                <Border Margin="0,16,0,0" Style="{StaticResource SubtlePanel}">
+                                    <StackPanel>
+                                        <CheckBox Content="Share diagnostic data"
+                                                  Click="ShareDiagnosticData_Click"
+                                                  IsChecked="{Binding ShareDiagnosticData, Mode=OneWay}" />
+                                        <TextBlock Margin="0,8,0,0"
+                                                   Text="Sends sanitized crashes, exceptions, and app health events. Typed text, commands, pairing secrets, device names, and full file paths are not sent. Turning this off deletes queued reports."
+                                                   Style="{StaticResource MutedText}" />
+                                        <Button Margin="0,14,0,0"
+                                                HorizontalAlignment="Left"
+                                                Content="Read privacy policy"
+                                                Click="OpenPrivacyPolicy_Click" />
+                                    </StackPanel>
+                                </Border>
+                            </StackPanel>
+                        </Border>
+                    </StackPanel>
                 </Grid>
             </ScrollViewer>
         </Grid>
diff --git a/src/SwitchifyPc.App/SettingsWindow.xaml.cs b/src/SwitchifyPc.App/SettingsWindow.xaml.cs
index 769e70c..cbaa81b 100644
--- a/src/SwitchifyPc.App/SettingsWindow.xaml.cs
+++ b/src/SwitchifyPc.App/SettingsWindow.xaml.cs
@@ -1,4 +1,5 @@
 using System.Windows;
+using System.Diagnostics;
 using SwitchifyPc.Core.Ui;
 using SwitchifyPc.Core.Updates;
 using WpfButton = System.Windows.Controls.Button;
@@ -104,6 +105,27 @@ private void SectionNav_Checked(object sender, RoutedEventArgs e)
         GeneralPanel.Visibility = section == "general" ? Visibility.Visible : Visibility.Collapsed;
         PointerPanel.Visibility = section == "pointer" ? Visibility.Visible : Visibility.Collapsed;
         UpdatesPanel.Visibility = section == "updates" ? Visibility.Visible : Visibility.Collapsed;
+        PrivacyPanel.Visibility = section == "privacy" ? Visibility.Visible : Visibility.Collapsed;
+    }
+
+    private void ShareDiagnosticData_Click(object sender, RoutedEventArgs e)
+    {
+        if (!isApplyingSettings && settingsLoaded && controller is not null && sender is WpfCheckBox checkBox)
+        {
+            controller.SetShareDiagnosticData(checkBox.IsChecked == true);
+        }
+    }
+
+    private void OpenPrivacyPolicy_Click(object sender, RoutedEventArgs e)
+    {
+        try
+        {
+            Process.Start(new ProcessStartInfo("https://switchifyapp.com/privacy") { UseShellExecute = true });
+        }
+        catch
+        {
+            WpfMessageBox.Show("The privacy policy could not be opened.", "Switchify PC settings", MessageBoxButton.OK, MessageBoxImage.Warning);
+        }
     }
 
     private async void ForgetPairedDevice_Click(object sender, RoutedEventArgs e)
diff --git a/src/SwitchifyPc.App/SetupGuideWindow.xaml b/src/SwitchifyPc.App/SetupGuideWindow.xaml
index 162fa53..7c6fcc1 100644
--- a/src/SwitchifyPc.App/SetupGuideWindow.xaml
+++ b/src/SwitchifyPc.App/SetupGuideWindow.xaml
@@ -283,6 +283,30 @@
                         </Border>
                     </StackPanel>
                 </Border>
+
+                <Border Style="{StaticResource Panel}"
+                        Visibility="{Binding IsDiagnosticsStep, Converter={StaticResource BooleanToVisibilityConverter}}">
+                    <StackPanel VerticalAlignment="Center">
+                        <TextBlock Text="Help improve Switchify PC"
+                                   Foreground="{DynamicResource Text}"
+                                   FontSize="21"
+                                   FontWeight="Bold" />
+                        <TextBlock Margin="0,8,0,0"
+                                   Text="Choose whether to share sanitized crashes, exceptions, and app health events. This never includes typed text, commands, pairing secrets, device names, or full file paths."
+                                   Style="{StaticResource MutedText}" />
+                        <WrapPanel Margin="0,22,0,0">
+                            <Button Content="Share diagnostic data"
+                                    Style="{StaticResource PrimaryButton}"
+                                    Click="ShareDiagnostics_Click" />
+                            <Button Margin="10,0,0,0"
+                                    Content="No thanks"
+                                    Click="DeclineDiagnostics_Click" />
+                        </WrapPanel>
+                        <TextBlock Margin="0,14,0,0"
+                                   Text="Your choice can be changed later in Settings > Privacy."
+                                   Style="{StaticResource MutedText}" />
+                    </StackPanel>
+                </Border>
             </Grid>
 
             <Grid Grid.Row="2">
diff --git a/src/SwitchifyPc.App/SetupGuideWindow.xaml.cs b/src/SwitchifyPc.App/SetupGuideWindow.xaml.cs
index 5911c66..ba1750d 100644
--- a/src/SwitchifyPc.App/SetupGuideWindow.xaml.cs
+++ b/src/SwitchifyPc.App/SetupGuideWindow.xaml.cs
@@ -13,6 +13,7 @@ public partial class SetupGuideWindow : Window
     private readonly Func<bool, Task>? setStartWithSystem;
     private readonly Action? finish;
     private readonly Action? skip;
+    private readonly Action<bool>? setShareDiagnosticData;
 
     public SetupGuideWindow(
         SetupGuideViewModel? viewModel = null,
@@ -21,7 +22,8 @@ public SetupGuideWindow(
         Action<string>? rejectPairingApproval = null,
         Func<bool, Task>? setStartWithSystem = null,
         Action? finish = null,
-        Action? skip = null)
+        Action? skip = null,
+        Action<bool>? setShareDiagnosticData = null)
     {
         this.viewModel = viewModel ?? new SetupGuideViewModel();
         this.openAndroidDownload = openAndroidDownload;
@@ -30,10 +32,23 @@ public SetupGuideWindow(
         this.setStartWithSystem = setStartWithSystem;
         this.finish = finish;
         this.skip = skip;
+        this.setShareDiagnosticData = setShareDiagnosticData;
         InitializeComponent();
         DataContext = this.viewModel;
     }
 
+    private void ShareDiagnostics_Click(object sender, RoutedEventArgs e)
+    {
+        viewModel.SetShareDiagnosticData(true);
+        setShareDiagnosticData?.Invoke(true);
+    }
+
+    private void DeclineDiagnostics_Click(object sender, RoutedEventArgs e)
+    {
+        viewModel.SetShareDiagnosticData(false);
+        setShareDiagnosticData?.Invoke(false);
+    }
+
     private void Back_Click(object sender, RoutedEventArgs e)
     {
         viewModel.MoveBack();
diff --git a/src/SwitchifyPc.App/SwitchifyPc.App.csproj b/src/SwitchifyPc.App/SwitchifyPc.App.csproj
index 7c8d8ce..6e415bc 100644
--- a/src/SwitchifyPc.App/SwitchifyPc.App.csproj
+++ b/src/SwitchifyPc.App/SwitchifyPc.App.csproj
@@ -20,12 +20,16 @@
     <ApplicationIcon>..\..\build\icon.ico</ApplicationIcon>
     <ApplicationManifest Condition="'$(SwitchifySandboxBuild)' != 'true'">..\..\build\win-uiaccess.manifest</ApplicationManifest>
     <ApplicationManifest Condition="'$(SwitchifySandboxBuild)' == 'true'">..\..\build\win-sandbox.manifest</ApplicationManifest>
-    <Version>0.6.3</Version>
+    <Version>0.6.4</Version>
     <AssemblyVersion>0.4.2.0</AssemblyVersion>
     <FileVersion>0.4.2.0</FileVersion>
     <IncludeSourceRevisionInInformationalVersion>false</IncludeSourceRevisionInInformationalVersion>
   </PropertyGroup>
 
+  <ItemGroup>
+    <AssemblyMetadata Include="TimberlogsApiKey" Value="$(TIMBERLOGS_API_KEY)" />
+  </ItemGroup>
+
   <ItemGroup>
     <Resource Include="..\..\build\icon.ico" Link="Assets\icon.ico" />
     <Resource Include="Assets\android-download-qr.png" />
diff --git a/src/SwitchifyPc.Core/Diagnostics/TelemetryReporter.cs b/src/SwitchifyPc.Core/Diagnostics/TelemetryReporter.cs
new file mode 100644
index 0000000..b37271d
--- /dev/null
+++ b/src/SwitchifyPc.Core/Diagnostics/TelemetryReporter.cs
@@ -0,0 +1,230 @@
+using System.Net.Http.Headers;
+using System.Net.Http.Json;
+using System.Text.Json;
+
+namespace SwitchifyPc.Core.Diagnostics;
+
+public sealed record TelemetryBreadcrumb(string Name, string Dataset, string Level, string Timestamp);
+
+public sealed record TelemetryLog(
+    string Level,
+    string Message,
+    string Source,
+    string Environment,
+    string Dataset,
+    string Version,
+    IReadOnlyDictionary<string, string>? Data,
+    string? ErrorName,
+    string? ErrorStack,
+    IReadOnlyList<string> Tags,
+    string UserId,
+    string Timestamp,
+    IReadOnlyList<TelemetryBreadcrumb>? Breadcrumbs = null);
+
+public interface ITelemetryReporter : IDisposable
+{
+    bool Enabled { get; }
+    void RecordBreadcrumb(string name, string dataset = "health", string level = "info");
+    Task ReportExceptionAsync(Exception error, string dataset, IReadOnlyDictionary<string, string>? data = null, CancellationToken cancellationToken = default);
+    Task ReportHealthAsync(string name, IReadOnlyDictionary<string, string>? data = null, CancellationToken cancellationToken = default);
+    Task FlushAsync(CancellationToken cancellationToken = default);
+    void SetEnabled(bool enabled);
+}
+
+public sealed class TelemetryReporter : ITelemetryReporter
+{
+    public static readonly Uri Endpoint = new("https://timberlogs-ingest.enaboapps.workers.dev/v1/logs");
+    private const int MaximumQueuedLogs = 20;
+    private const int MaximumBreadcrumbs = 30;
+    private readonly ITelemetrySettingsStore settingsStore;
+    private readonly HttpClient httpClient;
+    private readonly string apiKey;
+    private readonly string version;
+    private readonly string queuePath;
+    private readonly object sync = new();
+    private readonly SemaphoreSlim sendLock = new(1, 1);
+    private readonly Queue<TelemetryBreadcrumb> breadcrumbs = new();
+    private readonly JsonSerializerOptions jsonOptions = new(JsonSerializerDefaults.Web) { WriteIndented = true };
+    private TelemetrySettings settings;
+
+    public TelemetryReporter(
+        ITelemetrySettingsStore settingsStore,
+        HttpClient httpClient,
+        string apiKey,
+        string version,
+        string queuePath)
+    {
+        this.settingsStore = settingsStore;
+        this.httpClient = httpClient;
+        this.apiKey = apiKey.Trim();
+        this.version = version;
+        this.queuePath = queuePath;
+        settings = settingsStore.Load();
+        httpClient.Timeout = TimeSpan.FromSeconds(5);
+    }
+
+    public bool Enabled => settings.Enabled && !string.IsNullOrWhiteSpace(apiKey);
+
+    public void SetEnabled(bool enabled)
+    {
+        settings = settingsStore.Save(enabled);
+        if (enabled && !string.IsNullOrWhiteSpace(apiKey)) return;
+        lock (sync)
+        {
+            breadcrumbs.Clear();
+            TryDeleteQueue();
+        }
+    }
+
+    public void RecordBreadcrumb(string name, string dataset = "health", string level = "info")
+    {
+        if (!Enabled) return;
+        string? safeName = TelemetrySanitizer.Message(name);
+        if (safeName is null) return;
+        lock (sync)
+        {
+            breadcrumbs.Enqueue(new(safeName, SafeLabel(dataset), SafeLabel(level), DateTimeOffset.UtcNow.ToString("O")));
+            while (breadcrumbs.Count > MaximumBreadcrumbs) breadcrumbs.Dequeue();
+        }
+    }
+
+    public async Task ReportExceptionAsync(Exception error, string dataset, IReadOnlyDictionary<string, string>? data = null, CancellationToken cancellationToken = default)
+    {
+        if (!Enabled) return;
+        try
+        {
+            TelemetryLog log = CreateLog(
+                "error",
+                TelemetrySanitizer.Message(error.Message) ?? error.GetType().Name,
+                SafeLabel(dataset),
+                SafeData(data),
+                error.GetType().FullName,
+                TelemetrySanitizer.Stack(error.ToString()),
+                ["exception"]);
+            Enqueue(log);
+            await FlushAsync(cancellationToken).ConfigureAwait(false);
+        }
+        catch
+        {
+            // Reporting must never affect the app's error path.
+        }
+    }
+
+    public async Task ReportHealthAsync(string name, IReadOnlyDictionary<string, string>? data = null, CancellationToken cancellationToken = default)
+    {
+        if (!Enabled) return;
+        try
+        {
+            TelemetryLog log = CreateLog("info", TelemetrySanitizer.Message(name) ?? "health", "health", SafeData(data), null, null, ["health"]);
+            await SendAsync([log], cancellationToken).ConfigureAwait(false);
+        }
+        catch
+        {
+            // Health reporting is best effort and is never queued.
+        }
+    }
+
+    public async Task FlushAsync(CancellationToken cancellationToken = default)
+    {
+        if (!Enabled) return;
+        await sendLock.WaitAsync(cancellationToken).ConfigureAwait(false);
+        try
+        {
+            List<TelemetryLog> queued = ReadQueue();
+            if (queued.Count == 0) return;
+            if (await SendAsync(queued, cancellationToken).ConfigureAwait(false)) TryDeleteQueue();
+        }
+        finally
+        {
+            sendLock.Release();
+        }
+    }
+
+    private TelemetryLog CreateLog(string level, string message, string dataset, IReadOnlyDictionary<string, string>? data, string? errorName, string? errorStack, IReadOnlyList<string> tags)
+    {
+        IReadOnlyList<TelemetryBreadcrumb>? snapshot;
+        lock (sync) snapshot = breadcrumbs.Count == 0 ? null : breadcrumbs.ToArray();
+        return new(level, message, "switchify-pc", "production", dataset, version, data,
+            TelemetrySanitizer.Message(errorName), errorStack, tags, settings.InstallId, DateTimeOffset.UtcNow.ToString("O"), snapshot);
+    }
+
+    private async Task<bool> SendAsync(IReadOnlyList<TelemetryLog> logs, CancellationToken cancellationToken)
+    {
+        try
+        {
+            using HttpRequestMessage request = new(HttpMethod.Post, Endpoint)
+            {
+                Content = JsonContent.Create(new { logs })
+            };
+            request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);
+            using HttpResponseMessage response = await httpClient.SendAsync(request, cancellationToken).ConfigureAwait(false);
+            return response.IsSuccessStatusCode;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    private void Enqueue(TelemetryLog log)
+    {
+        lock (sync)
+        {
+            List<TelemetryLog> logs = ReadQueueUnsafe();
+            logs.Add(log);
+            if (logs.Count > MaximumQueuedLogs) logs.RemoveRange(0, logs.Count - MaximumQueuedLogs);
+            string? directory = Path.GetDirectoryName(queuePath);
+            if (!string.IsNullOrEmpty(directory)) Directory.CreateDirectory(directory);
+            string temporaryPath = queuePath + ".tmp";
+            File.WriteAllText(temporaryPath, JsonSerializer.Serialize(logs, jsonOptions));
+            File.Move(temporaryPath, queuePath, true);
+        }
+    }
+
+    private List<TelemetryLog> ReadQueue()
+    {
+        lock (sync) return ReadQueueUnsafe();
+    }
+
+    private List<TelemetryLog> ReadQueueUnsafe()
+    {
+        try
+        {
+            if (!File.Exists(queuePath)) return [];
+            return JsonSerializer.Deserialize<List<TelemetryLog>>(File.ReadAllText(queuePath), jsonOptions) ?? [];
+        }
+        catch
+        {
+            TryDeleteQueue();
+            return [];
+        }
+    }
+
+    private void TryDeleteQueue()
+    {
+        try { File.Delete(queuePath); } catch { }
+    }
+
+    private static IReadOnlyDictionary<string, string>? SafeData(IReadOnlyDictionary<string, string>? data)
+    {
+        if (data is null || data.Count == 0) return null;
+        Dictionary<string, string> safe = new(StringComparer.Ordinal);
+        foreach (KeyValuePair<string, string> pair in data.Take(12))
+        {
+            safe[SafeLabel(pair.Key)] = TelemetrySanitizer.Message(pair.Value) ?? string.Empty;
+        }
+        return safe;
+    }
+
+    private static string SafeLabel(string value)
+    {
+        string safe = new(value.Where(character => char.IsLetterOrDigit(character) || character is '.' or '_' or '-').Take(64).ToArray());
+        return string.IsNullOrEmpty(safe) ? "unknown" : safe;
+    }
+
+    public void Dispose()
+    {
+        sendLock.Dispose();
+        httpClient.Dispose();
+    }
+}
diff --git a/src/SwitchifyPc.Core/Diagnostics/TelemetrySanitizer.cs b/src/SwitchifyPc.Core/Diagnostics/TelemetrySanitizer.cs
new file mode 100644
index 0000000..e9b9b54
--- /dev/null
+++ b/src/SwitchifyPc.Core/Diagnostics/TelemetrySanitizer.cs
@@ -0,0 +1,36 @@
+using System.Text.RegularExpressions;
+
+namespace SwitchifyPc.Core.Diagnostics;
+
+public static partial class TelemetrySanitizer
+{
+    public const int MaximumMessageLength = 300;
+    public const int MaximumStackLength = 128 * 1024;
+
+    public static string? Message(string? value) => Sanitize(value, MaximumMessageLength);
+
+    public static string? Stack(string? value) => Sanitize(value, MaximumStackLength);
+
+    private static string? Sanitize(string? value, int maximumLength)
+    {
+        if (string.IsNullOrWhiteSpace(value)) return null;
+        string text = value.Replace('\0', ' ').Trim();
+        text = BearerPattern().Replace(text, "$1[redacted]");
+        text = SecretPattern().Replace(text, "$1[redacted]");
+        text = TimberlogsKeyPattern().Replace(text, "[redacted]");
+        text = UserPathPattern().Replace(text, "$1\\Users\\[redacted]");
+        return text.Length <= maximumLength ? text : text[..maximumLength];
+    }
+
+    [GeneratedRegex("(?i)(authorization\\s*[:=]\\s*bearer\\s+|bearer\\s+)[^\\s,;]+")]
+    private static partial Regex BearerPattern();
+
+    [GeneratedRegex("(?i)(api[_ -]?key|token|password|secret|pairing[_ -]?code)(\\s*[:=]\\s*)[^\\s,;]+")]
+    private static partial Regex SecretPattern();
+
+    [GeneratedRegex("(?i)\\btb_[a-z0-9_-]+")]
+    private static partial Regex TimberlogsKeyPattern();
+
+    [GeneratedRegex("(?i)([a-z]:)\\\\Users\\\\[^\\\\\r\n]+")]
+    private static partial Regex UserPathPattern();
+}
diff --git a/src/SwitchifyPc.Core/Diagnostics/TelemetrySettings.cs b/src/SwitchifyPc.Core/Diagnostics/TelemetrySettings.cs
new file mode 100644
index 0000000..606ddb3
--- /dev/null
+++ b/src/SwitchifyPc.Core/Diagnostics/TelemetrySettings.cs
@@ -0,0 +1,72 @@
+using System.Text.Json;
+
+namespace SwitchifyPc.Core.Diagnostics;
+
+public sealed record TelemetrySettings(bool Enabled, bool ConsentRecorded, string InstallId);
+
+public interface ITelemetrySettingsStore
+{
+    TelemetrySettings Load();
+    TelemetrySettings Save(bool enabled, bool consentRecorded = true);
+}
+
+public sealed class JsonTelemetrySettingsStore(string path) : ITelemetrySettingsStore
+{
+    private static readonly JsonSerializerOptions JsonOptions = new(JsonSerializerDefaults.Web) { WriteIndented = true };
+
+    public TelemetrySettings Load()
+    {
+        try
+        {
+            if (File.Exists(path))
+            {
+                TelemetrySettings? settings = JsonSerializer.Deserialize<TelemetrySettings>(File.ReadAllText(path), JsonOptions);
+                if (settings is not null && Guid.TryParse(settings.InstallId, out _)) return settings;
+            }
+        }
+        catch
+        {
+            // Invalid settings fail closed.
+        }
+
+        return SaveNewInstall();
+    }
+
+    public TelemetrySettings Save(bool enabled, bool consentRecorded = true)
+    {
+        TelemetrySettings current = LoadWithoutCreating() ?? new(false, false, Guid.NewGuid().ToString("D"));
+        TelemetrySettings next = current with { Enabled = enabled, ConsentRecorded = consentRecorded };
+        Write(next);
+        return next;
+    }
+
+    private TelemetrySettings SaveNewInstall()
+    {
+        TelemetrySettings settings = new(false, false, Guid.NewGuid().ToString("D"));
+        Write(settings);
+        return settings;
+    }
+
+    private TelemetrySettings? LoadWithoutCreating()
+    {
+        try
+        {
+            if (!File.Exists(path)) return null;
+            TelemetrySettings? settings = JsonSerializer.Deserialize<TelemetrySettings>(File.ReadAllText(path), JsonOptions);
+            return settings is not null && Guid.TryParse(settings.InstallId, out _) ? settings : null;
+        }
+        catch
+        {
+            return null;
+        }
+    }
+
+    private void Write(TelemetrySettings settings)
+    {
+        string? directory = Path.GetDirectoryName(path);
+        if (!string.IsNullOrEmpty(directory)) Directory.CreateDirectory(directory);
+        string temporaryPath = path + ".tmp";
+        File.WriteAllText(temporaryPath, JsonSerializer.Serialize(settings, JsonOptions));
+        File.Move(temporaryPath, path, true);
+    }
+}
diff --git a/src/SwitchifyPc.Core/Ui/SettingsController.cs b/src/SwitchifyPc.Core/Ui/SettingsController.cs
index 026194f..58f7f51 100644
--- a/src/SwitchifyPc.Core/Ui/SettingsController.cs
+++ b/src/SwitchifyPc.Core/Ui/SettingsController.cs
@@ -2,6 +2,7 @@
 using SwitchifyPc.Core.Startup;
 using SwitchifyPc.Core.Updates;
 using SwitchifyPc.Core.Pairing;
+using SwitchifyPc.Core.Diagnostics;
 
 namespace SwitchifyPc.Core.Ui;
 
@@ -14,6 +15,8 @@ public sealed class SettingsController
     private readonly ICursorOverlaySettingsStore cursorOverlaySettings;
     private readonly IUpdateSettingsService updates;
     private readonly IPairingStore pairingStore;
+    private readonly ITelemetrySettingsStore? telemetrySettings;
+    private readonly ITelemetryReporter? telemetryReporter;
 
     public SettingsController(
         SettingsViewModel viewModel,
@@ -22,7 +25,9 @@ public SettingsController(
         IMouseRepeatSettingsStore mouseRepeatSettings,
         ICursorOverlaySettingsStore cursorOverlaySettings,
         IUpdateSettingsService updates,
-        IPairingStore pairingStore)
+        IPairingStore pairingStore,
+        ITelemetrySettingsStore? telemetrySettings = null,
+        ITelemetryReporter? telemetryReporter = null)
     {
         this.viewModel = viewModel;
         this.startupSettings = startupSettings;
@@ -31,6 +36,8 @@ public SettingsController(
         this.cursorOverlaySettings = cursorOverlaySettings;
         this.updates = updates;
         this.pairingStore = pairingStore;
+        this.telemetrySettings = telemetrySettings;
+        this.telemetryReporter = telemetryReporter;
     }
 
     public SettingsViewModel ViewModel => viewModel;
@@ -42,9 +49,18 @@ public async Task LoadAsync()
         viewModel.SetMouseRepeatSettings(mouseRepeatSettings.Load());
         viewModel.SetCursorOverlaySettings(cursorOverlaySettings.Load());
         viewModel.SetUpdateState(updates.GetState());
+        if (telemetrySettings is not null) viewModel.SetTelemetrySettings(telemetrySettings.Load());
         await RefreshPairedDevicesAsync().ConfigureAwait(false);
     }
 
+    public TelemetrySettings SetShareDiagnosticData(bool enabled)
+    {
+        telemetryReporter?.SetEnabled(enabled);
+        TelemetrySettings saved = telemetrySettings?.Load() ?? new(false, false, Guid.Empty.ToString("D"));
+        viewModel.SetTelemetrySettings(saved);
+        return saved;
+    }
+
     public MouseRepeatSettings SetMouseRepeatEnabled(bool enabled)
     {
         MouseRepeatSettings saved = mouseRepeatSettings.Save(CurrentMouseRepeatSettings() with { Enabled = enabled });
diff --git a/src/SwitchifyPc.Core/Ui/SettingsViewModel.cs b/src/SwitchifyPc.Core/Ui/SettingsViewModel.cs
index 131bf35..5bef975 100644
--- a/src/SwitchifyPc.Core/Ui/SettingsViewModel.cs
+++ b/src/SwitchifyPc.Core/Ui/SettingsViewModel.cs
@@ -5,6 +5,7 @@
 using SwitchifyPc.Core.Settings;
 using SwitchifyPc.Core.Startup;
 using SwitchifyPc.Core.Updates;
+using SwitchifyPc.Core.Diagnostics;
 
 namespace SwitchifyPc.Core.Ui;
 
@@ -26,11 +27,14 @@ public sealed class SettingsViewModel : INotifyPropertyChanged
     private CursorOverlaySettings cursorOverlaySettings = CursorOverlaySettingsModel.Default;
     private UpdateState updateState = UpdateState.CreateInitial("0.2.0");
     private IReadOnlyList<PairedDeviceSettingsView> pairedDevices = [];
+    private TelemetrySettings telemetrySettings = new(false, false, Guid.Empty.ToString("D"));
 
     public event PropertyChangedEventHandler? PropertyChanged;
 
     public bool StartWithSystem => startupSettings.StartWithSystem;
 
+    public bool ShareDiagnosticData => telemetrySettings.Enabled;
+
     public bool StartWithSystemSupported => startupSettings.Supported;
 
     public string StartWithSystemMessage
@@ -278,6 +282,12 @@ public void SetUpdateState(UpdateState state)
         OnPropertyChanged(nameof(CanInstallUpdate));
     }
 
+    public void SetTelemetrySettings(TelemetrySettings settings)
+    {
+        telemetrySettings = settings;
+        OnPropertyChanged(nameof(ShareDiagnosticData));
+    }
+
     public static string UpdateCheckMessage(UpdateInfo info)
     {
         if (info.Reason == UpdateFailureReason.NotPackaged) return "Updates are only available in packaged builds.";
diff --git a/src/SwitchifyPc.Core/Ui/SetupGuideViewModel.cs b/src/SwitchifyPc.Core/Ui/SetupGuideViewModel.cs
index c67d391..f544a97 100644
--- a/src/SwitchifyPc.Core/Ui/SetupGuideViewModel.cs
+++ b/src/SwitchifyPc.Core/Ui/SetupGuideViewModel.cs
@@ -12,7 +12,8 @@ public enum SetupGuideStep
     Bluetooth,
     AndroidApp,
     PairDevice,
-    Startup
+    Startup,
+    Diagnostics
 }
 
 public static class SetupGuidePrompt
@@ -47,6 +48,7 @@ public sealed class SetupGuideViewModel : INotifyPropertyChanged
         StartWithSystem: false,
         StartsHidden: true,
         Reason: "unpackaged");
+    private bool? shareDiagnosticData;
 
     public event PropertyChangedEventHandler? PropertyChanged;
 
@@ -54,7 +56,7 @@ public sealed class SetupGuideViewModel : INotifyPropertyChanged
 
     public int StepNumber => (int)currentStep + 1;
 
-    public string StepProgress => $"Step {StepNumber} of 4";
+    public string StepProgress => $"Step {StepNumber} of 5";
 
     public bool IsBluetoothStep => currentStep == SetupGuideStep.Bluetooth;
 
@@ -64,11 +66,17 @@ public sealed class SetupGuideViewModel : INotifyPropertyChanged
 
     public bool IsStartupStep => currentStep == SetupGuideStep.Startup;
 
+    public bool IsDiagnosticsStep => currentStep == SetupGuideStep.Diagnostics;
+
+    public bool? ShareDiagnosticData => shareDiagnosticData;
+
+    public bool IsDiagnosticChoiceRequired => IsDiagnosticsStep && shareDiagnosticData is null;
+
     public bool CanGoBack => currentStep != SetupGuideStep.Bluetooth;
 
-    public bool CanGoNext => currentStep != SetupGuideStep.PairDevice || hasPairedDevices;
+    public bool CanGoNext => (currentStep != SetupGuideStep.PairDevice || hasPairedDevices) && !IsDiagnosticChoiceRequired;
 
-    public bool IsFinalStep => currentStep == SetupGuideStep.Startup;
+    public bool IsFinalStep => currentStep == SetupGuideStep.Diagnostics;
 
     public string NextButtonText => IsFinalStep ? "Finish" : "Next";
 
@@ -184,6 +192,14 @@ public void SetStartupSettings(SystemStartupSettings settings)
         OnPropertyChanged(nameof(StartWithSystemMessage));
     }
 
+    public void SetShareDiagnosticData(bool enabled)
+    {
+        shareDiagnosticData = enabled;
+        OnPropertyChanged(nameof(ShareDiagnosticData));
+        OnPropertyChanged(nameof(IsDiagnosticChoiceRequired));
+        OnPropertyChanged(nameof(CanGoNext));
+    }
+
     private void NotifyStepChanged()
     {
         OnPropertyChanged(nameof(CurrentStep));
@@ -193,6 +209,8 @@ private void NotifyStepChanged()
         OnPropertyChanged(nameof(IsAndroidAppStep));
         OnPropertyChanged(nameof(IsPairDeviceStep));
         OnPropertyChanged(nameof(IsStartupStep));
+        OnPropertyChanged(nameof(IsDiagnosticsStep));
+        OnPropertyChanged(nameof(IsDiagnosticChoiceRequired));
         OnPropertyChanged(nameof(CanGoBack));
         OnPropertyChanged(nameof(CanGoNext));
         OnPropertyChanged(nameof(IsFinalStep));
diff --git a/src/SwitchifyPc.Tests/SetupGuideViewModelTests.cs b/src/SwitchifyPc.Tests/SetupGuideViewModelTests.cs
index 0d7781b..81f6e75 100644
--- a/src/SwitchifyPc.Tests/SetupGuideViewModelTests.cs
+++ b/src/SwitchifyPc.Tests/SetupGuideViewModelTests.cs
@@ -37,7 +37,7 @@ public void MarksGuideShownAndCompletedWithoutChangingLegacyPreference()
     }
 
     [Fact]
-    public void NavigatesFourStepsAndRequiresPairingBeforeStartup()
+    public void NavigatesFiveStepsAndRequiresPairingAndDiagnosticChoice()
     {
         SetupGuideViewModel viewModel = new();
 
@@ -55,11 +55,17 @@ public void NavigatesFourStepsAndRequiresPairingBeforeStartup()
         Assert.True(viewModel.CanGoNext);
         Assert.True(viewModel.MoveNext());
         Assert.True(viewModel.IsStartupStep);
+        Assert.False(viewModel.IsFinalStep);
+        Assert.True(viewModel.MoveNext());
+        Assert.True(viewModel.IsDiagnosticsStep);
+        Assert.False(viewModel.CanGoNext);
+        viewModel.SetShareDiagnosticData(false);
+        Assert.True(viewModel.CanGoNext);
         Assert.True(viewModel.IsFinalStep);
         Assert.Equal("Finish", viewModel.NextButtonText);
         Assert.False(viewModel.MoveNext());
         Assert.True(viewModel.MoveBack());
-        Assert.True(viewModel.IsPairDeviceStep);
+        Assert.True(viewModel.IsStartupStep);
     }
 
     [Fact]
diff --git a/src/SwitchifyPc.Tests/SetupGuideWindowTests.cs b/src/SwitchifyPc.Tests/SetupGuideWindowTests.cs
index e91066b..a6e1e26 100644
--- a/src/SwitchifyPc.Tests/SetupGuideWindowTests.cs
+++ b/src/SwitchifyPc.Tests/SetupGuideWindowTests.cs
@@ -32,13 +32,13 @@ public void LoadsBluetoothStepWithCustomChrome()
                 Assert.Equal(ResizeMode.NoResize, window.ResizeMode);
                 Assert.NotNull(WindowChrome.GetWindowChrome(window));
                 Assert.Contains("Check Bluetooth", TextBlocks(window));
-                Assert.Contains("Step 1 of 4", TextBlocks(window));
+                Assert.Contains("Step 1 of 5", TextBlocks(window));
                 Assert.NotNull(ButtonByAutomationName(window, "Minimize"));
                 Assert.NotNull(ButtonByAutomationName(window, "Close"));
                 SolidColorBrush chromeForeground = Assert.IsType<SolidColorBrush>(window.FindResource("ChromeForeground"));
                 Assert.Equal(chromeForeground.Color, Assert.IsType<SolidColorBrush>(TextBlockByText(window, "Setup guide").Foreground).Color);
                 Assert.Equal(chromeForeground.Color, Assert.IsType<SolidColorBrush>(TextBlockByText(window, "Connect Switchify for Android").Foreground).Color);
-                Assert.Equal(chromeForeground.Color, Assert.IsType<SolidColorBrush>(TextBlockByText(window, "Step 1 of 4").Foreground).Color);
+                Assert.Equal(chromeForeground.Color, Assert.IsType<SolidColorBrush>(TextBlockByText(window, "Step 1 of 5").Foreground).Color);
             }
             finally
             {
diff --git a/src/SwitchifyPc.Tests/TelemetryTests.cs b/src/SwitchifyPc.Tests/TelemetryTests.cs
new file mode 100644
index 0000000..3e78ea9
--- /dev/null
+++ b/src/SwitchifyPc.Tests/TelemetryTests.cs
@@ -0,0 +1,144 @@
+using System.Net;
+using System.Text.Json;
+using SwitchifyPc.Core.Diagnostics;
+
+namespace SwitchifyPc.Tests;
+
+public sealed class TelemetryTests
+{
+    [Fact]
+    public void SettingsDefaultToOptedOutWithStableOpaqueInstallId()
+    {
+        using TemporaryDirectory directory = new();
+        JsonTelemetrySettingsStore store = new(Path.Combine(directory.Path, "settings.json"));
+
+        TelemetrySettings first = store.Load();
+        TelemetrySettings second = store.Load();
+
+        Assert.False(first.Enabled);
+        Assert.False(first.ConsentRecorded);
+        Assert.True(Guid.TryParse(first.InstallId, out _));
+        Assert.Equal(first.InstallId, second.InstallId);
+    }
+
+    [Fact]
+    public void SanitizerRemovesSecretsAndUserProfilePaths()
+    {
+        string input = "Authorization: Bearer abc123 token=secret pairing_code=654321 tb_live_value at C:\\Users\\Alice\\private.txt";
+
+        string safe = TelemetrySanitizer.Message(input)!;
+
+        Assert.DoesNotContain("abc123", safe);
+        Assert.DoesNotContain("secret", safe);
+        Assert.DoesNotContain("654321", safe);
+        Assert.DoesNotContain("tb_live_value", safe);
+        Assert.DoesNotContain("Alice", safe);
+        Assert.Contains("[redacted]", safe);
+    }
+
+    [Fact]
+    public async Task OptedOutReporterDoesNotSendOrQueue()
+    {
+        using TemporaryDirectory directory = new();
+        JsonTelemetrySettingsStore store = new(Path.Combine(directory.Path, "settings.json"));
+        RecordingHandler handler = new(HttpStatusCode.OK);
+        using TelemetryReporter reporter = CreateReporter(directory, store, handler);
+
+        await reporter.ReportExceptionAsync(new InvalidOperationException("failure"), "test");
+
+        Assert.Empty(handler.Requests);
+        Assert.False(File.Exists(Path.Combine(directory.Path, "queue.json")));
+    }
+
+    [Fact]
+    public async Task ExceptionIsSanitizedAuthenticatedAndRemovedAfterSuccessfulUpload()
+    {
+        using TemporaryDirectory directory = new();
+        JsonTelemetrySettingsStore store = new(Path.Combine(directory.Path, "settings.json"));
+        store.Save(true);
+        RecordingHandler handler = new(HttpStatusCode.OK);
+        using TelemetryReporter reporter = CreateReporter(directory, store, handler);
+
+        await reporter.ReportExceptionAsync(new InvalidOperationException("token=private-value"), "runtime");
+
+        RecordingRequest request = Assert.Single(handler.Requests);
+        Assert.Equal("Bearer", request.Scheme);
+        Assert.Equal("test-key", request.Parameter);
+        Assert.DoesNotContain("private-value", request.Body);
+        Assert.Contains("switchify-pc", request.Body);
+        Assert.Contains(store.Load().InstallId, request.Body);
+        Assert.False(File.Exists(Path.Combine(directory.Path, "queue.json")));
+    }
+
+    [Fact]
+    public async Task FailedExceptionUploadQueuesAndOptOutPurges()
+    {
+        using TemporaryDirectory directory = new();
+        JsonTelemetrySettingsStore store = new(Path.Combine(directory.Path, "settings.json"));
+        store.Save(true);
+        RecordingHandler handler = new(HttpStatusCode.ServiceUnavailable);
+        string queuePath = Path.Combine(directory.Path, "queue.json");
+        using TelemetryReporter reporter = CreateReporter(directory, store, handler);
+
+        await reporter.ReportExceptionAsync(new Exception("failure"), "runtime");
+        Assert.True(File.Exists(queuePath));
+
+        reporter.SetEnabled(false);
+
+        Assert.False(File.Exists(queuePath));
+        Assert.False(store.Load().Enabled);
+        Assert.True(store.Load().ConsentRecorded);
+    }
+
+    [Fact]
+    public async Task HealthFailuresAreNotQueued()
+    {
+        using TemporaryDirectory directory = new();
+        JsonTelemetrySettingsStore store = new(Path.Combine(directory.Path, "settings.json"));
+        store.Save(true);
+        RecordingHandler handler = new(HttpStatusCode.ServiceUnavailable);
+        using TelemetryReporter reporter = CreateReporter(directory, store, handler);
+
+        await reporter.ReportHealthAsync("app.startup.completed");
+
+        Assert.Single(handler.Requests);
+        Assert.False(File.Exists(Path.Combine(directory.Path, "queue.json")));
+    }
+
+    private static TelemetryReporter CreateReporter(TemporaryDirectory directory, JsonTelemetrySettingsStore store, RecordingHandler handler)
+    {
+        return new TelemetryReporter(store, new HttpClient(handler), "test-key", "0.6.4", Path.Combine(directory.Path, "queue.json"));
+    }
+
+    private sealed record RecordingRequest(string? Scheme, string? Parameter, string Body);
+
+    private sealed class RecordingHandler(HttpStatusCode statusCode) : HttpMessageHandler
+    {
+        public List<RecordingRequest> Requests { get; } = [];
+
+        protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+        {
+            Requests.Add(new(
+                request.Headers.Authorization?.Scheme,
+                request.Headers.Authorization?.Parameter,
+                request.Content is null ? string.Empty : await request.Content.ReadAsStringAsync(cancellationToken)));
+            return new HttpResponseMessage(statusCode);
+        }
+    }
+
+    private sealed class TemporaryDirectory : IDisposable
+    {
+        public TemporaryDirectory()
+        {
+            Path = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "switchify-telemetry-tests", Guid.NewGuid().ToString("N"));
+            Directory.CreateDirectory(Path);
+        }
+
+        public string Path { get; }
+
+        public void Dispose()
+        {
+            try { Directory.Delete(Path, true); } catch { }
+        }
+    }
+}