levels

czkawka_core/src/bad_extensions.rs

@@ -194,7 +194,7 @@ impl BadExtensions {
         }
     }
 
-    #[fun_time(message = "find_bad_extensions_files")]
+    #[fun_time(message = "find_bad_extensions_files", level = "info")]
     pub fn find_bad_extensions_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) {
         self.optimize_dirs_before_start();
         if !self.check_files(stop_receiver, progress_sender) {
@@ -208,7 +208,7 @@ impl BadExtensions {
         self.debug_print();
     }
 
-    #[fun_time(message = "check_files")]
+    #[fun_time(message = "check_files", level = "debug")]
     fn check_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) -> bool {
         let result = DirTraversalBuilder::new()
             .root_dirs(self.common_data.directories.included_directories.clone())
@@ -238,7 +238,7 @@ impl BadExtensions {
         }
     }
 
-    #[fun_time(message = "look_for_bad_extensions_files")]
+    #[fun_time(message = "look_for_bad_extensions_files", level = "debug")]
     fn look_for_bad_extensions_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) -> bool {
         let (progress_thread_handle, progress_thread_run, atomic_counter, check_was_stopped) =
             prepare_thread_handler_common(progress_sender, 1, 1, self.files_to_check.len(), CheckingMethod::None, self.get_cd().tool_type);
@@ -270,7 +270,7 @@ impl BadExtensions {
         true
     }
 
-    #[fun_time(message = "verify_extensions")]
+    #[fun_time(message = "verify_extensions", level = "debug")]
     fn verify_extensions(
         &self,
         files_to_check: Vec<FileEntry>,

czkawka_core/src/big_file.rs

@@ -56,7 +56,7 @@ impl BigFile {
         }
     }
 
-    #[fun_time(message = "find_big_files")]
+    #[fun_time(message = "find_big_files", level = "info")]
     pub fn find_big_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) {
         self.optimize_dirs_before_start();
         if !self.look_for_big_files(stop_receiver, progress_sender) {
@@ -67,7 +67,7 @@ impl BigFile {
         self.debug_print();
     }
 
-    #[fun_time(message = "look_for_big_files")]
+    #[fun_time(message = "look_for_big_files", level = "debug")]
     fn look_for_big_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) -> bool {
         let mut folders_to_check: Vec<PathBuf> = Vec::with_capacity(1024 * 2); // This should be small enough too not see to big difference and big enough to store most of paths without needing to resize vector
         let mut old_map: BTreeMap<u64, Vec<FileEntry>> = Default::default();
@@ -181,7 +181,7 @@ impl BigFile {
         fe_result.push((fe.size, fe));
     }
 
-    #[fun_time(message = "extract_n_biggest_files")]
+    #[fun_time(message = "extract_n_biggest_files", level = "debug")]
     pub fn extract_n_biggest_files(&mut self, old_map: BTreeMap<u64, Vec<FileEntry>>) {
         let iter: Box<dyn Iterator<Item = _>>;
         if self.search_mode == SearchMode::SmallestFiles {

czkawka_core/src/broken_files.rs

@@ -92,7 +92,7 @@ impl BrokenFiles {
         }
     }
 
-    #[fun_time(message = "find_broken_files")]
+    #[fun_time(message = "find_broken_files", level = "info")]
     pub fn find_broken_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) {
         self.optimize_dirs_before_start();
         if !self.check_files(stop_receiver, progress_sender) {
@@ -107,7 +107,7 @@ impl BrokenFiles {
         self.debug_print();
     }
 
-    #[fun_time(message = "check_files")]
+    #[fun_time(message = "check_files", level = "debug")]
     fn check_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) -> bool {
         let mut folders_to_check: Vec<PathBuf> = Vec::with_capacity(1024 * 2); // This should be small enough too not see to big difference and big enough to store most of paths without needing to resize vector
 
@@ -319,7 +319,7 @@ impl BrokenFiles {
         }
     }
 
-    #[fun_time(message = "load_cache")]
+    #[fun_time(message = "load_cache", level = "debug")]
     fn load_cache(&mut self) -> (BTreeMap<String, FileEntry>, BTreeMap<String, FileEntry>, BTreeMap<String, FileEntry>) {
         let loaded_hash_map;
 
@@ -346,7 +346,7 @@ impl BrokenFiles {
         (loaded_hash_map, records_already_cached, non_cached_files_to_check)
     }
 
-    #[fun_time(message = "look_for_broken_files")]
+    #[fun_time(message = "look_for_broken_files", level = "debug")]
     fn look_for_broken_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) -> bool {
         let (loaded_hash_map, records_already_cached, non_cached_files_to_check) = self.load_cache();
 
@@ -396,7 +396,7 @@ impl BrokenFiles {
 
         true
     }
-    #[fun_time(message = "save_to_cache")]
+    #[fun_time(message = "save_to_cache", level = "debug")]
     fn save_to_cache(&mut self, vec_file_entry: &[FileEntry], loaded_hash_map: BTreeMap<String, FileEntry>) {
         if self.common_data.use_cache {
             // Must save all results to file, old loaded from file with all currently counted results
@@ -414,7 +414,7 @@ impl BrokenFiles {
         }
     }
 
-    #[fun_time(message = "delete_files")]
+    #[fun_time(message = "delete_files", level = "debug")]
     fn delete_files(&mut self) {
         match self.common_data.delete_method {
             DeleteMethod::Delete => {

czkawka_core/src/common.rs

@@ -505,7 +505,7 @@ pub fn prepare_thread_handler_common(
     (progress_thread_sender, progress_thread_run, atomic_counter, check_was_stopped)
 }
 
-#[fun_time(message = "send_info_and_wait_for_ending_all_threads")]
+#[fun_time(message = "send_info_and_wait_for_ending_all_threads", level = "debug")]
 pub fn send_info_and_wait_for_ending_all_threads(progress_thread_run: &Arc<AtomicBool>, progress_thread_handle: JoinHandle<()>) {
     progress_thread_run.store(false, Ordering::Relaxed);
     progress_thread_handle.join().unwrap();

czkawka_core/src/common_cache.rs

@@ -41,7 +41,7 @@ pub fn get_duplicate_cache_file(type_of_hash: &HashType, is_prehash: bool) -> St
     format!("cache_duplicates_{type_of_hash:?}{prehash_str}_61.bin")
 }
 
-#[fun_time(message = "save_cache_to_file_generalized")]
+#[fun_time(message = "save_cache_to_file_generalized", level = "debug")]
 pub fn save_cache_to_file_generalized<T>(cache_file_name: &str, hashmap: &BTreeMap<String, T>, save_also_as_json: bool, minimum_file_size: u64) -> Messages
 where
     T: Serialize + ResultEntry + Sized + Send + Sync,
@@ -85,7 +85,7 @@ where
     text_messages
 }
 
-#[fun_time(message = "load_cache_from_file_generalized_by_path")]
+#[fun_time(message = "load_cache_from_file_generalized_by_path", level = "debug")]
 pub fn load_cache_from_file_generalized_by_path<T>(cache_file_name: &str, delete_outdated_cache: bool, used_files: &BTreeMap<String, T>) -> (Messages, Option<BTreeMap<String, T>>)
 where
     for<'a> T: Deserialize<'a> + ResultEntry + Sized + Send + Sync + Clone,
@@ -105,7 +105,7 @@ where
     (text_messages, Some(map_loaded_entries))
 }
 
-#[fun_time(message = "load_cache_from_file_generalized_by_size")]
+#[fun_time(message = "load_cache_from_file_generalized_by_size", level = "debug")]
 pub fn load_cache_from_file_generalized_by_size<T>(
     cache_file_name: &str,
     delete_outdated_cache: bool,
@@ -136,7 +136,7 @@ where
     (text_messages, Some(map_loaded_entries))
 }
 
-#[fun_time(message = "load_cache_from_file_generalized_by_path_from_size")]
+#[fun_time(message = "load_cache_from_file_generalized_by_path_from_size", level = "debug")]
 pub fn load_cache_from_file_generalized_by_path_from_size<T>(
     cache_file_name: &str,
     delete_outdated_cache: bool,
@@ -167,7 +167,7 @@ where
     (text_messages, Some(map_loaded_entries))
 }
 
-#[fun_time(message = "load_cache_from_file_generalized")]
+#[fun_time(message = "load_cache_from_file_generalized", level = "debug")]
 fn load_cache_from_file_generalized<T>(cache_file_name: &str, delete_outdated_cache: bool, used_files: &BTreeMap<String, T>) -> (Messages, Option<Vec<T>>)
 where
     for<'a> T: Deserialize<'a> + ResultEntry + Sized + Send + Sync + Clone,

czkawka_core/src/common_dir_traversal.rs

@@ -340,7 +340,7 @@ where
     F: Fn(&FileEntry) -> T,
     T: Ord + PartialOrd,
 {
-    #[fun_time(message = "run(collecting files/dirs)")]
+    #[fun_time(message = "run(collecting files/dirs)", level = "debug")]
     pub fn run(self) -> DirTraversalResult<T> {
         let mut all_warnings = vec![];
         let mut grouped_file_entries: BTreeMap<T, Vec<FileEntry>> = BTreeMap::new();

czkawka_core/src/common_traits.rs

@@ -11,7 +11,7 @@ pub trait DebugPrint {
 pub trait PrintResults {
     fn write_results<T: Write>(&self, writer: &mut T) -> std::io::Result<()>;
 
-    #[fun_time(message = "print_results_to_output")]
+    #[fun_time(message = "print_results_to_output", level = "debug")]
     fn print_results_to_output(&self) {
         let stdout = std::io::stdout();
         let mut handle = stdout.lock();
@@ -19,7 +19,7 @@ pub trait PrintResults {
         handle.flush().unwrap();
     }
 
-    #[fun_time(message = "print_results_to_file")]
+    #[fun_time(message = "print_results_to_file", level = "debug")]
     fn print_results_to_file(&self, file_name: &str) -> std::io::Result<()> {
         let file_name: String = match file_name {
             "" => "results.txt".to_string(),
@@ -43,7 +43,7 @@ pub trait PrintResults {
         }
     }
 
-    #[fun_time(message = "save_results_to_file_as_json_pretty")]
+    #[fun_time(message = "save_results_to_file_as_json_pretty", level = "debug")]
     fn save_results_to_file_as_json_pretty<T: Serialize>(&self, file_name: &str, item_to_serialize: &T) -> std::io::Result<()> {
         let file_handler = File::create(file_name)?;
         let mut writer = BufWriter::new(file_handler);
@@ -51,7 +51,7 @@ pub trait PrintResults {
         Ok(())
     }
 
-    #[fun_time(message = "save_results_to_file_as_json_compact")]
+    #[fun_time(message = "save_results_to_file_as_json_compact", level = "debug")]
     fn save_results_to_file_as_json_compact<T: Serialize>(&self, file_name: &str, item_to_serialize: &T) -> std::io::Result<()> {
         let file_handler = File::create(file_name)?;
         let mut writer = BufWriter::new(file_handler);

czkawka_core/src/duplicate.rs

@@ -110,7 +110,7 @@ impl DuplicateFinder {
         }
     }
 
-    #[fun_time(message = "find_duplicates")]
+    #[fun_time(message = "find_duplicates", level = "info")]
     pub fn find_duplicates(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) {
         self.optimize_dirs_before_start();
         self.common_data.use_reference_folders = !self.common_data.directories.reference_directories.is_empty();
@@ -150,7 +150,7 @@ impl DuplicateFinder {
         self.debug_print();
     }
 
-    #[fun_time(message = "check_files_name")]
+    #[fun_time(message = "check_files_name", level = "debug")]
     fn check_files_name(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) -> bool {
         let group_by_func = if self.case_sensitive_name_comparison {
             |fe: &FileEntry| fe.path.file_name().unwrap().to_string_lossy().to_string()
@@ -225,7 +225,7 @@ impl DuplicateFinder {
         }
     }
 
-    #[fun_time(message = "check_files_size_name")]
+    #[fun_time(message = "check_files_size_name", level = "debug")]
     fn check_files_size_name(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) -> bool {
         let group_by_func = if self.case_sensitive_name_comparison {
             |fe: &FileEntry| (fe.size, fe.path.file_name().unwrap().to_string_lossy().to_string())
@@ -302,7 +302,7 @@ impl DuplicateFinder {
         }
     }
 
-    #[fun_time(message = "check_files_size")]
+    #[fun_time(message = "check_files_size", level = "debug")]
     fn check_files_size(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) -> bool {
         let max_stage = match self.check_method {
             CheckingMethod::Size => 0,
@@ -377,7 +377,7 @@ impl DuplicateFinder {
         }
     }
 
-    #[fun_time(message = "filter_reference_folders_by_size")]
+    #[fun_time(message = "filter_reference_folders_by_size", level = "debug")]
     fn filter_reference_folders_by_size(&mut self) {
         if self.common_data.use_reference_folders && self.check_method == CheckingMethod::Size {
             let vec = mem::take(&mut self.files_with_identical_size)
@@ -400,7 +400,7 @@ impl DuplicateFinder {
         }
     }
 
-    #[fun_time(message = "prehash_load_cache_at_start")]
+    #[fun_time(message = "prehash_load_cache_at_start", level = "debug")]
     fn prehash_load_cache_at_start(&mut self) -> (BTreeMap<u64, Vec<FileEntry>>, BTreeMap<u64, Vec<FileEntry>>, BTreeMap<u64, Vec<FileEntry>>) {
         // Cache algorithm
         // - Load data from cache
@@ -453,7 +453,7 @@ impl DuplicateFinder {
         (loaded_hash_map, records_already_cached, non_cached_files_to_check)
     }
 
-    #[fun_time(message = "prehash_save_cache_at_exit")]
+    #[fun_time(message = "prehash_save_cache_at_exit", level = "debug")]
     fn prehash_save_cache_at_exit(&mut self, loaded_hash_map: BTreeMap<u64, Vec<FileEntry>>, pre_hash_results: &Vec<(u64, BTreeMap<String, Vec<FileEntry>>, Vec<String>)>) {
         if self.use_prehash_cache {
             // All results = records already cached + computed results
@@ -487,7 +487,7 @@ impl DuplicateFinder {
         }
     }
 
-    #[fun_time(message = "prehashing")]
+    #[fun_time(message = "prehashing", level = "debug")]
     fn prehashing(
         &mut self,
         stop_receiver: Option<&Receiver<()>>,
@@ -577,7 +577,7 @@ impl DuplicateFinder {
         Some(())
     }
 
-    #[fun_time(message = "full_hashing_load_cache_at_start")]
+    #[fun_time(message = "full_hashing_load_cache_at_start", level = "debug")]
     fn full_hashing_load_cache_at_start(
         &mut self,
         mut pre_checked_map: BTreeMap<u64, Vec<FileEntry>>,
@@ -628,7 +628,7 @@ impl DuplicateFinder {
         (loaded_hash_map, records_already_cached, non_cached_files_to_check)
     }
 
-    #[fun_time(message = "full_hashing_save_cache_at_exit")]
+    #[fun_time(message = "full_hashing_save_cache_at_exit", level = "debug")]
     fn full_hashing_save_cache_at_exit(
         &mut self,
         records_already_cached: BTreeMap<u64, Vec<FileEntry>>,
@@ -680,7 +680,7 @@ impl DuplicateFinder {
         self.get_text_messages_mut().extend_with_another_messages(messages);
     }
 
-    // #[fun_time(message = "full_hashing")]
+    // #[fun_time(message = "full_hashing", level = "debug")]
     fn full_hashing(
         &mut self,
         stop_receiver: Option<&Receiver<()>>,
@@ -757,7 +757,7 @@ impl DuplicateFinder {
         Some(())
     }
 
-    #[fun_time(message = "hash_reference_folders")]
+    #[fun_time(message = "hash_reference_folders", level = "debug")]
     fn hash_reference_folders(&mut self) {
         // Reference - only use in size, because later hash will be counted differently
         if self.common_data.use_reference_folders {
@@ -806,7 +806,7 @@ impl DuplicateFinder {
         }
     }
 
-    #[fun_time(message = "check_files_hash")]
+    #[fun_time(message = "check_files_hash", level = "debug")]
     fn check_files_hash(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) -> bool {
         assert_eq!(self.check_method, CheckingMethod::Hash);
 
@@ -829,7 +829,7 @@ impl DuplicateFinder {
         true
     }
 
-    #[fun_time(message = "delete_files")]
+    #[fun_time(message = "delete_files", level = "debug")]
     fn delete_files(&mut self) {
         if self.common_data.delete_method == DeleteMethod::None {
             return;

czkawka_core/src/empty_files.rs

@@ -40,7 +40,7 @@ impl EmptyFiles {
         }
     }
 
-    #[fun_time(message = "find_empty_files")]
+    #[fun_time(message = "find_empty_files", level = "info")]
     pub fn find_empty_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) {
         self.optimize_dirs_before_start();
         if !self.check_files(stop_receiver, progress_sender) {
@@ -51,7 +51,7 @@ impl EmptyFiles {
         self.debug_print();
     }
 
-    #[fun_time(message = "check_files")]
+    #[fun_time(message = "check_files", level = "debug")]
     fn check_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) -> bool {
         let result = DirTraversalBuilder::new()
             .root_dirs(self.common_data.directories.included_directories.clone())
@@ -84,7 +84,7 @@ impl EmptyFiles {
         }
     }
 
-    #[fun_time(message = "delete_files")]
+    #[fun_time(message = "delete_files", level = "debug")]
     fn delete_files(&mut self) {
         match self.common_data.delete_method {
             DeleteMethod::Delete => {

czkawka_core/src/empty_folder.rs

@@ -41,7 +41,7 @@ impl EmptyFolder {
         &self.information
     }
 
-    #[fun_time(message = "find_empty_folders")]
+    #[fun_time(message = "find_empty_folders", level = "info")]
     pub fn find_empty_folders(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) {
         self.optimize_dirs_before_start();
         if !self.check_for_empty_folders(stop_receiver, progress_sender) {
@@ -73,7 +73,7 @@ impl EmptyFolder {
         self.information.number_of_empty_folders = self.empty_folder_list.len();
     }
 
-    #[fun_time(message = "check_for_empty_folders")]
+    #[fun_time(message = "check_for_empty_folders", level = "debug")]
     fn check_for_empty_folders(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) -> bool {
         let result = DirTraversalBuilder::new()
             .root_dirs(self.common_data.directories.included_directories.clone())
@@ -106,7 +106,7 @@ impl EmptyFolder {
         }
     }
 
-    // #[fun_time(message = "delete_files")]
+    // #[fun_time(message = "delete_files", level = "debug")]
     fn delete_files(&mut self) {
         if self.get_delete_method() == DeleteMethod::None {
             return;

czkawka_core/src/invalid_symlinks.rs

@@ -30,7 +30,7 @@ impl InvalidSymlinks {
         }
     }
 
-    #[fun_time(message = "find_invalid_links")]
+    #[fun_time(message = "find_invalid_links", level = "info")]
     pub fn find_invalid_links(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) {
         self.optimize_dirs_before_start();
         if !self.check_files(stop_receiver, progress_sender) {
@@ -41,7 +41,7 @@ impl InvalidSymlinks {
         self.debug_print();
     }
 
-    #[fun_time(message = "check_files")]
+    #[fun_time(message = "check_files", level = "debug")]
     fn check_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) -> bool {
         let result = DirTraversalBuilder::new()
             .root_dirs(self.common_data.directories.included_directories.clone())
@@ -69,7 +69,7 @@ impl InvalidSymlinks {
         }
     }
 
-    #[fun_time(message = "delete_files")]
+    #[fun_time(message = "delete_files", level = "debug")]
     fn delete_files(&mut self) {
         match self.common_data.delete_method {
             DeleteMethod::Delete => {

czkawka_core/src/same_music.rs

@@ -132,7 +132,7 @@ impl SameMusic {
         }
     }
 
-    #[fun_time(message = "print_results")]
+    #[fun_time(message = "print_results", level = "info")]
     pub fn find_same_music(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) {
         self.optimize_dirs_before_start();
         self.common_data.use_reference_folders = !self.common_data.directories.reference_directories.is_empty();
@@ -171,7 +171,7 @@ impl SameMusic {
         self.debug_print();
     }
 
-    #[fun_time(message = "check_files")]
+    #[fun_time(message = "check_files", level = "debug")]
     fn check_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) -> bool {
         if !self.common_data.allowed_extensions.using_custom_extensions() {
             self.common_data.allowed_extensions.extend_allowed_extensions(AUDIO_FILES_EXTENSIONS);
@@ -215,7 +215,7 @@ impl SameMusic {
         }
     }
 
-    #[fun_time(message = "load_cache")]
+    #[fun_time(message = "load_cache", level = "debug")]
     fn load_cache(&mut self, checking_tags: bool) -> (BTreeMap<String, MusicEntry>, BTreeMap<String, MusicEntry>, BTreeMap<String, MusicEntry>) {
         let loaded_hash_map;
 
@@ -250,7 +250,7 @@ impl SameMusic {
         (loaded_hash_map, records_already_cached, non_cached_files_to_check)
     }
 
-    #[fun_time(message = "save_cache")]
+    #[fun_time(message = "save_cache", level = "debug")]
     fn save_cache(&mut self, vec_file_entry: Vec<MusicEntry>, loaded_hash_map: BTreeMap<String, MusicEntry>, checking_tags: bool) {
         if !self.common_data.use_cache {
             return;
@@ -266,7 +266,7 @@ impl SameMusic {
         self.get_text_messages_mut().extend_with_another_messages(messages);
     }
 
-    #[fun_time(message = "calculate_fingerprint")]
+    #[fun_time(message = "calculate_fingerprint", level = "debug")]
     fn calculate_fingerprint(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) -> bool {
         let (loaded_hash_map, records_already_cached, non_cached_files_to_check) = self.load_cache(false);
 
@@ -313,7 +313,7 @@ impl SameMusic {
         true
     }
 
-    #[fun_time(message = "read_tags")]
+    #[fun_time(message = "read_tags", level = "debug")]
     fn read_tags(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) -> bool {
         let (loaded_hash_map, records_already_cached, non_cached_files_to_check) = self.load_cache(true);
 
@@ -359,7 +359,7 @@ impl SameMusic {
         true
     }
 
-    #[fun_time(message = "check_for_duplicate_tags")]
+    #[fun_time(message = "check_for_duplicate_tags", level = "debug")]
     fn check_for_duplicate_tags(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) -> bool {
         let (progress_thread_handle, progress_thread_run, atomic_counter, _check_was_stopped) =
             prepare_thread_handler_common(progress_sender, 2, 2, self.music_to_check.len(), self.check_type, self.common_data.tool_type);
@@ -458,7 +458,7 @@ impl SameMusic {
 
         true
     }
-    #[fun_time(message = "read_tags_to_files_similar_by_content")]
+    #[fun_time(message = "read_tags_to_files_similar_by_content", level = "debug")]
     fn read_tags_to_files_similar_by_content(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) -> bool {
         let groups_to_check = max(self.duplicated_music_entries.len(), self.duplicated_music_entries_referenced.len());
         let (progress_thread_handle, progress_thread_run, atomic_counter, check_was_stopped) =
@@ -525,7 +525,7 @@ impl SameMusic {
         (base_files, files_to_compare)
     }
 
-    #[fun_time(message = "compare_fingerprints")]
+    #[fun_time(message = "compare_fingerprints", level = "debug")]
     fn compare_fingerprints(
         &mut self,
         stop_receiver: Option<&Receiver<()>>,
@@ -584,7 +584,7 @@ impl SameMusic {
         Some(duplicated_music_entries)
     }
 
-    #[fun_time(message = "check_for_duplicate_fingerprints")]
+    #[fun_time(message = "check_for_duplicate_fingerprints", level = "debug")]
     fn check_for_duplicate_fingerprints(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) -> bool {
         let (base_files, files_to_compare) = self.split_fingerprints_to_check();
         let (progress_thread_handle, progress_thread_run, atomic_counter, _check_was_stopped) =
@@ -621,7 +621,7 @@ impl SameMusic {
         true
     }
 
-    #[fun_time(message = "check_music_item")]
+    #[fun_time(message = "check_music_item", level = "debug")]
     fn check_music_item(
         &self,
         old_duplicates: Vec<Vec<MusicEntry>>,
@@ -653,7 +653,7 @@ impl SameMusic {
         new_duplicates
     }
 
-    #[fun_time(message = "delete_files")]
+    #[fun_time(message = "delete_files", level = "debug")]
     fn delete_files(&mut self) {
         if self.common_data.delete_method == DeleteMethod::None {
             return;
@@ -887,7 +887,7 @@ impl Default for SameMusic {
 }
 
 impl DebugPrint for SameMusic {
-    #[fun_time(message = "debug_print")]
+    #[fun_time(message = "debug_print", level = "debug")]
     fn debug_print(&self) {
         if !cfg!(debug_assertions) {
             return;

czkawka_core/src/similar_images.rs

@@ -124,7 +124,7 @@ impl SimilarImages {
         }
     }
 
-    #[fun_time(message = "find_similar_images")]
+    #[fun_time(message = "find_similar_images", level = "info")]
     pub fn find_similar_images(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) {
         self.optimize_dirs_before_start();
         self.common_data.use_reference_folders = !self.common_data.directories.reference_directories.is_empty();
@@ -144,7 +144,7 @@ impl SimilarImages {
         self.debug_print();
     }
 
-    #[fun_time(message = "check_for_similar_images")]
+    #[fun_time(message = "check_for_similar_images", level = "debug")]
     fn check_for_similar_images(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) -> bool {
         let mut folders_to_check: Vec<PathBuf> = Vec::with_capacity(1024 * 2); // This should be small enough too not see to big difference and big enough to store most of paths without needing to resize vector
 
@@ -258,7 +258,7 @@ impl SimilarImages {
         }
     }
 
-    #[fun_time(message = "hash_images_load_cache")]
+    #[fun_time(message = "hash_images_load_cache", level = "debug")]
     fn hash_images_load_cache(&mut self) -> (BTreeMap<String, FileEntry>, BTreeMap<String, FileEntry>, BTreeMap<String, FileEntry>) {
         let loaded_hash_map;
 
@@ -303,7 +303,7 @@ impl SimilarImages {
     // - Join already read hashes with hashes which were read from file
     // - Join all hashes and save it to file
 
-    #[fun_time(message = "hash_images")]
+    #[fun_time(message = "hash_images", level = "debug")]
     fn hash_images(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) -> bool {
         let (loaded_hash_map, records_already_cached, non_cached_files_to_check) = self.hash_images_load_cache();
 
@@ -352,7 +352,7 @@ impl SimilarImages {
         true
     }
 
-    #[fun_time(message = "save_to_cache")]
+    #[fun_time(message = "save_to_cache", level = "debug")]
     fn save_to_cache(&mut self, vec_file_entry: Vec<(FileEntry, ImHash)>, loaded_hash_map: BTreeMap<String, FileEntry>) {
         if self.common_data.use_cache {
             // Must save all results to file, old loaded from file with all currently counted results
@@ -443,7 +443,7 @@ impl SimilarImages {
     }
 
     // Split hashes at 2 parts, base hashes and hashes to compare, 3 argument is set of hashes with multiple images
-    #[fun_time(message = "split_hashes")]
+    #[fun_time(message = "split_hashes", level = "debug")]
     fn split_hashes(&mut self, all_hashed_images: &HashMap<ImHash, Vec<FileEntry>>) -> (Vec<ImHash>, HashSet<ImHash>) {
         let hashes_with_multiple_images: HashSet<ImHash> = all_hashed_images
             .iter()
@@ -485,7 +485,7 @@ impl SimilarImages {
         (base_hashes, hashes_with_multiple_images)
     }
 
-    #[fun_time(message = "collect_hash_compare_result")]
+    #[fun_time(message = "collect_hash_compare_result", level = "debug")]
     fn collect_hash_compare_result(
         &self,
         hashes_parents: HashMap<ImHash, u32>,
@@ -545,7 +545,7 @@ impl SimilarImages {
         }
     }
 
-    #[fun_time(message = "compare_hashes_with_non_zero_tolerance")]
+    #[fun_time(message = "compare_hashes_with_non_zero_tolerance", level = "debug")]
     fn compare_hashes_with_non_zero_tolerance(
         &mut self,
         all_hashed_images: &HashMap<ImHash, Vec<FileEntry>>,
@@ -621,7 +621,7 @@ impl SimilarImages {
         true
     }
 
-    #[fun_time(message = "connect_results")]
+    #[fun_time(message = "connect_results", level = "debug")]
     fn connect_results(
         &self,
         partial_results: Vec<(&ImHash, Vec<(u32, &ImHash)>)>,
@@ -683,7 +683,7 @@ impl SimilarImages {
         }
     }
 
-    #[fun_time(message = "find_similar_hashes")]
+    #[fun_time(message = "find_similar_hashes", level = "debug")]
     fn find_similar_hashes(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) -> bool {
         if self.image_hashes.is_empty() {
             return true;
@@ -736,7 +736,7 @@ impl SimilarImages {
         true
     }
 
-    #[fun_time(message = "exclude_items_with_same_size")]
+    #[fun_time(message = "exclude_items_with_same_size", level = "debug")]
     fn exclude_items_with_same_size(&mut self) {
         if self.exclude_images_with_same_size {
             for vec_file_entry in mem::take(&mut self.similar_vectors) {
@@ -755,7 +755,7 @@ impl SimilarImages {
         }
     }
 
-    #[fun_time(message = "remove_multiple_records_from_reference_folders")]
+    #[fun_time(message = "remove_multiple_records_from_reference_folders", level = "debug")]
     fn remove_multiple_records_from_reference_folders(&mut self) {
         if self.common_data.use_reference_folders {
             self.similar_referenced_vectors = mem::take(&mut self.similar_vectors)

czkawka_core/src/similar_videos.rs

@@ -100,7 +100,7 @@ impl SimilarVideos {
         }
     }
 
-    #[fun_time(message = "find_similar_videos")]
+    #[fun_time(message = "find_similar_videos", level = "info")]
     pub fn find_similar_videos(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) {
         if !check_if_ffmpeg_is_installed() {
             self.common_data.text_messages.errors.push(flc!("core_ffmpeg_not_found"));
@@ -127,7 +127,7 @@ impl SimilarVideos {
         self.debug_print();
     }
 
-    #[fun_time(message = "check_for_similar_videos")]
+    #[fun_time(message = "check_for_similar_videos", level = "debug")]
     fn check_for_similar_videos(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) -> bool {
         let mut folders_to_check: Vec<PathBuf> = Vec::with_capacity(1024 * 2); // This should be small enough too not see to big difference and big enough to store most of paths without needing to resize vector
 
@@ -237,7 +237,7 @@ impl SimilarVideos {
         }
     }
 
-    #[fun_time(message = "load_cache_at_start")]
+    #[fun_time(message = "load_cache_at_start", level = "debug")]
     fn load_cache_at_start(&mut self) -> (BTreeMap<String, FileEntry>, BTreeMap<String, FileEntry>, BTreeMap<String, FileEntry>) {
         let loaded_hash_map;
         let mut records_already_cached: BTreeMap<String, FileEntry> = Default::default();
@@ -263,7 +263,7 @@ impl SimilarVideos {
         (loaded_hash_map, records_already_cached, non_cached_files_to_check)
     }
 
-    #[fun_time(message = "sort_videos")]
+    #[fun_time(message = "sort_videos", level = "debug")]
     fn sort_videos(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) -> bool {
         let (loaded_hash_map, records_already_cached, non_cached_files_to_check) = self.load_cache_at_start();
 
@@ -343,7 +343,7 @@ impl SimilarVideos {
         true
     }
 
-    #[fun_time(message = "save_cache")]
+    #[fun_time(message = "save_cache", level = "debug")]
     fn save_cache(&mut self, vec_file_entry: Vec<FileEntry>, loaded_hash_map: BTreeMap<String, FileEntry>) {
         if self.common_data.use_cache {
             // Must save all results to file, old loaded from file with all currently counted results
@@ -357,7 +357,7 @@ impl SimilarVideos {
         }
     }
 
-    #[fun_time(message = "match_groups_of_videos")]
+    #[fun_time(message = "match_groups_of_videos", level = "debug")]
     fn match_groups_of_videos(&mut self, vector_of_hashes: Vec<VideoHash>, hashmap_with_file_entries: &HashMap<String, FileEntry>) {
         let match_group = vid_dup_finder_lib::search(vector_of_hashes, NormalizedTolerance::new(self.tolerance as f64 / 100.0f64));
         let mut collected_similar_videos: Vec<Vec<FileEntry>> = Default::default();
@@ -383,7 +383,7 @@ impl SimilarVideos {
         self.similar_vectors = collected_similar_videos;
     }
 
-    #[fun_time(message = "remove_from_reference_folders")]
+    #[fun_time(message = "remove_from_reference_folders", level = "debug")]
     fn remove_from_reference_folders(&mut self) {
         if self.common_data.use_reference_folders {
             self.similar_referenced_vectors = mem::take(&mut self.similar_vectors)
@@ -420,7 +420,7 @@ impl Default for SimilarVideos {
 }
 
 impl DebugPrint for SimilarVideos {
-    #[fun_time(message = "debug_print")]
+    #[fun_time(message = "debug_print", level = "debug")]
     fn debug_print(&self) {
         if !cfg!(debug_assertions) {
             return;

czkawka_core/src/temporary.rs

@@ -59,7 +59,7 @@ impl Temporary {
         }
     }
 
-    #[fun_time(message = "find_temporary_files")]
+    #[fun_time(message = "find_temporary_files", level = "info")]
     pub fn find_temporary_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) {
         self.optimize_dirs_before_start();
         if !self.check_files(stop_receiver, progress_sender) {
@@ -70,7 +70,7 @@ impl Temporary {
         self.debug_print();
     }
 
-    #[fun_time(message = "check_files")]
+    #[fun_time(message = "check_files", level = "debug")]
     fn check_files(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&UnboundedSender<ProgressData>>) -> bool {
         let mut folders_to_check: Vec<PathBuf> = Vec::with_capacity(1024 * 2); // This should be small enough too not see to big difference and big enough to store most of paths without needing to resize vector
 
@@ -172,7 +172,7 @@ impl Temporary {
         })
     }
 
-    #[fun_time(message = "delete_files")]
+    #[fun_time(message = "delete_files", level = "debug")]
     fn delete_files(&mut self) {
         match self.common_data.delete_method {
             DeleteMethod::Delete => {

czkawka_gui/src/compute_results.rs

@@ -230,7 +230,7 @@ pub fn connect_compute_results(gui_data: &GuiData, glib_stop_receiver: Receiver<
     });
 }
 
-#[fun_time(message = "computer_bad_extensions")]
+#[fun_time(message = "computer_bad_extensions", level = "debug")]
 fn computer_bad_extensions(
     be: BadExtensions,
     entry_info: &Entry,
@@ -304,7 +304,7 @@ fn computer_bad_extensions(
     }
 }
 
-#[fun_time(message = "computer_broken_files")]
+#[fun_time(message = "computer_broken_files", level = "debug")]
 fn computer_broken_files(
     br: BrokenFiles,
     entry_info: &Entry,
@@ -378,7 +378,7 @@ fn computer_broken_files(
     }
 }
 
-#[fun_time(message = "computer_invalid_symlinks")]
+#[fun_time(message = "computer_invalid_symlinks", level = "debug")]
 fn computer_invalid_symlinks(
     ifs: InvalidSymlinks,
     entry_info: &Entry,
@@ -450,7 +450,7 @@ fn computer_invalid_symlinks(
     }
 }
 
-#[fun_time(message = "computer_same_music")]
+#[fun_time(message = "computer_same_music", level = "debug")]
 fn computer_same_music(
     mf: SameMusic,
     entry_info: &Entry,
@@ -625,7 +625,7 @@ fn computer_same_music(
     }
 }
 
-#[fun_time(message = "computer_similar_videos")]
+#[fun_time(message = "computer_similar_videos", level = "debug")]
 fn computer_similar_videos(
     ff: SimilarVideos,
     entry_info: &Entry,
@@ -727,7 +727,7 @@ fn computer_similar_videos(
     }
 }
 
-#[fun_time(message = "computer_similar_images")]
+#[fun_time(message = "computer_similar_images", level = "debug")]
 fn computer_similar_images(
     sf: SimilarImages,
     entry_info: &Entry,
@@ -860,7 +860,7 @@ fn computer_similar_images(
     }
 }
 
-#[fun_time(message = "computer_temporary_files")]
+#[fun_time(message = "computer_temporary_files", level = "debug")]
 fn computer_temporary_files(
     tf: Temporary,
     entry_info: &Entry,
@@ -932,7 +932,7 @@ fn computer_temporary_files(
     }
 }
 
-#[fun_time(message = "computer_big_files")]
+#[fun_time(message = "computer_big_files", level = "debug")]
 fn computer_big_files(
     bf: BigFile,
     entry_info: &Entry,
@@ -1000,7 +1000,7 @@ fn computer_big_files(
     }
 }
 
-#[fun_time(message = "computer_empty_files")]
+#[fun_time(message = "computer_empty_files", level = "debug")]
 fn computer_empty_files(
     vf: EmptyFiles,
     entry_info: &Entry,
@@ -1067,7 +1067,7 @@ fn computer_empty_files(
     }
 }
 
-#[fun_time(message = "computer_empty_folders")]
+#[fun_time(message = "computer_empty_folders", level = "debug")]
 fn computer_empty_folders(
     ef: EmptyFolder,
     entry_info: &Entry,
@@ -1139,7 +1139,7 @@ fn computer_empty_folders(
     }
 }
 
-#[fun_time(message = "computer_duplicate_finder")]
+#[fun_time(message = "computer_duplicate_finder", level = "debug")]
 fn computer_duplicate_finder(
     df: DuplicateFinder,
     entry_info: &Entry,

czkawka_gui/src/connect_things/connect_button_search.rs

@@ -794,7 +794,7 @@ fn bad_extensions_search(
     });
 }
 
-#[fun_time(message = "clean_tree_view")]
+#[fun_time(message = "clean_tree_view", level = "debug")]
 fn clean_tree_view(tree_view: &gtk4::TreeView) {
     let list_store = get_list_store(tree_view);
     list_store.clear();