Crate iceoryx2_bb_log

Simplistic logger. It has 6 LogLevels which can be set via set_log_level() and read via get_log_level().

The logger provides convinience macros to combine error/panic handling directly with the logger. The fail! macro can return when the function which was called return an error containing result. The fatal_panic! macro calls panic!.

Example

Logging

use iceoryx2_bb_log::{debug, error, info, trace, warn};

#[derive(Debug)]
struct MyDataType {
    value: u64
}

impl MyDataType {
    fn log_stuff(&self) {
        trace!("trace message");
        trace!(from self, "trace message");
        trace!(from "Custom::Origin", "trace message");

        debug!("hello {} {}", 123, 456);
        debug!(from self, "hello {}", 123);
        debug!(from "Another::Origin", "hello {}", 123);

        info!("world");
        info!(from self, "world");
        info!(from "hello", "world");

        warn!("warn message");
        warn!(from self, "warning");
        warn!(from "Somewhere::Else", "warning!");

        error!("bla {}", 1);
        error!(from self, "bla {}", 1);
        error!(from "error origin", "bla {}", 1);
    }
}

Error Handling

use iceoryx2_bb_log::fail;

#[derive(Debug)]
struct MyDataType {
    value: u64
}

impl MyDataType {
    fn doStuff(&self, value: u64) -> Result<(), ()> {
        if value == 0 { Err(()) } else { Ok(()) }
    }

    fn doMoreStuff(&self) -> Result<(), u64> {
        // fail when doStuff.is_err() and return the error 1234
        fail!(from self, when self.doStuff(0),
                with 1234, "Failed while calling doStuff");
        Ok(())
    }

    fn doMore(&self) -> Result<(), u64> {
        if self.value == 0 {
            // without condition, return error 4567
            fail!(from self, with 4567, "Value is zero");
        }

        Ok(())
    }

    fn evenMore(&self) -> Result<(), u64> {
        // forward error when it is compatible or convertable
        fail!(from self, when self.doMore(), "doMore failed");
        Ok(())
    }
}

Panic Handling

use iceoryx2_bb_log::fatal_panic;

#[derive(Debug)]
struct MyDataType {
    value: u64
}

impl MyDataType {
    fn doStuff(&self, value: u64) {
        if value == 0 {
            fatal_panic!(from self, "value is {}", value);
        }
    }

    fn moreStuff(&self) -> Result<(), ()> {
        if self.value == 0 { Err(()) } else { Ok(()) }
    }

    fn doIt(&self) {
        fatal_panic!(from self, when self.moreStuff(), "moreStuff failed");
    }
}

Setting custom logger on application startup

In this example we use the crate::logger::buffer::Logger, that stores every log message in an internal buffer, and use it as the default logger.

use iceoryx2_bb_log::{set_logger, info};

static LOGGER: iceoryx2_bb_log::logger::buffer::Logger =
    iceoryx2_bb_log::logger::buffer::Logger::new();

assert!(set_logger(&LOGGER));
info!("hello world");
let log_content = LOGGER.content();

for entry in log_content {
    println!("{:?} {} {}", entry.log_level, entry.origin, entry.message);
}

Modules

• fail
  Combines error handling with logging.
• log
  Contains all macros to log messages.
• logger
  Trait which can be implemented by logger, see crate::logger::console::Logger for instance.

Macros

• debug
  Logs a debug message.
• error
  Logs an error message.
• fail
  Macro to combine error handling with log messages. It automatically fails and converts the error with From.
• fatal_panic
  Logs a fatal error message and calls panic.
• info
  Logs a info message.
• trace
  Logs a trace message.
• warn
  Logs a warn message.

Enums

• LogLevel
  Describes the log level.

Traits

• Log

Functions

• get_log_level
  Returns the current log level
• get_logger
  Returns a reference to the Logger.
• set_log_level
  Sets the current log level. This is ignored for external frameworks like log or tracing. Here you have to use the log-level settings of that framework.
• set_logger
  Sets the Logger. Can be only called once at the beginning of the program. If the Logger is already set it returns false and does not update it.