decoder

type Decoder ¶

type Decoder interface {
	Start()
	Stop()
	GetLineCount() int64
	GetDetectedPattern() *regexp.Regexp
	InputChan() chan *message.Message
	OutputChan() chan *message.Message
}

Decoder translates a sequence of byte buffers (such as from a file or a network socket) into log messages.

Decoder is structured as an actor receiving messages on `InputChan` and writing its output in `OutputChan`

The Decoder's run() takes data from InputChan, uses a Framer to break it into frames. The Framer passes that data to a LineParser, which uses a Parser to parse it and to pass it to the LineHander.

The LineHandler processes the messages it as necessary (as single lines, multiple lines, or auto-detecting the two), and sends the result to the Decoder's output channel.

func InitializeDecoder(source *sources.ReplaceableSource, parser parsers.Parser, tailerInfo *status.InfoRegistry) Decoder

func New(InputChan chan *message.Message, OutputChan chan *message.Message, framer *framer.Framer, lineParser LineParser, lineHandler LineHandler, detectedPattern *DetectedPattern) Decoder

func NewDecoderFromSource(source *sources.ReplaceableSource, tailerInfo *status.InfoRegistry) Decoder

func NewDecoderFromSourceWithPattern(source *sources.ReplaceableSource, multiLinePattern *regexp.Regexp, tailerInfo *status.InfoRegistry) Decoder

func NewDecoderWithFraming(source *sources.ReplaceableSource, parser parsers.Parser, framing framer.Framing, multiLinePattern *regexp.Regexp, tailerInfo *status.InfoRegistry) Decoder

func NewNoopDecoder() Decoder

type DetectedPattern ¶

type DetectedPattern struct {
	sync.Mutex
	// contains filtered or unexported fields
}

DetectedPattern is a container to safely access a detected multiline pattern

func (d *DetectedPattern) Get() *regexp.Regexp

func (d *DetectedPattern) Set(pattern *regexp.Regexp)

type LegacyAutoMultilineHandler ¶

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

LegacyAutoMultilineHandler can attempts to detect a known/commob pattern (a timestamp) in the logs and will switch to a MultiLine handler if one is detected and the thresholds are met.

func NewLegacyAutoMultilineHandler(
	outputFn func(*message.Message),
	lineLimit, linesToAssess int,
	matchThreshold float64,
	matchTimeout time.Duration,
	flushTimeout time.Duration,
	source *sources.ReplaceableSource,
	additionalPatterns []*regexp.Regexp,
	detectedPattern *DetectedPattern,
	tailerInfo *status.InfoRegistry,
) *LegacyAutoMultilineHandler

type LineHandler ¶

type LineHandler interface {
	// contains filtered or unexported methods
}

LineHandler handles raw lines to form structured lines.

type LineParser ¶

type LineParser interface {
	// contains filtered or unexported methods
}

LineParser handles decoded lines, parsing them into decoder.Message's using an embedded parsers.Parser.

type MockDecoder ¶

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

MockDecoder is a mock decoder that can be used to test the decoder

func NewMockDecoder() *MockDecoder

func NewMockDecoderWithOptions(options *MockDecoderOptions) *MockDecoder

func (d *MockDecoder) GetDetectedPattern() *regexp.Regexp

func (d *MockDecoder) GetLineCount() int64

func (d *MockDecoder) InputChan() chan *message.Message

func (d *MockDecoder) OutputChan() chan *message.Message

func (d *MockDecoder) Start()

func (d *MockDecoder) Stop()

type MockDecoderOptions ¶

type MockDecoderOptions struct {
	InputChanSize  int
	OutputChanSize int
}

MockDecoderOptions are the options for creating a mock decoder

type MultiLineHandler ¶

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

MultiLineHandler makes sure that multiple lines from a same content are properly put together.

func NewMultiLineHandler(outputFn func(*message.Message), newContentRe *regexp.Regexp, flushTimeout time.Duration, lineLimit int, telemetryEnabled bool, tailerInfo *status.InfoRegistry, multiLineTagValue string) *MultiLineHandler

func (h *MultiLineHandler) CountInfo() *status.CountInfo

func (h *MultiLineHandler) LinesCombinedInfo() *status.CountInfo

func (h *MultiLineHandler) SetCountInfo(info *status.CountInfo)

func (h *MultiLineHandler) SetLinesCombinedInfo(info *status.CountInfo)

type MultiLineParser ¶

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

MultiLineParser makes sure that chunked lines are properly put together.

func NewMultiLineParser(
	lineHandler LineHandler,
	flushTimeout time.Duration,
	parser parsers.Parser,
	lineLimit int,
) *MultiLineParser

type NoopLineHandler ¶

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

NoopLineHandler provides a passthrough functionality for flows that don't need a functional line handler

func NewNoopLineHandler(outputChan chan *message.Message) *NoopLineHandler

type SingleLineHandler ¶

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

SingleLineHandler takes care of tracking the line length and truncating them when they are too long.

func NewSingleLineHandler(outputFn func(*message.Message), lineLimit int) *SingleLineHandler

type SingleLineParser ¶

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

SingleLineParser makes sure that multiple lines from a same content are properly put together.

func NewSingleLineParser(
	lineHandler LineHandler,
	parser parsers.Parser) *SingleLineParser