helper

Documentation

Index

• Variables
• type MetricSet
  • func NewMetricSet(name string, new func() MetricSeter, module *Module) (*MetricSet, error)
  • func (m *MetricSet) Fetch() error
  • func (m *MetricSet) Setup() error
• type MetricSeter
• type Module
  • func NewModule(cfg *common.Config, moduler func() Moduler) (*Module, error)
  • func (m *Module) FetchMetricSets(metricSet *MetricSet)
  • func (m *Module) ProcessConfig(config interface{}) error
  • func (m *Module) Run(period time.Duration, b *beat.Beat)
  • func (m *Module) Start(b *beat.Beat) error
  • func (m *Module) Stop()
• type ModuleConfig
• type Moduler
• type Register
  • func (r *Register) AddMetricSeter(module string, name string, new func() MetricSeter)
  • func (r *Register) AddModuler(name string, m func() Moduler)
  • func (r *Register) GetMetricSet(module *Module, metricsetName string) (*MetricSet, error)
  • func (r *Register) GetModule(cfg *common.Config) (*Module, error)

Variables

var Registry = Register{}

TODO: Global variables should be prevent.

This should be moved into the metricbeat object but can't because the init()
functions in each metricset are called before the beater object exists.

Types

type MetricSet

type MetricSet struct {
	Name        string
	MetricSeter MetricSeter
	// Inherits config from module
	Config ModuleConfig
	Module *Module
	// contains filtered or unexported fields
}

Metric specific data This must be defined by each metric

func NewMetricSet

func NewMetricSet(name string, new func() MetricSeter, module *Module) (*MetricSet, error)

Creates a new MetricSet

func (*MetricSet) Fetch

func (m *MetricSet) Fetch() error

RunMetric runs the given metricSet and returns the event

func (*MetricSet) Setup

func (m *MetricSet) Setup() error

type MetricSeter

type MetricSeter interface {
	// Setup of MetricSeter
	// MetricSet which contains the MetricSeter is passed. This gives access to config
	// and the module.
	Setup(ms *MetricSet) error

	// Method to periodically fetch a new event from a host
	// Fetch is called for each host. In case where host does not exist, it can be transferred
	// differently in the setup to have a different meaning. An example here is for filesystem
	// of topbeat, where each host could be a filesystem.
	// Fetch is called on the predefined interval and does not take delays into account.
	Fetch(ms *MetricSet, host string) (common.MapStr, error)
}

Interface for each metric

type Module

type Module struct {

	// Module config
	Config ModuleConfig

	Timeout time.Duration

	Publish chan common.MapStr
	// contains filtered or unexported fields
}

Module specifics. This must be defined by each module

func NewModule

func NewModule(cfg *common.Config, moduler func() Moduler) (*Module, error)

NewModule creates a new module

func (*Module) FetchMetricSets

func (m *Module) FetchMetricSets(metricSet *MetricSet)

func (*Module) ProcessConfig

func (m *Module) ProcessConfig(config interface{}) error

ProcessConfig allows to process additional configuration params which are not part of the module default configuratoin. This allows each metricset to have its specific config params

func (*Module) Run

func (m *Module) Run(period time.Duration, b *beat.Beat)

func (*Module) Start

func (m *Module) Start(b *beat.Beat) error

Starts the given module

func (*Module) Stop

func (m *Module) Stop()

Stop stops module and all its metricSets

type ModuleConfig

type ModuleConfig struct {
	Hosts      []string `config:"hosts"`
	Period     string   `config:"period"`
	Timeout    string   `config:"timeout"`
	Module     string   `config:"module"`
	MetricSets []string `config:"metricsets"`
	Enabled    bool     `config:"enabled"`
	Selectors  []string `config:"selectors"`

	common.EventMetadata `config:",inline"` // Fields and tags to add to events.
}

Base configuration for each module/metricsets combination

type Moduler

type Moduler interface {
	// Raw *common.Config config is passed. This allows each module to extract its own local config variables
	Setup(m *Module) error
}

Interface for each module

type Register

type Register struct {
	Modulers     map[string]func() Moduler
	MetricSeters map[string]map[string]func() MetricSeter
}

func (*Register) AddMetricSeter

func (r *Register) AddMetricSeter(module string, name string, new func() MetricSeter)

func (*Register) AddModuler

func (r *Register) AddModuler(name string, m func() Moduler)

AddModule registers the given module with the registry

func (*Register) GetMetricSet

func (r *Register) GetMetricSet(module *Module, metricsetName string) (*MetricSet, error)

GetMetricSet returns a new metricset instance for the given metricset name combined with the module name

func (*Register) GetModule

func (r *Register) GetModule(cfg *common.Config) (*Module, error)

GetModule returns a new module instance for the given moduler name