Struct LoggedStream

pub struct LoggedStream<S: 'static, Formatter: 'static, Filter: RecordFilter + 'static, L: Logger + 'static> { /* private fields */ }

Wrapper for IO objects to log all read and write operations, errors, and drop events.

This structure can be used as a wrapper for underlying IO objects that implement the Read and Write traits, or their asynchronous analogues from the tokio library, AsyncRead and AsyncWrite. It enables logging of all read and write operations, errors, and drop events.

LoggedStream structure constructs from four parts:

• Underlying IO object, which must implement Write and Read traits or their asynchronous analogues from tokio library: AsyncRead and AsyncWrite.
• Buffer formatting part, which must implement BufferFormatter trait provided by this library. This part of LoggedStream is responsible for the form you will see the input and output bytes. Currently this library provides the following implementations of BufferFormatter trait: LowercaseHexadecimalFormatter, UppercaseHexadecimalFormatter, DecimalFormatter, BinaryFormatter and OctalFormatter. Also BufferFormatter is public trait so you are free to construct your own implementation.
• Filtering part, which must implement RecordFilter trait provide by this library. This part of LoggedStream is responsible for log records filtering. Currently this library provides the following implementation of RecordFilter trait: DefaultFilter which accepts all log records and RecordKindFilter which accepts logs with kinds specified during construct. Also RecordFilter is public trait and you are free to construct your own implementation.
• Logging part, which must implement Logger trait provided by this library. This part of LoggedStream is responsible for further work with constructed, formatter and filtered log record. For example, it can be outputted to console, written to the file, written to database, written to the memory for further use or sended by the channel. Currently this library provides the following implementations of Logger trait: ConsoleLogger, MemoryStorageLogger, ChannelLogger and FileLogger. Also Logger is public trait and you are free to construct your own implementation.

Implementations

impl<S: 'static, Formatter: 'static, Filter: RecordFilter + 'static, L: Logger + 'static> LoggedStream<S, Formatter, Filter, L>

pub fn new(stream: S, formatter: Formatter, filter: Filter, logger: L) -> Self

Construct a new instance of LoggedStream using provided arguments.

impl<S: 'static, Formatter: 'static, Filter: RecordFilter + 'static> LoggedStream<S, Formatter, Filter, MemoryStorageLogger>

pub fn get_log_records(&self) -> VecDeque<Record>

pub fn clear_log_records(&mut self)

impl<S: 'static, Formatter: 'static, Filter: RecordFilter + 'static> LoggedStream<S, Formatter, Filter, ChannelLogger>

pub fn take_receiver(&mut self) -> Option<Receiver<Record>>

pub fn take_receiver_unchecked(&mut self) -> Receiver<Record>

Trait Implementations

impl<S: AsyncRead + Unpin + 'static, Formatter: BufferFormatter + Unpin + 'static, Filter: RecordFilter + Unpin + 'static, L: Logger + Unpin + 'static> AsyncRead for LoggedStream<S, Formatter, Filter, L>

fn poll_read( self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>, ) -> Poll<Result<()>>

Attempts to read from the AsyncRead into buf.

impl<S: AsyncWrite + Unpin + 'static, Formatter: BufferFormatter + Unpin + 'static, Filter: RecordFilter + Unpin + 'static, L: Logger + Unpin + 'static> AsyncWrite for LoggedStream<S, Formatter, Filter, L>

fn poll_write( self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8], ) -> Poll<Result<usize, Error>>

Attempt to write bytes from buf into the object.

fn poll_flush( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Error>>

Attempts to flush the object, ensuring that any buffered data reach their destination.

fn poll_shutdown( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Error>>

Initiates or attempts to shut down this writer, returning success when the I/O connection has completely shut down.

fn poll_write_vectored( self: Pin<&mut Self>, cx: &mut Context<'_>, bufs: &[IoSlice<'_>], ) -> Poll<Result<usize, Error>>

Like poll_write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

Determines if this writer has an efficient poll_write_vectored implementation.

impl<S: Debug + 'static, Formatter: Debug + 'static, Filter: RecordFilter + Debug + 'static, L: Logger + Debug + 'static> Debug for LoggedStream<S, Formatter, Filter, L>

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

Formats the value using the given formatter.

impl<S: 'static, Formatter: 'static, Filter: RecordFilter + 'static, L: Logger + 'static> Drop for LoggedStream<S, Formatter, Filter, L>

fn drop(&mut self)

Executes the destructor for this type.

impl<S: Read + 'static, Formatter: BufferFormatter + 'static, Filter: RecordFilter + 'static, L: Logger + 'static> Read for LoggedStream<S, Formatter, Filter, L>

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Reads all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Reads all bytes until EOF in this source, appending them to buf.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Reads the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Reads the exact number of bytes required to fill cursor.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R>

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

where Self: Sized,

Creates an adapter which will read at most limit bytes from it.

impl<S: Write + 'static, Formatter: BufferFormatter + 'static, Filter: RecordFilter + 'static, L: Logger + 'static> Write for LoggedStream<S, Formatter, Filter, L>

fn write(&mut self, buf: &[u8]) -> Result<usize>

Writes a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<()>

Flushes this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Write.