Struct NonblockLogger

pub struct NonblockLogger { /* private fields */ }

Implementations

impl NonblockLogger

pub fn new() -> Self

Examples found in repository

examples/drop.rs (line 12)

fn main() {
    let now;

    {
        // use Drop wait for log thread
        let _handle = NonblockLogger::new()
            .log_to_stdout()
            .map_err(|e| eprintln!("failed to init nonblock_logger: {:?}", e))
            .unwrap();

        now = time::Instant::now();

        include!("log.snippet");

        println!("join0_{}: {:?}", messages_in_channel(), now.elapsed());
    }

    println!("join1_{}: {:?}", messages_in_channel(), now.elapsed());
}

examples/formater.rs (line 12)

fn main() {
    let formater = BaseFormater::new().formater(format);

    let mut handle = NonblockLogger::new()
        .formater(formater)
        .log_to_stdout()
        .map_err(|e| eprintln!("failed to init nonblock_logger: {:?}", e))
        .unwrap();

    let now = time::Instant::now();

    include!("log.snippet");

    println!("join0_{}: {:?}", messages_in_channel(), now.elapsed());

    handle.join();

    println!("join1_{}: {:?}", messages_in_channel(), now.elapsed());
}

examples/basic.rs (line 8)

fn main() {
    let mut handle = NonblockLogger::new()
        .log_to_stdout()
        .map_err(|e| eprintln!("failed to init nonblock_logger: {:?}", e))
        .unwrap();

    let now = time::Instant::now();

    include!("log.snippet");
    if log_enabled!(Info) {
        println!("INFO enabled");
    }

    println!("join0_{}: {:?}", messages_in_channel(), now.elapsed());

    // let _: usize = fatal!("fatal!() will return !");

    // wait for log thread
    handle.join();

    println!("join1_{}: {:?}", messages_in_channel(), now.elapsed());
}

pub fn with_capacity(cap: usize) -> Self

pub fn sendfn<F>(self, sendfn: F) -> Self

where F: Fn(&NonblockLogger, Option<Message>) + Send + Sync + 'static,

pub fn formater<F: Formater>(self, formater: F) -> Self

Examples found in repository

examples/formater.rs (line 13)

fn main() {
    let formater = BaseFormater::new().formater(format);

    let mut handle = NonblockLogger::new()
        .formater(formater)
        .log_to_stdout()
        .map_err(|e| eprintln!("failed to init nonblock_logger: {:?}", e))
        .unwrap();

    let now = time::Instant::now();

    include!("log.snippet");

    println!("join0_{}: {:?}", messages_in_channel(), now.elapsed());

    handle.join();

    println!("join1_{}: {:?}", messages_in_channel(), now.elapsed());
}

pub fn filter<F: Filter>(self, filter: F) -> Result<Self, Error>

pub fn consumer<C: Consumer>(self, consumer: C) -> Result<Self, Error>

pub fn name<S: Into<String>>(self, name: S) -> Self

pub fn name_get(&self) -> Option<&String>

pub fn quiet(self) -> Self

Don’t panic if failed to send message to the consumer thread

pub fn quiet_get(&self) -> bool

pub fn spawn(self) -> Result<JoinHandle, Error>

pub fn log_to_stdout(self) -> Result<JoinHandle, Error>

Examples found in repository

examples/drop.rs (line 13)

fn main() {
    let now;

    {
        // use Drop wait for log thread
        let _handle = NonblockLogger::new()
            .log_to_stdout()
            .map_err(|e| eprintln!("failed to init nonblock_logger: {:?}", e))
            .unwrap();

        now = time::Instant::now();

        include!("log.snippet");

        println!("join0_{}: {:?}", messages_in_channel(), now.elapsed());
    }

    println!("join1_{}: {:?}", messages_in_channel(), now.elapsed());
}

examples/formater.rs (line 14)

fn main() {
    let formater = BaseFormater::new().formater(format);

    let mut handle = NonblockLogger::new()
        .formater(formater)
        .log_to_stdout()
        .map_err(|e| eprintln!("failed to init nonblock_logger: {:?}", e))
        .unwrap();

    let now = time::Instant::now();

    include!("log.snippet");

    println!("join0_{}: {:?}", messages_in_channel(), now.elapsed());

    handle.join();

    println!("join1_{}: {:?}", messages_in_channel(), now.elapsed());
}

examples/basic.rs (line 9)

fn main() {
    let mut handle = NonblockLogger::new()
        .log_to_stdout()
        .map_err(|e| eprintln!("failed to init nonblock_logger: {:?}", e))
        .unwrap();

    let now = time::Instant::now();

    include!("log.snippet");
    if log_enabled!(Info) {
        println!("INFO enabled");
    }

    println!("join0_{}: {:?}", messages_in_channel(), now.elapsed());

    // let _: usize = fatal!("fatal!() will return !");

    // wait for log thread
    handle.join();

    println!("join1_{}: {:?}", messages_in_channel(), now.elapsed());
}

pub fn log_to_stderr(self) -> Result<JoinHandle, Error>

impl NonblockLogger

pub fn global() -> Option<&'static Self>

pub fn send_exit(&self)

pub fn exit(&self)

pub fn exited(&self) -> bool

pub fn messages_in_channel(&self) -> usize

Trait Implementations

impl Debug for NonblockLogger

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.