Struct Shared 

struct Shared {
    fields: Entry,
    failing: AtomicBool,
    timed_out: Mutex<Option<Instant>>,
}

Fields

fields: Entry

The fields of every entry, encoded once.

failing: AtomicBool

Whether the last send failed, so that a journal which is unavailable gets reported once and not for every chunk of output.

timed_out: Mutex<Option<Instant>>

When the lines which last waited for the journal did not go out in time. The following chunks drop what the journal does not take right away instead of waiting as well, for at least another CHUNK_TIMEOUT and after that as long as it takes nothing, like a stalled one. Waiting for every chunk would slow down the reading of the output to about one per CHUNK_TIMEOUT, which the other log drivers and the container, blocked on a full pipe, would wait for. This way a journal which does not keep up holds it back by about half at most, and one which stalled not at all.

Implementations

impl Shared

fn skip_wait(&self, sent: usize) -> bool

Whether the lines which the journal did not take right away get dropped instead of waiting for it, after sent lines went out without waiting, see Shared::timed_out. Chunks which went out as a whole ask as well: they end the back-off like a partly taken one, a journal which recovered would get no bounded wait the next time it is busy otherwise.

fn socket(&self) -> &Path

Trait Implementations

impl Debug for Shared

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

Formats the value using the given formatter.