agent

Documentation

Index

• func NewAccumulator(maker MetricMaker, metrics chan<- telegraf.Metric) telegraf.Accumulator
• type Agent
  • func NewAgent(cfg *config.Config) (*Agent, error)
  • func (a *Agent) Once(ctx context.Context, wait time.Duration) error
  • func (a *Agent) Run(ctx context.Context) error
  • func (a *Agent) Test(ctx context.Context, wait time.Duration) error
• type AlignedTicker
  • func NewAlignedTicker(now time.Time, interval, jitter, offset time.Duration) *AlignedTicker
  • func (t *AlignedTicker) Elapsed() <-chan time.Time
  • func (t *AlignedTicker) Stop()
• type MetricMaker
• type RollingTicker
  • func NewRollingTicker(interval, jitter time.Duration) *RollingTicker
  • func (t *RollingTicker) Elapsed() <-chan time.Time
  • func (t *RollingTicker) Stop()
• type Ticker
• type UnalignedTicker
  • func NewUnalignedTicker(interval, jitter, offset time.Duration) *UnalignedTicker
  • func (t *UnalignedTicker) Elapsed() <-chan time.Time
  • func (t *UnalignedTicker) InjectTick()
  • func (t *UnalignedTicker) Stop()

Functions

func NewAccumulator

func NewAccumulator(
	maker MetricMaker,
	metrics chan<- telegraf.Metric,
) telegraf.Accumulator

Types

type Agent

type Agent struct {
	Config *config.Config
}

Agent runs a set of plugins.

func NewAgent

func NewAgent(cfg *config.Config) (*Agent, error)

NewAgent returns an Agent for the given Config.

func (*Agent) Once

func (a *Agent) Once(ctx context.Context, wait time.Duration) error

Once runs the full agent for a single gather.

func (*Agent) Run

func (a *Agent) Run(ctx context.Context) error

Run starts and runs the Agent until the context is done.

func (*Agent) Test

func (a *Agent) Test(ctx context.Context, wait time.Duration) error

Test runs the inputs, processors and aggregators for a single gather and writes the metrics to stdout.

type AlignedTicker

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

AlignedTicker delivers ticks at aligned times plus an optional jitter. Each tick is realigned to avoid drift and handle changes to the system clock.

The ticks may have an jitter duration applied to them as an random offset to the interval. However the overall pace of is that of the interval, so on average you will have one collection each interval.

The first tick is emitted at the next alignment.

Ticks are dropped for slow consumers.

The implementation currently does not recalculate until the next tick with no maximum sleep, when using large intervals alignment is not corrected until the next tick.

func NewAlignedTicker

func NewAlignedTicker(now time.Time, interval, jitter, offset time.Duration) *AlignedTicker

func (*AlignedTicker) Elapsed

func (t *AlignedTicker) Elapsed() <-chan time.Time

func (*AlignedTicker) Stop

func (t *AlignedTicker) Stop()

type MetricMaker

type MetricMaker interface {
	LogName() string
	MakeMetric(m telegraf.Metric) telegraf.Metric
	Log() telegraf.Logger
}

type RollingTicker

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

RollingTicker delivers ticks at regular but unaligned intervals.

Because the next interval is scheduled based on the interval + jitter, you are guaranteed at least interval seconds without missing a tick and ticks will be evenly scheduled over time.

On average you will have one collection each interval + (jitter/2).

The first tick is emitted after interval+jitter seconds.

Ticks are dropped for slow consumers.

func NewRollingTicker

func NewRollingTicker(interval, jitter time.Duration) *RollingTicker

func (*RollingTicker) Elapsed

func (t *RollingTicker) Elapsed() <-chan time.Time

func (*RollingTicker) Stop

func (t *RollingTicker) Stop()

type Ticker

type Ticker interface {
	Elapsed() <-chan time.Time
	Stop()
}

type UnalignedTicker

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

UnalignedTicker delivers ticks at regular but unaligned intervals. No effort is made to avoid drift.

The ticks may have an jitter duration applied to them as an random offset to the interval. However the overall pace of is that of the interval, so on average you will have one collection each interval.

The first tick is emitted immediately.

Ticks are dropped for slow consumers.

func NewUnalignedTicker

func NewUnalignedTicker(interval, jitter, offset time.Duration) *UnalignedTicker

func (*UnalignedTicker) Elapsed

func (t *UnalignedTicker) Elapsed() <-chan time.Time

func (*UnalignedTicker) InjectTick

func (t *UnalignedTicker) InjectTick()

func (*UnalignedTicker) Stop

func (t *UnalignedTicker) Stop()