feat: add logging via tracing crate

src-tauri/src/lib.rs

@@ -1,29 +1,45 @@
-mod ff;
-mod media;
-mod models;
+pub mod ff;
+pub mod media;
+pub mod models;
 pub mod strings;
 
 use ff::extract_streams;
 use media::{detect_media_type, is_media_file};
 use models::{StreamResult, StreamResultError};
+use strings::transform_filename;
 use std::path::Path;
+use tracing::{debug, error, info, instrument, warn};
 
 // detection, helpers moved to modules above
 
 #[tauri::command]
+#[instrument(skip(paths), fields(file_count = paths.len()))]
 fn has_streams(paths: Vec<String>) -> Result<Vec<StreamResult>, StreamResultError> {
-    paths
+    info!(file_count = paths.len(), "Processing files for stream analysis");
+    
+    let results = paths
         .into_iter()
-        .map(|path_str| {
+        .enumerate()
+        .map(|(index, path_str)| {
             let path = Path::new(&path_str);
             let filename = path
                 .file_name()
                 .and_then(|name| name.to_str())
                 .unwrap_or("unknown")
                 .to_string();
+            
+            // Log full path only on first occurrence, then use truncated filename
+            if index == 0 {
+                debug!(full_path = %path_str, filename = %filename, "Processing first file");
+            } else {
+                let truncated_name = transform_filename(&filename, 15);
+                debug!(filename = %truncated_name, "Processing file");
+            }
 
             // Check if file exists
             if !path.exists() {
+                let truncated_name = transform_filename(&filename, 15);
+                warn!(filename = %truncated_name, "File does not exist");
                 return Err(StreamResultError {
                     filename: Some(filename),
                     reason: "File does not exist".to_string(),
@@ -33,6 +49,8 @@ fn has_streams(paths: Vec<String>) -> Result<Vec<StreamResult>, StreamResultErro
 
             // Check if it's a file (not directory)
             if !path.is_file() {
+                let truncated_name = transform_filename(&filename, 15);
+                warn!(filename = %truncated_name, "Path is not a file");
                 return Err(StreamResultError {
                     filename: Some(filename),
                     reason: "Not a file (directory or other)".to_string(),
@@ -45,11 +63,17 @@ fn has_streams(paths: Vec<String>) -> Result<Vec<StreamResult>, StreamResultErro
                 .map(|metadata| metadata.len())
                 .unwrap_or(0);
 
+            let truncated_name = transform_filename(&filename, 15);
+            debug!(filename = %truncated_name, size = size, "File metadata retrieved");
+
             // Detect media type using magic numbers and fallback to extensions
             let media_type = detect_media_type(path);
+            debug!(filename = %truncated_name, media_type = ?media_type, "Media type detected");
 
             // Only try to analyze media files with ffprobe
             if is_media_file(&media_type) {
+                info!(filename = %truncated_name, media_type = ?media_type, "Analyzing media file with ffprobe");
+                
                 // Analyze with ffprobe
                 match ffprobe::ffprobe(&path_str) {
                     Ok(info) => {
@@ -59,6 +83,13 @@ fn has_streams(paths: Vec<String>) -> Result<Vec<StreamResult>, StreamResultErro
                             .duration
                             .and_then(|dur_str| dur_str.parse::<f64>().ok());
 
+                        info!(
+                            filename = %truncated_name,
+                            stream_count = streams.len(),
+                            duration = ?duration,
+                            "Successfully analyzed media file"
+                        );
+
                         Ok(StreamResult {
                             filename,
                             path: path_str,
@@ -69,7 +100,7 @@ fn has_streams(paths: Vec<String>) -> Result<Vec<StreamResult>, StreamResultErro
                         })
                     }
                     Err(err) => {
-                        eprintln!("Could not analyze media file with ffprobe: {err:?}");
+                        error!(filename = %truncated_name, error = %err, "Failed to analyze media file with ffprobe");
                         Err(StreamResultError {
                             filename: Some(filename),
                             reason: format!("Could not analyze media file: {err}"),
@@ -78,6 +109,7 @@ fn has_streams(paths: Vec<String>) -> Result<Vec<StreamResult>, StreamResultErro
                     }
                 }
             } else {
+                debug!(filename = %truncated_name, media_type = ?media_type, "Skipping non-media file");
                 // For non-media files, return an error indicating it's not a media file
                 Err(StreamResultError {
                     filename: Some(filename),
@@ -86,14 +118,26 @@ fn has_streams(paths: Vec<String>) -> Result<Vec<StreamResult>, StreamResultErro
                 })
             }
         })
-        .collect::<Result<Vec<_>, _>>()
+        .collect::<Result<Vec<_>, _>>();
+
+    match &results {
+        Ok(streams) => {
+            info!(successful_files = streams.len(), "Successfully processed all files");
+        }
+        Err(_) => {
+            warn!("Some files failed to process");
+        }
+    }
+
+    results
 }
 
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
+    info!("Initializing Tauri application");
     tauri::Builder::default()
         .plugin(tauri_plugin_opener::init())
         .invoke_handler(tauri::generate_handler![has_streams])
         .run(tauri::generate_context!())
         .expect("error while running tauri application");
-}
+}