Struct RotatingFileWriter 

pub struct RotatingFileWriter { /* private fields */ }

A Write + Clone file writer that rotates itself by size.

All clones share the same underlying state behind an Arc<Mutex<..>>>, so it is safe to hand a clone to every tracing writer/task: writes are serialized through the mutex, which both prevents interleaved/corrupted lines under concurrent logging from many tokio tasks and makes the size-check-then-rotate sequence atomic with respect to other writers (no writer can observe a mid-rotation state).

Also implements tracing_subscriber::fmt::MakeWriter directly so it can be passed straight to fmt::layer().with_writer(..), or wrapped by another MakeWriter (e.g. a color-processing writer) that delegates its inner writes to a clone of this type.

Implementations

impl RotatingFileWriter

pub fn new<P: Into<PathBuf>>(path: P) -> Result<Self>

Open (or create) path as a rotating log file using the crate defaults (DEFAULT_MAX_LOG_BYTES / DEFAULT_MAX_LOG_FILES).

If the file already exists and is already at or past the size cap (e.g. an old unbounded log), the existing contents are preserved, never truncated or deleted: the first write rotates it out to <path>.1 before appending, exactly like any other rotation.

pub fn with_limits<P: Into<PathBuf>>( path: P, max_bytes: u64, max_files: usize, ) -> Result<Self>

Same as Self::new but with explicit limits, primarily for tests and callers that want non-default rotation behavior.

max_bytes = 0 disables rotation (unbounded growth). max_files = 0 rotates by discarding the old file’s contents instead of retaining history.

Trait Implementations

impl Clone for RotatingFileWriter

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> MakeWriter<'a> for RotatingFileWriter

type Writer = RotatingFileWriter

The concrete io::Write implementation returned by make_writer.

fn make_writer(&'a self) -> Self::Writer

Returns an instance of Writer.

fn make_writer_for(&'a self, meta: &Metadata<'_>) -> Self::Writer

Returns a Writer for writing data from the span or event described by the provided Metadata.

impl Write for RotatingFileWriter

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

Overridden (rather than relying on the default loop-over-write) so the mutex is acquired exactly once for the whole buffer: no other writer can interleave a write — or observe/trigger a rotation — in the middle of this record.

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

Overridden so a single write!()/writeln!() call — which std::fmt may internally split into several write_str fragments (one per literal segment and per formatted argument) — is first assembled into one buffer and then written via Self::write_all under a single lock acquisition, instead of each fragment taking and releasing the lock separately (which would let another thread’s fragment land in between and corrupt the line). This mirrors how tracing-subscriber’s fmt layer already formats a full event into a buffer before issuing one write_all call.

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_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 by_ref(&mut self) -> &mut Self

where Self: Sized,

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