recombine

Documentation

Index

• Constants
• type Config
  • func NewConfig() *Config
  • func NewConfigWithID(operatorID string) *Config
  • func (c *Config) Build(set component.TelemetrySettings) (operator.Operator, error)
• type Transformer
  • func (t *Transformer) Process(ctx context.Context, e *entry.Entry) error
  • func (t *Transformer) Start(_ operator.Persister) error
  • func (t *Transformer) Stop() error

Constants

const DefaultSourceIdentifier = "DefaultSourceIdentifier"

Types

type Config

type Config struct {
	helper.TransformerConfig `mapstructure:",squash"`
	IsFirstEntry             string          `mapstructure:"is_first_entry"`
	IsLastEntry              string          `mapstructure:"is_last_entry"`
	MaxBatchSize             int             `mapstructure:"max_batch_size"`
	MaxUnmatchedBatchSize    int             `mapstructure:"max_unmatched_batch_size"`
	CombineField             entry.Field     `mapstructure:"combine_field"`
	CombineWith              string          `mapstructure:"combine_with"`
	SourceIdentifier         entry.Field     `mapstructure:"source_identifier"`
	OverwriteWith            string          `mapstructure:"overwrite_with"`
	ForceFlushTimeout        time.Duration   `mapstructure:"force_flush_period"`
	MaxSources               int             `mapstructure:"max_sources"`
	MaxLogSize               helper.ByteSize `mapstructure:"max_log_size,omitempty"`
}

Config is the configuration of a recombine operator

func NewConfig

func NewConfig() *Config

NewConfig creates a new recombine config with default values

func NewConfigWithID

func NewConfigWithID(operatorID string) *Config

NewConfigWithID creates a new recombine config with default values

func (*Config) Build

func (c *Config) Build(set component.TelemetrySettings) (operator.Operator, error)

Build creates a new Transformer from a config

type Transformer

type Transformer struct {
	helper.TransformerOperator

	sync.Mutex
	// contains filtered or unexported fields
}

Transformer is an operator that combines a field from consecutive log entries into a single

func (*Transformer) Process

func (t *Transformer) Process(ctx context.Context, e *entry.Entry) error

func (*Transformer) Start

func (t *Transformer) Start(_ operator.Persister) error

func (*Transformer) Stop

func (t *Transformer) Stop() error