Struct opendal::layers::LoggingLayer

pub struct LoggingLayer<I = DefaultLoggingInterceptor> { /* private fields */ }

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(())

Implementations

impl LoggingLayer

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

Create the layer with specific logging interceptor.

Trait Implementations

impl<I: Debug> Debug for LoggingLayer<I>

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

Formats the value using the given formatter.

impl Default for LoggingLayer

fn default() -> Self

Returns the “default value” for a type.

impl<A: Access, I: LoggingInterceptor> Layer<A> for LoggingLayer<I>

type LayeredAccess = LoggingAccessor<A, I>

The layered accessor that returned by this layer.

fn layer(&self, inner: A) -> Self::LayeredAccess

Intercept the operations on the underlying storage.