Struct r3bl_terminal_async::public_api::tracing_setup::TracingConfig

pub struct TracingConfig {
    pub writers: Vec<WriterArg>,
    pub level: Level,
    pub tracing_log_file_path_and_prefix: String,
    pub preferred_display: DisplayPreference,
}

Fields:

• writers: Vec<WriterArg> - Zero or more writers to use for tracing.
• level: tracing::Level - The log level to use for tracing.
• tracing_log_file_path_and_prefix: String - The file path and prefix to use for the log file. Eg: /tmp/tcp_api_server or tcp_api_server.

Fields

writers: Vec<WriterArg>

level: Level

tracing_log_file_path_and_prefix: String

preferred_display: DisplayPreference

Implementations

impl TracingConfig

pub fn new(preferred_display: DisplayPreference) -> Self

The default configuration for tracing. This will log to both the given DisplayPreference and a file.

Examples found in repository

examples/terminal_async.rs (line 143)

async fn main() -> miette::Result<()> {
    let maybe_terminal_async = TerminalAsync::try_new("> ").await?;

    // If the terminal is not fully interactive, then return early.
    let mut terminal_async = match maybe_terminal_async {
        None => return Ok(()),
        _ => maybe_terminal_async.unwrap(),
    };

    // Pre-populate the readline's history with some entries.
    for command in Command::iter() {
        terminal_async
            .readline
            .add_history_entry(command.to_string());
    }

    // Initialize tracing w/ the "async stdout" (SharedWriter), and file writer.
    let display_preference = DisplayPreference::SharedWriter(terminal_async.shared_writer.clone());
    let config = TracingConfig::new(display_preference);
    tracing_setup::init(config)?;

    // Start tasks.
    let mut state = State::default();
    let mut interval_1_task = interval(state.task_1_state.interval_delay);
    let mut interval_2_task = interval(state.task_2_state.interval_delay);

    terminal_async.println(get_info_message().to_string()).await;

    loop {
        select! {
            _ = interval_1_task.tick() => {
                task_1::tick(&mut state, &mut terminal_async.clone_shared_writer())?;
            },
            _ = interval_2_task.tick() => {
                task_2::tick(&mut state, &mut terminal_async.clone_shared_writer())?;
            },
            user_input = terminal_async.get_readline_event() => match user_input {
                Ok(readline_event) => {
                    let continuation = process_input_event::process_readline_event(
                        readline_event, &mut state, &mut terminal_async.clone_shared_writer(), &mut terminal_async.readline
                    )?;
                    if let ControlFlow::Break(_) = continuation { break }
                },
                Err(err) => {
                    let msg_1 = format!("Received err: {}", format!("{:?}",err).red());
                    let msg_2 = format!("{}", "Exiting...".red());
                    terminal_async.println(msg_1).await;
                    terminal_async.println(msg_2).await;
                    break;
                },
            }
        }
    }

    // Flush all writers to stdout
    let _ = terminal_async.flush().await;

    Ok(())
}

pub fn get_level_filter(&self) -> LevelFilter

Trait Implementations

impl Clone for TracingConfig

fn clone(&self) -> TracingConfig

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.