Add light modules registry

metricbeat/autodiscover/builder/hints/config.go

@@ -21,7 +21,7 @@ import "github.com/elastic/beats/metricbeat/mb"
 
 type config struct {
 	Key      string `config:"key"`
-	Registry *mb.Register
+	Registry mb.ModulesRegistry
 }
 
 func defaultConfig() config {

metricbeat/autodiscover/builder/hints/metrics.go

@@ -50,7 +50,7 @@ const (
 
 type metricHints struct {
 	Key      string
-	Registry *mb.Register
+	Registry mb.ModulesRegistry
 }
 
 // NewMetricHints builds a new metrics builder based on hints

metricbeat/mb/builders.go

@@ -47,7 +47,7 @@ var (
 // will be unpacked into ModuleConfig structs). r is the Register where the
 // ModuleFactory's and MetricSetFactory's will be obtained from. This method
 // returns a Module and its configured MetricSets or an error.
-func NewModule(config *common.Config, r *Register) (Module, []MetricSet, error) {
+func NewModule(config *common.Config, r ModulesRegistry) (Module, []MetricSet, error) {
 	if !config.Enabled() {
 		return nil, nil, ErrModuleDisabled
 	}
@@ -97,7 +97,7 @@ func newBaseModuleFromConfig(rawConfig *common.Config) (BaseModule, error) {
 	return baseModule, nil
 }
 
-func createModule(r *Register, bm BaseModule) (Module, error) {
+func createModule(r ModulesRegistry, bm BaseModule) (Module, error) {
 	f := r.moduleFactory(bm.Name())
 	if f == nil {
 		f = DefaultModuleFactory
@@ -106,7 +106,7 @@ func createModule(r *Register, bm BaseModule) (Module, error) {
 	return f(bm)
 }
 
-func initMetricSets(r *Register, m Module) ([]MetricSet, error) {
+func initMetricSets(r ModulesRegistry, m Module) ([]MetricSet, error) {
 	var (
 		errs       multierror.Errors
 		metricsets []MetricSet
@@ -157,7 +157,7 @@ func initMetricSets(r *Register, m Module) ([]MetricSet, error) {
 // newBaseMetricSets creates a new BaseMetricSet for all MetricSets defined
 // in the module's config. An error is returned if no MetricSets are specified
 // in the module's config and no default MetricSet is defined.
-func newBaseMetricSets(r *Register, m Module) ([]BaseMetricSet, error) {
+func newBaseMetricSets(r ModulesRegistry, m Module) ([]BaseMetricSet, error) {
 	hosts := []string{""}
 	if l := m.Config().Hosts; len(l) > 0 {
 		hosts = l

metricbeat/mb/lightmodules.go

@@ -0,0 +1,125 @@
+// Licensed to Elasticsearch B.V. under one or more contributor
+// license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright
+// ownership. Elasticsearch B.V. licenses this file to you under
+// the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package mb
+
+import (
+	"fmt"
+	"sort"
+
+	"github.com/pkg/errors"
+)
+
+// LigthModulesRegistry wraps
+type LightModulesRegistry struct {
+	ModulesRegistry
+
+	paths []string
+}
+
+// NewLightModulesRegistry creates a new LightModulesRegistry
+func NewLightModulesRegistry(paths ...string) *LightModulesRegistry {
+	return &LightModulesRegistry{
+		ModulesRegistry: NewRegister(),
+		paths:           paths,
+	}
+}
+
+func (r *LightModulesRegistry) DefaultMetricSets(module string) ([]string, error) {
+	if stringInSlice(module, r.parent().Modules()) {
+		return r.parent().DefaultMetricSets(module)
+	}
+	module, err := r.readModule(module)
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed to get default metricsets for module '%s'", module)
+	}
+	var metricsets []string
+	for i, ms := range module.Metricsets {
+		if ms.Default {
+			metricsets = append(metricsets, ms)
+		}
+	}
+	if len(metricsets) == 0 {
+		return nil, fmt.Errorf("no default metricset exists for module '%s'", module)
+	}
+	return metricsets, nil
+}
+
+func (r *LightModulesRegistry) Modules() []string {
+	registeredModules := r.parent().Modules()
+	modules := r.listModules()
+	return append(registeredModules, modules...)
+}
+
+func (r *LightModulesRegistry) MetricSets(module string) []string {
+	if stringInSlice(module, r.parent().Modules()) {
+		return r.parent().MetricSets(module)
+	}
+	module, err := r.readModule(module)
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed to get metricsets for module '%s'", module)
+	}
+	metricsets := make([]string, len(module.MetricSets))
+	for i := range module.Metricsets {
+		metricset[i] = module.MetricSets[i].Name
+	}
+	return metricsets
+}
+
+func (r *LightModulesRegistry) String() string {
+	var metricsets []string
+	modules := r.listModules()
+	for _, moduleName := range modules {
+		module, err := r.readModule(module)
+		if err != nil {
+			continue
+		}
+		for _, metricset := range module.MetricSets {
+			metricsets = append(metricsets, fmt.Sprintf("%s/%s", moduleName, metricset.Name))
+		}
+	}
+	sort.Strings(metricsets)
+	parent := r.parent().String()
+	if len(modules) == 0 {
+		return parent
+	}
+	return fmt.Sprintf("%s, Light Modules [MetricSets:[%s]]",
+		parent,
+		strings.Join(metricsets, ", "),
+	)
+}
+
+func (r *LightModulesRegistry) moduleFactory(name string) ModuleFactory {
+	return r.parent().moduleFactory(name)
+}
+
+func (r *LightModulesRegistry) metricSetRegistration(module, name string) (MetricSetRegistration, error) {
+	return r.parent().metricSetRegistration(module, name)
+}
+
+func (r *LightModulesRegistry) parent() ModulesRegistry {
+	return r.ModulesRegistry
+}
+
+func stringInSlice(s string, slice []string) bool {
+	for i := range slice {
+		if s == slice[i] {
+			return true
+		}
+	}
+	return false
+}

metricbeat/mb/module/wrapper.go

@@ -77,7 +77,7 @@ type stats struct {
 
 // NewWrapper create a new Module and its associated MetricSets based
 // on the given configuration.
-func NewWrapper(config *common.Config, r *mb.Register, options ...Option) (*Wrapper, error) {
+func NewWrapper(config *common.Config, r mb.ModulesRegistry, options ...Option) (*Wrapper, error) {
 	module, metricsets, err := mb.NewModule(config, r)
 	if err != nil {
 		return nil, err

metricbeat/mb/registry.go

@@ -28,9 +28,23 @@ import (
 
 const initialSize = 20 // initialSize specifies the initial size of the Register.
 
+// ModulesRegistry is the interface implemented by module registries
+type ModulesRegistry interface {
+	AddModule(name string, factory ModuleFactory) error
+	AddMetricSet(module string, name string, factory MetricSetFactory, hostParser ...HostParser) error
+	MustAddMetricSet(module, name string, factory MetricSetFactory, options ...MetricSetOption)
+	DefaultMetricSets(module string) ([]string, error)
+	Modules() []string
+	MetricSets(module string) []string
+	String() string
+
+	moduleFactory(name string) ModuleFactory
+	metricSetRegistration(module, name string) (MetricSetRegistration, error)
+}
+
 // Registry is the singleton Register instance where all ModuleFactory's and
 // MetricSetFactory's should be registered.
-var Registry = NewRegister()
+var Registry ModulesRegistry = NewLightModulesRegistry()
 
 // DefaultModuleFactory returns the given BaseModule and never returns an error.
 // If a MetricSets are registered without an associated ModuleFactory, then