add tracing

Author: jerryshell

Cargo.lock

@@ -7,3 +7,5 @@ edition = "2021"
 aurora-core = { path = "../aurora-core" }
 dotenv = "0.15"
 glob = "0.3"
+tracing = "0.1"
+tracing-subscriber = "0.3"

aurora-cli/Cargo.toml

@@ -10,35 +10,35 @@ fn get_j() -> String {
 
 pub fn run(video_filename: &str, target_frame_rate: usize) {
     let origin_frame_rate = aurora_core::get_origin_frame_rate(video_filename);
-    println!("origin_frame_rate: {origin_frame_rate}");
+    tracing::info!("origin_frame_rate: {origin_frame_rate}");
 
     let frame_multiple = (target_frame_rate as f32 / origin_frame_rate).ceil() as usize;
-    println!("frame_multiple: {frame_multiple}");
+    tracing::info!("frame_multiple: {frame_multiple}");
     if frame_multiple <= 1 {
-        println!("frame_multiple <= 1, skip");
+        tracing::info!("frame_multiple <= 1, skip");
         return;
     }
 
     let video_extract_audio_filename = aurora_core::extract_audio(video_filename);
-    println!("video_extract_audio_filename: {video_extract_audio_filename}");
+    tracing::info!("video_extract_audio_filename: {video_extract_audio_filename}");
 
     let video_frames_dir_name = aurora_core::video_frames_dir_mkdir(video_filename);
-    println!("video_frames_dir_name: {video_frames_dir_name}");
+    tracing::info!("video_frames_dir_name: {video_frames_dir_name}");
 
     aurora_core::decode_frames(video_filename, &video_frames_dir_name);
 
     let origin_frame_count = aurora_core::get_origin_frame_count(&video_frames_dir_name);
-    println!("origin_frame_count: {origin_frame_count}");
+    tracing::info!("origin_frame_count: {origin_frame_count}");
 
     let target_frame_count = frame_multiple * origin_frame_count;
-    println!("target_frame_count: {target_frame_count}");
+    tracing::info!("target_frame_count: {target_frame_count}");
 
     let video_interpolate_frames_dir_name =
         aurora_core::video_interpolate_frames_dir_mkdir(video_filename);
-    println!("video_interpolate_frames_dir_name: {video_interpolate_frames_dir_name}");
+    tracing::info!("video_interpolate_frames_dir_name: {video_interpolate_frames_dir_name}");
 
     let j = get_j();
-    println!("j: {j}");
+    tracing::info!("j: {j}");
 
     aurora_core::interpolate_frame(
         target_frame_count,
@@ -48,7 +48,7 @@ pub fn run(video_filename: &str, target_frame_rate: usize) {
     );
 
     let target_frame_rate = frame_multiple as f32 * origin_frame_rate;
-    println!("target_frame_rate: {target_frame_rate}");
+    tracing::info!("target_frame_rate: {target_frame_rate}");
 
     aurora_core::encode_video(
         target_frame_rate,

aurora-cli/src/lib.rs

@@ -1,25 +1,27 @@
 fn main() {
     dotenv::dotenv().ok();
 
+    tracing_subscriber::fmt::init();
+
     let video_glob = std::env::var("VIDEO_GLOB").expect("VICEO_GLOB must be set");
-    println!("video_glob: {video_glob}");
+    tracing::info!("video_glob: {video_glob}");
 
     let path_list = glob::glob(&video_glob)
         .expect("failed to read glob pattern")
         .filter_map(|e| e.ok())
         .map(|path| path.to_str().unwrap_or("").to_owned())
         .filter(|s| !s.is_empty())
         .collect::<Vec<String>>();
-    println!("path_list: {path_list:?}");
+    tracing::info!("path_list: {path_list:?}");
 
     for video_filename in path_list {
-        println!("video_filename: {video_filename}");
+        tracing::info!("video_filename: {video_filename}");
 
         let target_frame_rate = match std::env::var("TARGET_FRAME_RATE") {
             Ok(str) => str.parse::<usize>().unwrap_or(60),
             Err(_) => 60,
         };
-        println!("target_frame_rate: {target_frame_rate}");
+        tracing::info!("target_frame_rate: {target_frame_rate}");
 
         aurora_cli::run(&video_filename, target_frame_rate);
     }

aurora-cli/src/main.rs

@@ -6,3 +6,4 @@ edition = "2021"
 [dependencies]
 regex = "1.7"
 num_cpus = "1.15"
+tracing = "0.1"

aurora-core/Cargo.toml

@@ -5,17 +5,17 @@ pub fn clean(
 ) {
     if !video_extract_audio_filename.is_empty() {
         let remove_video_extract_audio_result = std::fs::remove_file(video_extract_audio_filename);
-        println!("remove_video_extract_audio_result: {remove_video_extract_audio_result:?}");
+        tracing::info!("remove_video_extract_audio_result: {remove_video_extract_audio_result:?}");
     }
 
     if !video_frames_dir_name.is_empty() {
         let remove_video_frames_dir_result = std::fs::remove_dir_all(video_frames_dir_name);
-        println!("remove_video_frames_dir_result: {remove_video_frames_dir_result:?}");
+        tracing::info!("remove_video_frames_dir_result: {remove_video_frames_dir_result:?}");
     }
 
     if !video_interpolate_frames_dir_name.is_empty() {
         let remove_video_interpolate_frames_dir_result =
             std::fs::remove_dir_all(video_interpolate_frames_dir_name);
-        println!("remove_video_interpolate_frames_dir_result: {remove_video_interpolate_frames_dir_result:?}");
+        tracing::info!("remove_video_interpolate_frames_dir_result: {remove_video_interpolate_frames_dir_result:?}");
     }
 }

aurora-core/src/clean.rs

@@ -8,8 +8,8 @@ pub fn decode_frames(video_filename: &str, video_frames_dir_name: &str) {
             r"ffmpeg/ffmpeg -y -vsync passthrough -i {video_filename} {video_frames_dir_name}/frame_%08d.png"
         )
     };
-    println!("decode_frames_cmd_str: {decode_frames_cmd_str}");
+    tracing::info!("decode_frames_cmd_str: {decode_frames_cmd_str}");
 
     let decode_frames_cmd_output = crate::execute_cmd(&decode_frames_cmd_str);
-    println!("decode_frames_cmd_output: {decode_frames_cmd_output:?}");
+    tracing::info!("decode_frames_cmd_output: {decode_frames_cmd_output:?}");
 }

aurora-core/src/decode_frames.rs

@@ -7,7 +7,7 @@ pub fn encode_video(
         Ok(str) => str,
         Err(_) => "libx264".to_owned(),
     };
-    println!("video_encoder: {video_encoder}");
+    tracing::info!("video_encoder: {video_encoder}");
     let encode_video_cmd_str = if cfg!(target_os = "windows") {
         format!(
             r"ffmpeg\ffmpeg.exe -y -framerate {target_frame_rate} -i {video_interpolate_frames_dir_name}/%08d.png -i {video_filename}_audio.m4a -c:a copy -crf 20 -c:v {video_encoder} -pix_fmt yuv420p output_{video_filename}.mp4"
@@ -17,8 +17,8 @@ pub fn encode_video(
             r"ffmpeg/ffmpeg -y -framerate {target_frame_rate} -i {video_interpolate_frames_dir_name}/%08d.png -i {video_filename}_audio.m4a -c:a copy -crf 20 -c:v {video_encoder} -pix_fmt yuv420p output_{video_filename}.mp4"
         )
     };
-    println!("encode_video_cmd_str: {encode_video_cmd_str}");
+    tracing::info!("encode_video_cmd_str: {encode_video_cmd_str}");
 
     let encode_video_cmd_output = crate::execute_cmd(&encode_video_cmd_str);
-    println!("encode_video_cmd_output: {encode_video_cmd_output:?}");
+    tracing::info!("encode_video_cmd_output: {encode_video_cmd_output:?}");
 }