diff options
| -rw-r--r-- | TODO.md | 4 | ||||
| -rw-r--r-- | src/app.rs | 58 | ||||
| -rw-r--r-- | src/app/data_collection.rs | 21 | ||||
| -rw-r--r-- | src/app/data_collection/disks.rs | 37 | ||||
| -rw-r--r-- | src/app/data_collection/processes.rs | 2 | ||||
| -rw-r--r-- | src/canvas.rs | 90 | ||||
| -rw-r--r-- | src/convert_data.rs | 49 | ||||
| -rw-r--r-- | src/main.rs | 71 | ||||
| -rw-r--r-- | src/utils/logging.rs | 8 |
9 files changed, 239 insertions, 101 deletions
@@ -18,6 +18,8 @@ ## After making public +* Header should be clear on current sorting direction! + * Scaling in and out (zoom), may need to show zoom levels * It would be maybe a good idea to see if we can run the process calculation across ALL cpus...? @@ -42,4 +44,6 @@ * Help screen +* Modularity + * Potentially process managing? Depends on the libraries... @@ -12,19 +12,29 @@ pub enum ApplicationPosition { PROCESS, } +pub enum ScrollDirection { + /// UP means scrolling up --- this usually DECREMENTS + UP, + /// DOWN means scrolling down --- this usually INCREMENTS + DOWN, +} + pub struct App { pub should_quit : bool, pub process_sorting_type : processes::ProcessSorting, pub process_sorting_reverse : bool, pub to_be_resorted : bool, - pub currently_selected_process_position : u64, - pub currently_selected_disk_position : u64, - pub currently_selected_temperature_position : u64, + pub currently_selected_process_position : i64, + pub currently_selected_disk_position : i64, + pub currently_selected_temperature_position : i64, pub temperature_type : temperature::TemperatureType, pub update_rate_in_milliseconds : u64, pub show_average_cpu : bool, pub current_application_position : ApplicationPosition, pub current_zoom_level_percent : f64, // Make at most 200, least 50? + pub data : data_collection::Data, + pub scroll_direction : ScrollDirection, + pub previous_process_position : i64, } impl App { @@ -42,6 +52,9 @@ impl App { show_average_cpu, current_application_position : ApplicationPosition::PROCESS, current_zoom_level_percent : 100.0, + data : data_collection::Data::default(), + scroll_direction : ScrollDirection::DOWN, + previous_process_position : 0, } } @@ -62,6 +75,7 @@ impl App { } } self.to_be_resorted = true; + self.currently_selected_process_position = 0; } 'm' => { match self.process_sorting_type { @@ -72,6 +86,7 @@ impl App { } } self.to_be_resorted = true; + self.currently_selected_process_position = 0; } 'p' => { match self.process_sorting_type { @@ -82,6 +97,7 @@ impl App { } } self.to_be_resorted = true; + self.currently_selected_process_position = 0; } 'n' => { match self.process_sorting_type { @@ -92,6 +108,7 @@ impl App { } } self.to_be_resorted = true; + self.currently_selected_process_position = 0; } _ => {} } @@ -111,39 +128,42 @@ impl App { pub fn decrement_position_count(&mut self) { match self.current_application_position { - ApplicationPosition::PROCESS => self.change_process_position(1), - ApplicationPosition::TEMP => self.change_temp_position(1), - ApplicationPosition::DISK => self.change_disk_position(1), + ApplicationPosition::PROCESS => self.change_process_position(-1), + ApplicationPosition::TEMP => self.change_temp_position(-1), + ApplicationPosition::DISK => self.change_disk_position(-1), _ => {} } + self.scroll_direction = ScrollDirection::UP; } pub fn increment_position_count(&mut self) { match self.current_application_position { - ApplicationPosition::PROCESS => self.change_process_position(-1), - ApplicationPosition::TEMP => self.change_temp_position(-1), - ApplicationPosition::DISK => self.change_disk_position(-1), + ApplicationPosition::PROCESS => self.change_process_position(1), + ApplicationPosition::TEMP => self.change_temp_position(1), + ApplicationPosition::DISK => self.change_disk_position(1), _ => {} } + self.scroll_direction = ScrollDirection::DOWN; } - fn change_process_position(&mut self, num_to_change_by : i32) { - if self.currently_selected_process_position + num_to_change_by as u64 > 0 { - self.currently_selected_process_position += num_to_change_by as u64; + fn change_process_position(&mut self, num_to_change_by : i64) { + if self.currently_selected_process_position + num_to_change_by >= 0 + && self.currently_selected_process_position + num_to_change_by < self.data.list_of_processes.len() as i64 + { + self.currently_selected_process_position += num_to_change_by; } - // else if self.currently_selected_process_position < // TODO: Need to finish this! This should never go PAST the number of elements } - fn change_temp_position(&mut self, num_to_change_by : i32) { - if self.currently_selected_temperature_position + num_to_change_by as u64 > 0 { - self.currently_selected_temperature_position += num_to_change_by as u64; + fn change_temp_position(&mut self, num_to_change_by : i64) { + if self.currently_selected_temperature_position + num_to_change_by >= 0 { + self.currently_selected_temperature_position += num_to_change_by; } // else if self.currently_selected_temperature_position < // TODO: Need to finish this! This should never go PAST the number of elements } - fn change_disk_position(&mut self, num_to_change_by : i32) { - if self.currently_selected_disk_position + num_to_change_by as u64 > 0 { - self.currently_selected_disk_position += num_to_change_by as u64; + fn change_disk_position(&mut self, num_to_change_by : i64) { + if self.currently_selected_disk_position + num_to_change_by >= 0 { + self.currently_selected_disk_position += num_to_change_by; } // else if self.currently_selected_disk_position < // TODO: Need to finish this! This should never go PAST the number of elements } diff --git a/src/app/data_collection.rs b/src/app/data_collection.rs index 4e45b719..c292fb94 100644 --- a/src/app/data_collection.rs +++ b/src/app/data_collection.rs @@ -80,6 +80,11 @@ impl DataState { self.sys.refresh_system(); self.sys.refresh_network(); + if !cfg!(target_os = "linux") { + // For now, might be just windows tbh + self.sys.refresh_processes(); + } + // What we want to do: For timed data, if there is an error, just do not add. For other data, just don't update! push_if_valid(&network::get_network_data(&self.sys), &mut self.data.network); push_if_valid(&cpu::get_cpu_data_list(&self.sys), &mut self.data.list_of_cpu_packages); @@ -94,7 +99,7 @@ impl DataState { set_if_valid(&disks::get_disk_usage_list().await, &mut self.data.list_of_disks); push_if_valid(&disks::get_io_usage_list(false).await, &mut self.data.list_of_io); - push_if_valid(&disks::get_io_usage_list(true).await, &mut self.data.list_of_physical_io); + //push_if_valid(&disks::get_io_usage_list(true).await, &mut self.data.list_of_physical_io); set_if_valid(&temperature::get_temperature_data(&self.temperature_type).await, &mut self.data.list_of_temperature_sensor); if self.first_run { @@ -144,13 +149,13 @@ impl DataState { .filter(|entry| current_instant.duration_since(entry.instant).as_secs() <= self.stale_max_seconds) .collect::<Vec<_>>(); - self.data.list_of_physical_io = self - .data - .list_of_physical_io - .iter() - .cloned() - .filter(|entry| current_instant.duration_since(entry.instant).as_secs() <= self.stale_max_seconds) - .collect::<Vec<_>>(); + // self.data.list_of_physical_io = self + // .data + // .list_of_physical_io + // .iter() + // .cloned() + // .filter(|entry| current_instant.duration_since(entry.instant).as_secs() <= self.stale_max_seconds) + // .collect::<Vec<_>>(); debug!("End updating..."); } diff --git a/src/app/data_collection/disks.rs b/src/app/data_collection/disks.rs index 4e532b8a..10349a61 100644 --- a/src/app/data_collection/disks.rs +++ b/src/app/data_collection/disks.rs @@ -10,7 +10,7 @@ pub struct DiskData { pub total_space : u64, } -#[derive(Clone)] +#[derive(Clone, Debug)] pub struct IOData { pub mount_point : Box<str>, pub read_bytes : u64, @@ -19,37 +19,46 @@ pub struct IOData { #[derive(Clone)] pub struct IOPackage { - pub io_list : Vec<IOData>, + pub io_hash : std::collections::HashMap<String, IOData>, pub instant : Instant, } +// TODO: This is total --- we have to change the calculation to PER SECOND! pub async fn get_io_usage_list(get_physical : bool) -> Result<IOPackage, heim::Error> { - let mut io_list : Vec<IOData> = Vec::new(); + let mut io_hash : std::collections::HashMap<String, IOData> = std::collections::HashMap::new(); if get_physical { let mut physical_counter_stream = heim::disk::io_counters_physical(); while let Some(io) = physical_counter_stream.next().await { let io = io?; - io_list.push(IOData { - mount_point : Box::from(io.device_name().to_str().unwrap_or("Name Unavailable")), - read_bytes : io.read_bytes().get::<heim_common::units::information::megabyte>(), - write_bytes : io.write_bytes().get::<heim_common::units::information::megabyte>(), - }) + let mount_point = io.device_name().to_str().unwrap_or("Name Unavailable"); + io_hash.insert( + mount_point.to_string(), + IOData { + mount_point : Box::from(mount_point), + read_bytes : io.read_bytes().get::<heim_common::units::information::megabyte>(), + write_bytes : io.write_bytes().get::<heim_common::units::information::megabyte>(), + }, + ); } } else { let mut counter_stream = heim::disk::io_counters(); while let Some(io) = counter_stream.next().await { let io = io?; - io_list.push(IOData { - mount_point : Box::from(io.device_name().to_str().unwrap_or("Name Unavailable")), - read_bytes : io.read_bytes().get::<heim_common::units::information::megabyte>(), - write_bytes : io.write_bytes().get::<heim_common::units::information::megabyte>(), - }) + let mount_point = io.device_name().to_str().unwrap_or("Name Unavailable"); + io_hash.insert( + mount_point.to_string(), + IOData { + mount_point : Box::from(mount_point), + read_bytes : io.read_bytes().get::<heim_common::units::information::byte>(), + write_bytes : io.write_bytes().get::<heim_common::units::information::byte>(), + }, + ); } } Ok(IOPackage { - io_list, + io_hash, instant : Instant::now(), }) } diff --git a/src/app/data_collection/processes.rs b/src/app/data_collection/processes.rs index e688b560..cb9d4516 100644 --- a/src/app/data_collection/processes.rs +++ b/src/app/data_collection/processes.rs @@ -196,6 +196,8 @@ pub async fn get_sorted_processes_list( } else if cfg!(target_os = "windows") { // Windows + + // TODO: DO NOT USE HEIM! let mut process_stream = heim::process::processes().map_ok(non_linux_cpu_usage).try_buffer_unordered(std::usize::MAX); let mut process_vector : Vec<ProcessData> = Vec::new(); diff --git a/src/canvas.rs b/src/canvas.rs index c6154351..2233c37f 100644 --- a/src/canvas.rs +++ b/src/canvas.rs @@ -27,7 +27,7 @@ pub struct CanvasData { pub cpu_data : Vec<(String, Vec<(f64, f64)>)>, } -pub fn draw_data<B : tui::backend::Backend>(terminal : &mut Terminal<B>, app_data : &app::App, canvas_data : &CanvasData) -> error::Result<()> { +pub fn draw_data<B : tui::backend::Backend>(terminal : &mut Terminal<B>, app_state : &mut app::App, canvas_data : &CanvasData) -> error::Result<()> { let border_style : Style = Style::default().fg(BORDER_STYLE_COLOUR); let temperature_rows = canvas_data @@ -35,13 +35,9 @@ pub fn draw_data<B : tui::backend::Backend>(terminal : &mut Terminal<B>, app_dat .iter() .map(|sensor| Row::StyledData(sensor.iter(), Style::default().fg(TEXT_COLOUR))); let disk_rows = canvas_data.disk_data.iter().map(|disk| Row::StyledData(disk.iter(), Style::default().fg(TEXT_COLOUR))); - let process_rows = canvas_data - .process_data - .iter() - .map(|process| Row::StyledData(process.iter(), Style::default().fg(TEXT_COLOUR))); terminal.draw(|mut f| { - debug!("Drawing!"); + //debug!("Drawing!"); let vertical_chunks = Layout::default() .direction(Direction::Vertical) .margin(1) @@ -51,7 +47,7 @@ pub fn draw_data<B : tui::backend::Backend>(terminal : &mut Terminal<B>, app_dat let middle_chunks = Layout::default() .direction(Direction::Horizontal) .margin(0) - .constraints([Constraint::Percentage(65), Constraint::Percentage(35)].as_ref()) + .constraints([Constraint::Percentage(60), Constraint::Percentage(40)].as_ref()) .split(vertical_chunks[1]); let middle_divided_chunk_2 = Layout::default() @@ -76,7 +72,7 @@ pub fn draw_data<B : tui::backend::Backend>(terminal : &mut Terminal<B>, app_dat for (i, cpu) in canvas_data.cpu_data.iter().enumerate() { let mut avg_cpu_exist_offset = 0; - if app_data.show_average_cpu { + if app_state.show_average_cpu { if i == 0 { // Skip, we want to render the average cpu last! continue; @@ -95,7 +91,7 @@ pub fn draw_data<B : tui::backend::Backend>(terminal : &mut Terminal<B>, app_dat ); } - if !canvas_data.cpu_data.is_empty() && app_data.show_average_cpu { + if !canvas_data.cpu_data.is_empty() && app_state.show_average_cpu { dataset_vector.push( Dataset::default() .name(&canvas_data.cpu_data[0].0) @@ -154,14 +150,13 @@ pub fn draw_data<B : tui::backend::Backend>(terminal : &mut Terminal<B>, app_dat .block(Block::default().title("Disk Usage").borders(Borders::ALL).border_style(border_style)) .header_style(Style::default().fg(Color::LightBlue).modifier(Modifier::BOLD)) .widths(&[ - // Must make sure these are NEVER zero! It will fail to display! Seems to only be this... - (width * 0.2) as u16 + 1, - (width * 0.2) as u16 + 1, - (width * 0.1) as u16 + 1, - (width * 0.1) as u16 + 1, - (width * 0.1) as u16 + 1, - (width * 0.1) as u16 + 1, - (width * 0.1) as u16 + 1, + (width * 0.18) as u16, + (width * 0.14) as u16, + (width * 0.13) as u16, + (width * 0.13) as u16, + (width * 0.13) as u16, + (width * 0.13) as u16, + (width * 0.13) as u16, ]) .render(&mut f, middle_divided_chunk_2[1]); } @@ -192,6 +187,65 @@ pub fn draw_data<B : tui::backend::Backend>(terminal : &mut Terminal<B>, app_dat // Processes table { let width = f64::from(bottom_chunks[1].width); + + // Admittedly this is kinda a hack... but we need to: + // * Scroll + // * Show/hide elements based on scroll position + // As such, we use a process_counter to know when we've hit the process we've currently scrolled to. We also need to move the list - we can + // do so by hiding some elements! + let num_rows = i64::from(bottom_chunks[1].height) - 3; + let mut process_counter = 0; + + //TODO: Fix this! + let start_position = if num_rows <= app_state.currently_selected_process_position { + match app_state.scroll_direction { + app::ScrollDirection::UP => { + if app_state.previous_process_position - app_state.currently_selected_process_position <= num_rows { + // We don't need to scroll up yet... + debug!("No need to scroll up yet..."); + app_state.previous_process_position + } + else { + // We need to scroll up! + debug!("Scroll up! Scroll up!"); + app_state.previous_process_position = app_state.currently_selected_process_position; + app_state.currently_selected_process_position + } + } + app::ScrollDirection::DOWN => { + app_state.previous_process_position = app_state.currently_selected_process_position - num_rows + 1; + (app_state.currently_selected_process_position - num_rows + 1) + } + } + } + else { + 0 + }; + + debug!( + "START POSN: {}, CURRENT SELECTED POSN: {}, NUM ROWS: {}", + start_position, app_state.currently_selected_process_position, num_rows + ); + + let sliced_vec : Vec<Vec<String>> = (&canvas_data.process_data[start_position as usize..]).to_vec(); + + let process_rows = sliced_vec.iter().map(|process| { + Row::StyledData( + process.iter(), + if process_counter == app_state.currently_selected_process_position - start_position { + // TODO: This is what controls the highlighting! + process_counter = -1; + Style::default().fg(Color::Black).bg(Color::Cyan) + } + else { + if process_counter >= 0 { + process_counter += 1; + } + Style::default().fg(TEXT_COLOUR) + }, + ) + }); + Table::new(["PID", "Name", "CPU%", "Mem%"].iter(), process_rows) .block(Block::default().title("Processes").borders(Borders::ALL).border_style(border_style)) .header_style(Style::default().fg(Color::LightBlue)) @@ -200,5 +254,7 @@ pub fn draw_data<B : tui::backend::Backend>(terminal : &mut Terminal<B>, app_dat } })?; + //debug!("Finished drawing."); + Ok(()) } diff --git a/src/convert_data.rs b/src/convert_data.rs index e3b70831..d802dfbd 100644 --- a/src/convert_data.rs +++ b/src/convert_data.rs @@ -19,10 +19,51 @@ pub fn update_temp_row(app_data : &data_collection::Data, temp_type : &data_coll sensor_vector } -// TODO: IO count NEEDS TO BE DONE!!!!! pub fn update_disk_row(app_data : &data_collection::Data) -> Vec<Vec<String>> { let mut disk_vector : Vec<Vec<String>> = Vec::new(); for disk in &app_data.list_of_disks { + let io_activity = if app_data.list_of_io.len() > 2 { + let io_package = &app_data.list_of_io.last().unwrap(); + let prev_io_package = &app_data.list_of_io[app_data.list_of_io.len() - 2]; + + let io_hashmap = &io_package.io_hash; + let prev_io_hashmap = &prev_io_package.io_hash; + let trimmed_mount = &disk.name.to_string().split('/').last().unwrap().to_string(); + let time_difference = io_package.instant.duration_since(prev_io_package.instant).as_secs_f64(); + if io_hashmap.contains_key(trimmed_mount) && prev_io_hashmap.contains_key(trimmed_mount) { + // Ideally change this... + let ele = &io_hashmap[trimmed_mount]; + let prev = &prev_io_hashmap[trimmed_mount]; + let read_bytes_per_sec = ((ele.read_bytes - prev.read_bytes) as f64 / time_difference) as u64; + let write_bytes_per_sec = ((ele.write_bytes - prev.write_bytes) as f64 / time_difference) as u64; + ( + if read_bytes_per_sec < 1024 { + format!("{}B", read_bytes_per_sec) + } + else if read_bytes_per_sec < 1024 * 1024 { + format!("{}KB", read_bytes_per_sec / 1024) + } + else { + format!("{}MB", read_bytes_per_sec / 1024 / 1024) + }, + if write_bytes_per_sec < 1024 { + format!("{}B", write_bytes_per_sec) + } + else if write_bytes_per_sec < 1024 * 1024 { + format!("{}KB", write_bytes_per_sec / 1024) + } + else { + format!("{}MB", write_bytes_per_sec / 1024 / 1024) + }, + ) + } + else { + ("0B".to_string(), "0B".to_string()) + } + } + else { + ("0B".to_string(), "0B".to_string()) + }; disk_vector.push(vec![ disk.name.to_string(), disk.mount_point.to_string(), @@ -39,6 +80,8 @@ pub fn update_disk_row(app_data : &data_collection::Data) -> Vec<Vec<String>> { else { (disk.total_space / 1024).to_string() + "GB" }, + io_activity.0, + io_activity.1, ]); } @@ -215,8 +258,8 @@ pub fn convert_network_data_points(network_data : &[data_collection::network::Ne rx.push(rx_data); tx.push(tx_data); - debug!("Pushed rx: ({}, {})", rx.last().unwrap().0, rx.last().unwrap().1); - debug!("Pushed tx: ({}, {})", tx.last().unwrap().0, tx.last().unwrap().1); + //debug!("Pushed rx: ({}, {})", rx.last().unwrap().0, rx.last().unwrap().1); + //debug!("Pushed tx: ({}, {})", tx.last().unwrap().0, tx.last().unwrap().1); } let rx_display = if network_data.is_empty() { diff --git a/src/main.rs b/src/main.rs index d1c3c80f..40b66018 100644 --- a/src/main.rs +++ b/src/main.rs @@ -113,7 +113,6 @@ fn main() -> error::Result<()> { _ => {} } } - input.disable_mouse_mode().unwrap(); }); } @@ -142,14 +141,12 @@ fn main() -> error::Result<()> { }); } - let mut app_data = data_collection::Data::default(); let mut canvas_data = canvas::CanvasData::default(); - loop { if let Ok(recv) = rx.recv_timeout(Duration::from_millis(TICK_RATE_IN_MILLISECONDS)) { match recv { Event::KeyInput(event) => { - debug!("Keyboard event fired!"); + // debug!("Keyboard event fired!"); match event { KeyEvent::Ctrl('c') | KeyEvent::Esc => break, KeyEvent::Char(c) => app.on_key(c), // TODO: We can remove the 'q' event and just move it to the quit? @@ -161,55 +158,46 @@ fn main() -> error::Result<()> { } if app.to_be_resorted { - data_collection::processes::sort_processes(&mut app_data.list_of_processes, &app.process_sorting_type, app.process_sorting_reverse); - canvas_data.process_data = update_process_row(&app_data); + data_collection::processes::sort_processes(&mut app.data.list_of_processes, &app.process_sorting_type, app.process_sorting_reverse); + canvas_data.process_data = update_process_row(&app.data); app.to_be_resorted = false; } - debug!("Input event complete."); + // debug!("Input event complete."); } Event::MouseInput(event) => { - debug!("Mouse event fired!"); + // debug!("Mouse event fired!"); match event { - MouseEvent::Press(e, _x, _y) => { - debug!("Mouse press!"); - match e { - MouseButton::WheelUp => { - debug!("Wheel up!"); - } - MouseButton::WheelDown => { - debug!("Wheel down!"); - } - _ => {} + MouseEvent::Press(e, _x, _y) => match e { + MouseButton::WheelUp => { + app.decrement_position_count(); } - } - MouseEvent::Hold(_x, _y) => { - debug!("Mouse hold!"); - } - MouseEvent::Release(_x, _y) => { - debug!("Mouse release!"); - } - _ => { - debug!("Mouse unknown event..."); - } + MouseButton::WheelDown => { + app.increment_position_count(); + } + _ => {} + }, + MouseEvent::Hold(_x, _y) => {} + MouseEvent::Release(_x, _y) => {} + _ => {} } } Event::Update(data) => { - debug!("Update event fired!"); - app_data = *data; - data_collection::processes::sort_processes(&mut app_data.list_of_processes, &app.process_sorting_type, app.process_sorting_reverse); + // debug!("Update event fired!"); + app.data = *data; + data_collection::processes::sort_processes(&mut app.data.list_of_processes, &app.process_sorting_type, app.process_sorting_reverse); // Convert all data into tui components - let network_data = update_network_data_points(&app_data); + let network_data = update_network_data_points(&app.data); canvas_data.network_data_rx = network_data.rx; canvas_data.network_data_tx = network_data.tx; canvas_data.rx_display = network_data.rx_display; canvas_data.tx_display = network_data.tx_display; - canvas_data.disk_data = update_disk_row(&app_data); - canvas_data.temp_sensor_data = update_temp_row(&app_data, &app.temperature_type); - canvas_data.process_data = update_process_row(&app_data); - canvas_data.mem_data = update_mem_data_points(&app_data); - canvas_data.swap_data = update_swap_data_points(&app_data); - canvas_data.cpu_data = update_cpu_data_points(app.show_average_cpu, &app_data); + canvas_data.disk_data = update_disk_row(&app.data); + canvas_data.temp_sensor_data = update_temp_row(&app.data, &app.temperature_type); + canvas_data.process_data = update_process_row(&app.data); + canvas_data.mem_data = update_mem_data_points(&app.data); + canvas_data.swap_data = update_swap_data_points(&app.data); + canvas_data.cpu_data = update_cpu_data_points(app.show_average_cpu, &app.data); debug!("Update event complete."); } @@ -219,9 +207,14 @@ fn main() -> error::Result<()> { } } // Draw! - canvas::draw_data(&mut terminal, &app, &canvas_data)?; + if let Err(err) = canvas::draw_data(&mut terminal, &mut app, &canvas_data) { + input().disable_mouse_mode().unwrap(); + error!("{}", err); + return Err(err); + } } + input().disable_mouse_mode().unwrap(); debug!("Terminating."); Ok(()) } diff --git a/src/utils/logging.rs b/src/utils/logging.rs index f3afea42..c9281109 100644 --- a/src/utils/logging.rs +++ b/src/utils/logging.rs @@ -10,7 +10,13 @@ pub fn init_logger() -> Result<(), fern::InitError> { )) }) .level(if cfg!(debug_assertions) { log::LevelFilter::Debug } else { log::LevelFilter::Info }) - .chain(fern::log_file("debug.log")?) + .chain(if cfg!(debug_assertions) { + //std::fs::OpenOptions::new().write(true).create(true).append(false).open("debug.log")? + fern::log_file("debug.log")? + } + else { + fern::log_file("logging.log")? + }) .apply()?; Ok(()) |