use std::fmt::Debug;
use std::future::Future;
use futures::FutureExt;
use minitrace::prelude::*;
use crate::raw::oio::ListOperation;
use crate::raw::oio::ReadOperation;
use crate::raw::oio::WriteOperation;
use crate::raw::*;
use crate::*;
pub struct MinitraceLayer;
impl<A: Access> Layer<A> for MinitraceLayer {
type LayeredAccess = MinitraceAccessor<A>;
fn layer(&self, inner: A) -> Self::LayeredAccess {
MinitraceAccessor { inner }
}
}
#[derive(Debug)]
pub struct MinitraceAccessor<A> {
inner: A,
}
impl<A: Access> LayeredAccess for MinitraceAccessor<A> {
type Inner = A;
type Reader = MinitraceWrapper<A::Reader>;
type BlockingReader = MinitraceWrapper<A::BlockingReader>;
type Writer = MinitraceWrapper<A::Writer>;
type BlockingWriter = MinitraceWrapper<A::BlockingWriter>;
type Lister = MinitraceWrapper<A::Lister>;
type BlockingLister = MinitraceWrapper<A::BlockingLister>;
fn inner(&self) -> &Self::Inner {
&self.inner
}
#[trace]
fn metadata(&self) -> AccessorInfo {
self.inner.info()
}
#[trace(name = "create", enter_on_poll = true)]
async fn create_dir(&self, path: &str, args: OpCreateDir) -> Result<RpCreateDir> {
self.inner.create_dir(path, args).await
}
#[trace(enter_on_poll = true)]
async fn read(&self, path: &str, args: OpRead) -> Result<(RpRead, Self::Reader)> {
self.inner
.read(path, args)
.map(|v| {
v.map(|(rp, r)| {
(
rp,
MinitraceWrapper::new(Span::enter_with_local_parent("ReadOperation"), r),
)
})
})
.await
}
#[trace(enter_on_poll = true)]
async fn write(&self, path: &str, args: OpWrite) -> Result<(RpWrite, Self::Writer)> {
self.inner
.write(path, args)
.map(|v| {
v.map(|(rp, r)| {
(
rp,
MinitraceWrapper::new(Span::enter_with_local_parent("WriteOperation"), r),
)
})
})
.await
}
#[trace(enter_on_poll = true)]
async fn copy(&self, from: &str, to: &str, args: OpCopy) -> Result<RpCopy> {
self.inner().copy(from, to, args).await
}
#[trace(enter_on_poll = true)]
async fn rename(&self, from: &str, to: &str, args: OpRename) -> Result<RpRename> {
self.inner().rename(from, to, args).await
}
#[trace(enter_on_poll = true)]
async fn stat(&self, path: &str, args: OpStat) -> Result<RpStat> {
self.inner.stat(path, args).await
}
#[trace(enter_on_poll = true)]
async fn delete(&self, path: &str, args: OpDelete) -> Result<RpDelete> {
self.inner.delete(path, args).await
}
#[trace(enter_on_poll = true)]
async fn list(&self, path: &str, args: OpList) -> Result<(RpList, Self::Lister)> {
self.inner
.list(path, args)
.map(|v| {
v.map(|(rp, s)| {
(
rp,
MinitraceWrapper::new(Span::enter_with_local_parent("ListOperation"), s),
)
})
})
.await
}
#[trace(enter_on_poll = true)]
async fn presign(&self, path: &str, args: OpPresign) -> Result<RpPresign> {
self.inner.presign(path, args).await
}
#[trace(enter_on_poll = true)]
async fn batch(&self, args: OpBatch) -> Result<RpBatch> {
self.inner.batch(args).await
}
#[trace]
fn blocking_create_dir(&self, path: &str, args: OpCreateDir) -> Result<RpCreateDir> {
self.inner.blocking_create_dir(path, args)
}
#[trace]
fn blocking_read(&self, path: &str, args: OpRead) -> Result<(RpRead, Self::BlockingReader)> {
self.inner.blocking_read(path, args).map(|(rp, r)| {
(
rp,
MinitraceWrapper::new(Span::enter_with_local_parent("ReadOperation"), r),
)
})
}
#[trace]
fn blocking_write(&self, path: &str, args: OpWrite) -> Result<(RpWrite, Self::BlockingWriter)> {
self.inner.blocking_write(path, args).map(|(rp, r)| {
(
rp,
MinitraceWrapper::new(Span::enter_with_local_parent("WriteOperation"), r),
)
})
}
#[trace]
fn blocking_copy(&self, from: &str, to: &str, args: OpCopy) -> Result<RpCopy> {
self.inner().blocking_copy(from, to, args)
}
#[trace]
fn blocking_rename(&self, from: &str, to: &str, args: OpRename) -> Result<RpRename> {
self.inner().blocking_rename(from, to, args)
}
#[trace]
fn blocking_stat(&self, path: &str, args: OpStat) -> Result<RpStat> {
self.inner.blocking_stat(path, args)
}
#[trace]
fn blocking_delete(&self, path: &str, args: OpDelete) -> Result<RpDelete> {
self.inner.blocking_delete(path, args)
}
#[trace]
fn blocking_list(&self, path: &str, args: OpList) -> Result<(RpList, Self::BlockingLister)> {
self.inner.blocking_list(path, args).map(|(rp, it)| {
(
rp,
MinitraceWrapper::new(Span::enter_with_local_parent("PageOperation"), it),
)
})
}
}
pub struct MinitraceWrapper<R> {
span: Span,
inner: R,
}
impl<R> MinitraceWrapper<R> {
fn new(span: Span, inner: R) -> Self {
Self { span, inner }
}
}
impl<R: oio::Read> oio::Read for MinitraceWrapper<R> {
#[trace(enter_on_poll = true)]
async fn read_at(&self, offset: u64, limit: usize) -> Result<Buffer> {
self.inner.read_at(offset, limit).await
}
}
impl<R: oio::BlockingRead> oio::BlockingRead for MinitraceWrapper<R> {
fn read_at(&self, offset: u64, limit: usize) -> Result<Buffer> {
let _g = self.span.set_local_parent();
let _span = LocalSpan::enter_with_local_parent(ReadOperation::BlockingRead.into_static());
self.inner.read_at(offset, limit)
}
}
impl<R: oio::Write> oio::Write for MinitraceWrapper<R> {
fn write(&mut self, bs: Buffer) -> impl Future<Output = Result<usize>> + MaybeSend {
let _g = self.span.set_local_parent();
let _span = LocalSpan::enter_with_local_parent(WriteOperation::Write.into_static());
self.inner.write(bs)
}
fn abort(&mut self) -> impl Future<Output = Result<()>> + MaybeSend {
let _g = self.span.set_local_parent();
let _span = LocalSpan::enter_with_local_parent(WriteOperation::Abort.into_static());
self.inner.abort()
}
fn close(&mut self) -> impl Future<Output = Result<()>> + MaybeSend {
let _g = self.span.set_local_parent();
let _span = LocalSpan::enter_with_local_parent(WriteOperation::Close.into_static());
self.inner.close()
}
}
impl<R: oio::BlockingWrite> oio::BlockingWrite for MinitraceWrapper<R> {
fn write(&mut self, bs: Buffer) -> Result<usize> {
let _g = self.span.set_local_parent();
let _span = LocalSpan::enter_with_local_parent(WriteOperation::BlockingWrite.into_static());
self.inner.write(bs)
}
fn close(&mut self) -> Result<()> {
let _g = self.span.set_local_parent();
let _span = LocalSpan::enter_with_local_parent(WriteOperation::BlockingClose.into_static());
self.inner.close()
}
}
impl<R: oio::List> oio::List for MinitraceWrapper<R> {
#[trace(enter_on_poll = true)]
async fn next(&mut self) -> Result<Option<oio::Entry>> {
self.inner.next().await
}
}
impl<R: oio::BlockingList> oio::BlockingList for MinitraceWrapper<R> {
fn next(&mut self) -> Result<Option<oio::Entry>> {
let _g = self.span.set_local_parent();
let _span = LocalSpan::enter_with_local_parent(ListOperation::BlockingNext.into_static());
self.inner.next()
}
}