Add diagnostics to log upload and update types

Author: richiemcilroy

apps/desktop/src-tauri/src/logging.rs

@@ -1,4 +1,5 @@
-use crate::{ArcLock, web_api::ManagerExt};
+use crate::{ArcLock, feeds::microphone::MicrophoneFeed, permissions, web_api::ManagerExt};
+use serde::Serialize;
 use std::{fs, path::PathBuf};
 use tauri::{AppHandle, Manager};
 
@@ -29,6 +30,60 @@ async fn get_latest_log_file(app: &AppHandle) -> Option<PathBuf> {
     log_files.first().map(|(path, _)| path.clone())
 }
 
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct LogUploadDiagnostics {
+    system: cap_recording::diagnostics::SystemDiagnostics,
+    cameras: Vec<String>,
+    microphones: Vec<String>,
+    permissions: PermissionsInfo,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct PermissionsInfo {
+    screen_recording: String,
+    camera: String,
+    microphone: String,
+}
+
+fn collect_diagnostics_for_upload() -> LogUploadDiagnostics {
+    let system = cap_recording::diagnostics::collect_diagnostics();
+    let permissions = permissions::do_permissions_check(false);
+
+    let cameras: Vec<String> = if permissions.camera.permitted() {
+        cap_camera::list_cameras()
+            .map(|c| c.display_name().to_string())
+            .collect()
+    } else {
+        vec![]
+    };
+
+    let microphones: Vec<String> = if permissions.microphone.permitted() {
+        MicrophoneFeed::list().keys().cloned().collect()
+    } else {
+        vec![]
+    };
+
+    let perm_status = |p: &permissions::OSPermissionStatus| match p {
+        permissions::OSPermissionStatus::NotNeeded => "not_needed",
+        permissions::OSPermissionStatus::Empty => "not_requested",
+        permissions::OSPermissionStatus::Granted => "granted",
+        permissions::OSPermissionStatus::Denied => "denied",
+    };
+
+    LogUploadDiagnostics {
+        system,
+        cameras,
+        microphones,
+        permissions: PermissionsInfo {
+            screen_recording: perm_status(&permissions.screen_recording).to_string(),
+            camera: perm_status(&permissions.camera).to_string(),
+            microphone: perm_status(&permissions.microphone).to_string(),
+        },
+    }
+}
+
 pub async fn upload_log_file(app: &AppHandle) -> Result<(), String> {
     let log_file = get_latest_log_file(app).await.ok_or("No log file found")?;
 
@@ -62,10 +117,14 @@ pub async fn upload_log_file(app: &AppHandle) -> Result<(), String> {
         fs::read_to_string(&log_file).map_err(|e| format!("Failed to read log file: {e}"))?
     };
 
+    let diagnostics = collect_diagnostics_for_upload();
+    let diagnostics_json = serde_json::to_string(&diagnostics).unwrap_or_else(|_| "{}".to_string());
+
     let form = reqwest::multipart::Form::new()
         .text("log", log_content)
         .text("os", std::env::consts::OS)
-        .text("version", env!("CARGO_PKG_VERSION"));
+        .text("version", env!("CARGO_PKG_VERSION"))
+        .text("diagnostics", diagnostics_json);
 
     let response = app
         .api_request("/api/desktop/logs", |client, url| {

apps/desktop/src/utils/tauri.ts

@@ -375,7 +375,6 @@ uploadProgressEvent: "upload-progress-event"
 
 /** user-defined types **/
 
-export type AllGpusInfo = { gpus: GpuInfoDiag[]; primaryGpuIndex: number | null; isMultiGpuSystem: boolean; hasDiscreteGpu: boolean }
 export type Annotation = { id: string; type: AnnotationType; x: number; y: number; width: number; height: number; strokeColor: string; strokeWidth: number; fillColor: string; opacity: number; rotation: number; text: string | null; maskType?: MaskType | null; maskLevel?: number | null }
 export type AnnotationType = "arrow" | "circle" | "rectangle" | "text" | "mask"
 export type AppTheme = "system" | "light" | "dark"
@@ -445,7 +444,6 @@ quality: number | null;
  * Whether to prioritize speed over quality (default: false)
  */
 fast: boolean | null }
-export type GpuInfoDiag = { vendor: string; description: string; dedicatedVideoMemoryMb: number; adapterIndex: number; isSoftwareAdapter: boolean; isBasicRenderDriver: boolean; supportsHardwareEncoding: boolean }
 export type HapticPattern = "alignment" | "levelChange" | "generic"
 export type HapticPerformanceTime = "default" | "now" | "drawCompleted"
 export type Hotkey = { code: string; meta: boolean; ctrl: boolean; alt: boolean; shift: boolean }
@@ -458,6 +456,7 @@ export type JsonValue<T> = [T]
 export type LogicalBounds = { position: LogicalPosition; size: LogicalSize }
 export type LogicalPosition = { x: number; y: number }
 export type LogicalSize = { width: number; height: number }
+export type MacOSVersionInfo = { displayName: string }
 export type MainWindowRecordingStartBehaviour = "close" | "minimise"
 export type MaskKeyframes = { position?: MaskVectorKeyframe[]; size?: MaskVectorKeyframe[]; intensity?: MaskScalarKeyframe[] }
 export type MaskKind = "sensitive" | "highlight"
@@ -500,7 +499,6 @@ export type RecordingStatus = "pending" | "recording"
 export type RecordingStopped = null
 export type RecordingTargetMode = "display" | "window" | "area"
 export type RenderFrameEvent = { frame_number: number; fps: number; resolution_base: XY<number> }
-export type RenderingStatus = { isUsingSoftwareRendering: boolean; isUsingBasicRenderDriver: boolean; hardwareEncodingAvailable: boolean; warningMessage: string | null }
 export type RequestOpenRecordingPicker = { target_mode: RecordingTargetMode | null }
 export type RequestOpenSettings = { page: string }
 export type RequestScreenCapturePrewarm = { force?: boolean }
@@ -521,7 +519,7 @@ export type StartRecordingInputs = { capture_target: ScreenCaptureTarget; captur
 export type StereoMode = "stereo" | "monoL" | "monoR"
 export type StudioRecordingMeta = { segment: SingleSegment } | { inner: MultipleSegments }
 export type StudioRecordingStatus = { status: "InProgress" } | { status: "NeedsRemux" } | { status: "Failed"; error: string } | { status: "Complete" }
-export type SystemDiagnostics = { windowsVersion: WindowsVersionInfo | null; gpuInfo: GpuInfoDiag | null; allGpus: AllGpusInfo | null; renderingStatus: RenderingStatus; availableEncoders: string[]; graphicsCaptureSupported: boolean; d3D11VideoProcessorAvailable: boolean }
+export type SystemDiagnostics = { macosVersion: MacOSVersionInfo | null; availableEncoders: string[]; screenCaptureSupported: boolean }
 export type TargetUnderCursor = { display_id: DisplayId | null; window: WindowUnderCursor | null }
 export type TextSegment = { start: number; end: number; enabled?: boolean; content?: string; center?: XY<number>; size?: XY<number>; fontFamily?: string; fontSize?: number; fontWeight?: number; italic?: boolean; color?: string; fadeDuration?: number }
 export type TimelineConfiguration = { segments: TimelineSegment[]; zoomSegments: ZoomSegment[]; sceneSegments?: SceneSegment[]; maskSegments?: MaskSegment[]; textSegments?: TextSegment[] }
@@ -538,7 +536,6 @@ export type VideoUploadInfo = { id: string; link: string; config: S3UploadMeta }
 export type WindowExclusion = { bundleIdentifier?: string | null; ownerName?: string | null; windowTitle?: string | null }
 export type WindowId = string
 export type WindowUnderCursor = { id: WindowId; app_name: string; bounds: LogicalBounds }
-export type WindowsVersionInfo = { major: number; minor: number; build: number; displayName: string; meetsRequirements: boolean; isWindows11: boolean }
 export type XY<T> = { x: T; y: T }
 export type ZoomMode = "auto" | { manual: { x: number; y: number } }
 export type ZoomSegment = { start: number; end: number; amount: number; mode: ZoomMode }