Struct LoggingLayer

pub struct LoggingLayer<I = DefaultLoggingInterceptor> {
    logger: I,
}

Add log for every operation.

Logging

• OpenDAL will log in structural way.
• Every operation will start with a started log entry.
• Every operation will finish with the following status:
  • succeeded: the operation is successful, but might have more to take.
  • finished: the whole operation is finished.
  • failed: the operation returns an unexpected error.
• The default log level while expected error happened is Warn.
• The default log level while unexpected failure happened is Error.

Examples

let _ = Operator::new(services::Memory::default())?
    .layer(LoggingLayer::default())
    .finish();
Ok(())

Output

OpenDAL is using log for logging internally.

To enable logging output, please set RUST_LOG:

RUST_LOG=debug ./app

To config logging output, please refer to Configure Logging:

RUST_LOG="info,opendal::services=debug" ./app

Logging Interceptor

You can implement your own logging interceptor to customize the logging behavior.

#[derive(Debug, Clone)]
struct MyLoggingInterceptor;

impl LoggingInterceptor for MyLoggingInterceptor {
    fn log(
        &self,
        info: &raw::AccessorInfo,
        operation: raw::Operation,
        context: &[(&str, &str)],
        message: &str,
        err: Option<&Error>,
    ) {
        // log something
    }
}

let _ = Operator::new(services::Memory::default())?
    .layer(LoggingLayer::new(MyLoggingInterceptor))
    .finish();
Ok(())

Fields

logger: I

Implementations

impl LoggingLayer

pub fn new<I>(logger: I) -> LoggingLayer<I>

where I: LoggingInterceptor,

Create the layer with specific logging interceptor.

Trait Implementations

impl<I> Debug for LoggingLayer<I>

where I: Debug,

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

Formats the value using the given formatter.

impl Default for LoggingLayer

fn default() -> LoggingLayer

Returns the “default value” for a type.

impl<A, I> Layer<A> for LoggingLayer<I>

where A: Access, I: LoggingInterceptor,

type LayeredAccess = LoggingAccessor<A, I>

The layered accessor that returned by this layer.

fn layer(&self, inner: A) -> <LoggingLayer<I> as Layer<A>>::LayeredAccess

Intercept the operations on the underlying storage.