add support for conditional registration of metrics (#620)

* add support for conditional registration

Signed-off-by: Rama Chavali <[email protected]>

* make with noop

Signed-off-by: Rama Chavali <[email protected]>

* change to disabledMetric

Signed-off-by: Rama Chavali <[email protected]>

Signed-off-by: Rama Chavali <[email protected]>

Author: ramaraochavali

monitoring/monitoring.go

@@ -85,6 +85,10 @@ type (
 		ValueFrom(valueFn func() float64, labelValues ...string)
 	}
 
+	disabledMetric struct {
+		name string
+	}
+
 	// Options encode changes to the options passed to a Metric at creation time.
 	Options func(*options)
 
@@ -116,6 +120,35 @@ type (
 	}
 )
 
+// Decrement implements Metric
+func (dm *disabledMetric) Decrement() {}
+
+// Increment implements Metric
+func (dm *disabledMetric) Increment() {}
+
+// Name implements Metric
+func (dm *disabledMetric) Name() string {
+	return dm.name
+}
+
+// Record implements Metric
+func (dm *disabledMetric) Record(value float64) {}
+
+// RecordInt implements Metric
+func (dm *disabledMetric) RecordInt(value int64) {}
+
+// Register implements Metric
+func (dm *disabledMetric) Register() error {
+	return nil
+}
+
+// With implements Metric
+func (dm *disabledMetric) With(labelValues ...LabelValue) Metric {
+	return dm
+}
+
+var _ Metric = &disabledMetric{}
+
 var (
 	recordHooks     map[string]RecordHook
 	recordHookMutex sync.RWMutex
@@ -204,6 +237,21 @@ func MustRegister(metrics ...Metric) {
 	}
 }
 
+// RegisterIf is a helper function that will ensure that the provided
+// Metric is registered if enabled function returns true.
+// If a metric fails to register, this method will panic.
+// It returns the registered metric or no-op metric based on enabled function.
+// NOTE: It is important to use the returned Metric if RegisterIf is used.
+func RegisterIf(metric Metric, enabled func() bool) Metric {
+	if enabled() {
+		if err := metric.Register(); err != nil {
+			panic(err)
+		}
+		return metric
+	}
+	return &disabledMetric{name: metric.Name()}
+}
+
 // NewSum creates a new Metric with an aggregation type of Sum (the values will be cumulative).
 // That means that data collected by the new Metric will be summed before export.
 func NewSum(name, description string, opts ...Options) Metric {

monitoring/monitoring_test.go

@@ -69,10 +69,24 @@ var (
 		"test_gauge",
 		"Testing gauge functionality",
 	)
+
+	testDisabledSum = monitoring.NewSum(
+		"events_disabled_total",
+		"Number of events observed, by name and kind",
+		monitoring.WithLabels(name, kind),
+	)
+
+	testConditionalSum = monitoring.NewSum(
+		"events_conditional_total",
+		"Number of events observed, by name and kind",
+		monitoring.WithLabels(name, kind),
+	)
 )
 
 func init() {
 	monitoring.MustRegister(testSum, hookSum, int64Sum, testDistribution, testGauge)
+	testDisabledSum = monitoring.RegisterIf(testDisabledSum, func() bool { return false })
+	testConditionalSum = monitoring.RegisterIf(testConditionalSum, func() bool { return true })
 }
 
 func TestSum(t *testing.T) {
@@ -141,6 +155,23 @@ func TestSum(t *testing.T) {
 	}
 }
 
+func TestRegisterIfSum(t *testing.T) {
+	testDisabledSum.With(name.Value("foo"), kind.Value("bar")).Increment()
+	var err error
+	_, err = view.RetrieveData(testDisabledSum.Name())
+	if err == nil || !strings.EqualFold(err.Error(), "cannot retrieve data; view \"events_disabled_total\" is not registered") {
+		t.Errorf("failure validating disabled metrics. exptected error but got %v", err)
+	}
+	testConditionalSum.With(name.Value("foo"), kind.Value("bar")).Increment()
+	rows, err := view.RetrieveData(testConditionalSum.Name())
+	if err != nil {
+		t.Errorf("exptected to register metric %s but got %v", testConditionalSum.Name(), err)
+	}
+	if len(rows) == 0 {
+		t.Errorf("exptected to metric %s has values  but got %v", testConditionalSum.Name(), len(rows))
+	}
+}
+
 func TestGauge(t *testing.T) {
 	exp := &testExporter{rows: make(map[string][]*view.Row)}
 	view.RegisterExporter(exp)