Struct StderrTail 

pub struct StderrTail { /* private fields */ }

A background drain of one stderr stream. Keeps the most recent lines whose total size is at most max_bytes; older lines fall off the front. A single line that alone exceeds the budget is cut to its last bytes, so snapshot never returns more than max_bytes bytes.

Implementations

impl StderrTail

pub fn capture<R: Read + Send + 'static>( stderr: R, max_bytes: usize, map: impl Fn(&str) -> Option<String> + Send + 'static, on_line: impl Fn(&str) + Send + 'static, ) -> Self

Drain stderr on a thread. map sees every line first and returns the text to keep (redaction), or None to drop it. on_line receives the kept text as it arrives (forward to logs/telemetry).

A line longer than four times max_bytes cannot be inspected whole, and map is a line-based redactor: handing it the first piece and then the rest as if each were a line would let a secret that spans the cut through unredacted. So such a line never reaches map. Its bytes are read and discarded up to its newline, and one marker line, [stderr line over N bytes dropped], takes its place (forwarded to on_line, and retained, without passing through map: it holds nothing from the child).

Best effort: if the drain thread cannot be spawned, this returns a tail that retains nothing (the error is discarded, and stderr is dropped undrained). Use try_capture to learn that the drain never started.

pub fn try_capture<R: Read + Send + 'static>( stderr: R, max_bytes: usize, map: impl Fn(&str) -> Option<String> + Send + 'static, on_line: impl Fn(&str) + Send + 'static, ) -> Result<Self>

Like capture, but returns the operating-system error when the drain thread cannot be spawned, so the caller can fail, retry, or log that stderr is not being captured. On success the behaviour is identical to capture.

pub fn plain<R: Read + Send + 'static>(stderr: R, max_bytes: usize) -> Self

Capture with no redaction and no forwarding.

pub fn snapshot(&self) -> String

The retained lines, oldest first, joined by newlines.

pub fn finish_within(&mut self, timeout: Duration) -> String

Like Self::finish but gives up after timeout (a grandchild that inherited stderr can keep the stream open after the child is gone) and returns what was captured so far.

pub fn finish(&mut self) -> String

Wait for the stream to end (the child exited) so the tail is complete.