parse

type Event struct {
	// Format is the format that decoded the event ("json", "logfmt",
	// "plain", ...). When a structured format fails on a line, the event
	// falls back to "plain" and Fallback is set.
	Format   string
	Fallback bool

	// Time is the event's timestamp. HasTime is false when the event
	// carries none; Inherited is set when the reader filled Time from the
	// previous timed event of the same stream.
	Time      time.Time
	HasTime   bool
	Inherited bool

	// Fields is the structured part (top-level members), without the keys
	// that became Time and Message. For free text, only parser-known
	// fields (a plain line's level), else nil.
	Fields []Member
	// TimeKey and MessageKey name the keys Time and Message came from.
	TimeKey    string
	MessageKey string
	// Message is the free-text part, masked in text mode.
	Message string

	// Raw is the assembled text of the event (lines joined by "\n", line
	// terminators removed, invalid UTF-8 replaced). Callers must not
	// modify it.
	Raw string

	// Offset and Length locate the event in the stream: the byte offset of
	// its first line and the number of stream bytes it consumed, including
	// line terminators and any dropped tail of a truncated line.
	Offset int64
	Length int64
	// Lines is the number of lines in the event.
	Lines int
	// Truncated is set when a line was cut at MaxLineBytes.
	Truncated bool
	// Split is set when this event continues a previous one that hit
	// MaxEventBytes or MaxEventLines.
	Split bool

	// Unterminated is set when the event's last line had no terminator
	// (the end of a stream that may still be written).
	Unterminated bool

	// Attrs are the container frame's fields (stream, ...) for framed
	// formats, after the source's static attributes; nil otherwise.
	Attrs []Member
	// Framed is set when the event came out of a container frame (its
	// FrameKeys are in Attrs).
	Framed bool
	// contains filtered or unexported fields
}

type Format interface {
	// Name is the configuration name of the format.
	Name() string
	// Detect reports whether a line is in this format; "auto" tries the
	// registered detectable formats in priority order.
	Detect(line string) bool
	// Decode decodes an event's text. It fills Format, Time, Fields,
	// Message and the key names; the reader fills the position. It
	// returns false when the text is not in this format.
	Decode(text string, o *Options) (Event, bool)
}

type Frame struct {
	Text    string
	Time    time.Time
	HasTime bool
	Partial bool
	// Attrs are the frame's own fields (stream, ...), trusted metadata of
	// the runtime, kept apart from the payload's fields.
	Attrs []Member
}

type Framer interface {
	Format
	Unwrap(line string, o *Options) (Frame, bool)
}

type Kind uint8

type Line struct {
	// Text is the line without its terminator ("\n" or "\r\n"), cut at
	// MaxLineBytes on a UTF-8 boundary, invalid UTF-8 replaced by U+FFFD.
	Text string
	// Offset is the stream offset of the line's first byte.
	Offset int64
	// Length is the number of stream bytes the line consumed, terminator
	// and dropped tail included.
	Length int64
	// Truncated is set when the line was longer than MaxLineBytes.
	Truncated bool
	// Unterminated is set for a final line without a terminator: on a
	// stream that is still being written, the rest of it may follow.
	Unterminated bool
}

type LineReader struct {
	// contains filtered or unexported fields
}

type Member struct {
	Key   string
	Value Value
}

type Options struct {
	// Format is a registered format name or "auto" (default).
	Format string
	// Multiline is one of the Multiline* modes (default indent).
	Multiline string
	// Start is the RE2 pattern of MultilinePattern.
	Start string
	// Location reads zone-less timestamps; nil means UTC.
	Location *time.Location
	// FrameAttrs are the keys of a docker-json frame's "attrs" object (the
	// log driver's labels and env) kept in the event's "attrs" attribute;
	// the others are dropped, and the attribute too when none is left.
	// Default: none.
	FrameAttrs []string
	// StaticAttrs are attributes the source puts on every event, framed or
	// not, before the frame's own (docker: the trusted container name).
	StaticAttrs []Member
}

type Parser struct {
	// contains filtered or unexported fields
}

type Reader struct {
	// contains filtered or unexported fields
}

type Value struct {
	Kind    Kind
	Str     string
	Members []Member // KindObject
	Items   []Value  // KindArray
}