MM-10934 Update server dependencies. (#8981)

* Changing throttled import path.

* Upgrading dependencies.

vendor/github.com/armon/go-metrics/README.md

@@ -7,7 +7,7 @@ expose application metrics, and profile runtime performance in a flexible manner
 Current API: [![GoDoc](https://godoc.org/github.com/armon/go-metrics?status.svg)](https://godoc.org/github.com/armon/go-metrics)
 
 Sinks
-=====
+-----
 
 The `metrics` package makes use of a `MetricSink` interface to support delivery
 to any type of backend. Currently the following sinks are provided:
@@ -23,8 +23,26 @@ In addition to the sinks, the `InmemSignal` can be used to catch a signal,
 and dump a formatted output of recent metrics. For example, when a process gets
 a SIGUSR1, it can dump to stderr recent performance metrics for debugging.
 
+Labels
+------
+
+Most metrics do have an equivalent ending with `WithLabels`, such methods
+allow to push metrics with labels and use some features of underlying Sinks
+(ex: translated into Prometheus labels).
+
+Since some of these labels may increase greatly cardinality of metrics, the
+library allow to filter labels using a blacklist/whitelist filtering system
+which is global to all metrics.
+
+* If `Config.AllowedLabels` is not nil, then only labels specified in this value will be sent to underlying Sink, otherwise, all labels are sent by default.
+* If `Config.BlockedLabels` is not nil, any label specified in this value will not be sent to underlying Sinks.
+
+By default, both `Config.AllowedLabels` and `Config.BlockedLabels` are nil, meaning that
+no tags are filetered at all, but it allow to a user to globally block some tags with high
+cardinality at application level.
+
 Examples
-========
+--------
 
 Here is an example of using the package:
 
@@ -70,5 +88,4 @@ When a signal comes in, output like the following will be dumped to stderr:
     [2014-01-28 14:57:33.04 -0800 PST][G] 'foo': 42.000
     [2014-01-28 14:57:33.04 -0800 PST][P] 'bar': 30.000
     [2014-01-28 14:57:33.04 -0800 PST][C] 'baz': Count: 3 Min: 1.000 Mean: 41.000 Max: 80.000 Stddev: 39.509
-    [2014-01-28 14:57:33.04 -0800 PST][S] 'method.wow': Count: 3 Min: 22.000 Mean: 54.667 Max: 100.000 Stddev: 40.513
-
+    [2014-01-28 14:57:33.04 -0800 PST][S] 'method.wow': Count: 3 Min: 22.000 Mean: 54.667 Max: 100.000 Stddev: 40.513

vendor/github.com/armon/go-metrics/metrics.go

@@ -35,10 +35,11 @@ func (m *Metrics) SetGaugeWithLabels(key []string, val float32, labels []Label)
 			key = insert(0, m.ServiceName, key)
 		}
 	}
-	if !m.allowMetric(key) {
+	allowed, labelsFiltered := m.allowMetric(key, labels)
+	if !allowed {
 		return
 	}
-	m.sink.SetGaugeWithLabels(key, val, labels)
+	m.sink.SetGaugeWithLabels(key, val, labelsFiltered)
 }
 
 func (m *Metrics) EmitKey(key []string, val float32) {
@@ -48,7 +49,8 @@ func (m *Metrics) EmitKey(key []string, val float32) {
 	if m.ServiceName != "" {
 		key = insert(0, m.ServiceName, key)
 	}
-	if !m.allowMetric(key) {
+	allowed, _ := m.allowMetric(key, nil)
+	if !allowed {
 		return
 	}
 	m.sink.EmitKey(key, val)
@@ -72,10 +74,11 @@ func (m *Metrics) IncrCounterWithLabels(key []string, val float32, labels []Labe
 			key = insert(0, m.ServiceName, key)
 		}
 	}
-	if !m.allowMetric(key) {
+	allowed, labelsFiltered := m.allowMetric(key, labels)
+	if !allowed {
 		return
 	}
-	m.sink.IncrCounterWithLabels(key, val, labels)
+	m.sink.IncrCounterWithLabels(key, val, labelsFiltered)
 }
 
 func (m *Metrics) AddSample(key []string, val float32) {
@@ -96,10 +99,11 @@ func (m *Metrics) AddSampleWithLabels(key []string, val float32, labels []Label)
 			key = insert(0, m.ServiceName, key)
 		}
 	}
-	if !m.allowMetric(key) {
+	allowed, labelsFiltered := m.allowMetric(key, labels)
+	if !allowed {
 		return
 	}
-	m.sink.AddSampleWithLabels(key, val, labels)
+	m.sink.AddSampleWithLabels(key, val, labelsFiltered)
 }
 
 func (m *Metrics) MeasureSince(key []string, start time.Time) {
@@ -120,23 +124,45 @@ func (m *Metrics) MeasureSinceWithLabels(key []string, start time.Time, labels [
 			key = insert(0, m.ServiceName, key)
 		}
 	}
-	if !m.allowMetric(key) {
+	allowed, labelsFiltered := m.allowMetric(key, labels)
+	if !allowed {
 		return
 	}
 	now := time.Now()
 	elapsed := now.Sub(start)
 	msec := float32(elapsed.Nanoseconds()) / float32(m.TimerGranularity)
-	m.sink.AddSampleWithLabels(key, msec, labels)
+	m.sink.AddSampleWithLabels(key, msec, labelsFiltered)
 }
 
 // UpdateFilter overwrites the existing filter with the given rules.
 func (m *Metrics) UpdateFilter(allow, block []string) {
+	m.UpdateFilterAndLabels(allow, block, m.AllowedLabels, m.BlockedLabels)
+}
+
+// UpdateFilterAndLabels overwrites the existing filter with the given rules.
+func (m *Metrics) UpdateFilterAndLabels(allow, block, allowedLabels, blockedLabels []string) {
 	m.filterLock.Lock()
 	defer m.filterLock.Unlock()
 
 	m.AllowedPrefixes = allow
 	m.BlockedPrefixes = block
 
+	if allowedLabels == nil {
+		// Having a white list means we take only elements from it
+		m.allowedLabels = nil
+	} else {
+		m.allowedLabels = make(map[string]bool)
+		for _, v := range allowedLabels {
+			m.allowedLabels[v] = true
+		}
+	}
+	m.blockedLabels = make(map[string]bool)
+	for _, v := range blockedLabels {
+		m.blockedLabels[v] = true
+	}
+	m.AllowedLabels = allowedLabels
+	m.BlockedLabels = blockedLabels
+
 	m.filter = iradix.New()
 	for _, prefix := range m.AllowedPrefixes {
 		m.filter, _, _ = m.filter.Insert([]byte(prefix), true)
@@ -146,20 +172,56 @@ func (m *Metrics) UpdateFilter(allow, block []string) {
 	}
 }
 
+// labelIsAllowed return true if a should be included in metric
+// the caller should lock m.filterLock while calling this method
+func (m *Metrics) labelIsAllowed(label *Label) bool {
+	labelName := (*label).Name
+	if m.blockedLabels != nil {
+		_, ok := m.blockedLabels[labelName]
+		if ok {
+			// If present, let's remove this label
+			return false
+		}
+	}
+	if m.allowedLabels != nil {
+		_, ok := m.allowedLabels[labelName]
+		return ok
+	}
+	// Allow by default
+	return true
+}
+
+// filterLabels return only allowed labels
+// the caller should lock m.filterLock while calling this method
+func (m *Metrics) filterLabels(labels []Label) []Label {
+	if labels == nil {
+		return nil
+	}
+	toReturn := labels[:0]
+	for _, label := range labels {
+		if m.labelIsAllowed(&label) {
+			toReturn = append(toReturn, label)
+		}
+	}
+	return toReturn
+}
+
 // Returns whether the metric should be allowed based on configured prefix filters
-func (m *Metrics) allowMetric(key []string) bool {
+// Also return the applicable labels
+func (m *Metrics) allowMetric(key []string, labels []Label) (bool, []Label) {
 	m.filterLock.RLock()
 	defer m.filterLock.RUnlock()
 
 	if m.filter == nil || m.filter.Len() == 0 {
-		return m.Config.FilterDefault
+		return m.Config.FilterDefault, m.filterLabels(labels)
 	}
 
 	_, allowed, ok := m.filter.Root().LongestPrefix([]byte(strings.Join(key, ".")))
 	if !ok {
-		return m.Config.FilterDefault
+		return m.Config.FilterDefault, m.filterLabels(labels)
 	}
-	return allowed.(bool)
+
+	return allowed.(bool), m.filterLabels(labels)
 }
 
 // Periodically collects runtime stats to publish

vendor/github.com/armon/go-metrics/start.go

@@ -23,6 +23,8 @@ type Config struct {
 
 	AllowedPrefixes []string // A list of metric prefixes to allow, with '.' as the separator
 	BlockedPrefixes []string // A list of metric prefixes to block, with '.' as the separator
+	AllowedLabels   []string // A list of metric labels to allow, with '.' as the separator
+	BlockedLabels   []string // A list of metric labels to block, with '.' as the separator
 	FilterDefault   bool     // Whether to allow metrics by default
 }
 
@@ -30,10 +32,12 @@ type Config struct {
 // be used to emit
 type Metrics struct {
 	Config
-	lastNumGC  uint32
-	sink       MetricSink
-	filter     *iradix.Tree
-	filterLock sync.RWMutex
+	lastNumGC     uint32
+	sink          MetricSink
+	filter        *iradix.Tree
+	allowedLabels map[string]bool
+	blockedLabels map[string]bool
+	filterLock    sync.RWMutex // Lock filters and allowedLabels/blockedLabels access
 }
 
 // Shared global metrics instance
@@ -68,7 +72,7 @@ func New(conf *Config, sink MetricSink) (*Metrics, error) {
 	met := &Metrics{}
 	met.Config = *conf
 	met.sink = sink
-	met.UpdateFilter(conf.AllowedPrefixes, conf.BlockedPrefixes)
+	met.UpdateFilterAndLabels(conf.AllowedPrefixes, conf.BlockedPrefixes, conf.AllowedLabels, conf.BlockedLabels)
 
 	// Start the runtime collector
 	if conf.EnableRuntimeMetrics {
@@ -127,3 +131,11 @@ func MeasureSinceWithLabels(key []string, start time.Time, labels []Label) {
 func UpdateFilter(allow, block []string) {
 	globalMetrics.Load().(*Metrics).UpdateFilter(allow, block)
 }
+
+// UpdateFilterAndLabels set allow/block prefixes of metrics while allowedLabels
+// and blockedLabels - when not nil - allow filtering of labels in order to
+// block/allow globally labels (especially useful when having large number of
+// values for a given label). See README.md for more information about usage.
+func UpdateFilterAndLabels(allow, block, allowedLabels, blockedLabels []string) {
+	globalMetrics.Load().(*Metrics).UpdateFilterAndLabels(allow, block, allowedLabels, blockedLabels)
+}