adapter

type BaseConfig ¶

type BaseConfig struct {
	Operators      []operator.Config    `mapstructure:"operators"`
	StorageID      *component.ID        `mapstructure:"storage"`
	RetryOnFailure consumerretry.Config `mapstructure:"retry_on_failure"`
	// contains filtered or unexported fields
}

BaseConfig is the common configuration of a stanza-based receiver

type Converter ¶

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, │
    └─┤   and sends them on flushChan                     │
      └─────────────────────────┬─────────────────────────┘
                                │
                                ▼
    ┌─────────────────────────────────────────────────────┐
    │ flushLoop()                                         │
    │   receives log records from flushChan and sends     │
    │   them onto pLogsChan which is consumed by          │
    │   downstream consumers via OutChannel()             │
    └─────────────────────────────────────────────────────┘

func NewConverter(logger *zap.Logger, 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 FromPdataConverter ¶

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

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

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 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(logger *zap.SugaredLogger, opts ...emitterOption) *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 LogReceiverType ¶

type LogReceiverType interface {
	Type() component.Type
	CreateDefaultConfig() component.Config
	BaseConfig(component.Config) BaseConfig
	InputConfig(component.Config) operator.Config
}

LogReceiverType is the interface used by stanza-based log receivers