func (b *Beat) launch(bt Creator) error {
err := b.handleFlags()
if err != nil {
return err
}
svc.BeforeRun()
defer svc.Cleanup()
if err := b.configure(); err != nil {
return err
}
// load the beats config section
var sub *common.Config
configName := strings.ToLower(b.Name)
if b.RawConfig.HasField(configName) {
sub, err = b.RawConfig.Child(configName, -1)
if err != nil {
return err
}
} else {
sub = common.NewConfig()
}
logp.Info("Setup Beat: %s; Version: %s", b.Name, b.Version)
processors, err := processors.New(b.Config.Processors)
if err != nil {
return fmt.Errorf("error initializing processors: %v", err)
}
debugf("Initializing output plugins")
publisher, err := publisher.New(b.Name, b.Config.Output, b.Config.Shipper, processors)
if err != nil {
return fmt.Errorf("error initializing publisher: %v", err)
}
// TODO: some beats race on shutdown with publisher.Stop -> do not call Stop yet,
// but refine publisher to disconnect clients on stop automatically
// defer publisher.Stop()
b.Publisher = publisher
beater, err := bt(b, sub)
if err != nil {
return err
}
// If -configtest was specified, exit now prior to run.
if cfgfile.IsTestConfig() {
fmt.Println("Config OK")
return GracefulExit
}
svc.HandleSignals(beater.Stop)
logp.Info("%s start running.", b.Name)
defer logp.Info("%s stopped.", b.Name)
return beater.Run(b)
}
// NewModuleWrappers creates new Modules and their associated MetricSets based
// on the given configuration. It constructs the supporting filters and stores
// them all in a ModuleWrapper.
func NewModuleWrappers(modulesConfig []*common.Config, r *mb.Register) ([]*ModuleWrapper, error) {
modules, err := mb.NewModules(modulesConfig, r)
if err != nil {
return nil, err
}
// Wrap the Modules and MetricSet's.
var wrappers []*ModuleWrapper
var errs multierror.Errors
for k, v := range modules {
debugf("Initializing Module type '%s': %T=%+v", k.Name(), k, k)
f, err := processors.New(k.Config().Filters)
if err != nil {
errs = append(errs, errors.Wrapf(err, "module %s", k.Name()))
continue
}
mw := &ModuleWrapper{
Module: k,
filters: f,
}
wrappers = append(wrappers, mw)
msws := make([]*metricSetWrapper, 0, len(v))
for _, ms := range v {
debugf("Initializing MetricSet type '%s/%s' for host '%s': %T=%+v",
ms.Module().Name(), ms.Name(), ms.Host(), ms, ms)
expMap, err := getMetricSetExpvarMap(mw.Name(), ms.Name())
if err != nil {
return nil, err
}
msw := &metricSetWrapper{
MetricSet: ms,
module: mw,
stats: expMap,
}
msws = append(msws, msw)
}
mw.metricSets = msws
}
return wrappers, errs.Err()
}
func TestBadConfig(t *testing.T) {
if testing.Verbose() {
logp.LogInit(logp.LOG_DEBUG, "", false, true, []string{"*"})
}
yml := []map[string]interface{}{
map[string]interface{}{
"include_fields": map[string]interface{}{
"when": map[string]interface{}{
"contains": map[string]string{
"proc.name": "test",
},
},
"fields": []string{"proc.cpu.total_p", "proc.mem", "dd"},
},
"drop_fields": map[string]interface{}{
"fields": []string{"proc.cpu"},
},
},
}
config := processors.PluginConfig{}
for _, action := range yml {
c := map[string]common.Config{}
for name, actionYml := range action {
actionConfig, err := common.NewConfigFrom(actionYml)
assert.Nil(t, err)
c[name] = *actionConfig
}
config = append(config, c)
}
_, err := processors.New(config)
assert.NotNil(t, err)
}
func TestBadCondition(t *testing.T) {
if testing.Verbose() {
logp.LogInit(logp.LOG_DEBUG, "", false, true, []string{"*"})
}
yml := []map[string]interface{}{
map[string]interface{}{
"drop_event": map[string]interface{}{
"when": map[string]interface{}{
"equal": map[string]string{
"type": "process",
},
},
},
},
}
config := processors.PluginConfig{}
for _, action := range yml {
c := map[string]common.Config{}
for name, actionYml := range action {
actionConfig, err := common.NewConfigFrom(actionYml)
if err != nil {
t.Fatal(err)
}
c[name] = *actionConfig
}
config = append(config, c)
}
_, err := processors.New(config)
assert.Error(t, err)
}
func GetProcessors(t *testing.T, yml []map[string]interface{}) *processors.Processors {
config := processors.PluginConfig{}
for _, action := range yml {
c := map[string]common.Config{}
for name, actionYml := range action {
actionConfig, err := common.NewConfigFrom(actionYml)
assert.Nil(t, err)
c[name] = *actionConfig
}
config = append(config, c)
}
list, err := processors.New(config)
assert.Nil(t, err)
return list
}
func TestMissingFields(t *testing.T) {
if testing.Verbose() {
logp.LogInit(logp.LOG_DEBUG, "", false, true, []string{"*"})
}
yml := []map[string]interface{}{
map[string]interface{}{
"include_fields": map[string]interface{}{
"when": map[string]interface{}{
"equals": map[string]string{
"type": "process",
},
},
},
},
}
config := processors.PluginConfig{}
for _, action := range yml {
c := map[string]common.Config{}
for name, actionYml := range action {
actionConfig, err := common.NewConfigFrom(actionYml)
assert.Nil(t, err)
c[name] = *actionConfig
}
config = append(config, c)
}
_, err := processors.New(config)
assert.NotNil(t, err)
}