stanza

type BaseConfig ¶

type BaseConfig struct {
	config.ReceiverSettings `mapstructure:",squash"`
	Operators               OperatorConfigs `mapstructure:"operators"`
	Converter               ConverterConfig `mapstructure:"converter"`
}

BaseConfig is the common configuration of a stanza-based receiver

func (cfg BaseConfig) DecodeOperatorConfigs() ([]operator.Config, error)

type Converter ¶ added in v0.25.0

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

Converter converts a batch of entry.Entry into plog.Logs aggregating translated entries into logs coming from the same Resource.

The diagram below illustrates the internal communication inside the Converter:

          ┌─────────────────────────────────┐
          │ Batch()                         │
┌─────────┤  Ingests batches of log entries │
│         │  and sends them onto workerChan │
│         └─────────────────────────────────┘
│
│ ┌───────────────────────────────────────────────────┐
├─► workerLoop()                                      │
│ │ ┌─────────────────────────────────────────────────┴─┐
├─┼─► workerLoop()                                      │
│ │ │ ┌─────────────────────────────────────────────────┴─┐
└─┼─┼─► workerLoop()                                      │
  └─┤ │   consumes sent log entries from workerChan,      │
    │ │   translates received entries to plog.LogRecords,│
    └─┤   hashes them to generate an ID, and sends them   │
      │   onto batchChan                                  │
      └─────────────────────────┬─────────────────────────┘
                                │
                                ▼
    ┌─────────────────────────────────────────────────────┐
    │ aggregationLoop()                                   │
    │   consumes from batchChan, aggregates log records   │
    │   by marshaled Resource and sends the               │
    │   aggregated buffer to flushChan                    │
    └───────────────────────────┬─────────────────────────┘
                                │
                                ▼
    ┌─────────────────────────────────────────────────────┐
    │ flushLoop()                                         │
    │   receives log records from flushChan and sends     │
    │   them onto pLogsChan which is consumed by          │
    │   downstream consumers via OutChannel()             │
    └─────────────────────────────────────────────────────┘

func NewConverter(opts ...ConverterOption) *Converter

func (c *Converter) Batch(e []*entry.Entry) error

func (c *Converter) OutChannel() <-chan plog.Logs

func (c *Converter) Start()

func (c *Converter) Stop()

type ConverterConfig ¶ added in v0.25.0

type ConverterConfig struct {
	// MaxFlushCount defines the maximum number of entries that can be
	// accumulated before flushing them for further processing.
	MaxFlushCount uint `mapstructure:"max_flush_count"`
	// FlushInterval defines how often to flush the converted and accumulated
	// log entries.
	FlushInterval time.Duration `mapstructure:"flush_interval"`
	// WorkerCount defines how many worker goroutines used for entry.Entry to
	// log records translation should be spawned.
	// By default: math.Max(1, runtime.NumCPU()/4) workers are spawned.
	WorkerCount int `mapstructure:"worker_count"`
}

ConverterConfig controls how the internal entry.Entry to plog.Logs converter works.

type ConverterOption ¶ added in v0.25.0

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

func WithLogger(logger *zap.Logger) ConverterOption

func WithWorkerCount(workerCount int) ConverterOption

type FromPdataConverter ¶ added in v0.51.0

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

FromPdataConverter converts a set of entry.Entry into plog.Logs

The diagram below illustrates the internal communication inside the FromPdataConverter:

          ┌─────────────────────────────────┐
          │ Batch()                         │
┌─────────┤  Ingests plog.Logs, splits up   │
│         │  and places them on workerChan  │
│         └─────────────────────────────────┘
│
│ ┌───────────────────────────────────────────────────┐
├─► workerLoop()                                      │
│ │ ┌─────────────────────────────────────────────────┴─┐
├─┼─► workerLoop()                                      │
│ │ │ ┌─────────────────────────────────────────────────┴─┐
└─┼─┼─► workerLoop()                                      │
  └─┤ │   consumes sent log entries from workerChan,      │
    │ │   translates received logs to entry.Entry,        │
    └─┤   and sends them along entriesChan                │
      └───────────────────────────────────────────────────┘

func NewFromPdataConverter(workerCount int, logger *zap.Logger) *FromPdataConverter

func (c *FromPdataConverter) Batch(pLogs plog.Logs) error

func (c *FromPdataConverter) OutChannel() <-chan []*entry.Entry

func (c *FromPdataConverter) Start()

func (c *FromPdataConverter) Stop()

type InputConfig ¶

type InputConfig map[string]interface{}

InputConfig is an alias that allows unmarshaling outside of mapstructure This is meant to be used only for the input operator

type LogEmitter ¶

type LogEmitter struct {
	helper.OutputOperator
	// contains filtered or unexported fields
}

LogEmitter is a stanza operator that emits log entries to a channel

func NewLogEmitter(opts ...LogEmitterOption) *LogEmitter

func (e *LogEmitter) OutChannel() <-chan []*entry.Entry

func (e *LogEmitter) Process(ctx context.Context, ent *entry.Entry) error

func (e *LogEmitter) Start(_ operator.Persister) error

func (e *LogEmitter) Stop() error

type LogEmitterOption ¶ added in v0.41.0

type LogEmitterOption func(*LogEmitter)

func LogEmitterWithFlushInterval(flushInterval time.Duration) LogEmitterOption

func LogEmitterWithLogger(logger *zap.SugaredLogger) LogEmitterOption

func LogEmitterWithMaxBatchSize(maxBatchSize uint) LogEmitterOption

type LogReceiverType ¶

type LogReceiverType interface {
	Type() config.Type
	CreateDefaultConfig() config.Receiver
	BaseConfig(config.Receiver) BaseConfig
	DecodeInputConfig(config.Receiver) (*operator.Config, error)
}

LogReceiverType is the interface used by stanza-based log receivers

type OperatorConfigs ¶

type OperatorConfigs []map[string]interface{}

OperatorConfigs is an alias that allows for unmarshaling outside of mapstructure Stanza operators should will be migrated to mapstructure for greater compatibility but this allows a temporary solution